OracleStudio/PrinceOfGlory
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

上传YomovSDK

Browse Source
This commit is contained in:
Sora丶kong
2026-03-03 03:15:46 +08:00
parent 9096da7e6c
commit eb97f31065
6477 changed files with 1932208 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

170
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOAnchorSubsystem.cs Normal file
View File

@@ -0,0 +1,170 @@
#if AR_FOUNDATION_5||AR_FOUNDATION_6
using System;
using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using Unity.Collections;
using UnityEngine;
using UnityEngine.XR.ARSubsystems;
namespace Unity.XR.PXR
{
public class PICOAnchorSubsystem : XRAnchorSubsystem
{
internal const string k_SubsystemId = "PICOAnchorSubsystem";
class AnchorProvider : Provider
{
private Dictionary<TrackableId, ulong> trackableIdToHandleMap;
private Dictionary<ulong, XRAnchor> handleToXRAnchorMap;
private HashSet<ulong> managedAnchorHandles;
private Dictionary<Guid, ulong> lastAnchorToTime;
private bool isInit = false;
public override void Start()
{
StartSpatialAnchorProvider();
}
private async void StartSpatialAnchorProvider()
{
var result = await PXR_MixedReality.StartSenseDataProvider(PxrSenseDataProviderType.SpatialAnchor);
if (result == PxrResult.SUCCESS)
{
if (!isInit)
{
trackableIdToHandleMap = new Dictionary<TrackableId, ulong>();
handleToXRAnchorMap = new Dictionary<ulong, XRAnchor>();
managedAnchorHandles = new HashSet<ulong>();
isInit = true;
}
}
else
{
Debug.LogError("Spatial Anchor Provider Start Failed:" + result);
}
}
public override void Stop()
{
var result = PXR_MixedReality.StopSenseDataProvider(PxrSenseDataProviderType.SpatialAnchor);
if (result == PxrResult.SUCCESS)
{
}
else
{
Debug.LogError("Spatial Anchor Provider Stop Failed:" + result);
}
}
public override void Destroy()
{
}
public override TrackableChanges<XRAnchor> GetChanges(XRAnchor defaultAnchor, Allocator allocator)
{
return new TrackableChanges<XRAnchor>();
}
public override bool TryAddAnchor(Pose pose, out XRAnchor anchor)
{
var tcs = new TaskCompletionSource<(PxrResult result, ulong anchorHandle, Guid uuid)>();
var tcs2 = new TaskCompletionSource<PxrResult>();
Task.Run(() =>
{
var (pxrResult, handle, guid) = PXR_MixedReality.CreateSpatialAnchorAsync(pose.position, pose.rotation).Result;
tcs.SetResult((pxrResult, handle, guid));
});
var (result, anchorHandle, uuid) = tcs.Task.Result;
if (result == PxrResult.SUCCESS)
{
Task.Run(() =>
{
var pxrResult = PXR_MixedReality.PersistSpatialAnchorAsync(anchorHandle).Result;
tcs2.SetResult(pxrResult);
});
var result2 = tcs2.Task.Result;
if (result2 == PxrResult.SUCCESS)
{
var bytes = uuid.ToByteArray();
var trackabledId = new TrackableId(BitConverter.ToUInt64(bytes, 0), BitConverter.ToUInt64(bytes, 8));
var nativePtr = new IntPtr((long)anchorHandle);
anchor = new XRAnchor(trackabledId, pose, TrackingState.Tracking, nativePtr);
trackableIdToHandleMap[trackabledId] = anchorHandle;
handleToXRAnchorMap[anchorHandle] = anchor;
return true;
}
else
{
anchor = XRAnchor.defaultValue;
return false;
}
}
else
{
anchor = XRAnchor.defaultValue;
return false;
}
}
public async Task<bool> QuerySpatialAnchors()
{
return false;
}
public override bool TryRemoveAnchor(TrackableId anchorId)
{
var anchorHandle = trackableIdToHandleMap[anchorId];
var result = PXR_MixedReality.DestroyAnchor(anchorHandle);
if (result == PxrResult.SUCCESS)
{
var tcs = new TaskCompletionSource<PxrResult>();
Task.Run(() =>
{
var pxrResult = PXR_MixedReality.UnPersistSpatialAnchorAsync(anchorHandle).Result;
tcs.SetResult(pxrResult);
});
var result1 = tcs.Task.Result;
if (result1 == PxrResult.SUCCESS)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
}
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void RegisterDescriptor()
{
var cInfo = new XRAnchorSubsystemDescriptor.Cinfo()
{
id = k_SubsystemId,
providerType = typeof(AnchorProvider),
subsystemTypeOverride = typeof(PICOAnchorSubsystem),
supportsTrackableAttachments = false
};
#if AR_FOUNDATION_6
XRAnchorSubsystemDescriptor.Register(cInfo);
#elif AR_FOUNDATION_5
XRAnchorSubsystemDescriptor.Create(cInfo);
#endif
}
}
}
#endif

3
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOAnchorSubsystem.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 3fc1ceb510674152beda5a7148d8a52d
timeCreated: 1723083100

76
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOCameraSubsystem.cs Normal file
View File

@@ -0,0 +1,76 @@
#if AR_FOUNDATION_5||AR_FOUNDATION_6
using UnityEngine;
using UnityEngine.XR.ARSubsystems;
namespace Unity.XR.OpenXR.Features.PICOSupport
{
public class PICOCameraSubsystem: XRCameraSubsystem
{
internal const string k_SubsystemId = "PICOCameraSubsystem";
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void RegisterDescriptor()
{
var cameraSubsystemCinfo =
#if AR_FOUNDATION_5
new XRCameraSubsystemCinfo
#elif AR_FOUNDATION_6
new XRCameraSubsystemDescriptor.Cinfo
#endif
{
id = k_SubsystemId,
providerType = typeof(PICOOpenXRProvider),
subsystemTypeOverride = typeof(PICOCameraSubsystem),
supportsAverageBrightness = false,
supportsAverageColorTemperature = false,
supportsColorCorrection = false,
supportsDisplayMatrix = false,
supportsProjectionMatrix = false,
supportsTimestamp = false,
supportsCameraConfigurations = false,
supportsCameraImage = false,
supportsAverageIntensityInLumens = false,
supportsFocusModes = false,
supportsFaceTrackingAmbientIntensityLightEstimation = false,
supportsFaceTrackingHDRLightEstimation = false,
supportsWorldTrackingAmbientIntensityLightEstimation = false,
supportsWorldTrackingHDRLightEstimation = false,
supportsCameraGrain = false,
};
#if AR_FOUNDATION_5
XRCameraSubsystem.Register(cameraSubsystemCinfo);
#elif AR_FOUNDATION_6
XRCameraSubsystemDescriptor.Register(cameraSubsystemCinfo);
#endif
}
class PICOOpenXRProvider : Provider
{
/// <summary>
/// Construct the camera functionality provider for Meta.
/// </summary>
public PICOOpenXRProvider()
{
}
/// <summary>
/// Start the camera functionality.
/// </summary>
public override void Start() => PassthroughFeature.EnableSeeThroughManual(true);
/// <summary>
/// Stop the camera functionality.
/// </summary>
public override void Stop() => PassthroughFeature.EnableSeeThroughManual(false);
/// <summary>
/// Destroy any resources required for the camera functionality.
/// </summary>
public override void Destroy() => PassthroughFeature.Destroy();
}
}
}
#endif

11
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOCameraSubsystem.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: bf48cee72a30f8844bdd8d97f81f8ddd
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

118
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOSessionSubsystem.cs Normal file
View File

@@ -0,0 +1,118 @@
#if AR_FOUNDATION_5||AR_FOUNDATION_6
using Unity.XR.OpenXR.Features.PICOSupport;
using Unity.XR.PXR;
using UnityEngine;
using UnityEngine.XR.ARSubsystems;
public class PICOSessionSubsystem : XRSessionSubsystem
{
internal const string k_SubsystemId = "PICOSessionSubsystem";
internal static PICOSessionSubsystem instance { get; private set; }
/// <summary>
/// Do not call this directly. Call create on a valid <see cref="XRSessionSubsystemDescriptor"/> instead.
/// </summary>
public PICOSessionSubsystem()
{
instance = this;
}
internal void OnSessionStateChange(int newState)
=> ((SessionProvider)provider).OnSessionStateChange(newState);
class SessionProvider : Provider
{
XrSessionState m_SessionState;
/// <inheritdoc/>
public override TrackingState trackingState
{
get
{
switch (m_SessionState)
{
case XrSessionState.Idle:
case XrSessionState.Ready:
case XrSessionState.Synchronized:
return TrackingState.Limited;
case XrSessionState.Visible:
case XrSessionState.Focused:
return TrackingState.Tracking;
case XrSessionState.Unknown:
case XrSessionState.Stopping:
case XrSessionState.LossPending:
case XrSessionState.Exiting:
default:
return TrackingState.None;
}
}
}
/// <inheritdoc/>
public override NotTrackingReason notTrackingReason
{
get
{
switch (m_SessionState)
{
case XrSessionState.Idle:
case XrSessionState.Ready:
case XrSessionState.Synchronized:
return NotTrackingReason.Initializing;
case XrSessionState.Visible:
case XrSessionState.Focused:
return NotTrackingReason.None;
case XrSessionState.Unknown:
case XrSessionState.Stopping:
case XrSessionState.LossPending:
case XrSessionState.Exiting:
default:
return NotTrackingReason.Unsupported;
}
}
}
public void OnSessionStateChange(int newState)
{
m_SessionState = (XrSessionState)newState;
PLog.i(k_SubsystemId, $" OnSessionStateChange m_SessionState:{m_SessionState}");
}
}
enum XrSessionState
{
Unknown = 0,
Idle = 1,
Ready = 2,
Synchronized = 3,
Visible = 4,
Focused = 5,
Stopping = 6,
LossPending = 7,
Exiting = 8,
}
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void RegisterDescriptor()
{
#if AR_FOUNDATION_6
XRSessionSubsystemDescriptor.Register(new XRSessionSubsystemDescriptor.Cinfo
#elif AR_FOUNDATION_5
XRSessionSubsystemDescriptor.RegisterDescriptor(new XRSessionSubsystemDescriptor.Cinfo
#endif
{
id = k_SubsystemId,
providerType = typeof(SessionProvider),
subsystemTypeOverride = typeof(PICOSessionSubsystem),
supportsInstall = false,
supportsMatchFrameRate = false
});
}
}
#endif

3
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PICOSessionSubsystem.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: 98b3f31743cc4f1bb07a6c05b82dcd10
timeCreated: 1723083167

191
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PXR_HumanBodySubsystem.cs Normal file
View File

@@ -0,0 +1,191 @@
#if AR_FOUNDATION_5 || AR_FOUNDATION_6
using Unity.Collections;
using Unity.XR.OpenXR.Features.PICOSupport;
using Unity.XR.PXR;
using UnityEngine;
using UnityEngine.XR.ARSubsystems;
public class PXR_HumanBodySubsystem : XRHumanBodySubsystem
{
internal const string k_SubsystemId = "PXR_HumanBodySubsystem";
class HumanBodyProvider : Provider
{
bool isBodyTrackingSupported = false;
bool init = false;
private BodyTrackingGetDataInfo bdi = new BodyTrackingGetDataInfo();
private BodyTrackingData bd = new BodyTrackingData();
public override void Start()
{
PLog.i(k_SubsystemId, "Start");
init = true;
}
public override void Stop()
{
PLog.i(k_SubsystemId, "Stop");
int ret = BodyTrackingFeature.StopBodyTracking();
}
public override void Destroy()
{
PLog.i(k_SubsystemId, "Destroy");
}
public override void GetSkeleton(TrackableId trackableId, Allocator allocator, ref NativeArray<XRHumanBodyJoint> skeleton)
{
PLog.d(k_SubsystemId, $"GetSkeleton isBodyTrackingSupported={isBodyTrackingSupported}");
#if UNITY_ANDROID
if (isBodyTrackingSupported)
{
// Get the position and orientation data of each body node.
BodyTrackingStatus bs = new BodyTrackingStatus();
bool istracking = false;
BodyTrackingFeature.GetBodyTrackingState(ref istracking, ref bs);
Debug.Log( $"GetBodyTrackingState update stateCode = {bs.stateCode} message = {bs.message} ");
if (bs.stateCode!=BodyTrackingStatusCode.BT_VALID)
{
return;
}
int ret = BodyTrackingFeature.GetBodyTrackingData(ref bdi, ref bd);
// if the return is successful
if (ret == 0)
{
skeleton = new NativeArray<XRHumanBodyJoint>((int)BodyTrackerRole.ROLE_NUM, allocator);
for (int i = 0; i < (int)BodyTrackerRole.ROLE_NUM; i++)
{
BodyTrackerTransPose localPose = bd.roleDatas[i].localPose;
Vector3 pos = new Vector3((float)bd.roleDatas[i].localPose.PosX, (float)bd.roleDatas[i].localPose.PosY,
(float)bd.roleDatas[i].localPose.PosZ);
Quaternion qu = new Quaternion((float)bd.roleDatas[i].localPose.RotQx, (float)bd.roleDatas[i].localPose.RotQy,
(float)bd.roleDatas[i].localPose.RotQz, (float)bd.roleDatas[i].localPose.RotQw);
if (i == 0)
{
qu *= Quaternion.Euler(new Vector3(0, 180, 0));
}
else if (i == 1)
{
qu *= Quaternion.Euler(new Vector3(0, 0, -95));
}
else if (i == 2)
{
qu *= Quaternion.Euler(new Vector3(0, 0, 95));
}
else if (i == 4)
{
qu *= Quaternion.Euler(new Vector3(0, 0, -90));
}
else if (i == 3 || i == 5 || i == 12)
{
qu *= Quaternion.Euler(new Vector3(0, 0, 90));
}
else if (i == 7)
{
qu *= Quaternion.Euler(new Vector3(180, -90, 0));
}
else if (i == 6 || i == 9 || i == 15)
{
qu *= Quaternion.Euler(new Vector3(0, 90, 90));
}
else if (i == 8 || i == 10 || i == 11)
{
qu *= Quaternion.Euler(new Vector3(0, 90, 0));
}
else if (i == 13 || i == 14 || i == 16 || i == 17 || i == 18 || i == 19 || i == 20)
{
qu *= Quaternion.Euler(new Vector3(0, 0, 180));
}
else if (i == 21)
{
qu *= Quaternion.Euler(new Vector3(180, 0, 180));
}
Pose pose = new Pose(pos, qu);
XRHumanBodyJoint mXRHumanBodyJoint = new XRHumanBodyJoint(i, 0, Vector3.one, pose, Vector3.one, pose, true);
skeleton[i] = mXRHumanBodyJoint;
}
}
}
#endif
}
public override TrackableChanges<XRHumanBody> GetChanges(XRHumanBody defaultHumanBody, Allocator allocator)
{
PLog.d(k_SubsystemId, $"GetChanges init={init} ");
if (init)
{
// Query whether the current device supports human body tracking.
isBodyTrackingSupported=BodyTrackingFeature.IsBodyTrackingSupported();
if (isBodyTrackingSupported)
{
BodyTrackingBoneLength bones = new BodyTrackingBoneLength();
// Start BodyTracking
BodyTrackingFeature.StartBodyTracking(BodyJointSet.BODY_JOINT_SET_BODY_FULL_START, bones);
// Has Pico motion tracker completed calibration (0: not completed; 1: completed)?
BodyTrackingStatus bs = new BodyTrackingStatus();
bool istracking = false;
BodyTrackingFeature.GetBodyTrackingState(ref istracking, ref bs);
Debug.Log($"GetBodyTrackingState stateCode = {bs.stateCode} message = {bs.message} ");
// If not calibrated, invoked system motion tracker app for calibration.
if (bs.message==BodyTrackingMessage.BT_MESSAGE_TRACKER_NOT_CALIBRATED||bs.message==BodyTrackingMessage.BT_MESSAGE_UNKNOWN)
{
BodyTrackingFeature.StartMotionTrackerCalibApp();
}
}
init = false;
return new TrackableChanges<XRHumanBody>(1, 0, 0, allocator);
}
else
{
return new TrackableChanges<XRHumanBody>(0, 1, 0, allocator);
}
}
}
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
static void RegisterDescriptor()
{
PLog.i(k_SubsystemId, "RegisterDescriptor");
#if AR_FOUNDATION_5
var mXRHumanBodySubsystemCinfo = new XRHumanBodySubsystemCinfo
#endif
#if AR_FOUNDATION_6
var mXRHumanBodySubsystemCinfo = new XRHumanBodySubsystemDescriptor.Cinfo
#endif
{
id = k_SubsystemId,
providerType = typeof(HumanBodyProvider),
subsystemTypeOverride = typeof(PXR_HumanBodySubsystem),
supportsHumanBody2D = false,
supportsHumanBody3D = true,
supportsHumanBody3DScaleEstimation = true,
};
#if AR_FOUNDATION_6
XRHumanBodySubsystemDescriptor.Register(mXRHumanBodySubsystemCinfo);
#endif
#if AR_FOUNDATION_5
if (!Register(mXRHumanBodySubsystemCinfo))
{
PLog.e(k_SubsystemId, $"Failed to register the {k_SubsystemId} subsystem.");
}
else
{
PLog.i(k_SubsystemId, $"success to register the {k_SubsystemId} subsystem.");
}
#endif
}
}
#endif

11
Packages/com.unity.xr.openxr.picoxr/Runtime/Subsystem/PXR_HumanBodySubsystem.cs.meta Normal file
View File

@@ -0,0 +1,11 @@
fileFormatVersion: 2
guid: 57a9dd5061c77de43b3b69aba7ec387d
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant: