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

Libraries: libSceVrTracker stubs (#3462)

Browse Source 
* libSceVrTracker stubs, structs, enums, and errors

* sceVrTrackerQueryMemory

* Clang and slight struct cleanup

* Implement sceVrTrackerInit

* Store memory pointers and sizes

Mainly for future developers, since I doubt these memory areas will be particularly useful for these stubs.

* sceVrTrackerRegisterDevice

I haven't really identified the difference between the two register device functions, but I do know that they both internally call the internal function with slightly different parameters.

* sceVrTrackerUnregisterDevice

Also changes Hmd and Move handles to be values closer to what real hardware returns, since this function seemingly relies on handles being different for all these device types.

* sceVrTrackerTerm

* Additional error checks in sceVrTrackerRegisterDeviceInternal

* sceVrTrackerGetTime

* sceVrTrackerRecalibrate

Recalibration succeeds on real hardware (at least for some device types), so I've left the stub log intact.

* Update vr_tracker.cpp

* sceVrTrackerSetDurationUntilStatusNotTracking stub

Only handled the error checks, so I left the stub log intact.

* sceVrTrackerGpu* functions

Most of these can't succeed without a camera attached.
This commit is contained in:
Stephen Miller
2025-08-26 19:16:10 -05:00
committed by GitHub
parent dcb256c930
commit e172323dd0
9 changed files with 1087 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@@ -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

1
src/common/logging/filter.cpp
View File

@@ -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) \

1
src/common/logging/types.h
View File

@@ -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

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

@@ -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;
}

2
src/core/libraries/libs.cpp
View File

@@ -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

5
src/core/libraries/move/move.cpp
View File

@@ -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) {

632
src/core/libraries/vr_tracker/vr_tracker.cpp Normal file
View File

@@ -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<VAddr>(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<VAddr>(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<VAddr>(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<u32>(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

407
src/core/libraries/vr_tracker/vr_tracker.h Normal file
View File

@@ -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

36
src/core/libraries/vr_tracker/vr_tracker_error.h Normal file
View File

@@ -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;