From e757063d3120e68fe53b9c888bc6c5fe7372b406 Mon Sep 17 00:00:00 2001 From: Stephen Miller <56742918+StevenMiller123@users.noreply.github.com> Date: Wed, 5 Feb 2025 09:21:05 -0600 Subject: [PATCH 1/5] Improved error handling in sceKernelAllocateDirectMemory (#2037) * Handle errors in sceKernelAllocateDirectMemory * Improve accuracy of error cases Some of our existing cases are normally EAGAIN returns. * Improve logging on errors * Clang * TEMPORARY HACK FOR NBA TESTS This will be removed before this PR is marked as ready, and is only here to make sure the other NBA games (and perhaps DOA3) work if some missing init behavior is handled. * Revert "TEMPORARY HACK FOR NBA TESTS" This reverts commit a0e27b0229811778c8390066d00b5221aa5d54a6. * Change error message --- src/core/libraries/kernel/memory.cpp | 28 ++++++++++++++++++++++------ src/core/memory.cpp | 5 ++++- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/src/core/libraries/kernel/memory.cpp b/src/core/libraries/kernel/memory.cpp index 8deefb496..551fd8e3e 100644 --- a/src/core/libraries/kernel/memory.cpp +++ b/src/core/libraries/kernel/memory.cpp @@ -26,17 +26,20 @@ u64 PS4_SYSV_ABI sceKernelGetDirectMemorySize() { int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u64 len, u64 alignment, int memoryType, s64* physAddrOut) { - if (searchStart < 0 || searchEnd <= searchStart) { - LOG_ERROR(Kernel_Vmm, "Provided address range is invalid!"); + if (searchStart < 0 || searchEnd < 0) { + LOG_ERROR(Kernel_Vmm, "Invalid parameters!"); return ORBIS_KERNEL_ERROR_EINVAL; } - const bool is_in_range = searchEnd - searchStart >= len; - if (len <= 0 || !Common::Is16KBAligned(len) || !is_in_range) { - LOG_ERROR(Kernel_Vmm, "Provided address range is invalid!"); + if (len <= 0 || !Common::Is16KBAligned(len)) { + LOG_ERROR(Kernel_Vmm, "Length {:#x} is invalid!", len); return ORBIS_KERNEL_ERROR_EINVAL; } if (alignment != 0 && !Common::Is16KBAligned(alignment)) { - LOG_ERROR(Kernel_Vmm, "Alignment value is invalid!"); + LOG_ERROR(Kernel_Vmm, "Alignment {:#x} is invalid!", alignment); + return ORBIS_KERNEL_ERROR_EINVAL; + } + if (memoryType > 10) { + LOG_ERROR(Kernel_Vmm, "Memory type {:#x} is invalid!", memoryType); return ORBIS_KERNEL_ERROR_EINVAL; } if (physAddrOut == nullptr) { @@ -44,8 +47,21 @@ int PS4_SYSV_ABI sceKernelAllocateDirectMemory(s64 searchStart, s64 searchEnd, u return ORBIS_KERNEL_ERROR_EINVAL; } + const bool is_in_range = searchEnd - searchStart >= len; + if (searchEnd <= searchStart || searchEnd < len || !is_in_range) { + LOG_ERROR(Kernel_Vmm, + "Provided address range is too small!" + " searchStart = {:#x}, searchEnd = {:#x}, length = {:#x}", + searchStart, searchEnd, len); + return ORBIS_KERNEL_ERROR_EAGAIN; + } + auto* memory = Core::Memory::Instance(); PAddr phys_addr = memory->Allocate(searchStart, searchEnd, len, alignment, memoryType); + if (phys_addr == -1) { + return ORBIS_KERNEL_ERROR_EAGAIN; + } + *physAddrOut = static_cast(phys_addr); LOG_INFO(Kernel_Vmm, diff --git a/src/core/memory.cpp b/src/core/memory.cpp index 271092eaf..4717b3a74 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -117,7 +117,10 @@ PAddr MemoryManager::Allocate(PAddr search_start, PAddr search_end, size_t size, dmem_area->second.GetEnd() <= search_end) { ++dmem_area; } - ASSERT_MSG(is_suitable(), "Unable to find free direct memory area: size = {:#x}", size); + if (!is_suitable()) { + LOG_ERROR(Kernel_Vmm, "Unable to find free direct memory area: size = {:#x}", size); + return -1; + } // Align free position PAddr free_addr = dmem_area->second.base; From ecfc940381a752a7a5ef728ad50826e643b671ee Mon Sep 17 00:00:00 2001 From: Stephen Miller <56742918+StevenMiller123@users.noreply.github.com> Date: Wed, 5 Feb 2025 09:24:53 -0600 Subject: [PATCH 2/5] libSceHmd Stubs (#2355) * Add generated libSceHmd stubs * Implement ReprojectionQuery functions These constant returns come from decompiling libSceHmd. * Clang * Clang --- CMakeLists.txt | 5 + src/common/logging/filter.cpp | 1 + src/common/logging/types.h | 1 + src/core/libraries/hmd/hmd.cpp | 1219 ++++++++++++++++++++++++++++++++ src/core/libraries/hmd/hmd.h | 203 ++++++ src/core/libraries/libs.cpp | 2 + 6 files changed, 1431 insertions(+) create mode 100644 src/core/libraries/hmd/hmd.cpp create mode 100644 src/core/libraries/hmd/hmd.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 8ecbbf0d6..8837a6584 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -486,6 +486,10 @@ set(ZLIB_LIB src/core/libraries/zlib/zlib.cpp src/core/libraries/zlib/zlib_error.h ) +set(VR_LIBS src/core/libraries/hmd/hmd.cpp + src/core/libraries/hmd/hmd.h +) + set(MISC_LIBS src/core/libraries/screenshot/screenshot.cpp src/core/libraries/screenshot/screenshot.h src/core/libraries/move/move.cpp @@ -663,6 +667,7 @@ set(CORE src/core/aerolib/stubs.cpp ${IME_LIB} ${FIBER_LIB} ${VDEC_LIB} + ${VR_LIBS} ${DEV_TOOLS} src/core/debug_state.cpp src/core/debug_state.h diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp index dd708c528..1a781cb4c 100644 --- a/src/common/logging/filter.cpp +++ b/src/common/logging/filter.cpp @@ -134,6 +134,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) { SUB(Lib, WebBrowserDialog) \ SUB(Lib, NpParty) \ SUB(Lib, Zlib) \ + SUB(Lib, Hmd) \ CLS(Frontend) \ CLS(Render) \ SUB(Render, Vulkan) \ diff --git a/src/common/logging/types.h b/src/common/logging/types.h index 54f8cdd0b..4078afcef 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -101,6 +101,7 @@ enum class Class : u8 { Lib_WebBrowserDialog, ///< The LibSceWebBrowserDialog implementation Lib_NpParty, ///< The LibSceNpParty implementation Lib_Zlib, ///< The LibSceZlib implementation. + Lib_Hmd, ///< The LibSceHmd implementation. Frontend, ///< Emulator UI Render, ///< Video Core Render_Vulkan, ///< Vulkan backend diff --git a/src/core/libraries/hmd/hmd.cpp b/src/core/libraries/hmd/hmd.cpp new file mode 100644 index 000000000..b43789822 --- /dev/null +++ b/src/core/libraries/hmd/hmd.cpp @@ -0,0 +1,1219 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#include "common/logging/log.h" +#include "core/libraries/error_codes.h" +#include "core/libraries/hmd/hmd.h" +#include "core/libraries/libs.h" + +namespace Libraries::Hmd { + +s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGet2dVrCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGetCompoundEyeCorrectionCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGetCorrectionCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGetWideNearCorrectionCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemoryAlign() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemorySize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionInitialize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdDistortionSetOutputMinColor() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_B26430EA74FC3DC0() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGet2DEyeOffset() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGet2dVrCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetAssyError() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDeviceInformation() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDeviceInformationByHandle() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDistortionCorrectionCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDistortionParams() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDistortionWorkMemoryAlign() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetDistortionWorkMemorySize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetFieldOfView() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetInertialSensorData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdGetWideNearDistortionCorrectionCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInitialize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInitialize315() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternal3dAudioClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternal3dAudioOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternal3dAudioSendData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetAudioStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetFadeState() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetVideoStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSendAudio() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSendVideo() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSetFadeAndSwitch() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalBindDeviceWithUserId() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCheckDeviceModelMk3() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCheckS3dPassModeAvailable() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCrashReportCancel() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCrashReportClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCrashReportOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCrashReportReadData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCrashReportReadDataSize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalCreateSharedMemory() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuCheckAfterPvt() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuCheckPartialUpdateAvailable() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuGetStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuReset() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuSend() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuSendSize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuSetMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalDfuStart() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalEventInitialize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetBrightness() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetCrashDumpInfo() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDebugMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDebugSocialScreenMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDebugTextMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDefaultLedData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDemoMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceInformation() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceInformationByHandle() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetEyeStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetHmuOpticalParam() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetHmuPowerStatusForDebug() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetHmuSerialNumber() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetIPD() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetIpdSettingEnableForSystemService() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetPuBuildNumber() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetPuPositionParam() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetPuRevision() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetPUSerialNumber() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetPUVersion() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetRequiredPUPVersion() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetStatusReport() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetTv4kCapability() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplayDepth() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplayHeight() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplaySize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalGetVr2dData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalIsCommonDlgMiniAppVr2d() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalIsCommonDlgVr2d() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalIsGameVr2d() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalIsMiniAppVr2d() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMapSharedMemory() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMirroringModeSetAspect() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMirroringModeSetAspectDebug() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMmapGetCount() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMmapGetModeId() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMmapGetSensorCalibrationData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalMmapIsConnect() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalPushVr2dData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalRegisterEventCallback() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalResetInertialSensor() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalResetLedForVrTracker() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalResetLedForVsh() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeClose() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeGetAudioStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeGetVideoStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeSendAudio() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeSendVideo() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetBrightness() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetCrashReportCommand() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDebugGpo() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDebugMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDebugSocialScreenMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDebugTextMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDefaultLedData() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDemoMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetDeviceConnection() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetForcedCrash() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetHmuPowerControl() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetHmuPowerControlForDebug() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetIPD() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetIpdSettingEnableForSystemService() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetLedOn() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetM2LedBrightness() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetM2LedOn() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetPortConnection() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetPortStatus() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetS3dPassMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetSidetone() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetUserType() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplayDepth() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplayHeight() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplaySize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSetVRMode() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenGetFadeState() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenSetFadeAndSwitch() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenSetOutput() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdOpen() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionAddDisplayBuffer() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionClearUserEventEnd() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionClearUserEventStart() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionDebugGetLastInfo() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionDebugGetLastInfoMultilayer() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionFinalize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionFinalizeCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionInitialize() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionInitializeCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionQueryGarlicBuffAlign() { + return 0x100; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionQueryGarlicBuffSize() { + return 0x100000; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionQueryOnionBuffAlign() { + return 0x100; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionQueryOnionBuffSize() { + return 0x810; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionSetCallback() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionSetDisplayBuffers() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionSetOutputMinColor() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionSetUserEventEnd() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionSetUserEventStart() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStart() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStart2dVr() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartLiveCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer2() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartWideNear() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartWideNearWithOverlay() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStartWithOverlay() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStop() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStopCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionStopLiveCapture() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionUnsetCallback() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdReprojectionUnsetDisplayBuffers() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceHmdTerminate() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_202D0D1A687FCD2F() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_358DBF818A3D8A12() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_5CCBADA76FE8F40E() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_63D403167DC08CF0() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_69383B2B4E3AEABF() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_791560C32F4F6D68() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_7C955961EA85B6D3() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_9952277839236BA7() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_9A276E739E54EEAF() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_9E501994E289CBE7() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_A31A0320D80EAD99() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_A31F4DA8B3BD2E12() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_A92D7C23AC364993() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_ADCCC25CB876FDBE() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_B16652641FE69F0E() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_B614F290B67FB59B() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_B9A6FA0735EC7E49() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_FC193BD653F2AF2E() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_FF2E0E53015FE231() { + LOG_ERROR(Lib_Hmd, "(STUBBED) called"); + return ORBIS_OK; +} + +void RegisterlibSceHmd(Core::Loader::SymbolsResolver* sym) { + LIB_FUNCTION("8gH1aLgty5I", "libsceHmdReprojectionMultilayer", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartMultilayer); + LIB_FUNCTION("gEokC+OGI8g", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGet2dVrCommand); + LIB_FUNCTION("ER2ar8yUmbk", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGetCompoundEyeCorrectionCommand); + LIB_FUNCTION("HT8qWOTOGmo", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGetCorrectionCommand); + LIB_FUNCTION("Vkkhy8RFIuk", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGetWideNearCorrectionCommand); + LIB_FUNCTION("1cS7W5J-v3k", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGetWorkMemoryAlign); + LIB_FUNCTION("36xDKk+Hw7o", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionGetWorkMemorySize); + LIB_FUNCTION("ao8NZ+FRYJE", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionInitialize); + LIB_FUNCTION("8A4T5ahi790", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, + sceHmdDistortionSetOutputMinColor); + LIB_FUNCTION("smQw6nT8PcA", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, Func_B26430EA74FC3DC0); + LIB_FUNCTION("6biw1XHTSqQ", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdClose); + LIB_FUNCTION("BWY-qKM5hxE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGet2DEyeOffset); + LIB_FUNCTION("za4xJfzCBcM", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGet2dVrCommand); + LIB_FUNCTION("Yx+CuF11D3Q", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetAssyError); + LIB_FUNCTION("thDt9upZlp8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetDeviceInformation); + LIB_FUNCTION("1pxQfif1rkE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdGetDeviceInformationByHandle); + LIB_FUNCTION("grCYks4m8Jw", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdGetDistortionCorrectionCommand); + LIB_FUNCTION("mP2ZcYmDg-o", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetDistortionParams); + LIB_FUNCTION("8Ick-e6cDVY", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdGetDistortionWorkMemoryAlign); + LIB_FUNCTION("D5JfdpJKvXk", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdGetDistortionWorkMemorySize); + LIB_FUNCTION("NPQwYFqi0bs", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetFieldOfView); + LIB_FUNCTION("rU3HK9Q0r8o", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetInertialSensorData); + LIB_FUNCTION("goi5ASvH-V8", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdGetWideNearDistortionCorrectionCommand); + LIB_FUNCTION("K4KnH0QkT2c", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInitialize); + LIB_FUNCTION("s-J66ar9g50", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInitialize315); + LIB_FUNCTION("riPQfAdebHk", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternal3dAudioClose); + LIB_FUNCTION("wHnZU1qtiqw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternal3dAudioOpen); + LIB_FUNCTION("NuEjeN8WCBA", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternal3dAudioSendData); + LIB_FUNCTION("QasPTUPWVZE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenClose); + LIB_FUNCTION("Wr5KVtyVDG0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenGetAudioStatus); + LIB_FUNCTION("whRxl6Hhrzg", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenGetFadeState); + LIB_FUNCTION("w8BEUsIYn8w", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenGetVideoStatus); + LIB_FUNCTION("0cQDAbkOt2A", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalAnotherScreenOpen); + LIB_FUNCTION("Asczi8gw1NM", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenSendAudio); + LIB_FUNCTION("6+v7m1vwE+0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenSendVideo); + LIB_FUNCTION("E0BLvy57IiQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalAnotherScreenSetFadeAndSwitch); + LIB_FUNCTION("UTqrWB+1+SU", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalBindDeviceWithUserId); + LIB_FUNCTION("ego1YdqNGpI", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalCheckDeviceModelMk3); + LIB_FUNCTION("WR7XsLdjcqQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalCheckS3dPassModeAvailable); + LIB_FUNCTION("eMI1Hq+NEwY", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalCrashReportCancel); + LIB_FUNCTION("dI3StPLQlMM", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalCrashReportClose); + LIB_FUNCTION("lqPT-Bf1s4I", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalCrashReportOpen); + LIB_FUNCTION("QxhJs6zHUmU", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalCrashReportReadData); + LIB_FUNCTION("A2jWOLPzHHE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalCrashReportReadDataSize); + LIB_FUNCTION("E9scVxt0DNg", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalCreateSharedMemory); + LIB_FUNCTION("6RclvsKxr3I", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuCheckAfterPvt); + LIB_FUNCTION("cE99PJR6b8w", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalDfuCheckPartialUpdateAvailable); + LIB_FUNCTION("SuE90Qscg0s", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuClose); + LIB_FUNCTION("5f-6lp7L5cY", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuGetStatus); + LIB_FUNCTION("dv2RqD7ZBd4", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuOpen); + LIB_FUNCTION("pN0HjRU86Jo", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuReset); + LIB_FUNCTION("mdc++HCXSsQ", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuSend); + LIB_FUNCTION("gjyqnphjGZE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuSendSize); + LIB_FUNCTION("bl4MkWNLxKs", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuSetMode); + LIB_FUNCTION("a1LmvXhZ6TM", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalDfuStart); + LIB_FUNCTION("+UzzSnc0z9A", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalEventInitialize); + LIB_FUNCTION("uQc9P8Hrr6U", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetBrightness); + LIB_FUNCTION("nK1g+MwMV10", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetCrashDumpInfo); + LIB_FUNCTION("L5WZgOTw41Y", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetDebugMode); + LIB_FUNCTION("3w8SkMfCHY0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetDebugSocialScreenMode); + LIB_FUNCTION("1Xmb76MHXug", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetDebugTextMode); + LIB_FUNCTION("S0ITgPRkfUg", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetDefaultLedData); + LIB_FUNCTION("mxjolbeBa78", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetDemoMode); + LIB_FUNCTION("RFIi20Wp9j0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetDeviceInformation); + LIB_FUNCTION("P04LQJQZ43Y", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetDeviceInformationByHandle); + LIB_FUNCTION("PPCqsD8B5uM", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetDeviceStatus); + LIB_FUNCTION("-u82z1UhOq4", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetEyeStatus); + LIB_FUNCTION("iINSFzCIaB8", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetHmuOpticalParam); + LIB_FUNCTION("Csuvq2MMXHU", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetHmuPowerStatusForDebug); + LIB_FUNCTION("UhFPniZvm8U", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetHmuSerialNumber); + LIB_FUNCTION("9exeDpk7JU8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetIPD); + LIB_FUNCTION("yNtYRsxZ6-A", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetIpdSettingEnableForSystemService); + LIB_FUNCTION("EKn+IFVsz0M", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetPuBuildNumber); + LIB_FUNCTION("AxQ6HtktYfQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetPuPositionParam); + LIB_FUNCTION("ynKv9QCSbto", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetPuRevision); + LIB_FUNCTION("3jcyx7XOm7A", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetPUSerialNumber); + LIB_FUNCTION("+PDyXnclP5w", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetPUVersion); + LIB_FUNCTION("67q17ERGBuw", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetRequiredPUPVersion); + LIB_FUNCTION("uGyN1CkvwYU", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetStatusReport); + LIB_FUNCTION("p9lSvZujLuo", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetTv4kCapability); + LIB_FUNCTION("-Z+-9u98m9o", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetVirtualDisplayDepth); + LIB_FUNCTION("df+b0FQnnVQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetVirtualDisplayHeight); + LIB_FUNCTION("i6yROd9ygJs", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalGetVirtualDisplaySize); + LIB_FUNCTION("Aajiktl6JXU", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetVr2dData); + LIB_FUNCTION("GwFVF2KkIT4", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalIsCommonDlgMiniAppVr2d); + LIB_FUNCTION("LWQpWHOSUvk", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalIsCommonDlgVr2d); + LIB_FUNCTION("YiIVBPLxmfE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalIsGameVr2d); + LIB_FUNCTION("LMlWs+oKHTg", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalIsMiniAppVr2d); + LIB_FUNCTION("nBv4CKUGX0Y", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalMapSharedMemory); + LIB_FUNCTION("4hTD8I3CyAk", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalMirroringModeSetAspect); + LIB_FUNCTION("EJwPtSSZykY", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalMirroringModeSetAspectDebug); + LIB_FUNCTION("r7f7M5q3snU", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalMmapGetCount); + LIB_FUNCTION("gCjTEtEsOOw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalMmapGetModeId); + LIB_FUNCTION("HAr740Mt9Hs", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalMmapGetSensorCalibrationData); + LIB_FUNCTION("1PNiQR-7L6k", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalMmapIsConnect); + LIB_FUNCTION("9-jaAXUNG-A", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalPushVr2dData); + LIB_FUNCTION("1gkbLH5+kxU", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalRegisterEventCallback); + LIB_FUNCTION("6kHBllapJas", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalResetInertialSensor); + LIB_FUNCTION("k1W6RPkd0mc", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalResetLedForVrTracker); + LIB_FUNCTION("dp1wu22jSGc", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalResetLedForVsh); + LIB_FUNCTION("d2TeoKeqM5U", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSeparateModeClose); + LIB_FUNCTION("WxsnAsjPF7Q", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSeparateModeGetAudioStatus); + LIB_FUNCTION("eOOeG9SpEuc", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSeparateModeGetVideoStatus); + LIB_FUNCTION("gA4Xnn+NSGk", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSeparateModeOpen); + LIB_FUNCTION("stQ7AsondmE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSeparateModeSendAudio); + LIB_FUNCTION("jfnS-OoDayM", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSeparateModeSendVideo); + LIB_FUNCTION("roHN4ml+tB8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetBrightness); + LIB_FUNCTION("0z2qLqedQH0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetCrashReportCommand); + LIB_FUNCTION("xhx5rVZEpnw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetDebugGpo); + LIB_FUNCTION("e7laRxRGCHc", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetDebugMode); + LIB_FUNCTION("CRyJ7Q-ap3g", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetDebugSocialScreenMode); + LIB_FUNCTION("dG4XPW4juU4", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetDebugTextMode); + LIB_FUNCTION("rAXmGoO-VmE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetDefaultLedData); + LIB_FUNCTION("lu9I7jnUvWQ", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetDemoMode); + LIB_FUNCTION("hyATMTuQSoQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetDeviceConnection); + LIB_FUNCTION("c4mSi64bXUw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetForcedCrash); + LIB_FUNCTION("U9kPT4g1mFE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetHmuPowerControl); + LIB_FUNCTION("dX-MVpXIPwQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetHmuPowerControlForDebug); + LIB_FUNCTION("4KIjvAf8PCA", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetIPD); + LIB_FUNCTION("NbxTfUKO184", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetIpdSettingEnableForSystemService); + LIB_FUNCTION("NnRKjf+hxW4", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetLedOn); + LIB_FUNCTION("4AP0X9qGhqw", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetM2LedBrightness); + LIB_FUNCTION("Mzzz2HPWM+8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetM2LedOn); + LIB_FUNCTION("LkBkse9Pit0", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetPortConnection); + LIB_FUNCTION("v243mvYg0Y0", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetPortStatus); + LIB_FUNCTION("EwXvkZpo9Go", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetS3dPassMode); + LIB_FUNCTION("g3DKNOy1tYw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetSidetone); + LIB_FUNCTION("mjMsl838XM8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetUserType); + LIB_FUNCTION("8IS0KLkDNQY", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetVirtualDisplayDepth); + LIB_FUNCTION("afhK5KcJOJY", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetVirtualDisplayHeight); + LIB_FUNCTION("+zPvzIiB+BU", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSetVirtualDisplaySize); + LIB_FUNCTION("9z8Lc64NF1c", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalSetVRMode); + LIB_FUNCTION("s5EqYh5kbwM", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSocialScreenGetFadeState); + LIB_FUNCTION("a1LMFZtK9b0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSocialScreenSetFadeAndSwitch); + LIB_FUNCTION("-6FjKlMA+Yc", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdInternalSocialScreenSetOutput); + LIB_FUNCTION("d2g5Ij7EUzo", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdOpen); + LIB_FUNCTION("NTIbBpSH9ik", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionAddDisplayBuffer); + LIB_FUNCTION("94+Ggm38KCg", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionClearUserEventEnd); + LIB_FUNCTION("mdyFbaJj66M", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionClearUserEventStart); + LIB_FUNCTION("MdV0akauNow", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionDebugGetLastInfo); + LIB_FUNCTION("ymiwVjPB5+k", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionDebugGetLastInfoMultilayer); + LIB_FUNCTION("ZrV5YIqD09I", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionFinalize); + LIB_FUNCTION("utHD2Ab-Ixo", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionFinalizeCapture); + LIB_FUNCTION("OuygGEWkins", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionInitialize); + LIB_FUNCTION("BTrQnC6fcAk", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionInitializeCapture); + LIB_FUNCTION("TkcANcGM0s8", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionQueryGarlicBuffAlign); + LIB_FUNCTION("z0KtN1vqF2E", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionQueryGarlicBuffSize); + LIB_FUNCTION("IWybWbR-xvA", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionQueryOnionBuffAlign); + LIB_FUNCTION("kLUAkN6a1e8", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionQueryOnionBuffSize); + LIB_FUNCTION("6CRWGc-evO4", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionSetCallback); + LIB_FUNCTION("E+dPfjeQLHI", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionSetDisplayBuffers); + LIB_FUNCTION("LjdLRysHU6Y", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionSetOutputMinColor); + LIB_FUNCTION("knyIhlkpLgE", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionSetUserEventEnd); + LIB_FUNCTION("7as0CjXW1B8", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionSetUserEventStart); + LIB_FUNCTION("dntZTJ7meIU", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStart); + LIB_FUNCTION("q3e8+nEguyE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStart2dVr); + LIB_FUNCTION("RrvyU1pjb9A", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStartCapture); + LIB_FUNCTION("XZ5QUzb4ae0", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartLiveCapture); + LIB_FUNCTION("8gH1aLgty5I", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartMultilayer); + LIB_FUNCTION("gqAG7JYeE7A", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartMultilayer2); + LIB_FUNCTION("3JyuejcNhC0", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStartWideNear); + LIB_FUNCTION("mKa8scOc4-k", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartWideNearWithOverlay); + LIB_FUNCTION("kcldQ7zLYQQ", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStartWithOverlay); + LIB_FUNCTION("vzMEkwBQciM", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStop); + LIB_FUNCTION("F7Sndm5teWw", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionStopCapture); + LIB_FUNCTION("PAa6cUL5bR4", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionStopLiveCapture); + LIB_FUNCTION("0wnZViigP9o", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdReprojectionUnsetCallback); + LIB_FUNCTION("iGNNpDDjcwo", "libSceHmd", 1, "libSceHmd", 1, 1, + sceHmdReprojectionUnsetDisplayBuffers); + LIB_FUNCTION("z-RMILqP6tE", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdTerminate); + LIB_FUNCTION("IC0NGmh-zS8", "libSceHmd", 1, "libSceHmd", 1, 1, Func_202D0D1A687FCD2F); + LIB_FUNCTION("NY2-gYo9ihI", "libSceHmd", 1, "libSceHmd", 1, 1, Func_358DBF818A3D8A12); + LIB_FUNCTION("XMutp2-o9A4", "libSceHmd", 1, "libSceHmd", 1, 1, Func_5CCBADA76FE8F40E); + LIB_FUNCTION("Y9QDFn3AjPA", "libSceHmd", 1, "libSceHmd", 1, 1, Func_63D403167DC08CF0); + LIB_FUNCTION("aTg7K0466r8", "libSceHmd", 1, "libSceHmd", 1, 1, Func_69383B2B4E3AEABF); + LIB_FUNCTION("eRVgwy9PbWg", "libSceHmd", 1, "libSceHmd", 1, 1, Func_791560C32F4F6D68); + LIB_FUNCTION("fJVZYeqFttM", "libSceHmd", 1, "libSceHmd", 1, 1, Func_7C955961EA85B6D3); + LIB_FUNCTION("mVIneDkja6c", "libSceHmd", 1, "libSceHmd", 1, 1, Func_9952277839236BA7); + LIB_FUNCTION("miduc55U7q8", "libSceHmd", 1, "libSceHmd", 1, 1, Func_9A276E739E54EEAF); + LIB_FUNCTION("nlAZlOKJy+c", "libSceHmd", 1, "libSceHmd", 1, 1, Func_9E501994E289CBE7); + LIB_FUNCTION("oxoDINgOrZk", "libSceHmd", 1, "libSceHmd", 1, 1, Func_A31A0320D80EAD99); + LIB_FUNCTION("ox9NqLO9LhI", "libSceHmd", 1, "libSceHmd", 1, 1, Func_A31F4DA8B3BD2E12); + LIB_FUNCTION("qS18I6w2SZM", "libSceHmd", 1, "libSceHmd", 1, 1, Func_A92D7C23AC364993); + LIB_FUNCTION("rczCXLh2-b4", "libSceHmd", 1, "libSceHmd", 1, 1, Func_ADCCC25CB876FDBE); + LIB_FUNCTION("sWZSZB-mnw4", "libSceHmd", 1, "libSceHmd", 1, 1, Func_B16652641FE69F0E); + LIB_FUNCTION("thTykLZ-tZs", "libSceHmd", 1, "libSceHmd", 1, 1, Func_B614F290B67FB59B); + LIB_FUNCTION("uab6BzXsfkk", "libSceHmd", 1, "libSceHmd", 1, 1, Func_B9A6FA0735EC7E49); + LIB_FUNCTION("-Bk71lPyry4", "libSceHmd", 1, "libSceHmd", 1, 1, Func_FC193BD653F2AF2E); + LIB_FUNCTION("-y4OUwFf4jE", "libSceHmd", 1, "libSceHmd", 1, 1, Func_FF2E0E53015FE231); +}; + +} // namespace Libraries::Hmd \ No newline at end of file diff --git a/src/core/libraries/hmd/hmd.h b/src/core/libraries/hmd/hmd.h new file mode 100644 index 000000000..12f1ac70a --- /dev/null +++ b/src/core/libraries/hmd/hmd.h @@ -0,0 +1,203 @@ +// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/types.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Libraries::Hmd { + +s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer(); +s32 PS4_SYSV_ABI sceHmdDistortionGet2dVrCommand(); +s32 PS4_SYSV_ABI sceHmdDistortionGetCompoundEyeCorrectionCommand(); +s32 PS4_SYSV_ABI sceHmdDistortionGetCorrectionCommand(); +s32 PS4_SYSV_ABI sceHmdDistortionGetWideNearCorrectionCommand(); +s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemoryAlign(); +s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemorySize(); +s32 PS4_SYSV_ABI sceHmdDistortionInitialize(); +s32 PS4_SYSV_ABI sceHmdDistortionSetOutputMinColor(); +s32 PS4_SYSV_ABI Func_B26430EA74FC3DC0(); +s32 PS4_SYSV_ABI sceHmdClose(); +s32 PS4_SYSV_ABI sceHmdGet2DEyeOffset(); +s32 PS4_SYSV_ABI sceHmdGet2dVrCommand(); +s32 PS4_SYSV_ABI sceHmdGetAssyError(); +s32 PS4_SYSV_ABI sceHmdGetDeviceInformation(); +s32 PS4_SYSV_ABI sceHmdGetDeviceInformationByHandle(); +s32 PS4_SYSV_ABI sceHmdGetDistortionCorrectionCommand(); +s32 PS4_SYSV_ABI sceHmdGetDistortionParams(); +s32 PS4_SYSV_ABI sceHmdGetDistortionWorkMemoryAlign(); +s32 PS4_SYSV_ABI sceHmdGetDistortionWorkMemorySize(); +s32 PS4_SYSV_ABI sceHmdGetFieldOfView(); +s32 PS4_SYSV_ABI sceHmdGetInertialSensorData(); +s32 PS4_SYSV_ABI sceHmdGetWideNearDistortionCorrectionCommand(); +s32 PS4_SYSV_ABI sceHmdInitialize(); +s32 PS4_SYSV_ABI sceHmdInitialize315(); +s32 PS4_SYSV_ABI sceHmdInternal3dAudioClose(); +s32 PS4_SYSV_ABI sceHmdInternal3dAudioOpen(); +s32 PS4_SYSV_ABI sceHmdInternal3dAudioSendData(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenClose(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetAudioStatus(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetFadeState(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenGetVideoStatus(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenOpen(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSendAudio(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSendVideo(); +s32 PS4_SYSV_ABI sceHmdInternalAnotherScreenSetFadeAndSwitch(); +s32 PS4_SYSV_ABI sceHmdInternalBindDeviceWithUserId(); +s32 PS4_SYSV_ABI sceHmdInternalCheckDeviceModelMk3(); +s32 PS4_SYSV_ABI sceHmdInternalCheckS3dPassModeAvailable(); +s32 PS4_SYSV_ABI sceHmdInternalCrashReportCancel(); +s32 PS4_SYSV_ABI sceHmdInternalCrashReportClose(); +s32 PS4_SYSV_ABI sceHmdInternalCrashReportOpen(); +s32 PS4_SYSV_ABI sceHmdInternalCrashReportReadData(); +s32 PS4_SYSV_ABI sceHmdInternalCrashReportReadDataSize(); +s32 PS4_SYSV_ABI sceHmdInternalCreateSharedMemory(); +s32 PS4_SYSV_ABI sceHmdInternalDfuCheckAfterPvt(); +s32 PS4_SYSV_ABI sceHmdInternalDfuCheckPartialUpdateAvailable(); +s32 PS4_SYSV_ABI sceHmdInternalDfuClose(); +s32 PS4_SYSV_ABI sceHmdInternalDfuGetStatus(); +s32 PS4_SYSV_ABI sceHmdInternalDfuOpen(); +s32 PS4_SYSV_ABI sceHmdInternalDfuReset(); +s32 PS4_SYSV_ABI sceHmdInternalDfuSend(); +s32 PS4_SYSV_ABI sceHmdInternalDfuSendSize(); +s32 PS4_SYSV_ABI sceHmdInternalDfuSetMode(); +s32 PS4_SYSV_ABI sceHmdInternalDfuStart(); +s32 PS4_SYSV_ABI sceHmdInternalEventInitialize(); +s32 PS4_SYSV_ABI sceHmdInternalGetBrightness(); +s32 PS4_SYSV_ABI sceHmdInternalGetCrashDumpInfo(); +s32 PS4_SYSV_ABI sceHmdInternalGetDebugMode(); +s32 PS4_SYSV_ABI sceHmdInternalGetDebugSocialScreenMode(); +s32 PS4_SYSV_ABI sceHmdInternalGetDebugTextMode(); +s32 PS4_SYSV_ABI sceHmdInternalGetDefaultLedData(); +s32 PS4_SYSV_ABI sceHmdInternalGetDemoMode(); +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceInformation(); +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceInformationByHandle(); +s32 PS4_SYSV_ABI sceHmdInternalGetDeviceStatus(); +s32 PS4_SYSV_ABI sceHmdInternalGetEyeStatus(); +s32 PS4_SYSV_ABI sceHmdInternalGetHmuOpticalParam(); +s32 PS4_SYSV_ABI sceHmdInternalGetHmuPowerStatusForDebug(); +s32 PS4_SYSV_ABI sceHmdInternalGetHmuSerialNumber(); +s32 PS4_SYSV_ABI sceHmdInternalGetIPD(); +s32 PS4_SYSV_ABI sceHmdInternalGetIpdSettingEnableForSystemService(); +s32 PS4_SYSV_ABI sceHmdInternalGetPuBuildNumber(); +s32 PS4_SYSV_ABI sceHmdInternalGetPuPositionParam(); +s32 PS4_SYSV_ABI sceHmdInternalGetPuRevision(); +s32 PS4_SYSV_ABI sceHmdInternalGetPUSerialNumber(); +s32 PS4_SYSV_ABI sceHmdInternalGetPUVersion(); +s32 PS4_SYSV_ABI sceHmdInternalGetRequiredPUPVersion(); +s32 PS4_SYSV_ABI sceHmdInternalGetStatusReport(); +s32 PS4_SYSV_ABI sceHmdInternalGetTv4kCapability(); +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplayDepth(); +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplayHeight(); +s32 PS4_SYSV_ABI sceHmdInternalGetVirtualDisplaySize(); +s32 PS4_SYSV_ABI sceHmdInternalGetVr2dData(); +s32 PS4_SYSV_ABI sceHmdInternalIsCommonDlgMiniAppVr2d(); +s32 PS4_SYSV_ABI sceHmdInternalIsCommonDlgVr2d(); +s32 PS4_SYSV_ABI sceHmdInternalIsGameVr2d(); +s32 PS4_SYSV_ABI sceHmdInternalIsMiniAppVr2d(); +s32 PS4_SYSV_ABI sceHmdInternalMapSharedMemory(); +s32 PS4_SYSV_ABI sceHmdInternalMirroringModeSetAspect(); +s32 PS4_SYSV_ABI sceHmdInternalMirroringModeSetAspectDebug(); +s32 PS4_SYSV_ABI sceHmdInternalMmapGetCount(); +s32 PS4_SYSV_ABI sceHmdInternalMmapGetModeId(); +s32 PS4_SYSV_ABI sceHmdInternalMmapGetSensorCalibrationData(); +s32 PS4_SYSV_ABI sceHmdInternalMmapIsConnect(); +s32 PS4_SYSV_ABI sceHmdInternalPushVr2dData(); +s32 PS4_SYSV_ABI sceHmdInternalRegisterEventCallback(); +s32 PS4_SYSV_ABI sceHmdInternalResetInertialSensor(); +s32 PS4_SYSV_ABI sceHmdInternalResetLedForVrTracker(); +s32 PS4_SYSV_ABI sceHmdInternalResetLedForVsh(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeClose(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeGetAudioStatus(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeGetVideoStatus(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeOpen(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeSendAudio(); +s32 PS4_SYSV_ABI sceHmdInternalSeparateModeSendVideo(); +s32 PS4_SYSV_ABI sceHmdInternalSetBrightness(); +s32 PS4_SYSV_ABI sceHmdInternalSetCrashReportCommand(); +s32 PS4_SYSV_ABI sceHmdInternalSetDebugGpo(); +s32 PS4_SYSV_ABI sceHmdInternalSetDebugMode(); +s32 PS4_SYSV_ABI sceHmdInternalSetDebugSocialScreenMode(); +s32 PS4_SYSV_ABI sceHmdInternalSetDebugTextMode(); +s32 PS4_SYSV_ABI sceHmdInternalSetDefaultLedData(); +s32 PS4_SYSV_ABI sceHmdInternalSetDemoMode(); +s32 PS4_SYSV_ABI sceHmdInternalSetDeviceConnection(); +s32 PS4_SYSV_ABI sceHmdInternalSetForcedCrash(); +s32 PS4_SYSV_ABI sceHmdInternalSetHmuPowerControl(); +s32 PS4_SYSV_ABI sceHmdInternalSetHmuPowerControlForDebug(); +s32 PS4_SYSV_ABI sceHmdInternalSetIPD(); +s32 PS4_SYSV_ABI sceHmdInternalSetIpdSettingEnableForSystemService(); +s32 PS4_SYSV_ABI sceHmdInternalSetLedOn(); +s32 PS4_SYSV_ABI sceHmdInternalSetM2LedBrightness(); +s32 PS4_SYSV_ABI sceHmdInternalSetM2LedOn(); +s32 PS4_SYSV_ABI sceHmdInternalSetPortConnection(); +s32 PS4_SYSV_ABI sceHmdInternalSetPortStatus(); +s32 PS4_SYSV_ABI sceHmdInternalSetS3dPassMode(); +s32 PS4_SYSV_ABI sceHmdInternalSetSidetone(); +s32 PS4_SYSV_ABI sceHmdInternalSetUserType(); +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplayDepth(); +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplayHeight(); +s32 PS4_SYSV_ABI sceHmdInternalSetVirtualDisplaySize(); +s32 PS4_SYSV_ABI sceHmdInternalSetVRMode(); +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenGetFadeState(); +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenSetFadeAndSwitch(); +s32 PS4_SYSV_ABI sceHmdInternalSocialScreenSetOutput(); +s32 PS4_SYSV_ABI sceHmdOpen(); +s32 PS4_SYSV_ABI sceHmdReprojectionAddDisplayBuffer(); +s32 PS4_SYSV_ABI sceHmdReprojectionClearUserEventEnd(); +s32 PS4_SYSV_ABI sceHmdReprojectionClearUserEventStart(); +s32 PS4_SYSV_ABI sceHmdReprojectionDebugGetLastInfo(); +s32 PS4_SYSV_ABI sceHmdReprojectionDebugGetLastInfoMultilayer(); +s32 PS4_SYSV_ABI sceHmdReprojectionFinalize(); +s32 PS4_SYSV_ABI sceHmdReprojectionFinalizeCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionInitialize(); +s32 PS4_SYSV_ABI sceHmdReprojectionInitializeCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionQueryGarlicBuffAlign(); +s32 PS4_SYSV_ABI sceHmdReprojectionQueryGarlicBuffSize(); +s32 PS4_SYSV_ABI sceHmdReprojectionQueryOnionBuffAlign(); +s32 PS4_SYSV_ABI sceHmdReprojectionQueryOnionBuffSize(); +s32 PS4_SYSV_ABI sceHmdReprojectionSetCallback(); +s32 PS4_SYSV_ABI sceHmdReprojectionSetDisplayBuffers(); +s32 PS4_SYSV_ABI sceHmdReprojectionSetOutputMinColor(); +s32 PS4_SYSV_ABI sceHmdReprojectionSetUserEventEnd(); +s32 PS4_SYSV_ABI sceHmdReprojectionSetUserEventStart(); +s32 PS4_SYSV_ABI sceHmdReprojectionStart(); +s32 PS4_SYSV_ABI sceHmdReprojectionStart2dVr(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartLiveCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer2(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartWideNear(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartWideNearWithOverlay(); +s32 PS4_SYSV_ABI sceHmdReprojectionStartWithOverlay(); +s32 PS4_SYSV_ABI sceHmdReprojectionStop(); +s32 PS4_SYSV_ABI sceHmdReprojectionStopCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionStopLiveCapture(); +s32 PS4_SYSV_ABI sceHmdReprojectionUnsetCallback(); +s32 PS4_SYSV_ABI sceHmdReprojectionUnsetDisplayBuffers(); +s32 PS4_SYSV_ABI sceHmdTerminate(); +s32 PS4_SYSV_ABI Func_202D0D1A687FCD2F(); +s32 PS4_SYSV_ABI Func_358DBF818A3D8A12(); +s32 PS4_SYSV_ABI Func_5CCBADA76FE8F40E(); +s32 PS4_SYSV_ABI Func_63D403167DC08CF0(); +s32 PS4_SYSV_ABI Func_69383B2B4E3AEABF(); +s32 PS4_SYSV_ABI Func_791560C32F4F6D68(); +s32 PS4_SYSV_ABI Func_7C955961EA85B6D3(); +s32 PS4_SYSV_ABI Func_9952277839236BA7(); +s32 PS4_SYSV_ABI Func_9A276E739E54EEAF(); +s32 PS4_SYSV_ABI Func_9E501994E289CBE7(); +s32 PS4_SYSV_ABI Func_A31A0320D80EAD99(); +s32 PS4_SYSV_ABI Func_A31F4DA8B3BD2E12(); +s32 PS4_SYSV_ABI Func_A92D7C23AC364993(); +s32 PS4_SYSV_ABI Func_ADCCC25CB876FDBE(); +s32 PS4_SYSV_ABI Func_B16652641FE69F0E(); +s32 PS4_SYSV_ABI Func_B614F290B67FB59B(); +s32 PS4_SYSV_ABI Func_B9A6FA0735EC7E49(); +s32 PS4_SYSV_ABI Func_FC193BD653F2AF2E(); +s32 PS4_SYSV_ABI Func_FF2E0E53015FE231(); + +void RegisterlibSceHmd(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::Hmd \ No newline at end of file diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp index 8cf286d13..074cf524e 100644 --- a/src/core/libraries/libs.cpp +++ b/src/core/libraries/libs.cpp @@ -11,6 +11,7 @@ #include "core/libraries/disc_map/disc_map.h" #include "core/libraries/game_live_streaming/gamelivestreaming.h" #include "core/libraries/gnmdriver/gnmdriver.h" +#include "core/libraries/hmd/hmd.h" #include "core/libraries/ime/error_dialog.h" #include "core/libraries/ime/ime.h" #include "core/libraries/ime/ime_dialog.h" @@ -113,6 +114,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) { Libraries::WebBrowserDialog::RegisterlibSceWebBrowserDialog(sym); Libraries::NpParty::RegisterlibSceNpParty(sym); Libraries::Zlib::RegisterlibSceZlib(sym); + Libraries::Hmd::RegisterlibSceHmd(sym); } } // namespace Libraries From 126cb824eaf914f798b8e9ab6b5bcd5d3e4e9bd1 Mon Sep 17 00:00:00 2001 From: Daniel Nylander Date: Wed, 5 Feb 2025 16:25:15 +0100 Subject: [PATCH 3/5] Updated Swedish translation (#2327) * Adding Swedish translation * Updated Swedish translation with additional strings Updated the Swedish translations using lupdate to found additional strings cd src/qt_gui/treanslations lupdate ../../../../shadPS4/ -tr-function-alias QT_TRANSLATE_NOOP+=TRANSLATE,QT_TRANSLATE_NOOP+=TRANSLATE_SV,QT_TRANSLATE_NOOP+=TRANSLATE_STR,QT_TRANSLATE_NOOP+=TRANSLATE_FS,QT_TRANSLATE_N_NOOP3+=TRANSLATE_FMT,QT_TRANSLATE_NOOP+=TRANSLATE_NOOP,translate+=TRANSLATE_PLURAL_STR,translate+=TRANSLATE_PLURAL_FS -no-obsolete -locations none -source-language en -ts sv.ts * Update sv.ts * Updated Swedish translation * Adding copyright boilerplate * Updated Swedish translation * Updated Swedish translation * Update sv.ts whitespace in boilerplate --- src/qt_gui/translations/sv.ts | 114 ++++++++++++++++++++++------------ 1 file changed, 73 insertions(+), 41 deletions(-) diff --git a/src/qt_gui/translations/sv.ts b/src/qt_gui/translations/sv.ts index deefa99d8..179064ef4 100644 --- a/src/qt_gui/translations/sv.ts +++ b/src/qt_gui/translations/sv.ts @@ -1,7 +1,7 @@ - AboutDialog @@ -210,7 +210,7 @@ Incompatibility Notice - Inkompatibilitetsmeddelande + Meddelande om inkompatibilitet Failed to open file: @@ -386,6 +386,30 @@ Unable to open compatibility.json for writing. Kunde inte öppna compatibility.json för skrivning. + + Unknown + Okänt + + + Nothing + Ingenting + + + Boots + Startar upp + + + Menus + Menyer + + + Ingame + Problem + + + Playable + Spelbart + ElfViewer @@ -756,7 +780,7 @@ Open shadPS4 Folder - Open shadPS4 Folder + Öppna shadPS4-mapp Exit @@ -788,7 +812,7 @@ Medium - Medel + Medelstora Large @@ -828,7 +852,7 @@ File - Arkiv + Fil View @@ -860,19 +884,19 @@ Dark - Mörk + Mörkt Light - Ljus + Ljust Green - Grön + Grönt Blue - Blå + Blått Violet @@ -880,7 +904,7 @@ toolBar - toolBar + Verktygsrad Game List @@ -1084,6 +1108,10 @@ Show Splash Visa startskärm + + ps4proCheckBox + Är PS4 Pro:\nGör att emulatorn agerar som en PS4 PRO, vilket kan aktivera speciella funktioner i spel som har stöd för det + Enable Discord Rich Presence Aktivera Discord Rich Presence @@ -1098,7 +1126,7 @@ Trophy - Trofé + Troféer Logger @@ -1122,15 +1150,15 @@ Cursor - Pekare + Muspekare Hide Cursor - Dölj pekare + Dölj muspekare Hide Cursor Idle Timeout - Dölj pekare vid overksam + Dölj muspekare vid overksam s @@ -1174,7 +1202,7 @@ Advanced - Avancerat + Avancerat Enable Shaders Dumping @@ -1222,23 +1250,23 @@ Enable Crash Diagnostics - Enable Crash Diagnostics + Aktivera kraschdiagnostik Collect Shaders - Collect Shaders + Samla shaders Copy GPU Buffers - Copy GPU Buffers + Kopiera GPU-buffertar Host Debug Markers - Host Debug Markers + Felsökningsmarkörer för värd Guest Debug Markers - Guest Debug Markers + Felsökningsmarkörer för gäst Update @@ -1262,7 +1290,7 @@ Title Music - Title Music + Titelmusik Disable Trophy Pop-ups @@ -1310,7 +1338,7 @@ Point your mouse at an option to display its description. - Peka din mus på ett alternativ för att visa dess beskrivning. + Flytta muspekaren till ett alternativ för att visa dess beskrivning. consoleLanguageGroupBox @@ -1465,25 +1493,25 @@ Aktivera RenderDoc-felsökning:\nOm aktiverad kommer emulatorn att tillhandahålla kompatibilitet med Renderdoc för att tillåta fångst och analys för aktuell renderad bildruta - collectShaderCheckBox - Collect Shaders:\nYou need this enabled to edit shaders with the debug menu (Ctrl + F10). - - - crashDiagnosticsCheckBox - Crash Diagnostics:\nCreates a .yaml file with info about the Vulkan state at the time of crashing.\nUseful for debugging 'Device lost' errors. If you have this enabled, you should enable Host AND Guest Debug Markers.\nDoes not work on Intel GPUs.\nYou need Vulkan Validation Layers enabled and the Vulkan SDK for this to work. - - - copyGPUBuffersCheckBox - Copy GPU Buffers:\nGets around race conditions involving GPU submits.\nMay or may not help with PM4 type 0 crashes. - - - hostMarkersCheckBox - Host Debug Markers:\nInserts emulator-side information like markers for specific AMDGPU commands around Vulkan commands, as well as giving resources debug names.\nIf you have this enabled, you should enable Crash Diagnostics.\nUseful for programs like RenderDoc. - - - guestMarkersCheckBox - Guest Debug Markers:\nInserts any debug markers the game itself has added to the command buffer.\nIf you have this enabled, you should enable Crash Diagnostics.\nUseful for programs like RenderDoc. - + collectShaderCheckBox + Samla shaders:\nDu behöver aktivera detta för att redigera shaders med felsökningsmenyn (Ctrl + F10) + + + crashDiagnosticsCheckBox + Krashdiagnostik:\nSkapar en .yaml-fil med information om Vulkan-tillståndet vid tid för kraschen.\nAnvändbart för felsökning av 'Device lost'-fel. Om du har aktiverat detta bör du aktivera felsökningsmarkörer för Värd OCH Gäst.\nFungerar inte på Intel GPUer.\nDu behöver aktivera Vulkan Validation Layers och Vulkan SDK för att detta ska fungera + + + copyGPUBuffersCheckBox + Kopiera GPU-buffertar:\nGör att man kan komma runt race conditions som involverar GPU submits.\nKan eller kan inte hjälpa med PM4 type 0-kraschar + + + hostMarkersCheckBox + Felsökningsmarkörer för värd:\nInfogar informationsliknande markörer i emulatorn för specifika AMDGPU-kommandon runt Vulkan-kommandon, så väl som ger resurser felsökningsnamn.\nOm du har detta aktiverat bör du aktivera Kraschdiagnostik.\nAnvändbart för program som RenderDoc + + + guestMarkersCheckBox + Felsökningsmarkörer för gäst:\nInfogar felsökningsmarkörer som själva spelet har lagt till i kommandobufferten.\nOm du har aktiverat detta bör du aktivera Kraschdiagnostik.\nAnvändbart för program som RenderDoc + Release Release @@ -1540,6 +1568,10 @@ browseButton Bläddra:\nBläddra efter en mapp att ställa in som sökväg för sparat data + + GUI + Gränssnitt + TrophyViewer From 00465d5e41a29ac0160d8d5400c071f2de7b4a12 Mon Sep 17 00:00:00 2001 From: SAN4EZDREAMS <126363936+SAN4EZDREAMS@users.noreply.github.com> Date: Wed, 5 Feb 2025 17:25:36 +0200 Subject: [PATCH 4/5] Updated uk_UA language to v0.6.1 (#2347) * Add Ukrainian localization * Fixed langIndexes * Fixed langIndexes_2 * Added uk_UA language support * Added uk_UA language support * Updated uk_UA localization to the latest version && corrected lexical mistakes * Added missing lines in the translation and minor edits * Correction * Second Correction * Added missed strings work test * Added more missed strings --------- Co-authored-by: SAN4EZDREAMS --- src/qt_gui/translations/uk_UA.ts | 332 ++++++++++++++++++++++--------- 1 file changed, 240 insertions(+), 92 deletions(-) diff --git a/src/qt_gui/translations/uk_UA.ts b/src/qt_gui/translations/uk_UA.ts index e80d363d3..3fb26546e 100644 --- a/src/qt_gui/translations/uk_UA.ts +++ b/src/qt_gui/translations/uk_UA.ts @@ -54,6 +54,14 @@ Select which directory you want to install to. Виберіть папку, до якої ви хочете встановити. + + Install All Queued to Selected Folder + Встановити все з черги до вибраної папки + + + Delete PKG File on Install + Видалити файл PKG під час встановлення + GameInstallDialog @@ -102,15 +110,19 @@ Open Game Folder - Відкрити папку з грою + Відкрити папку гри + + Open Update Folder + Відкрити папку оновлень + Open Save Data Folder - Відкрити Папку Збережених Даних + Відкрити папку збережень гри Open Log Folder - Відкрити Папку Логів + Відкрити папку логів Copy info... @@ -118,19 +130,27 @@ Copy Name - Копіювати Ім’я + Копіювати назву гри Copy Serial Копіювати серійний номер + + Copy Version + Копіювати версію + + + Copy Size + Копіювати розмір + Copy All Копіювати все Delete... - Видалення... + Видалити... Delete Game @@ -140,25 +160,29 @@ Delete Update Видалити оновлення + + Delete Save Data + Видалити збереження + Delete DLC Видалити DLC Compatibility... - Compatibility... + Сумісність... Update database - Update database + Оновити базу даних View report - View report + Переглянути звіт Submit a report - Submit a report + Створити звіт Shortcut creation @@ -182,7 +206,7 @@ Game - Ігри + гри requiresEnableSeparateUpdateFolder_MSG @@ -192,10 +216,22 @@ This game has no update to delete! Ця гра не має оновлень для видалення! + + This game has no update folder to open! + Ця гра не має папки оновленнь, щоб відкрити її! + Update Оновлення + + This game has no save data to delete! + Ця гра не містить збережень, які можна видалити! + + + Save Data + Збереження + This game has no DLC to delete! Ця гра не має DLC для видалення! @@ -206,11 +242,11 @@ Delete %1 - Видалити %1 + Видалення %1 Are you sure you want to delete %1's %2 directory? - Ви впевнені, що хочете видалити папку %1 з папки %2?? + Ви впевнені, що хочете видалити %1 з папки %2? @@ -229,7 +265,7 @@ Check for Updates - Перевити наявність оновлень + Перевірити наявність оновлень About shadPS4 @@ -249,7 +285,7 @@ Open shadPS4 Folder - Open shadPS4 Folder + Відкрити папку shadPS4 Exit @@ -297,15 +333,15 @@ Elf Viewer - Elf + Виконуваний файл Game Install Directory - Каталог встановлення гри + Каталоги встановлення ігор та оновлень Download Cheats/Patches - Завантажити Чити або Патчі + Завантажити Чити/Патчі Dump Game List @@ -329,7 +365,7 @@ Game List Icons - Розмір значків списку игр + Розмір значків списку ігор Game List Mode @@ -385,7 +421,7 @@ Download Cheats For All Installed Games - Завантажити чити для всіх встановлених ігор + Завантажити чити для усіх встановлених ігор Download Patches For All Games @@ -397,7 +433,7 @@ You have downloaded cheats for all the games you have installed. - Ви завантажили чити для всіх встановлених ігор. + Ви завантажили чити для усіх встановлених ігор. Patches Downloaded Successfully! @@ -417,7 +453,7 @@ ELF files (*.bin *.elf *.oelf) - Файл ELF (*.bin *.elf *.oelf) + Файли ELF (*.bin *.elf *.oelf) Game Boot @@ -429,7 +465,7 @@ PKG Extraction - Видобуток PKG + Розпакування PKG Patch detected! @@ -449,7 +485,7 @@ Game is installed: - Гра встановлена: + Встановлена гра: Would you like to install Patch: @@ -461,7 +497,7 @@ Would you like to install DLC: %1? - Ви бажаєте встановити DLC: %1?? + Ви бажаєте встановити DLC: %1? DLC already installed: @@ -481,11 +517,11 @@ Extracting PKG %1/%2 - Вилучення PKG %1/%2 + Витягування PKG %1/%2 Extraction Finished - Вилучення завершено + Розпакування завершено Game successfully installed at %1 @@ -542,8 +578,16 @@ Fullscreen Mode - Режим Повноекранний + Тип повноекранного режиму + + Borderless + Без рамок + + + True + Повний екран + Enable Separate Update Folder Увімкнути окрему папку оновлень @@ -554,7 +598,7 @@ Show Game Size In List - Показати розмір гри в списку + Показати розмір гри у списку Show Splash @@ -574,11 +618,11 @@ Trophy Key - Trophy Key + Ключ трофеїв Trophy - Trophy + Трофеї Logger @@ -588,6 +632,14 @@ Log Type Тип логів + + async + Асинхронний + + + sync + Синхронний + Log Filter Фільтр логів @@ -614,7 +666,7 @@ s - s + сек Controller @@ -622,14 +674,18 @@ Back Button Behavior - Поведінка кнопки назад + Перепризначення кнопки назад + + Enable Motion Controls + Увімкнути керування рухом + Graphics Графіка - Gui + GUI Інтерфейс @@ -660,6 +716,10 @@ Enable Shaders Dumping Увімкнути дамп шейдерів + + Auto Select + Автовибір + Enable NULL GPU Увімкнути NULL GPU @@ -678,8 +738,12 @@ Remove - Видалити + Вилучити + + Save Data Path + Шлях до файлів збережень + Debug Налагодження @@ -702,36 +766,45 @@ Enable Crash Diagnostics - Enable Crash Diagnostics + Увімкнути діагностику збоїв Collect Shaders - Collect Shaders + Збирати шейдери Copy GPU Buffers - Copy GPU Buffers + Копіювати буфери GPU Host Debug Markers - Host Debug Markers + Хостові маркери налагодження Guest Debug Markers - Guest Debug Markers + Гостьові маркери налагодження + Update Оновлення Check for Updates at Startup - Перевірка оновлень під час запуску + Перевіряти оновлення під час запуску Update Channel Канал оновлення + + Release + Релізний + + + Nightly + Тестовий + Check for Updates Перевірити оновлення @@ -742,31 +815,43 @@ Title Music - Title Music + Титульна музика Disable Trophy Pop-ups - Disable Trophy Pop-ups + Вимкнути спливаючі вікна трофеїв + + + Background Image + Фонове зображення + + + Show Background Image + Показувати фонове зображення + + + Opacity + Непрозорість Play title music - Програвати заголовну музику + Програвати титульну музику Update Compatibility Database On Startup - Update Compatibility Database On Startup + Оновлення даних ігрової сумісності під час запуску Game Compatibility - Game Compatibility + Сумісність з іграми Display Compatibility Data - Display Compatibility Data + Відображати данні ігрової сумістністі Update Compatibility Database - Update Compatibility Database + Оновити данні ігрової сумістності Volume @@ -774,7 +859,7 @@ Audio Backend - Audio Backend + Аудіосистема Save @@ -826,11 +911,11 @@ userName - Ім'я користувача:\nВстановіть ім'я користувача акаунта PS4. Це може відображатися в деяких іграх. + Ім'я користувача:\nВстановіть ім'я користувача акаунта PS4. Воно може відображатися в деяких іграх. TrophyKey - Trophy Key:\nKey used to decrypt trophies. Must be obtained from your jailbroken console.\nMust contain only hex characters. + Ключ трофеїв:\nКлюч для розшифровки трофеїв. Може бути отриманий зі зламаної консолі.\nПовинен містити лише шістнадцяткові символи. logTypeGroupBox @@ -842,19 +927,23 @@ updaterGroupBox - Оновлення:\nRelease: Офіційні версії, які випускаються щомісяця і можуть бути дуже старими, але вони більш надійні та перевірені.\nNightly: Версії для розробників, які мають усі найновіші функції та виправлення, але можуть містити помилки та є менш стабільними. + Оновлення:\nРелізний: Офіційні версії, які випускаються щомісяця і можуть бути дуже старими, але вони більш надійні та перевірені.\nТестовий: Версії для розробників, які мають усі найновіші функції та виправлення, але можуть містити помилки та є менш стабільними. + + + GUIBackgroundImageGroupBox + Фонове зображення:\nКерує непрозорістю фонового зображення гри. GUIMusicGroupBox - Грати заголовну музику:\nВмикає відтворення спеціальної музики під час вибору гри в списку, якщо вона це підтримує. + Грати титульну музику:\nВмикає відтворення спеціальної музики під час вибору гри в списку, якщо вона це підтримує. disableTrophycheckBox - Disable Trophy Pop-ups:\nDisable in-game trophy notifications. Trophy progress can still be tracked using the Trophy Viewer (right-click the game in the main window). + Вимкнути спливаючі вікна трофеїв:\nВимикає сповіщення про ігрові трофеї. Прогрес трофея все ще можна відстежувати за допомогою "Перегляд трофеїв" (клацніть правою кнопкою миші на грі у головному вікні). hideCursorGroupBox - Приховувати курсор:\nВиберіть, коли курсор зникне:\nНіколи: Ви завжди будете бачити мишу.\nПри бездіяльності: Встановіть час, через який курсор зникне в разі бездіяльності.\nЗавжди: Ви ніколи не будете бачити мишу. + Приховувати курсор:\nВиберіть, коли курсор зникатиме:\nНіколи: Курсор миші завжди буде видимий.\nПри бездіяльності: Встановіть час, через який курсор зникне в разі бездіяльності.\nЗавжди: Курсор миші завжди буде прихований. idleTimeoutGroupBox @@ -862,19 +951,19 @@ backButtonBehaviorGroupBox - Поведінка кнопки «Назад»:\nНалаштовує кнопку «Назад» контролера на емуляцію натискання на зазначену область на сенсорній панелі контролера PS4. + Перепризначення кнопки «Назад»:\nНалаштовує кнопку «Назад» контролера на емуляцію натискання на зазначену область на сенсорній панелі контролера PS4. enableCompatibilityCheckBox - Display Compatibility Data:\nDisplays game compatibility information in table view. Enable "Update Compatibility On Startup" to get up-to-date information. + Відображати данні ігрової сумістністі:\nВідображає інформацію про сумісність ігор у вигляді таблиці. Увімкніть "Оновлення даних ігрової сумісності під час запуску" для отримання актуальної інформації. checkCompatibilityOnStartupCheckBox - Update Compatibility On Startup:\nAutomatically update the compatibility database when shadPS4 starts. + Оновлення даних ігрової сумісності під час запуску:\nАвтоматично оновлює базу даних ігрової сумісності під час запуску shadPS4. updateCompatibilityButton - Update Compatibility Database:\nImmediately update the compatibility database. + Оновити данні ігрової сумістності:\nНегайно оновить базу даних ігрової сумісності. Never @@ -890,23 +979,23 @@ Touchpad Left - Тачпад ліворуч + Ліва сторона тачпаду Touchpad Right - Тачпад праворуч + Права сторона тачпаду Touchpad Center - Тачпад по центру + Середина тачпаду None - Ні + Без змін graphicsAdapterGroupBox - Графічний пристрій:\nУ системах із кількома GPU виберіть з випадаючого списку GPU, який буде використовувати емулятор,\nабо виберіть "Auto Select", щоб визначити його автоматично. + Графічний пристрій:\nУ системах із кількома GPU виберіть з випадаючого списку GPU, який буде використовувати емулятор,\nабо виберіть "Автовибір", щоб визначити його автоматично. resolutionLayout @@ -926,7 +1015,7 @@ gameFoldersBox - Ігрові папки:\nСписок папок для перевірки встановлених ігор. + Ігрові папки:\nСписок папок, що скануватимуться для виявлення ігор. addFolderButton @@ -934,7 +1023,7 @@ removeFolderButton - Видалити:\nВидалити папку зі списку. + Вилучити:\nВилучити папку зі списку. debugDump @@ -954,30 +1043,38 @@ collectShaderCheckBox - Collect Shaders:\nYou need this enabled to edit shaders with the debug menu (Ctrl + F10). + Збирати шейдери:\nВам потрібно увімкнути цю опцію, щоб редагувати шейдери за допомогою меню налагодження (Ctrl + F10). crashDiagnosticsCheckBox - Crash Diagnostics:\nCreates a .yaml file with info about the Vulkan state at the time of crashing.\nUseful for debugging 'Device lost' errors. If you have this enabled, you should enable Host AND Guest Debug Markers.\nDoes not work on Intel GPUs.\nYou need Vulkan Validation Layers enabled and the Vulkan SDK for this to work. + Діагностика збоїв:\nСтворює .yaml файл з інформацією про стан Vulkan на момент збою.\nКорисно для налагодження помилок 'Device lost'. Якщо у вас увімкнено цей параметр, вам слід увімкнути маркери налагодження Хоста ТА Гостя.\nНе працює на графічних процесорах Intel.\nДля цього вам потрібно увімкнути шари валідації Vulkan і мати Vulkan SDK. copyGPUBuffersCheckBox - Copy GPU Buffers:\nGets around race conditions involving GPU submits.\nMay or may not help with PM4 type 0 crashes. + Копіювати буфери GPU:\nДозволяє обійти проблеми синхронізації, пов'язані з відправленням даних на GPU\nМоже як допомогти, так і не вплинути на збої типу PM4 (тип 0). hostMarkersCheckBox - Host Debug Markers:\nInserts emulator-side information like markers for specific AMDGPU commands around Vulkan commands, as well as giving resources debug names.\nIf you have this enabled, you should enable Crash Diagnostics.\nUseful for programs like RenderDoc. + Хостові маркери налагодження:\nДодає інформацію емулятора, наприклад маркери для конкретних команд AMDGPU у Vulkan, також присвоює ресурсам налагоджувані назви.\nЯкщо ця опція увімкнена, рекомендується також активувати діагностику збоїв.\nКорисно для програм на кшталт RenderDoc. guestMarkersCheckBox - Guest Debug Markers:\nInserts any debug markers the game itself has added to the command buffer.\nIf you have this enabled, you should enable Crash Diagnostics.\nUseful for programs like RenderDoc. + Гостьові маркери налагодження:\nВставляє налагоджувані маркери, які сама гра додала до командного буфера.\nЯкщо ця опція увімкнена, рекомендується також активувати діагностику збоїв.\nКорисно для програм на кшталт RenderDoc. + + + saveDataBox + Шлях до файлів збережень:\nПапка, де будуть зберігатися ігрові збереження. + + + browseButton + Вибрати:\nВиберіть папку для ігрових збережень. CheatsPatches Cheats / Patches for - Cheats / Patches for + Чити та Патчі для defaultTextEdit_MSG @@ -1149,7 +1246,7 @@ The game is in version: %1 - Гра у версії: %1 + Версія гри: %1 The downloaded patch only works on version: %1 @@ -1189,7 +1286,7 @@ Name: - Ім'я: + Назва: Can't apply cheats before the game is started @@ -1212,7 +1309,7 @@ Compatibility - Compatibility + Сумісність Region @@ -1240,43 +1337,43 @@ Never Played - Never Played + Ніколи не запускалась h - h + год m - m + хв s - s + сек Compatibility is untested - Compatibility is untested + Сумісність не перевірена Game does not initialize properly / crashes the emulator - Game does not initialize properly / crashes the emulator + Гра не ініціалізується належним чином або спричиняє збій емулятора. Game boots, but only displays a blank screen - Game boots, but only displays a blank screen + Гра запускається, але відображає лише чорний екран. Game displays an image but does not go past the menu - Game displays an image but does not go past the menu + Гра відображає зображення, але не проходить далі меню. Game has game-breaking glitches or unplayable performance - Game has game-breaking glitches or unplayable performance + У грі є критичні баги або погана продуктивність Game can be completed with playable performance and no major glitches - Game can be completed with playable performance and no major glitches + Гру можна пройти з хорошою продуктивністю та без серйозних глюків. @@ -1303,7 +1400,7 @@ Invalid release data. - Неприпустимі дані релізу. + Некоректні дані про випуск. No download URL found for the specified asset. @@ -1311,7 +1408,7 @@ Your version is already up to date! - Вашу версію вже оновлено! + У вас актуальна версія! Update Available @@ -1386,23 +1483,74 @@ GameListUtils B - B + Б KB - KB + КБ MB - MB + GB - GB + ГБ TB - TB + ТБ - \ No newline at end of file + + CompatibilityInfoClass + + Fetching compatibility data, please wait + Отримання даних про сумісність. Будь ласка, зачекайте + + + Cancel + Відмінити + + + Loading... + Завантаження... + + + Error + Помилка + + + Unable to update compatibility data! Try again later. + Не вдалося оновити дані про сумісність! Спробуйте ще раз пізніше. + + + Unable to open compatibility.json for writing. + Не вдалося відкрити файл compatibility.json для запису. + + + Unknown + Невідомо + + + Nothing + Не працює + + + Boots + Запускається + + + Menus + У меню + + + Ingame + У грі + + + Playable + Іграбельно + + + From f5d64239cbc5afa89addc0caa281a50558661865 Mon Sep 17 00:00:00 2001 From: kalaposfos13 <153381648+kalaposfos13@users.noreply.github.com> Date: Wed, 5 Feb 2025 16:26:14 +0100 Subject: [PATCH 5/5] Add outer deadzone config (#2348) * Add outer deadzone * Documentation * Add max outer deadzone to the controller remapping GUI * Fix init values * fix GUI saving syntax --- src/common/config.cpp | 4 +- src/input/input_handler.cpp | 73 ++++++++++++++++++++++----------- src/qt_gui/control_settings.cpp | 4 +- src/qt_gui/kbm_help_dialog.h | 7 ++-- 4 files changed, 57 insertions(+), 31 deletions(-) diff --git a/src/common/config.cpp b/src/common/config.cpp index d9dfb861f..86e28285d 100644 --- a/src/common/config.cpp +++ b/src/common/config.cpp @@ -1008,8 +1008,8 @@ axis_right_x = axis_right_x axis_right_y = axis_right_y # Range of deadzones: 1 (almost none) to 127 (max) -analog_deadzone = leftjoystick, 2 -analog_deadzone = rightjoystick, 2 +analog_deadzone = leftjoystick, 2, 127 +analog_deadzone = rightjoystick, 2, 127 )"; } std::filesystem::path GetFoolproofKbmConfigFile(const std::string& game_id) { diff --git a/src/input/input_handler.cpp b/src/input/input_handler.cpp index 5394e4818..9c51ec8be 100644 --- a/src/input/input_handler.cpp +++ b/src/input/input_handler.cpp @@ -55,7 +55,8 @@ Don't be an idiot and test only the changed part expecting everything else to no */ bool leftjoystick_halfmode = false, rightjoystick_halfmode = false; -int leftjoystick_deadzone, rightjoystick_deadzone, lefttrigger_deadzone, righttrigger_deadzone; +std::pair leftjoystick_deadzone, rightjoystick_deadzone, lefttrigger_deadzone, + righttrigger_deadzone; std::list> pressed_keys; std::list toggled_keys; @@ -208,10 +209,10 @@ void ParseInputConfig(const std::string game_id = "") { float mouse_speed = 1; float mouse_speed_offset = 0.125; - leftjoystick_deadzone = 1; - rightjoystick_deadzone = 1; - lefttrigger_deadzone = 1; - righttrigger_deadzone = 1; + leftjoystick_deadzone = {1, 127}; + rightjoystick_deadzone = {1, 127}; + lefttrigger_deadzone = {1, 127}; + righttrigger_deadzone = {1, 127}; int lineCount = 0; @@ -298,26 +299,45 @@ void ParseInputConfig(const std::string game_id = "") { continue; } else if (output_string == "analog_deadzone") { std::stringstream ss(input_string); - std::string device; - int deadzone; - std::getline(ss, device, ','); - ss >> deadzone; - if (ss.fail()) { - LOG_WARNING(Input, "Failed to parse deadzone config from line: {}", line); + std::string device, inner_deadzone_str, outer_deadzone_str; + + if (!std::getline(ss, device, ',') || !std::getline(ss, inner_deadzone_str, ',') || + !std::getline(ss, outer_deadzone_str)) { + LOG_WARNING(Input, "Malformed deadzone config at line {}: \"{}\"", lineCount, line); continue; - } else { - LOG_DEBUG(Input, "Parsed deadzone: {} {}", device, deadzone); } - if (device == "leftjoystick") { - leftjoystick_deadzone = deadzone; - } else if (device == "rightjoystick") { - rightjoystick_deadzone = deadzone; - } else if (device == "l2") { - lefttrigger_deadzone = deadzone; - } else if (device == "r2") { - righttrigger_deadzone = deadzone; + + auto parseInt = [](const std::string& s) -> std::optional { + try { + return std::stoi(s); + } catch (...) { + return std::nullopt; + } + }; + + auto inner_deadzone = parseInt(inner_deadzone_str); + auto outer_deadzone = parseInt(outer_deadzone_str); + + if (!inner_deadzone || !outer_deadzone) { + LOG_WARNING(Input, "Invalid deadzone values at line {}: \"{}\"", lineCount, line); + continue; + } + + std::pair deadzone = {*inner_deadzone, *outer_deadzone}; + + static std::unordered_map&> deadzone_map = { + {"leftjoystick", leftjoystick_deadzone}, + {"rightjoystick", rightjoystick_deadzone}, + {"l2", lefttrigger_deadzone}, + {"r2", righttrigger_deadzone}, + }; + + if (auto it = deadzone_map.find(device); it != deadzone_map.end()) { + it->second = deadzone; + LOG_DEBUG(Input, "Parsed deadzone: {} {} {}", device, inner_deadzone_str, + outer_deadzone_str); } else { - LOG_WARNING(Input, "Invalid axis name at line: {}, data: \"{}\", skipping line.", + LOG_WARNING(Input, "Invalid axis name at line {}: \"{}\", skipping line.", lineCount, line); } continue; @@ -493,9 +513,14 @@ void ControllerOutput::FinalizeUpdate() { // avoid double-updating axes, but don't skip directional button bindings float multiplier = 1.0; int deadzone = 0; - auto ApplyDeadzone = [](s16* value, int deadzone) { - if (std::abs(*value) <= deadzone) { + auto ApplyDeadzone = [](s16* value, std::pair deadzone) { + if (std::abs(*value) <= deadzone.first || deadzone.first == deadzone.second) { *value = 0; + } else { + *value = (*value >= 0 ? 1 : -1) * + std::clamp((int)((128.0 * (std::abs(*value) - deadzone.first)) / + (float)(deadzone.second - deadzone.first)), + 0, 128); } }; Axis c_axis = GetAxisFromSDLAxis(axis); diff --git a/src/qt_gui/control_settings.cpp b/src/qt_gui/control_settings.cpp index 0374d2049..a07d36292 100644 --- a/src/qt_gui/control_settings.cpp +++ b/src/qt_gui/control_settings.cpp @@ -220,10 +220,10 @@ void ControlSettings::SaveControllerConfig(bool CloseOnSave) { lines.push_back("# Range of deadzones: 1 (almost none) to 127 (max)"); std::string deadzonevalue = std::to_string(ui->LeftDeadzoneSlider->value()); - lines.push_back("analog_deadzone = leftjoystick, " + deadzonevalue); + lines.push_back("analog_deadzone = leftjoystick, " + deadzonevalue + ", 127"); deadzonevalue = std::to_string(ui->RightDeadzoneSlider->value()); - lines.push_back("analog_deadzone = rightjoystick, " + deadzonevalue); + lines.push_back("analog_deadzone = rightjoystick, " + deadzonevalue + ", 127"); std::vector save; bool CurrentLineEmpty = false, LastLineEmpty = false; diff --git a/src/qt_gui/kbm_help_dialog.h b/src/qt_gui/kbm_help_dialog.h index c482d2b5c..3e39d4397 100644 --- a/src/qt_gui/kbm_help_dialog.h +++ b/src/qt_gui/kbm_help_dialog.h @@ -167,9 +167,10 @@ You can find these here, with detailed comments, examples and suggestions for mo You can make an input toggleable with this, for example: Let's say we want to be able to toggle l1 with t. You can then bind l1 to a key you won't use, like kpenter, then bind t to toggle that, so you will end up with this: l1 = kpenter; key_toggle = t, kpenter; -'analog_deadzone' = , ; - value goes from 1 to 127 (no deadzone to max deadzone) - devices: leftjoystick, rightjoystick, l2, r2 +'analog_deadzone' = , , ; + Values go from 1 to 127 (no deadzone to max deadzone), first is the inner, second is the outer deadzone + If you only want inner or outer deadzone, set the other to 1 or 127, respectively + Devices: leftjoystick, rightjoystick, l2, r2 )"; } }; \ No newline at end of file