mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-12-09 13:19:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Libraries: Improved libSceHmd stubs (#3442)

Browse Source 
* Initial work

* More work

* More stuff

* Update hmd.cpp

* Separate Reprojection and Distortion functions

Mainly doing this to clean up the code, since these sub-libraries are fairly self-contained.

* Fix weird Git issue

* Improve error documentation

After thorough decompilation, it seems clear that Sony didn't really put much thought into how libSceHmd behaves with no headset connected.

* Fix sceHmdGet2DEyeOffset

* Update hmd.cpp

* Add sceHmdInternalGetDeviceInformation and sceHmdInternalGetDeviceInformationByHandle

Based entirely off decompilation, these two functions are internally the cause of much of my trouble with this library.
They're also called by libSceVrTracker, but I don't think we'll be LLE'ing that anytime soon.

* Cleanup

* sceHmdGetAssyError

Struct isn't fully decompiled, but since it goes entirely unused when PSVR is disconnected, it doesn't matter too much.
I'm pretty certain it's 4 floats though, based on what I've decompiled of this function.

* More organization and fixes

* sceHmdGetInertialSensorData

Behavior should be fully accurate, but I've left the stub log since I haven't decompiled the parameters properly.
Also gave NID aTg7K0466r8 a proper name, based on what I've seen while decompiling. It behaves identically to sceHmdGetInertialSensorData, but with a slight difference in the params used for an internal function call.

* Update hmd.cpp

* Revert name change

* Organizational changes

These two functions modify internal variables used exclusively by reprojection functions.

* Remove internal device information calls

* Log PSVR-related attributes from param.sfo

Would mainly be helpful for compatibility list moderation, since these notices will be much more reliable for games that crash instantly.

* Remove unnecessary includes
This commit is contained in:
Stephen Miller
2025-08-21 17:49:05 -05:00
committed by GitHub
parent 630fba2822
commit 709a9ac0c8
8 changed files with 709 additions and 427 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -604,6 +604,8 @@ set(ZLIB_LIB src/core/libraries/zlib/zlib.cpp
)
set(VR_LIBS src/core/libraries/hmd/hmd.cpp
src/core/libraries/hmd/hmd_reprojection.cpp
src/core/libraries/hmd/hmd_distortion.cpp
src/core/libraries/hmd/hmd.h
)

1
src/common/elf_info.h
View File

@@ -85,6 +85,7 @@ public:
static constexpr u32 FW_45 = 0x4500000;
static constexpr u32 FW_50 = 0x5000000;
static constexpr u32 FW_55 = 0x5500000;
static constexpr u32 FW_60 = 0x6000000;
static constexpr u32 FW_80 = 0x8000000;
static ElfInfo& Instance() {

589
src/core/libraries/hmd/hmd.cpp
View File

@@ -1,135 +1,216 @@
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "common/elf_info.h"
#include "common/logging/log.h"
#include "core/libraries/error_codes.h"
#include "core/libraries/hmd/hmd.h"
#include "core/libraries/hmd/hmd_error.h"
#include "core/libraries/kernel/process.h"
#include "core/libraries/libs.h"
namespace Libraries::Hmd {
s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
static bool g_library_initialized = false;
static s32 g_firmware_version = 0;
static s32 g_internal_handle = 0;
static Libraries::UserService::OrbisUserServiceUserId g_user_id = -1;
s32 PS4_SYSV_ABI sceHmdInitialize(const OrbisHmdInitializeParam* param) {
if (g_library_initialized) {
return ORBIS_HMD_ERROR_ALREADY_INITIALIZED;
}
if (param == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
LOG_WARNING(Lib_Hmd, "PSVR headsets are not supported yet");
if (param->reserved0 != nullptr) {
sceHmdDistortionInitialize(param->reserved0);
}
g_library_initialized = true;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGet2dVrCommand() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
s32 PS4_SYSV_ABI sceHmdInitialize315(const OrbisHmdInitializeParam* param) {
if (g_library_initialized) {
return ORBIS_HMD_ERROR_ALREADY_INITIALIZED;
}
if (param == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
LOG_WARNING(Lib_Hmd, "PSVR headsets are not supported yet");
g_library_initialized = true;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetCompoundEyeCorrectionCommand() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
s32 PS4_SYSV_ABI sceHmdOpen(Libraries::UserService::OrbisUserServiceUserId user_id, s32 type,
s32 index, OrbisHmdOpenParam* param) {
LOG_DEBUG(Lib_Hmd, "called");
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
if (type != 0 || index != 0 || param != nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_INVALID;
}
if (g_internal_handle != 0) {
return ORBIS_HMD_ERROR_ALREADY_OPENED;
}
if (user_id == Libraries::UserService::ORBIS_USER_SERVICE_USER_ID_INVALID ||
user_id == Libraries::UserService::ORBIS_USER_SERVICE_USER_ID_SYSTEM) {
return ORBIS_HMD_ERROR_PARAMETER_INVALID;
}
// Return positive value representing handle
g_user_id = user_id;
g_internal_handle = 1;
return g_internal_handle;
}
s32 PS4_SYSV_ABI sceHmdGet2DEyeOffset(s32 handle, OrbisHmdEyeOffset* left_offset,
OrbisHmdEyeOffset* right_offset) {
LOG_DEBUG(Lib_Hmd, "called");
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (g_firmware_version >= Common::ElfInfo::FW_45) {
// Due to some faulty in-library checks, a missing headset results in this error
// instead of the expected ORBIS_HMD_ERROR_DEVICE_DISCONNECTED error.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (left_offset == nullptr || right_offset == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
// Return default values
left_offset->offset_x = -0.0315;
left_offset->offset_y = 0;
left_offset->offset_z = 0;
right_offset->offset_x = 0.0315;
right_offset->offset_y = 0;
right_offset->offset_z = 0;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetCorrectionCommand() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
s32 PS4_SYSV_ABI sceHmdGetAssyError(void* data) {
LOG_DEBUG(Lib_Hmd, "called");
if (data == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
return ORBIS_HMD_ERROR_DEVICE_DISCONNECTED;
}
s32 PS4_SYSV_ABI sceHmdGetDeviceInformation(OrbisHmdDeviceInformation* info) {
LOG_DEBUG(Lib_Hmd, "called");
if (info == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
memset(info, 0, sizeof(OrbisHmdDeviceInformation));
info->status = OrbisHmdDeviceStatus::ORBIS_HMD_DEVICE_STATUS_NOT_DETECTED;
info->user_id = g_user_id;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetWideNearCorrectionCommand() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
s32 PS4_SYSV_ABI sceHmdGetDeviceInformationByHandle(s32 handle, OrbisHmdDeviceInformation* info) {
LOG_DEBUG(Lib_Hmd, "called");
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (g_firmware_version >= Common::ElfInfo::FW_45) {
// Due to some faulty in-library checks, a missing headset results in this error
// instead of the expected ORBIS_HMD_ERROR_DEVICE_DISCONNECTED error.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (info == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
memset(info, 0, sizeof(OrbisHmdDeviceInformation));
info->status = OrbisHmdDeviceStatus::ORBIS_HMD_DEVICE_STATUS_NOT_DETECTED;
info->user_id = g_user_id;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemoryAlign() {
s32 PS4_SYSV_ABI sceHmdGetFieldOfView(s32 handle, OrbisHmdFieldOfView* field_of_view) {
LOG_DEBUG(Lib_Hmd, "called");
if (field_of_view == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (g_firmware_version >= Common::ElfInfo::FW_45) {
// Due to some faulty in-library checks, a missing headset results in this error
// instead of the expected ORBIS_HMD_ERROR_DEVICE_DISCONNECTED error.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
// These values are a hardcoded return when a headset is connected.
// Leaving this here for future developers.
// field_of_view->tan_out = 1.20743;
// field_of_view->tan_in = 1.181346;
// field_of_view->tan_top = 1.262872;
// field_of_view->tan_bottom = 1.262872;
// Fails internally due to some internal library checks that break without a connected headset.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
s32 PS4_SYSV_ABI sceHmdGetInertialSensorData(s32 handle, void* data, s32 unk) {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (g_firmware_version >= Common::ElfInfo::FW_45) {
// Due to some faulty in-library checks, a missing headset results in this error
// instead of the expected ORBIS_HMD_ERROR_DEVICE_DISCONNECTED error.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
return ORBIS_HMD_ERROR_DEVICE_DISCONNECTED;
}
s32 PS4_SYSV_ABI sceHmdClose(s32 handle) {
LOG_DEBUG(Lib_Hmd, "called");
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
g_internal_handle = 0;
g_user_id = -1;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemorySize() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
s32 PS4_SYSV_ABI sceHmdTerminate() {
LOG_DEBUG(Lib_Hmd, "called");
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
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");
sceHmdDistortionTerminate();
g_library_initialized = false;
return ORBIS_OK;
}
@@ -333,8 +414,13 @@ s32 PS4_SYSV_ABI sceHmdInternalGetDeviceInformationByHandle() {
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdInternalGetDeviceStatus() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
s32 PS4_SYSV_ABI sceHmdInternalGetDeviceStatus(OrbisHmdDeviceStatus* status) {
LOG_DEBUG(Lib_Hmd, "called");
if (status == nullptr) {
return ORBIS_HMD_ERROR_PARAMETER_NULL;
}
// Internal function fails with error DEVICE_DISCONNECTED
*status = OrbisHmdDeviceStatus::ORBIS_HMD_DEVICE_STATUS_NOT_DETECTED;
return ORBIS_OK;
}
@@ -479,8 +565,9 @@ s32 PS4_SYSV_ABI sceHmdInternalMmapGetSensorCalibrationData() {
}
s32 PS4_SYSV_ABI sceHmdInternalMmapIsConnect() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
LOG_DEBUG(Lib_Hmd, "called");
// Returns 0 when device is disconnected.
return 0;
}
s32 PS4_SYSV_ABI sceHmdInternalPushVr2dData() {
@@ -683,167 +770,6 @@ s32 PS4_SYSV_ABI sceHmdInternalSocialScreenSetOutput() {
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;
@@ -864,9 +790,21 @@ s32 PS4_SYSV_ABI Func_63D403167DC08CF0() {
return ORBIS_OK;
}
s32 PS4_SYSV_ABI Func_69383B2B4E3AEABF() {
s32 PS4_SYSV_ABI Func_69383B2B4E3AEABF(s32 handle, void* data, s32 unk) {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
if (handle != g_internal_handle) {
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
if (g_firmware_version >= Common::ElfInfo::FW_45) {
// Due to some faulty in-library checks, a missing headset results in this error
// instead of the expected ORBIS_HMD_ERROR_DEVICE_DISCONNECTED error.
return ORBIS_HMD_ERROR_HANDLE_INVALID;
}
return ORBIS_HMD_ERROR_DEVICE_DISCONNECTED;
}
s32 PS4_SYSV_ABI Func_791560C32F4F6D68() {
@@ -885,17 +823,12 @@ s32 PS4_SYSV_ABI Func_9952277839236BA7() {
}
s32 PS4_SYSV_ABI Func_9A276E739E54EEAF() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
// Stubbed on real hardware.
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");
// Stubbed on real hardware.
return ORBIS_OK;
}
@@ -910,7 +843,7 @@ s32 PS4_SYSV_ABI Func_A92D7C23AC364993() {
}
s32 PS4_SYSV_ABI Func_ADCCC25CB876FDBE() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
// Stubbed on real hardware.
return ORBIS_OK;
}
@@ -919,16 +852,6 @@ s32 PS4_SYSV_ABI Func_B16652641FE69F0E() {
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;
@@ -940,43 +863,15 @@ s32 PS4_SYSV_ABI Func_FF2E0E53015FE231() {
}
void RegisterLib(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);
Libraries::Kernel::sceKernelGetCompiledSdkVersion(&g_firmware_version);
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);
@@ -1044,6 +939,7 @@ void RegisterLib(Core::Loader::SymbolsResolver* sym) {
sceHmdInternalGetHmuPowerStatusForDebug);
LIB_FUNCTION("UhFPniZvm8U", "libSceHmd", 1, "libSceHmd", 1, 1,
sceHmdInternalGetHmuSerialNumber);
LIB_FUNCTION("aTg7K0466r8", "libSceHmd", 1, "libSceHmd", 1, 1, Func_69383B2B4E3AEABF);
LIB_FUNCTION("9exeDpk7JU8", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdInternalGetIPD);
LIB_FUNCTION("yNtYRsxZ6-A", "libSceHmd", 1, "libSceHmd", 1, 1,
sceHmdInternalGetIpdSettingEnableForSystemService);
@@ -1140,80 +1036,25 @@ void RegisterLib(Core::Loader::SymbolsResolver* sym) {
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);
RegisterDistortion(sym);
RegisterReprojection(sym);
};
} // namespace Libraries::Hmd

168
src/core/libraries/hmd/hmd.h
View File

@@ -4,6 +4,7 @@
#pragma once
#include "common/types.h"
#include "core/libraries/system/userservice.h"
namespace Core::Loader {
class SymbolsResolver;
@@ -11,31 +12,125 @@ class SymbolsResolver;
namespace Libraries::Hmd {
enum OrbisHmdDeviceStatus : u32 {
ORBIS_HMD_DEVICE_STATUS_READY,
ORBIS_HMD_DEVICE_STATUS_NOT_READY,
ORBIS_HMD_DEVICE_STATUS_NOT_DETECTED,
ORBIS_HMD_DEVICE_STATUS_NOT_READY_HMU_DISCONNECT,
};
struct OrbisHmdInitializeParam {
void* reserved0;
u8 reserved[8];
};
struct OrbisHmdOpenParam {
u8 reserve[32];
};
struct OrbisHmdFieldOfView {
float tan_out;
float tan_in;
float tan_top;
float tan_bottom;
};
struct OrbisHmdPanelResolution {
u32 width;
u32 height;
};
struct OrbisHmdFlipToDisplayLatency {
u16 refresh_rate_90hz;
u16 refresh_rate_120hz;
};
struct OrbisHmdDeviceInfo {
OrbisHmdPanelResolution panel_resolution;
OrbisHmdFlipToDisplayLatency flip_to_display_latency;
};
struct OrbisHmdDeviceInformation {
OrbisHmdDeviceStatus status;
Libraries::UserService::OrbisUserServiceUserId user_id;
u8 reserve0[4];
OrbisHmdDeviceInfo device_info;
u8 hmu_mount;
u8 reserve1[7];
};
struct OrbisHmdEyeOffset {
float offset_x;
float offset_y;
float offset_z;
u8 reserve[20];
};
// Reprojection
s32 PS4_SYSV_ABI sceHmdReprojectionStartMultilayer();
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();
// Distortion
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 sceHmdDistortionInitialize(void* reserved);
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 sceHmdDistortionTerminate();
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 Func_B26430EA74FC3DC0();
s32 PS4_SYSV_ABI Func_B614F290B67FB59B();
// libSceHmd
s32 PS4_SYSV_ABI sceHmdClose(s32 handle);
s32 PS4_SYSV_ABI sceHmdGet2DEyeOffset(s32 handle, OrbisHmdEyeOffset* left_offset,
OrbisHmdEyeOffset* right_offset);
s32 PS4_SYSV_ABI sceHmdGetAssyError(void* data);
s32 PS4_SYSV_ABI sceHmdGetDeviceInformation(OrbisHmdDeviceInformation* info);
s32 PS4_SYSV_ABI sceHmdGetDeviceInformationByHandle(s32 handle, OrbisHmdDeviceInformation* info);
s32 PS4_SYSV_ABI sceHmdGetFieldOfView(s32 handle, OrbisHmdFieldOfView* field_of_view);
s32 PS4_SYSV_ABI sceHmdGetInertialSensorData(s32 handle, void* data, s32 unk);
s32 PS4_SYSV_ABI sceHmdInitialize(const OrbisHmdInitializeParam* param);
s32 PS4_SYSV_ABI sceHmdInitialize315(const OrbisHmdInitializeParam* param);
s32 PS4_SYSV_ABI sceHmdOpen(Libraries::UserService::OrbisUserServiceUserId user_id, s32 type,
s32 index, OrbisHmdOpenParam* param);
s32 PS4_SYSV_ABI sceHmdTerminate();
// Internal
s32 PS4_SYSV_ABI sceHmdInternal3dAudioClose();
s32 PS4_SYSV_ABI sceHmdInternal3dAudioOpen();
s32 PS4_SYSV_ABI sceHmdInternal3dAudioSendData();
@@ -76,7 +171,7 @@ 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 sceHmdInternalGetDeviceStatus(OrbisHmdDeviceStatus* status);
s32 PS4_SYSV_ABI sceHmdInternalGetEyeStatus();
s32 PS4_SYSV_ABI sceHmdInternalGetHmuOpticalParam();
s32 PS4_SYSV_ABI sceHmdInternalGetHmuPowerStatusForDebug();
@@ -146,44 +241,12 @@ 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_69383B2B4E3AEABF(s32 handle, void* data, s32 unk);
s32 PS4_SYSV_ABI Func_791560C32F4F6D68();
s32 PS4_SYSV_ABI Func_7C955961EA85B6D3();
s32 PS4_SYSV_ABI Func_9952277839236BA7();
@@ -194,10 +257,11 @@ 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 RegisterDistortion(Core::Loader::SymbolsResolver* sym);
void RegisterReprojection(Core::Loader::SymbolsResolver* sym);
void RegisterLib(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Hmd

107
src/core/libraries/hmd/hmd_distortion.cpp Normal file
View File

@@ -0,0 +1,107 @@
// 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/hmd/hmd_error.h"
#include "core/libraries/libs.h"
namespace Libraries::Hmd {
static bool g_library_initialized = false;
s32 PS4_SYSV_ABI sceHmdDistortionInitialize(void* reserved) {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
g_library_initialized = true;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGet2dVrCommand() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetCompoundEyeCorrectionCommand() {
// Stubbed on real hardware.
return ORBIS_HMD_ERROR_PARAMETER_INVALID;
}
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() {
return 0x400;
}
s32 PS4_SYSV_ABI sceHmdDistortionGetWorkMemorySize() {
return 0x20000;
}
s32 PS4_SYSV_ABI sceHmdDistortionSetOutputMinColor() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI Func_B26430EA74FC3DC0() {
// Stubbed on real hardware.
return ORBIS_HMD_ERROR_PARAMETER_INVALID;
}
s32 PS4_SYSV_ABI sceHmdGetDistortionParams() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceHmdDistortionTerminate() {
// Internal (non-exported) library function for terminating the distortion sub-library.
if (!g_library_initialized) {
return ORBIS_HMD_ERROR_NOT_INITIALIZED;
}
g_library_initialized = false;
return ORBIS_OK;
}
s32 PS4_SYSV_ABI Func_B614F290B67FB59B() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
void RegisterDistortion(Core::Loader::SymbolsResolver* sym) {
LIB_FUNCTION("gEokC+OGI8g", "libSceHmdDistortion", 1, "libSceHmd", 1, 1,
sceHmdDistortionGet2dVrCommand);
LIB_FUNCTION("za4xJfzCBcM", "libSceHmd", 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("grCYks4m8Jw", "libSceHmd", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetCorrectionCommand);
LIB_FUNCTION("Vkkhy8RFIuk", "libSceHmdDistortion", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetWideNearCorrectionCommand);
LIB_FUNCTION("goi5ASvH-V8", "libSceHmd", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetWideNearCorrectionCommand);
LIB_FUNCTION("1cS7W5J-v3k", "libSceHmdDistortion", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetWorkMemoryAlign);
LIB_FUNCTION("8Ick-e6cDVY", "libSceHmd", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetWorkMemoryAlign);
LIB_FUNCTION("36xDKk+Hw7o", "libSceHmdDistortion", 1, "libSceHmd", 1, 1,
sceHmdDistortionGetWorkMemorySize);
LIB_FUNCTION("D5JfdpJKvXk", "libSceHmd", 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("mP2ZcYmDg-o", "libSceHmd", 1, "libSceHmd", 1, 1, sceHmdGetDistortionParams);
LIB_FUNCTION("smQw6nT8PcA", "libSceHmdDistortion", 1, "libSceHmd", 1, 1, Func_B26430EA74FC3DC0);
LIB_FUNCTION("thTykLZ-tZs", "libSceHmd", 1, "libSceHmd", 1, 1, Func_B614F290B67FB59B);
}
} // namespace Libraries::Hmd

27
src/core/libraries/hmd/hmd_error.h Normal file
View File

@@ -0,0 +1,27 @@
// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
constexpr int ORBIS_HMD_ERROR_ALREADY_INITIALIZED = 0x81110001;
constexpr int ORBIS_HMD_ERROR_NOT_INITIALIZED = 0x81110002;
constexpr int ORBIS_HMD_ERROR_HANDLE_INVALID = 0x81110003;
constexpr int ORBIS_HMD_ERROR_DEVICE_DISCONNECTED = 0x81110004;
constexpr int ORBIS_HMD_ERROR_WRONG_ID = 0x81110005;
constexpr int ORBIS_HMD_ERROR_ALREADY_OPENED = 0x81110006;
constexpr int ORBIS_HMD_ERROR_INSUFFICIENT_RESOURCE = 0x81110007;
constexpr int ORBIS_HMD_ERROR_PARAMETER_NULL = 0x81110008;
constexpr int ORBIS_HMD_ERROR_PARAMETER_INVALID = 0x81110009;
constexpr int ORBIS_HMD_ERROR_NO_2D_DISTORTION_MAP_MEMORY = 0x8111000A;
constexpr int ORBIS_HMD_ERROR_2D_DISTORTION_MAP_INITIALIZATION_ERROR = 0x8111000B;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_NOT_INITIALIZED = 0x8111000C;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_ALREADY_INITIALIZED = 0x8111000D;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_HMD_NOT_READY = 0x8111000E;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_NO_DISPLAY_BUFFER = 0x8111000F;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_WRONG_DISPLAY_BUFFER = 0x81110010;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_DISPLAY_BUFFER_BUSY = 0x81110011;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_RESOURCE_ALREADY_SET = 0x81110012;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_RESOURCE_NOT_SET = 0x81110013;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_THREAD_NOT_WORKING = 0x81110014;
constexpr int ORBIS_HMD_ERROR_REPROJECTION_NEVER_PROCESSED = 0x81110015;
constexpr int ORBIS_HMD_ERROR_UNSUPPORTED_FEATURE = 0x81110016;

238
src/core/libraries/hmd/hmd_reprojection.cpp Normal file
View File

@@ -0,0 +1,238 @@
// 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/hmd/hmd_error.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 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 Func_A31A0320D80EAD99() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI Func_B9A6FA0735EC7E49() {
LOG_ERROR(Lib_Hmd, "(STUBBED) called");
return ORBIS_OK;
}
void RegisterReprojection(Core::Loader::SymbolsResolver* sym) {
LIB_FUNCTION("8gH1aLgty5I", "libsceHmdReprojectionMultilayer", 1, "libSceHmd", 1, 1,
sceHmdReprojectionStartMultilayer);
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("oxoDINgOrZk", "libSceHmd", 1, "libSceHmd", 1, 1, Func_A31A0320D80EAD99);
LIB_FUNCTION("uab6BzXsfkk", "libSceHmd", 1, "libSceHmd", 1, 1, Func_B9A6FA0735EC7E49);
}
} // namespace Libraries::Hmd

2
src/emulator.cpp
View File

@@ -166,6 +166,8 @@ void Emulator::Run(std::filesystem::path file, const std::vector<std::string> ar
if (param_sfo_exists) {
LOG_INFO(Loader, "Game id: {} Title: {}", id, title);
LOG_INFO(Loader, "Fw: {:#x} App Version: {}", fw_version, app_version);
LOG_INFO(Loader, "PSVR Supported: {}", (bool)psf_attributes.support_ps_vr.Value());
LOG_INFO(Loader, "PSVR Required: {}", (bool)psf_attributes.require_ps_vr.Value());
}
if (!args.empty()) {
const auto argc = std::min<size_t>(args.size(), 32);