diff --git a/CMakeLists.txt b/CMakeLists.txt index 050490c8d..92a30808c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -609,6 +609,8 @@ set(VR_LIBS src/core/libraries/hmd/hmd.cpp src/core/libraries/hmd/hmd.h src/core/libraries/hmd/hmd_setup_dialog.cpp src/core/libraries/hmd/hmd_setup_dialog.h + src/core/libraries/vr_tracker/vr_tracker.cpp + src/core/libraries/vr_tracker/vr_tracker.h ) set(MISC_LIBS src/core/libraries/screenshot/screenshot.cpp diff --git a/src/common/logging/filter.cpp b/src/common/logging/filter.cpp index 8d6e7eab9..49c1b401a 100644 --- a/src/common/logging/filter.cpp +++ b/src/common/logging/filter.cpp @@ -145,6 +145,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) { SUB(Lib, CompanionHttpd) \ SUB(Lib, CompanionUtil) \ SUB(Lib, Voice) \ + SUB(Lib, VrTracker) \ CLS(Frontend) \ CLS(Render) \ SUB(Render, Vulkan) \ diff --git a/src/common/logging/types.h b/src/common/logging/types.h index f672793ea..e173dc67f 100644 --- a/src/common/logging/types.h +++ b/src/common/logging/types.h @@ -112,6 +112,7 @@ enum class Class : u8 { Lib_Camera, ///< The LibCamera implementation. Lib_CompanionHttpd, ///< The LibCompanionHttpd implementation. Lib_CompanionUtil, ///< The LibCompanionUtil implementation. + Lib_VrTracker, ///< The LibSceVrTracker 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 index 17c88370d..c494d89e0 100644 --- a/src/core/libraries/hmd/hmd.cpp +++ b/src/core/libraries/hmd/hmd.cpp @@ -60,9 +60,10 @@ s32 PS4_SYSV_ABI sceHmdOpen(Libraries::UserService::OrbisUserServiceUserId user_ return ORBIS_HMD_ERROR_PARAMETER_INVALID; } - // Return positive value representing handle + // Return positive value representing handle. + // Internal libSceVrTracker logic requires this handle to be different from other devices. g_user_id = user_id; - g_internal_handle = 1; + g_internal_handle = 0xf000000; return g_internal_handle; } diff --git a/src/core/libraries/libs.cpp b/src/core/libraries/libs.cpp index 0e38b9d58..422b8e351 100644 --- a/src/core/libraries/libs.cpp +++ b/src/core/libraries/libs.cpp @@ -64,6 +64,7 @@ #include "core/libraries/videodec/videodec2.h" #include "core/libraries/videoout/video_out.h" #include "core/libraries/voice/voice.h" +#include "core/libraries/vr_tracker/vr_tracker.h" #include "core/libraries/web_browser_dialog/webbrowserdialog.h" #include "core/libraries/zlib/zlib_sce.h" #include "fiber/fiber.h" @@ -137,6 +138,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) { Libraries::CompanionUtil::RegisterLib(sym); Libraries::Voice::RegisterLib(sym); Libraries::Rtc::RegisterLib(sym); + Libraries::VrTracker::RegisterLib(sym); } } // namespace Libraries diff --git a/src/core/libraries/move/move.cpp b/src/core/libraries/move/move.cpp index 7d3062e7c..4f71eb421 100644 --- a/src/core/libraries/move/move.cpp +++ b/src/core/libraries/move/move.cpp @@ -28,8 +28,9 @@ s32 PS4_SYSV_ABI sceMoveOpen(Libraries::UserService::OrbisUserServiceUserId user return ORBIS_MOVE_ERROR_NOT_INIT; } // Even when no controllers are connected, this returns a proper handle. - static s32 handle = 1; - return handle++; + // Internal libSceVrTracker logic requires this handle to be different from other devices. + static s32 handle = 0x30b0000; + return handle += 0x100; } s32 PS4_SYSV_ABI sceMoveGetDeviceInfo(s32 handle, OrbisMoveDeviceInfo* info) { diff --git a/src/core/libraries/vr_tracker/vr_tracker.cpp b/src/core/libraries/vr_tracker/vr_tracker.cpp new file mode 100644 index 000000000..0c999d28c --- /dev/null +++ b/src/core/libraries/vr_tracker/vr_tracker.cpp @@ -0,0 +1,632 @@ +// SPDX-FileCopyrightText: Copyright 2025 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/kernel/time.h" +#include "core/libraries/libs.h" +#include "core/libraries/vr_tracker/vr_tracker.h" +#include "core/libraries/vr_tracker/vr_tracker_error.h" +#include "core/memory.h" +#include "video_core/amdgpu/liverpool.h" + +namespace Libraries::VrTracker { + +static bool g_library_initialized = false; + +// Internal memory +static void* g_garlic_memory_pointer = nullptr; +static u32 g_garlic_size = 0; +static void* g_onion_memory_pointer = nullptr; +static u32 g_onion_size = 0; +static void* g_work_memory_pointer = nullptr; +static u32 g_work_size = 0; + +// Registered handles +static s32 g_pad_handle = -1; +static s32 g_move_handle = -1; +static s32 g_gun_handle = -1; +static s32 g_hmd_handle = -1; + +s32 PS4_SYSV_ABI sceVrTrackerQueryMemory(const OrbisVrTrackerQueryMemoryParam* param, + OrbisVrTrackerQueryMemoryResult* result) { + LOG_DEBUG(Lib_VrTracker, "called"); + if (param == nullptr || result == nullptr || + param->size != sizeof(OrbisVrTrackerQueryMemoryParam) || + (param->profile != OrbisVrTrackerProfile::ORBIS_VR_TRACKER_PROFILE_000 && + param->profile != OrbisVrTrackerProfile::ORBIS_VR_TRACKER_PROFILE_100) || + param->calibration_settings.pad_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO || + // Hmd doesn't support auto calibration + param->calibration_settings.hmd_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_MANUAL || + param->calibration_settings.move_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO || + param->calibration_settings.gun_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + // Setting move_position to ORBIS_VR_TRACKER_CALIBRATION_AUTO doubles required onion memory. + u32 required_onion_size = ORBIS_VR_TRACKER_BASE_ONION_SIZE; + if (param->calibration_settings.move_position == + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO) { + required_onion_size *= 2; + } + + result->direct_memory_onion_size = required_onion_size; + result->direct_memory_onion_alignment = ORBIS_VR_TRACKER_MEMORY_ALIGNMENT; + result->direct_memory_garlic_size = ORBIS_VR_TRACKER_GARLIC_SIZE; + result->direct_memory_garlic_alignment = ORBIS_VR_TRACKER_MEMORY_ALIGNMENT; + result->work_memory_size = ORBIS_VR_TRACKER_WORK_SIZE; + result->work_memory_alignment = ORBIS_VR_TRACKER_MEMORY_ALIGNMENT; + + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerInit(const OrbisVrTrackerInitParam* param) { + if (g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_ALREADY_INITIALIZED; + } + + // Calculate correct onion size for parameter checks + u32 required_onion_size = ORBIS_VR_TRACKER_BASE_ONION_SIZE; + if (param->calibration_settings.move_position == ORBIS_VR_TRACKER_CALIBRATION_AUTO) { + required_onion_size *= 2; + } + + // Parameter checks are fairly thorough here. + if (param->size != sizeof(OrbisVrTrackerInitParam) || + // Check garlic memory parameters + param->direct_memory_garlic == nullptr || + param->direct_memory_garlic_alignment != ORBIS_VR_TRACKER_MEMORY_ALIGNMENT || + param->direct_memory_garlic_size != ORBIS_VR_TRACKER_GARLIC_SIZE || + // Check onion memory parameters + param->direct_memory_onion == nullptr || + param->direct_memory_onion_alignment != ORBIS_VR_TRACKER_MEMORY_ALIGNMENT || + param->direct_memory_onion_size != required_onion_size || + // Check work memory parameters + param->work_memory == nullptr || + param->work_memory_alignment != ORBIS_VR_TRACKER_MEMORY_ALIGNMENT || + param->work_memory_size != ORBIS_VR_TRACKER_WORK_SIZE || + // Check compute queue parameters + param->gpu_pipe_id >= AmdGpu::Liverpool::NumComputePipes || + param->gpu_queue_id >= AmdGpu::Liverpool::NumQueuesPerPipe || + // Check calibration settings + param->calibration_settings.pad_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO || + param->calibration_settings.hmd_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_MANUAL || + param->calibration_settings.move_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO || + param->calibration_settings.gun_position > + OrbisVrTrackerCalibrationMode::ORBIS_VR_TRACKER_CALIBRATION_AUTO) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + // Real hardware will segfault if any of the supplied mappings aren't long enough, + // Validate each of them to ensure nothing weird can occur when this library is implemented. + auto* memory = Core::Memory::Instance(); + Libraries::Kernel::OrbisVirtualQueryInfo info; + // The memory type for the whole range should be the same here, + // so the memory should be contained in one VMA. + VAddr addr_to_check = std::bit_cast(param->direct_memory_garlic); + s32 result = memory->VirtualQuery(addr_to_check, 0, &info); + ASSERT_MSG(result == 0 && info.end - addr_to_check >= param->direct_memory_garlic_size, + "Insufficient garlic memory provided"); + + g_garlic_memory_pointer = param->direct_memory_garlic; + g_garlic_size = param->direct_memory_garlic_size; + + addr_to_check = std::bit_cast(param->direct_memory_onion); + result = memory->VirtualQuery(addr_to_check, 0, &info); + ASSERT_MSG(result == 0 && info.end - addr_to_check >= param->direct_memory_onion_size, + "Insufficient onion memory provided"); + + g_onion_memory_pointer = param->direct_memory_onion; + g_onion_size = param->direct_memory_onion_size; + + addr_to_check = std::bit_cast(param->work_memory); + result = memory->VirtualQuery(addr_to_check, 0, &info); + ASSERT_MSG(result == 0 && info.end - addr_to_check >= param->work_memory_size, + "Insufficient work memory provided"); + + g_work_memory_pointer = param->work_memory; + g_work_size = param->work_memory_size; + + // All initialization checks passed. + LOG_WARNING(Lib_VrTracker, "PSVR headsets are not supported yet"); + g_library_initialized = true; + + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerRegisterDevice(const OrbisVrTrackerDeviceType device_type, + const s32 handle) { + LOG_TRACE(Lib_VrTracker, "redirected to sceVrTrackerRegisterDeviceInternal"); + return sceVrTrackerRegisterDeviceInternal(device_type, handle, -1, 0); +} + +s32 PS4_SYSV_ABI sceVrTrackerRegisterDevice2(const OrbisVrTrackerDeviceType device_type, + const s32 handle) { + LOG_TRACE(Lib_VrTracker, "redirected to sceVrTrackerRegisterDeviceInternal"); + return sceVrTrackerRegisterDeviceInternal(device_type, handle, -1, 1); +} + +s32 PS4_SYSV_ABI sceVrTrackerRegisterDeviceInternal(const OrbisVrTrackerDeviceType device_type, + const s32 handle, s32 unk0, s32 unk1) { + LOG_WARNING(Lib_VrTracker, "(STUBBED) called, device_type = {}, handle = {}", + static_cast(device_type), handle); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (device_type > OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_GUN || unk0 > 4) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + // Ignore handle handle validation for now, since most of that logic isn't really handled. + switch (device_type) { + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_HMD: { + if (g_hmd_handle != -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_ALREADY_REGISTERED; + } + g_hmd_handle = handle; + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_DUALSHOCK4: { + if (g_pad_handle != -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_ALREADY_REGISTERED; + } + g_pad_handle = handle; + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_MOVE: { + if (g_move_handle != -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_ALREADY_REGISTERED; + } + g_move_handle = handle; + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_GUN: { + if (g_gun_handle != -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_ALREADY_REGISTERED; + } + g_gun_handle = handle; + break; + } + default: { + // Shouldn't be possible to hit this. + UNREACHABLE(); + } + } + + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerCpuProcess(const OrbisVrTrackerCpuProcessParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerGetPlayAreaWarningInfo(OrbisVrTrackerPlayAreaWarningInfo* info) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerGetResult(const OrbisVrTrackerGetResultParam* param, + OrbisVrTrackerResultData* result) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerGetTime(u64* time) { + LOG_TRACE(Lib_VrTracker, "called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (time == nullptr) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + *time = Libraries::Kernel::sceKernelGetProcessTime(); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerGpuSubmit(const OrbisVrTrackerGpuSubmitParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + + // Impossible to submit valid data here since sceCameraGetFrameData returns an error. + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; +} + +s32 PS4_SYSV_ABI sceVrTrackerGpuWait(const OrbisVrTrackerGpuWaitParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (param == nullptr || param->size != sizeof(OrbisVrTrackerGpuWaitParam)) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + // Impossible to perform GPU submits + return ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_GPU_SUBMIT; +} + +s32 PS4_SYSV_ABI sceVrTrackerGpuWaitAndCpuProcess() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + + // Impossible to perform GPU submits + return ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_GPU_SUBMIT; +} + +s32 PS4_SYSV_ABI +sceVrTrackerNotifyEndOfCpuProcess(const OrbisVrTrackerNotifyEndOfCpuProcessParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerRecalibrate(const OrbisVrTrackerRecalibrateParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (param == nullptr || param->size != sizeof(OrbisVrTrackerRecalibrateParam) || + param->device_type > OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_GUN) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + OrbisVrTrackerDeviceType device_type = param->device_type; + switch (device_type) { + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_HMD: { + // Seems like the lack of a connected hmd results in this? + return ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_REGISTERED; + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_DUALSHOCK4: { + if (g_pad_handle == -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_REGISTERED; + } + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_MOVE: { + if (g_move_handle == -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_REGISTERED; + } + break; + } + case OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_GUN: { + if (g_gun_handle == -1) { + return ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_REGISTERED; + } + break; + } + default: { + // Shouldn't be possible to hit this. + UNREACHABLE(); + } + } + + // TODO: handle internal recalibration behaviors. + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerResetAll() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerResetOrientationRelative(const OrbisVrTrackerDeviceType device_type, + const s32 handle) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSaveInternalBuffers() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSetDurationUntilStatusNotTracking( + const OrbisVrTrackerDeviceType device_type, const u32 duration_camera_frames) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (device_type > OrbisVrTrackerDeviceType::ORBIS_VR_TRACKER_DEVICE_GUN) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + // Seems to unconditionally return 0 when parameters are valid. + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSetExtendedMode() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSetLEDBrightness() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSetRestingMode() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI +sceVrTrackerUpdateMotionSensorData(const OrbisVrTrackerUpdateMotionSensorDataParam* param) { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_0FA4C949F8D3024E() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_285C6AFC09C42F7E() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_9A6CDB2103664F8A() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_B4D26B7D8B18DF06() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerSetDeviceRejection() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_1119B0BE399F37E7() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_4928B43816BC440D() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_863EF32EFCB0FA9C() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_E6E726CBC85C48F9() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI Func_F6407E46C66DF383() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerCpuPopMarker() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerCpuPushMarker() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerGetLiveCaptureId() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerStartLiveCapture() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerStopLiveCapture() { + LOG_ERROR(Lib_VrTracker, "(STUBBED) called"); + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerUnregisterDevice(const s32 handle) { + LOG_DEBUG(Lib_VrTracker, "called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + if (handle < 0) { + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + // Since this function only takes a handle, compare the handle to registered handles. + if (handle == g_hmd_handle) { + g_hmd_handle = -1; + } else if (handle == g_pad_handle) { + g_pad_handle = -1; + } else if (handle == g_move_handle) { + g_move_handle = -1; + } else if (handle == g_gun_handle) { + g_gun_handle = -1; + } else { + // If none of the handles match up, then return an error. + return ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID; + } + + return ORBIS_OK; +} + +s32 PS4_SYSV_ABI sceVrTrackerTerm() { + LOG_DEBUG(Lib_VrTracker, "called"); + if (!g_library_initialized) { + return ORBIS_VR_TRACKER_ERROR_NOT_INIT; + } + g_library_initialized = false; + return ORBIS_OK; +} + +void RegisterLib(Core::Loader::SymbolsResolver* sym) { + // OpenOrbis Toolchain seems to link with module version 1,1 while actual games use 0,0 + LIB_FUNCTION("24kDA+A0Ox0", "libSceVrTrackerFourDeviceAllowed", 1, "libSceVrTracker", 1, 1, + sceVrTrackerRegisterDevice2); + LIB_FUNCTION("5IFOAYv-62g", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerCpuProcess); + LIB_FUNCTION("zvyKP0Z3UvU", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerGetPlayAreaWarningInfo); + LIB_FUNCTION("76OBvrrQXUc", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerGetResult); + LIB_FUNCTION("XoeWzXlrnMw", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, sceVrTrackerGetTime); + LIB_FUNCTION("TVegDMLaBB8", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerGpuSubmit); + LIB_FUNCTION("gkGuO9dd57M", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, sceVrTrackerGpuWait); + LIB_FUNCTION("ARhgpXvwoR0", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerGpuWaitAndCpuProcess); + LIB_FUNCTION("QkRl7pART9M", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, sceVrTrackerInit); + LIB_FUNCTION("VItTwN8DmS8", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerNotifyEndOfCpuProcess); + LIB_FUNCTION("K7yhYrsIBPc", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerQueryMemory); + LIB_FUNCTION("EUCaQtXXYNI", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerRecalibrate); + LIB_FUNCTION("sIh8GwcevaQ", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerRegisterDevice); + LIB_FUNCTION("ufexf4aNiwg", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerRegisterDeviceInternal); + LIB_FUNCTION("CtWUbFgmq+I", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerResetAll); + LIB_FUNCTION("E0P0sN-wy+4", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerResetOrientationRelative); + LIB_FUNCTION("bDGZVTwwZ1A", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSaveInternalBuffers); + LIB_FUNCTION("qBjnR0HtMYI", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSetDurationUntilStatusNotTracking); + LIB_FUNCTION("NhPkY3V8E+8", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSetExtendedMode); + LIB_FUNCTION("vpsLLotiSUg", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSetLEDBrightness); + LIB_FUNCTION("lgWSHQ8p4i4", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSetRestingMode); + LIB_FUNCTION("IBv4P3q1pQ0", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, sceVrTrackerTerm); + LIB_FUNCTION("Q8skQqEwn5c", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerUnregisterDevice); + LIB_FUNCTION("9fvHMUbsom4", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + sceVrTrackerUpdateMotionSensorData); + LIB_FUNCTION("D6TJSfjTAk4", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + Func_0FA4C949F8D3024E); + LIB_FUNCTION("KFxq-AnEL34", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + Func_285C6AFC09C42F7E); + LIB_FUNCTION("mmzbIQNmT4o", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + Func_9A6CDB2103664F8A); + LIB_FUNCTION("tNJrfYsY3wY", "libSceVrTracker", 1, "libSceVrTracker", 1, 1, + Func_B4D26B7D8B18DF06); + LIB_FUNCTION("jGqEkPy0iLU", "libSceVrTrackerDeviceRejection", 1, "libSceVrTracker", 1, 1, + sceVrTrackerSetDeviceRejection); + LIB_FUNCTION("ERmwvjmfN+c", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 1, 1, + Func_1119B0BE399F37E7); + LIB_FUNCTION("SSi0OBa8RA0", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 1, 1, + Func_4928B43816BC440D); + LIB_FUNCTION("hj7zLvyw+pw", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 1, 1, + Func_863EF32EFCB0FA9C); + LIB_FUNCTION("5ucmy8hcSPk", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 1, 1, + Func_E6E726CBC85C48F9); + LIB_FUNCTION("9kB+RsZt84M", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 1, 1, + Func_F6407E46C66DF383); + LIB_FUNCTION("sBkAqyF5Gns", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 1, 1, + sceVrTrackerCpuPopMarker); + LIB_FUNCTION("rvCywCbc7Pk", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 1, 1, + sceVrTrackerCpuPushMarker); + LIB_FUNCTION("lm6T1Ur6JRk", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 1, 1, + sceVrTrackerGetLiveCaptureId); + LIB_FUNCTION("qa1+CeXKDPc", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 1, 1, + sceVrTrackerStartLiveCapture); + LIB_FUNCTION("3YCwwpHkHIg", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 1, 1, + sceVrTrackerStopLiveCapture); + + // For proper games + LIB_FUNCTION("24kDA+A0Ox0", "libSceVrTrackerFourDeviceAllowed", 1, "libSceVrTracker", 0, 0, + sceVrTrackerRegisterDevice2); + LIB_FUNCTION("5IFOAYv-62g", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerCpuProcess); + LIB_FUNCTION("zvyKP0Z3UvU", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerGetPlayAreaWarningInfo); + LIB_FUNCTION("76OBvrrQXUc", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerGetResult); + LIB_FUNCTION("XoeWzXlrnMw", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, sceVrTrackerGetTime); + LIB_FUNCTION("TVegDMLaBB8", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerGpuSubmit); + LIB_FUNCTION("gkGuO9dd57M", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, sceVrTrackerGpuWait); + LIB_FUNCTION("ARhgpXvwoR0", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerGpuWaitAndCpuProcess); + LIB_FUNCTION("QkRl7pART9M", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, sceVrTrackerInit); + LIB_FUNCTION("VItTwN8DmS8", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerNotifyEndOfCpuProcess); + LIB_FUNCTION("K7yhYrsIBPc", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerQueryMemory); + LIB_FUNCTION("EUCaQtXXYNI", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerRecalibrate); + LIB_FUNCTION("sIh8GwcevaQ", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerRegisterDevice); + LIB_FUNCTION("ufexf4aNiwg", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerRegisterDeviceInternal); + LIB_FUNCTION("CtWUbFgmq+I", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerResetAll); + LIB_FUNCTION("E0P0sN-wy+4", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerResetOrientationRelative); + LIB_FUNCTION("bDGZVTwwZ1A", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSaveInternalBuffers); + LIB_FUNCTION("qBjnR0HtMYI", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSetDurationUntilStatusNotTracking); + LIB_FUNCTION("NhPkY3V8E+8", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSetExtendedMode); + LIB_FUNCTION("vpsLLotiSUg", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSetLEDBrightness); + LIB_FUNCTION("lgWSHQ8p4i4", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSetRestingMode); + LIB_FUNCTION("IBv4P3q1pQ0", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, sceVrTrackerTerm); + LIB_FUNCTION("Q8skQqEwn5c", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerUnregisterDevice); + LIB_FUNCTION("9fvHMUbsom4", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + sceVrTrackerUpdateMotionSensorData); + LIB_FUNCTION("D6TJSfjTAk4", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + Func_0FA4C949F8D3024E); + LIB_FUNCTION("KFxq-AnEL34", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + Func_285C6AFC09C42F7E); + LIB_FUNCTION("mmzbIQNmT4o", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + Func_9A6CDB2103664F8A); + LIB_FUNCTION("tNJrfYsY3wY", "libSceVrTracker", 1, "libSceVrTracker", 0, 0, + Func_B4D26B7D8B18DF06); + LIB_FUNCTION("jGqEkPy0iLU", "libSceVrTrackerDeviceRejection", 1, "libSceVrTracker", 0, 0, + sceVrTrackerSetDeviceRejection); + LIB_FUNCTION("ERmwvjmfN+c", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 0, 0, + Func_1119B0BE399F37E7); + LIB_FUNCTION("SSi0OBa8RA0", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 0, 0, + Func_4928B43816BC440D); + LIB_FUNCTION("hj7zLvyw+pw", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 0, 0, + Func_863EF32EFCB0FA9C); + LIB_FUNCTION("5ucmy8hcSPk", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 0, 0, + Func_E6E726CBC85C48F9); + LIB_FUNCTION("9kB+RsZt84M", "libSceVrTrackerGpuTest", 1, "libSceVrTracker", 0, 0, + Func_F6407E46C66DF383); + LIB_FUNCTION("sBkAqyF5Gns", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 0, 0, + sceVrTrackerCpuPopMarker); + LIB_FUNCTION("rvCywCbc7Pk", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 0, 0, + sceVrTrackerCpuPushMarker); + LIB_FUNCTION("lm6T1Ur6JRk", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 0, 0, + sceVrTrackerGetLiveCaptureId); + LIB_FUNCTION("qa1+CeXKDPc", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 0, 0, + sceVrTrackerStartLiveCapture); + LIB_FUNCTION("3YCwwpHkHIg", "libSceVrTrackerLiveCapture", 1, "libSceVrTracker", 0, 0, + sceVrTrackerStopLiveCapture); +}; + +} // namespace Libraries::VrTracker \ No newline at end of file diff --git a/src/core/libraries/vr_tracker/vr_tracker.h b/src/core/libraries/vr_tracker/vr_tracker.h new file mode 100644 index 000000000..6a052c5fb --- /dev/null +++ b/src/core/libraries/vr_tracker/vr_tracker.h @@ -0,0 +1,407 @@ +// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +#include "common/types.h" +#include "core/libraries/camera/camera.h" + +namespace Core::Loader { +class SymbolsResolver; +} + +namespace Libraries::VrTracker { + +static constexpr s32 ORBIS_VR_TRACKER_MAX_LED_NUM = 16; +static constexpr u32 ORBIS_VR_TRACKER_MEMORY_ALIGNMENT = 0x10000; +static constexpr u32 ORBIS_VR_TRACKER_BASE_ONION_SIZE = 0x400000; +static constexpr u32 ORBIS_VR_TRACKER_GARLIC_SIZE = 0x3000000; +static constexpr u32 ORBIS_VR_TRACKER_WORK_SIZE = 0x1000000; + +enum OrbisVrTrackerProfile { + ORBIS_VR_TRACKER_PROFILE_000 = 0, + ORBIS_VR_TRACKER_PROFILE_100 = 100, +}; + +enum OrbisVrTrackerCalibrationMode { + ORBIS_VR_TRACKER_CALIBRATION_MANUAL = 0, + ORBIS_VR_TRACKER_CALIBRATION_AUTO = 1, +}; + +enum OrbisVrTrackerExecutionMode { + ORBIS_VR_TRACKER_EXECUTION_MODE_SERIAL = 0, + ORBIS_VR_TRACKER_EXECUTION_MODE_PARALLEL = 1, +}; + +enum OrbisVrTrackerDeviceType { + ORBIS_VR_TRACKER_DEVICE_HMD = 0, + ORBIS_VR_TRACKER_DEVICE_DUALSHOCK4 = 1, + ORBIS_VR_TRACKER_DEVICE_MOVE = 2, + ORBIS_VR_TRACKER_DEVICE_GUN = 3, +}; + +enum OrbisVrTrackerCalibrationType { + ORBIS_VR_TRACKER_CALIBRATION_POSITION = 0, + ORBIS_VR_TRACKER_CALIBRATION_ALL = 2, +}; + +enum OrbisVrTrackerPreferenceType { + ORBIS_VR_TRACKER_PREFERENCE_FAR_POSITION = 0, + ORBIS_VR_TRACKER_PREFERENCE_STABLE_POSITION = 1, +}; + +enum OrbisVrTrackerCameraMetaCheckMode { + ORBIS_VR_TRACKER_CAMERA_META_CHECK_ENABLE = 0, + ORBIS_VR_TRACKER_CAMERA_META_CHECK_DISABLE = 1, +}; + +enum OrbisVrTrackerDevicePermitType { + ORBIS_VR_TRACKER_DEVICE_PERMIT_ALL = 0, + ORBIS_VR_TRACKER_DEVICE_PERMIT_HMD_ONLY = 1, +}; + +enum OrbisVrTrackerRobustnessLevel { + ORBIS_VR_TRACKER_ROBUSTNESS_LEVEL_HIGH = 0, + ORBIS_VR_TRACKER_ROBUSTNESS_LEVEL_LOW = 3, + ORBIS_VR_TRACKER_ROBUSTNESS_LEVEL_MEDIUM = 6, + ORBIS_VR_TRACKER_ROBUSTNESS_LEVEL_LEGACY = 99, +}; + +enum OrbisVrTrackerCpuProcessOperationMode { + ORBIS_VR_TRACKER_CPU_PROCESS_OPERATION_MODE_WHOLE = 0, + ORBIS_VR_TRACKER_CPU_PROCESS_OPERATION_MODE_HANDLE = 1, +}; + +enum OrbisVrTrackerUpdateMotionSensorDataOperationMode { + ORBIS_VR_TRACKER_UPDATE_MOTION_SENSORDATA_OPERATION_MODE_DEVICE_TYPE = 0, + ORBIS_VR_TRACKER_UPDATE_MOTION_SENSORDATA_OPERATION_MODE_HANDLE = 1, +}; + +enum OrbisVrTrackerResultType { + ORBIS_VR_TRACKER_RESULT_PREDICTED = 0, + ORBIS_VR_TRACKER_RESULT_RAW = 1, +}; + +enum OrbisVrTrackerOrientationType { + ORBIS_VR_TRACKER_ORIENTATION_ABSOLUTE = 0, + ORBIS_VR_TRACKER_ORIENTATION_RELATIVE = 1, +}; + +enum OrbisVrTrackerUsageType { + ORBIS_VR_TRACKER_USAGE_DEFAULT = 0, + ORBIS_VR_TRACKER_USAGE_OPTIMIZED_FOR_HMD_USER = 1, +}; + +enum OrbisVrTrackerDebugMarkerType { + ORBIS_VR_TRACKER_DEBUG_MARKER_UNSPECIFIED = 0, + ORBIS_VR_TRACKER_DEBUG_MARKER_DEFAULT_UPDATE = 1, + ORBIS_VR_TRACKER_DEBUG_MARKER_FINAL_UPDATE = 2, + ORBIS_VR_TRACKER_DEBUG_MARKER_OTHER = 3, +}; + +enum OrbisVrTrackerRecalibrateNecessityType { + ORBIS_VR_TRACKER_RECALIBRATE_NECESSITY_NOTHING = 0, + ORBIS_VR_TRACKER_RECALIBRATE_NECESSITY_POSITION = 4, +}; + +enum OrbisVrTrackerPlayareaBrightnessRiskType { + ORBIS_VR_TRACKER_PLAYAREA_BRIGHTNESS_RISK_LOW = 0, + ORBIS_VR_TRACKER_PLAYAREA_BRIGHTNESS_RISK_HIGH = 5, + ORBIS_VR_TRACKER_PLAYAREA_BRIGHTNESS_RISK_MAX = 10, +}; + +enum OrbisVrTrackerLedColor { + ORBIS_VR_TRACKER_LED_COLOR_BLUE = 0, + ORBIS_VR_TRACKER_LED_COLOR_RED = 1, + ORBIS_VR_TRACKER_LED_COLOR_CYAN = 2, + ORBIS_VR_TRACKER_LED_COLOR_MAGENTA = 3, + ORBIS_VR_TRACKER_LED_COLOR_YELLOW = 4, + ORBIS_VR_TRACKER_LED_COLOR_GREEN = 2 +}; + +enum OrbisVrTrackerStatus { + ORBIS_VR_TRACKER_STATUS_NOT_STARTED = 0, + ORBIS_VR_TRACKER_STATUS_TRACKING = 1, + ORBIS_VR_TRACKER_STATUS_NOT_TRACKING = 2, + ORBIS_VR_TRACKER_STATUS_CALIBRATING = 3, +}; + +enum OrbisVrTrackerQuality { + ORBIS_VR_TRACKER_QUALITY_NONE = 0, + ORBIS_VR_TRACKER_QUALITY_NOT_VISIBLE = 3, + ORBIS_VR_TRACKER_QUALITY_PARTIAL = 6, + ORBIS_VR_TRACKER_QUALITY_FULL = 9, +}; + +enum OrbisVrTrackerLedAdjustmentStatus { + ORBIS_VR_TRACKER_LED_ADJUSTMENT_NOT_USED = 0, + ORBIS_VR_TRACKER_LED_ADJUSTMENT_USED = 1, +}; + +enum OrbisVrTrackerHmdRearTrackingStatus { + ORBIS_VR_TRACKER_REAR_TRACKING_NOT_READY = 0, + ORBIS_VR_TRACKER_REAR_TRACKING_READY = 1, +}; + +struct OrbisVrTrackerCalibrationSettings { + OrbisVrTrackerCalibrationMode hmd_position; + OrbisVrTrackerCalibrationMode pad_position; + OrbisVrTrackerCalibrationMode move_position; + OrbisVrTrackerCalibrationMode gun_position; + u32 reserved[4]; +}; + +struct OrbisVrTrackerQueryMemoryParam { + u32 size; + OrbisVrTrackerProfile profile; + u32 reserved[6]; + OrbisVrTrackerCalibrationSettings calibration_settings; +}; + +struct OrbisVrTrackerQueryMemoryResult { + u32 size; + u32 direct_memory_onion_size; + u32 direct_memory_onion_alignment; + u32 direct_memory_garlic_size; + u32 direct_memory_garlic_alignment; + u32 work_memory_size; + u32 work_memory_alignment; + u32 reserved[9]; +}; + +struct OrbisVrTrackerInitParam { + u32 size; + OrbisVrTrackerProfile profile; + OrbisVrTrackerExecutionMode execution_mode; + s32 hmd_thread_priority; + s32 pad_thread_priority; + s32 move_thread_priority; + s32 gun_thread_priority; + s32 reserved; + u64 cpu_mask; + OrbisVrTrackerCalibrationSettings calibration_settings; + void* direct_memory_onion; + u32 direct_memory_onion_size; + u32 direct_memory_onion_alignment; + void* direct_memory_garlic; + u32 direct_memory_garlic_size; + u32 direct_memory_garlic_alignment; + void* work_memory; + u32 work_memory_size; + u32 work_memory_alignment; + s32 gpu_pipe_id; + s32 gpu_queue_id; +}; + +struct OrbisVrTrackerRecalibrateParam { + u32 size; + OrbisVrTrackerDeviceType device_type; + OrbisVrTrackerCalibrationType calibration_type; + u32 reserved[5]; +}; + +struct OrbisVrTrackerGpuSubmitParam { + u32 size; + OrbisVrTrackerPreferenceType pad_tracking_preference; + OrbisVrTrackerCameraMetaCheckMode camera_meta_check_mode; + OrbisVrTrackerDevicePermitType tracking_device_permit_type; + OrbisVrTrackerRobustnessLevel robustness_level; + u32 reserved0[10]; + u32 reserved1; + Libraries::Camera::OrbisCameraFrameData camera_frame_data; +}; + +struct OrbisVrTrackerGpuWaitParam { + u32 size; + u32 reserved[7]; +}; + +struct OrbisVrTrackerCpuProcessParam { + u32 size; + OrbisVrTrackerCpuProcessOperationMode operation_mode; + s32 handle; + u32 reserved[5]; +}; + +struct OrbisVrTrackerNotifyEndOfCpuProcessParam { + u32 size; + u32 reserved[7]; +}; + +struct OrbisVrTrackerUpdateMotionSensorDataParam { + u32 size; + OrbisVrTrackerDeviceType device_type; + OrbisVrTrackerUpdateMotionSensorDataOperationMode operation_mode; + s32 handle; + s32 reserved[4]; +}; + +struct OrbisVrTrackerGetResultParam { + u32 size; + s32 handle; + OrbisVrTrackerResultType result_type; + u32 reserved0; + u64 prediction_time; + OrbisVrTrackerOrientationType orientation_type; + u32 reserved1; + OrbisVrTrackerUsageType usage_type; + u32 user_frame_number; + OrbisVrTrackerDebugMarkerType debug_marker_type; + u32 reserved2[2]; +}; + +struct OrbisVrTrackerPoseData { + float position_x; + float position_y; + float position_z; + u32 reserved0[1]; + float orientation_x; + float orientation_y; + float orientation_z; + float orientation_w; + u32 reserved1[8]; +}; + +struct OrbisVrTrackerHmdInfo { + OrbisVrTrackerPoseData device_pose; + OrbisVrTrackerPoseData left_eye_pose; + OrbisVrTrackerPoseData right_eye_pose; + OrbisVrTrackerPoseData head_pose; + OrbisVrTrackerHmdRearTrackingStatus rear_tracking_status; + u32 reserved0[3]; + u64 sensor_read_system_timestamp; + u32 reserved1[10]; +}; + +struct OrbisVrTrackerPadInfo { + OrbisVrTrackerPoseData device_pose; + u32 reserved[64]; +}; + +struct OrbisVrTrackerMoveInfo { + OrbisVrTrackerPoseData device_pose; + u32 reserved[64]; +}; + +struct OrbisVrTrackerGunInfo { + OrbisVrTrackerPoseData device_pose; + u32 reserved[64]; +}; + +struct OrbisVrTrackerLedResult { + float x; + float y; + float rx; + float ry; + u32 reserved[4]; +}; + +struct OrbisVrTrackerResultData { + s32 handle; + u32 connected; + u32 reserved0[2]; + u64 timestamp; + u64 device_timestamp; + OrbisVrTrackerRecalibrateNecessityType recalibrate_necessity; + OrbisVrTrackerPlayareaBrightnessRiskType playarea_brightness_risk; + u32 reserved1[2]; + OrbisVrTrackerLedColor led_color; + OrbisVrTrackerStatus status; + OrbisVrTrackerQuality position_quality; + OrbisVrTrackerQuality orientation_quality; + float velocity_x; + float velocity_y; + float velocity_z; + float acceleration_x; + float acceleration_y; + float acceleration_z; + float angular_velocity_x; + float angular_velocity_y; + float angular_velocity_z; + float angular_acceleration_x; + float angular_acceleration_y; + float angular_acceleration_z; + float camera_orientation_x; + float camera_orientation_y; + float camera_orientation_z; + float camera_orientation_w; + union { + OrbisVrTrackerHmdInfo hmd_info; + OrbisVrTrackerPadInfo pad_info; + OrbisVrTrackerMoveInfo move_info; + OrbisVrTrackerGunInfo gun_info; + }; + u32 user_frame_number; + OrbisVrTrackerLedAdjustmentStatus led_adjustment_status; + u64 timestamp_of_led_result; + u32 reserved2[2]; + s32 number_of_led_result[Libraries::Camera::ORBIS_CAMERA_MAX_DEVICE_NUM]; + u32 reserved3[4]; + OrbisVrTrackerLedResult led[Libraries::Camera::ORBIS_CAMERA_MAX_DEVICE_NUM] + [ORBIS_VR_TRACKER_MAX_LED_NUM]; +}; + +struct OrbisVrTrackerPlayAreaWarningInfo { + u32 size; + u32 reserved0[3]; + bool is_out_of_play_area; + u8 reserved1[3]; + u32 reserved2[3]; + bool is_distance_data_valid; + u8 reserved3[3]; + float distance_from_vertical_boundary; + float distance_from_horizontal_boundary; + u32 reserved4[5]; +}; + +s32 PS4_SYSV_ABI sceVrTrackerQueryMemory(const OrbisVrTrackerQueryMemoryParam* param, + OrbisVrTrackerQueryMemoryResult* result); +s32 PS4_SYSV_ABI sceVrTrackerInit(const OrbisVrTrackerInitParam* param); +s32 PS4_SYSV_ABI sceVrTrackerRegisterDevice(const OrbisVrTrackerDeviceType device_type, + const s32 handle); +s32 PS4_SYSV_ABI sceVrTrackerRegisterDevice2(const OrbisVrTrackerDeviceType device_type, + const s32 handle); +s32 PS4_SYSV_ABI sceVrTrackerRegisterDeviceInternal(const OrbisVrTrackerDeviceType device_type, + const s32 handle, s32 unk0, s32 unk1); +s32 PS4_SYSV_ABI sceVrTrackerCpuProcess(const OrbisVrTrackerCpuProcessParam* param); +s32 PS4_SYSV_ABI sceVrTrackerGetPlayAreaWarningInfo(OrbisVrTrackerPlayAreaWarningInfo* info); +s32 PS4_SYSV_ABI sceVrTrackerGetResult(const OrbisVrTrackerGetResultParam* param, + OrbisVrTrackerResultData* result); +s32 PS4_SYSV_ABI sceVrTrackerGetTime(u64* time); +s32 PS4_SYSV_ABI sceVrTrackerGpuSubmit(const OrbisVrTrackerGpuSubmitParam* param); +s32 PS4_SYSV_ABI sceVrTrackerGpuWait(const OrbisVrTrackerGpuWaitParam* param); +s32 PS4_SYSV_ABI sceVrTrackerGpuWaitAndCpuProcess(); +s32 PS4_SYSV_ABI +sceVrTrackerNotifyEndOfCpuProcess(const OrbisVrTrackerNotifyEndOfCpuProcessParam* param); +s32 PS4_SYSV_ABI sceVrTrackerRecalibrate(const OrbisVrTrackerRecalibrateParam* param); +s32 PS4_SYSV_ABI sceVrTrackerResetAll(); +s32 PS4_SYSV_ABI sceVrTrackerResetOrientationRelative(const OrbisVrTrackerDeviceType device_type, + const s32 handle); +s32 PS4_SYSV_ABI sceVrTrackerSaveInternalBuffers(); +s32 PS4_SYSV_ABI sceVrTrackerSetDurationUntilStatusNotTracking( + const OrbisVrTrackerDeviceType device_type, const u32 duration_camera_frames); +s32 PS4_SYSV_ABI sceVrTrackerSetExtendedMode(); +s32 PS4_SYSV_ABI sceVrTrackerSetLEDBrightness(); +s32 PS4_SYSV_ABI sceVrTrackerSetRestingMode(); +s32 PS4_SYSV_ABI +sceVrTrackerUpdateMotionSensorData(const OrbisVrTrackerUpdateMotionSensorDataParam* param); +s32 PS4_SYSV_ABI Func_0FA4C949F8D3024E(); +s32 PS4_SYSV_ABI Func_285C6AFC09C42F7E(); +s32 PS4_SYSV_ABI Func_9A6CDB2103664F8A(); +s32 PS4_SYSV_ABI Func_B4D26B7D8B18DF06(); +s32 PS4_SYSV_ABI sceVrTrackerSetDeviceRejection(); +s32 PS4_SYSV_ABI Func_1119B0BE399F37E7(); +s32 PS4_SYSV_ABI Func_4928B43816BC440D(); +s32 PS4_SYSV_ABI Func_863EF32EFCB0FA9C(); +s32 PS4_SYSV_ABI Func_E6E726CBC85C48F9(); +s32 PS4_SYSV_ABI Func_F6407E46C66DF383(); +s32 PS4_SYSV_ABI sceVrTrackerCpuPopMarker(); +s32 PS4_SYSV_ABI sceVrTrackerCpuPushMarker(); +s32 PS4_SYSV_ABI sceVrTrackerGetLiveCaptureId(); +s32 PS4_SYSV_ABI sceVrTrackerStartLiveCapture(); +s32 PS4_SYSV_ABI sceVrTrackerStopLiveCapture(); +s32 PS4_SYSV_ABI sceVrTrackerUnregisterDevice(const s32 handle); +s32 PS4_SYSV_ABI sceVrTrackerTerm(); + +void RegisterLib(Core::Loader::SymbolsResolver* sym); +} // namespace Libraries::VrTracker \ No newline at end of file diff --git a/src/core/libraries/vr_tracker/vr_tracker_error.h b/src/core/libraries/vr_tracker/vr_tracker_error.h new file mode 100644 index 000000000..a096229cf --- /dev/null +++ b/src/core/libraries/vr_tracker/vr_tracker_error.h @@ -0,0 +1,36 @@ +// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project +// SPDX-License-Identifier: GPL-2.0-or-later + +#pragma once + +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_INIT = 0x81260801; +constexpr int ORBIS_VR_TRACKER_ERROR_ALREADY_INITIALIZED = 0x81260802; +constexpr int ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_REGISTERED = 0x81260803; +constexpr int ORBIS_VR_TRACKER_ERROR_DEVICE_ALREADY_REGISTERED = 0x81260804; +constexpr int ORBIS_VR_TRACKER_ERROR_DEVICE_LIMIT = 0x81260805; +constexpr int ORBIS_VR_TRACKER_ERROR_ARGUMENT_INVALID = 0x81260806; +constexpr int ORBIS_VR_TRACKER_ERROR_INVALID_DEVICE_HANDLE = 0x81260807; +constexpr int ORBIS_VR_TRACKER_ERROR_BUSY = 0x81260808; +constexpr int ORBIS_VR_TRACKER_ERROR_INTERNAL_ERROR = 0x81260809; +constexpr int ORBIS_VR_TRACKER_ERROR_NO_MOTION_SENSOR_DATA = 0x8126080A; +constexpr int ORBIS_VR_TRACKER_ERROR_DEVICE_NOT_ORIENTED = 0x8126080B; +constexpr int ORBIS_VR_TRACKER_ERROR_TIMESTAMP_OUT_OF_RANGE = 0x8126080C; +constexpr int ORBIS_VR_TRACKER_ERROR_CAMERA_ACCELEROMETER_INVALID_DATA = 0x8126080D; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_GPU_PROCESS = 0x8126080E; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_ENOUGH_SENSOR_HISTORY = 0x8126080F; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_YET_DETECTING_FRONT_LID = 0x81260810; +constexpr int ORBIS_VR_TRACKER_ERROR_ALREADY_PROCESSING_CAMERA_FRAME = 0x81260811; +constexpr int ORBIS_VR_TRACKER_ERROR_INVALID_CAMERA_CONFIGURATION = 0x81260812; +constexpr int ORBIS_VR_TRACKER_ERROR_INVALID_STATUS_OF_CAMERA_FRAME = 0x81260813; +constexpr int ORBIS_VR_TRACKER_ERROR_PLAYSTATION_CAMERA_NOT_CONNECTED = 0x81260814; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_GPU_SUBMIT = 0x81260815; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_GPU_WAIT = 0x81260816; +constexpr int ORBIS_VR_TRACKER_ERROR_UPDATE_HMD_MOTION_SENSOR_DATA = 0x81260817; +constexpr int ORBIS_VR_TRACKER_ERROR_UPDATE_DS4_MOTION_SENSOR_DATA = 0x81260818; +constexpr int ORBIS_VR_TRACKER_ERROR_UPDATE_MOVE_MOTION_SENSOR_DATA = 0x81260819; +constexpr int ORBIS_VR_TRACKER_ERROR_CAMERA_ADJUSTMENT_IS_NECESSARY = 0x8126081A; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_EXECUTE_CPU_PROCESS = 0x8126081B; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_STARTED = 0x8126081C; +constexpr int ORBIS_VR_TRACKER_ERROR_INVALID_CPU_MODE = 0x8126081D; +constexpr int ORBIS_VR_TRACKER_ERROR_NOT_SUPPORTED = 0x8126081E; +constexpr int ORBIS_VR_TRACKER_ERROR_FATAL = 0x812608FF; \ No newline at end of file