Init

2025-11-13 17:40:28 +08:00
parent 962ab49609
commit 10156da245
5503 changed files with 805282 additions and 0 deletions
--- a/SDK-3.3.2-20251111/Runtime/Scripts/PXR_Loader.cs
+++ b/SDK-3.3.2-20251111/Runtime/Scripts/PXR_Loader.cs
@@ -0,0 +1,680 @@
+/*******************************************************************************
+Copyright © 2015-2022 PICO Technology Co., Ltd.All rights reserved.  
+
+NOTICE：All information contained herein is, and remains the property of 
+PICO Technology Co., Ltd. The intellectual and technical concepts 
+contained herein are proprietary to PICO Technology Co., Ltd. and may be 
+covered by patents, patents in process, and are protected by trade secret or 
+copyright law. Dissemination of this information or reproduction of this 
+material is strictly forbidden unless prior written permission is obtained from
+PICO Technology Co., Ltd. 
+*******************************************************************************/
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.XR.Management;
+using UnityEngine.XR;
+using AOT;
+
+#if UNITY_INPUT_SYSTEM
+using UnityEngine.InputSystem;
+using UnityEngine.InputSystem.Layouts;
+using UnityEngine.InputSystem.XR;
+using Unity.XR.PXR.Input;
+using System.Linq;
+
+#if XR_COMPOSITION_LAYERS
+using Unity.XR.CompositionLayers.Services;
+#endif
+
+#endif
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+using UnityEngine.XR.ARSubsystems;
+#endif
+
+#if XR_HANDS
+using UnityEngine.XR.Hands;
+#endif
+
+
+namespace Unity.XR.PXR
+{
+#if UNITY_INPUT_SYSTEM
+#if UNITY_EDITOR
+    [InitializeOnLoad]
+#endif
+    static class InputLayoutLoader
+    {
+        static InputLayoutLoader()
+        {
+            RegisterInputLayouts();
+        }
+
+        public static void RegisterInputLayouts()
+        {
+            InputSystem.RegisterLayout<PXR_HMD>(matches: new InputDeviceMatcher().WithInterface(XRUtilities.InterfaceMatchAnyVersion).WithProduct(@"^(PICO HMD)|^(PICO Neo)|^(PICO G)"));
+            InputSystem.RegisterLayout<PXR_Controller>(matches: new InputDeviceMatcher().WithInterface(XRUtilities.InterfaceMatchAnyVersion).WithProduct(@"^(PICO Controller)"));
+        }
+    }
+#endif
+
+    public class PXR_Loader : XRLoaderHelper
+#if UNITY_EDITOR
+    , IXRLoaderPreInit
+#endif
+    {
+        private const string TAG = "PXR_Loader";
+        private static List<XRDisplaySubsystemDescriptor> displaySubsystemDescriptors = new List<XRDisplaySubsystemDescriptor>();
+        private static List<XRInputSubsystemDescriptor> inputSubsystemDescriptors = new List<XRInputSubsystemDescriptor>();
+        private static List<XRMeshSubsystemDescriptor> meshSubsystemDescriptors = new List<XRMeshSubsystemDescriptor>();
+#if XR_HANDS
+        private static List<XRHandSubsystemDescriptor> handSubsystemDescriptors = new List<XRHandSubsystemDescriptor>();
+#endif
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+        private static List<XRSessionSubsystemDescriptor> sessionSubsystemDescriptors = new List<XRSessionSubsystemDescriptor>();
+        private static List<XRCameraSubsystemDescriptor> cameraSubsystemDescriptors = new List<XRCameraSubsystemDescriptor>();
+        private static List<XRFaceSubsystemDescriptor> faceSubsystemDescriptors = new List<XRFaceSubsystemDescriptor>();
+        private static List<XRHumanBodySubsystemDescriptor> humanBodySubsystemDescriptors = new List<XRHumanBodySubsystemDescriptor>();
+        private static List<XRAnchorSubsystemDescriptor> anchorSubsystemDescriptors = new List<XRAnchorSubsystemDescriptor>();
+#endif
+
+        public delegate Quaternion ConvertRotationWith2VectorDelegate(Vector3 from, Vector3 to);
+
+        public XRDisplaySubsystem displaySubsystem
+        {
+            get
+            {
+                return GetLoadedSubsystem<XRDisplaySubsystem>();
+            }
+        }
+
+        public XRInputSubsystem inputSubsystem
+        {
+            get
+            {
+                return GetLoadedSubsystem<XRInputSubsystem>();
+            }
+        }
+
+        public XRMeshSubsystem meshSubsystem
+        {
+            get
+            {
+                return GetLoadedSubsystem<XRMeshSubsystem>();
+            }
+        }
+        internal enum LoaderState
+        {
+            Uninitialized,
+            InitializeAttempted,
+            Initialized,
+            StartAttempted,
+            Started,
+            StopAttempted,
+            Stopped,
+            DeinitializeAttempted
+        }
+
+        internal LoaderState currentLoaderState { get; private set; } = LoaderState.Uninitialized;
+
+        List<LoaderState> validLoaderInitStates = new List<LoaderState> { LoaderState.Uninitialized, LoaderState.InitializeAttempted };
+        List<LoaderState> validLoaderStartStates = new List<LoaderState> { LoaderState.Initialized, LoaderState.StartAttempted, LoaderState.Stopped };
+        List<LoaderState> validLoaderStopStates = new List<LoaderState> { LoaderState.StartAttempted, LoaderState.Started, LoaderState.StopAttempted };
+        List<LoaderState> validLoaderDeinitStates = new List<LoaderState> { LoaderState.InitializeAttempted, LoaderState.Initialized, LoaderState.Stopped, LoaderState.DeinitializeAttempted };
+
+        List<LoaderState> runningStates = new List<LoaderState>()
+        {
+            LoaderState.Initialized,
+            LoaderState.StartAttempted,
+            LoaderState.Started
+        };
+        public override bool Initialize()
+        {
+            Debug.Log($"{TAG} Initialize() currentLoaderState={currentLoaderState}");
+#if UNITY_INPUT_SYSTEM
+            InputLayoutLoader.RegisterInputLayouts();
+#endif
+// #if UNITY_ANDROID 
+       
+            PXR_Settings settings = GetSettings();
+            if (settings != null)
+            {
+                UserDefinedSettings userDefinedSettings = new UserDefinedSettings
+                {
+                    stereoRenderingMode = settings.GetStereoRenderingMode(),
+                    colorSpace = (ushort)((QualitySettings.activeColorSpace == ColorSpace.Linear) ? 1 : 0),
+                    useContentProtect = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().useContentProtect),
+                    systemDisplayFrequency = settings.GetSystemDisplayFrequency(),
+                    optimizeBufferDiscards = settings.GetOptimizeBufferDiscards(),
+                    enableAppSpaceWarp = Convert.ToUInt16(settings.enableAppSpaceWarp),
+                    enableSubsampled = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().enableSubsampled),
+                    lateLatchingDebug = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().latelatchingDebug),
+                    enableStageMode = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().stageMode),
+                    enableSuperResolution = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().superResolution),
+                    normalSharpening = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().normalSharpening),
+                    qualitySharpening = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().qualitySharpening),
+                    fixedFoveatedSharpening = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().fixedFoveatedSharpening),
+                    selfAdaptiveSharpening = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().selfAdaptiveSharpening),
+                    enableETFR = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().enableETFR),
+                    foveationLevel = Convert.ToUInt16((int)PXR_ProjectSetting.GetProjectConfig().foveationLevel + 1),
+                    spatialMeshLod = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().meshLod),
+                    enableEyeTracking = Convert.ToUInt16(PXR_ProjectSetting.GetProjectConfig().eyeTracking),
+                    dynamicFoveation =1,
+                };
+                
+                PXR_Plugin.System.UPxr_SetUserDefinedSettings(userDefinedSettings);
+            }
+            PXR_Plugin.System.UPxr_SetXrEventDataBufferCallBack(XrEventDataBufferFunction);
+// #endif
+
+            PXR_Plugin.System.ProductName = PXR_Plugin.System.UPxr_GetProductName();
+            if (currentLoaderState == LoaderState.Initialized)
+                return true;
+
+            if (!validLoaderInitStates.Contains(currentLoaderState))
+                return false;
+
+            if (displaySubsystem == null)
+            {
+                CreateSubsystem<XRDisplaySubsystemDescriptor, XRDisplaySubsystem>(displaySubsystemDescriptors, "PICO Display");
+                if (displaySubsystem == null)
+                    return false;
+            }
+
+            if (inputSubsystem == null)
+            {
+                CreateSubsystem<XRInputSubsystemDescriptor, XRInputSubsystem>(inputSubsystemDescriptors, "PICO Input");
+                if (inputSubsystem == null)
+                    return false;
+            }
+            if (PXR_ProjectSetting.GetProjectConfig().spatialMesh)
+            {
+                CreateSubsystem<XRMeshSubsystemDescriptor, XRMeshSubsystem>(meshSubsystemDescriptors, "PICO Mesh");
+            }
+#if XR_HANDS
+            CreateSubsystem<XRHandSubsystemDescriptor, XRHandSubsystem>(handSubsystemDescriptors, "PICO Hands");
+#endif
+
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+            if (PXR_ProjectSetting.GetProjectConfig().arFoundation)
+            {
+                CreateSubsystem<XRSessionSubsystemDescriptor, XRSessionSubsystem>(sessionSubsystemDescriptors, PXR_SessionSubsystem.k_SubsystemId);
+                CreateSubsystem<XRCameraSubsystemDescriptor, XRCameraSubsystem>(cameraSubsystemDescriptors, PXR_CameraSubsystem.k_SubsystemId);
+                if (PXR_ProjectSetting.GetProjectConfig().faceTracking)
+                {
+                    CreateSubsystem<XRFaceSubsystemDescriptor, XRFaceSubsystem>(faceSubsystemDescriptors, PXR_FaceSubsystem.k_SubsystemId);
+                }
+                if (PXR_ProjectSetting.GetProjectConfig().bodyTracking)
+                {
+                    CreateSubsystem<XRHumanBodySubsystemDescriptor, XRHumanBodySubsystem>(humanBodySubsystemDescriptors, PXR_HumanBodySubsystem.k_SubsystemId);
+                }
+                if (PXR_ProjectSetting.GetProjectConfig().spatialAnchor)
+                {
+                    CreateSubsystem<XRAnchorSubsystemDescriptor, XRAnchorSubsystem>(anchorSubsystemDescriptors, PXR_AnchorSubsystem.k_SubsystemId);
+                }
+            }
+#endif
+
+            if (displaySubsystem == null && inputSubsystem == null)
+            {
+                Debug.LogError("PXRLog Unable to start PICO Plugin.");
+            }
+            else if (displaySubsystem == null)
+            {
+                Debug.LogError("PXRLog Failed to load display subsystem.");
+            }
+            else if (inputSubsystem == null)
+            {
+                Debug.LogError("PXRLog Failed to load input subsystem.");
+            }
+            else
+            {
+                PXR_Plugin.System.UPxr_InitializeFocusCallback();
+            }
+
+#if XR_HANDS
+            var handSubSystem = GetLoadedSubsystem<XRHandSubsystem>();
+            if (handSubSystem == null)
+            {
+                Debug.LogError("PXRLog Failed to load XRHandSubsystem.");
+            }
+#endif
+
+            if (PXR_ProjectSetting.GetProjectConfig().spatialAnchor)
+            {
+                PXR_Plugin.MixedReality.UPxr_CreateSpatialAnchorSenseDataProvider();
+            }
+            if (PXR_ProjectSetting.GetProjectConfig().sceneCapture)
+            {
+                PXR_Plugin.MixedReality.UPxr_CreateSceneCaptureSenseDataProvider();
+            }
+
+            currentLoaderState = LoaderState.Initialized;
+            return displaySubsystem != null;
+        }
+
+        public override bool Start()
+        {
+            Debug.Log($"{TAG} Start() currentLoaderState={currentLoaderState}");
+            if (currentLoaderState == LoaderState.Started)
+                return true;
+
+            if (!validLoaderStartStates.Contains(currentLoaderState))
+                return false;
+
+            currentLoaderState = LoaderState.StartAttempted;
+
+            StartSubsystem<XRDisplaySubsystem>();
+            StartSubsystem<XRInputSubsystem>();
+#if XR_HANDS
+            StartSubsystem<XRHandSubsystem>();
+#endif
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+            if (PXR_ProjectSetting.GetProjectConfig().arFoundation)
+            {
+                StartSubsystem<XRCameraSubsystem>();
+                if (PXR_ProjectSetting.GetProjectConfig().bodyTracking)
+                {
+                    StartSubsystem<XRHumanBodySubsystem>();
+                }
+
+                if (PXR_ProjectSetting.GetProjectConfig().faceTracking)
+                {
+                    StartSubsystem<XRFaceSubsystem>();
+                }
+            }
+
+            if (PXR_ProjectSetting.GetProjectConfig().spatialAnchor)
+            {
+                StartSubsystem<XRAnchorSubsystem>();
+            }
+#endif
+
+            if (!displaySubsystem?.running ?? false)
+            {
+                StartSubsystem<XRDisplaySubsystem>();
+            }
+
+            if (!inputSubsystem?.running ?? false)
+            {
+                StartSubsystem<XRInputSubsystem>();
+            }
+            currentLoaderState = LoaderState.Started;
+
+            return true;
+        }
+
+        public override bool Stop()
+        {
+            Debug.Log($"{TAG} Stop() currentLoaderState={currentLoaderState}");
+            if (currentLoaderState == LoaderState.Stopped)
+                return true;
+
+            if (!validLoaderStopStates.Contains(currentLoaderState))
+                return false;
+
+            currentLoaderState = LoaderState.StopAttempted;
+
+            var inputRunning = inputSubsystem?.running ?? false;
+            var displayRunning = displaySubsystem?.running ?? false;
+            if (inputRunning)
+            {
+                StopSubsystem<XRInputSubsystem>();
+            }
+
+            if (displayRunning)
+            {
+                StopSubsystem<XRDisplaySubsystem>();
+            }
+
+#if XR_HANDS
+            StopSubsystem<XRHandSubsystem>();
+#endif
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+            if (PXR_ProjectSetting.GetProjectConfig().arFoundation)
+            {
+                StopSubsystem<XRCameraSubsystem>();
+                if (PXR_ProjectSetting.GetProjectConfig().bodyTracking)
+                {
+                    StopSubsystem<XRHumanBodySubsystem>();
+                }
+
+                if (PXR_ProjectSetting.GetProjectConfig().faceTracking)
+                {
+                    StopSubsystem<XRFaceSubsystem>();
+                }
+            }
+
+            if (PXR_ProjectSetting.GetProjectConfig().spatialAnchor)
+            {
+                StopSubsystem<XRAnchorSubsystem>();
+            }
+#endif
+            currentLoaderState = LoaderState.Stopped;
+            return true;
+        }
+
+        public override bool Deinitialize()
+        {
+            Debug.Log($"{TAG} Deinitialize() currentLoaderState={currentLoaderState}");
+            if (PXR_Plugin.System.IsOpenXRLoaderActive())
+            {
+                return false;
+            }
+            if (currentLoaderState == LoaderState.Uninitialized)
+                return true;
+
+            if (!validLoaderDeinitStates.Contains(currentLoaderState))
+            {
+                return false;
+            }
+
+            currentLoaderState = LoaderState.DeinitializeAttempted;
+
+            DestroySubsystem<XRDisplaySubsystem>();
+            DestroySubsystem<XRInputSubsystem>();
+            if (PXR_ProjectSetting.GetProjectConfig().spatialMesh)
+            {
+                if (meshSubsystem.running)
+                {
+                    StopSubsystem<XRMeshSubsystem>();
+                }
+                PXR_Plugin.MixedReality.UPxr_DisposeMesh();
+                DestroySubsystem<XRMeshSubsystem>();
+            }
+#if XR_HANDS
+            DestroySubsystem<XRHandSubsystem>();
+#endif
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+            if (PXR_ProjectSetting.GetProjectConfig().arFoundation)
+            {
+                DestroySubsystem<XRCameraSubsystem>();
+                if (PXR_ProjectSetting.GetProjectConfig().bodyTracking)
+                {
+                    DestroySubsystem<XRHumanBodySubsystem>();
+                }
+
+                if (PXR_ProjectSetting.GetProjectConfig().faceTracking)
+                {
+                    DestroySubsystem<XRFaceSubsystem>();
+                }
+            }
+#endif
+
+            PXR_Plugin.System.UPxr_DeinitializeFocusCallback();
+
+            if (PXR_ProjectSetting.GetProjectConfig().spatialAnchor)
+            {
+                PXR_MixedReality.GetSenseDataProviderState(PxrSenseDataProviderType.SpatialAnchor, out var providerState);
+                if (providerState == PxrSenseDataProviderState.Running)
+                {
+                    PXR_MixedReality.StopSenseDataProvider(PxrSenseDataProviderType.SpatialAnchor);
+                }
+                PXR_Plugin.MixedReality.UPxr_DestroySenseDataProvider(PXR_Plugin.MixedReality.UPxr_GetSenseDataProviderHandle(PxrSenseDataProviderType.SpatialAnchor));
+            }
+            if (PXR_ProjectSetting.GetProjectConfig().sceneCapture)
+            {
+                PXR_MixedReality.GetSenseDataProviderState(PxrSenseDataProviderType.SceneCapture, out var providerState);
+                if (providerState == PxrSenseDataProviderState.Running)
+                {
+                    PXR_MixedReality.StopSenseDataProvider(PxrSenseDataProviderType.SceneCapture);
+                }
+                PXR_Plugin.MixedReality.UPxr_DestroySenseDataProvider(PXR_Plugin.MixedReality.UPxr_GetSenseDataProviderHandle(PxrSenseDataProviderType.SceneCapture));
+            }
+            currentLoaderState = LoaderState.Uninitialized;
+
+            return true;
+        }
+
+        [MonoPInvokeCallback(typeof(ConvertRotationWith2VectorDelegate))]
+        static Quaternion ConvertRotationWith2Vector(Vector3 from, Vector3 to)
+        {
+            return Quaternion.FromToRotation(from, to);
+        }
+
+        [MonoPInvokeCallback(typeof(XrEventDataBufferCallBack))]
+        static void XrEventDataBufferFunction(ref XrEventDataBuffer eventDB)
+        {
+            int status, action;
+            PLog.d("PxrUnity",$"XrEventDataBufferFunction eventType={eventDB.type}",false);
+            switch (eventDB.type)
+            {
+                case XrStructureType.XR_TYPE_EVENT_DATA_SESSION_STATE_CHANGED:
+                    
+                    int sessionstate = BitConverter.ToInt32(eventDB.data, 8);
+                    Debug.Log($"XrEventDataBufferFunction sessionstate={sessionstate}");
+                    if (PXR_Plugin.System.SessionStateChanged != null)
+                    {                        
+                        PXR_Plugin.System.SessionStateChanged((XrSessionState)sessionstate);
+                    }
+#if AR_FOUNDATION_5 || AR_FOUNDATION_6
+                    PXR_SessionSubsystem.instance?.OnSessionStateChange((XrSessionState)sessionstate);
+#endif
+#if XR_COMPOSITION_LAYERS
+                    OnSessionStateChanged((XrSessionState)sessionstate);
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_CONTROLLER_STATE_CHANGED_PICO:
+
+                    XrDeviceEventType eventType = (XrDeviceEventType)eventDB.data[0];
+                    status = eventDB.data[5];
+                    action = eventDB.data[6];
+                    PLog.i(TAG, $"Controller eventType={eventType}, status={status}, action={action}", false);
+                    switch (eventType)
+                    {
+                        case XrDeviceEventType.XR_DEVICE_INPUTDEVICE_CHANGED:
+                            if (PXR_Plugin.System.InputDeviceChanged != null)
+                            {
+                                PXR_Plugin.System.InputDeviceChanged(status);
+                            }
+                            break;
+                    }
+
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_DISPLAY_REFRESH_RATE_CHANGED_FB:
+                    float drRate = BitConverter.ToSingle(eventDB.data, 4);
+                    if (PXR_Plugin.System.DisplayRefreshRateChangedAction != null)
+                    {
+                        PXR_Plugin.System.DisplayRefreshRateChangedAction(drRate);
+                    }
+
+                    PLog.i(TAG, $"RefreshRateChanged value ={drRate}", false);
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_SEETHROUGH_STATE_CHANGED:
+                    status = BitConverter.ToInt32(eventDB.data, 0);
+                    PXR_Plugin.Boundary.seeThroughState = status;
+                    if (PXR_Plugin.Boundary.SeethroughStateChangedAction != null)
+                    {
+                        PXR_Plugin.Boundary.SeethroughStateChangedAction(status);
+                    }
+
+                    PLog.i(TAG, $"SeethroughStateChanged status ={status}", false);
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_MRC_STATUS_CHANGED_PICO:
+                    status = BitConverter.ToInt32(eventDB.data, 0);
+                    PLog.i(TAG, $"XR_TYPE_EVENT_DATA_MRC_STATUS_CHANGED_PICO status ={status}", false);
+                    PXR_Plugin.System.enableMRC = status == 1;
+                    if (PXR_Plugin.System.MRCStateChangedAction != null)
+                    {
+                        PXR_Plugin.System.MRCStateChangedAction(status == 1);
+                    }
+
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_LOG_LEVEL_CHANGE:
+                    status = BitConverter.ToInt32(eventDB.data, 4);
+                    PLog.logLevel = (PLog.LogLevel)status;
+                    PLog.i(TAG, $"SDKLoglevelChanged logLevel ={status}", false);
+
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_USER_PRESENCE_CHANGED_EXT:
+                    bool isUserPresent = BitConverter.ToBoolean(eventDB.data, 8);
+                    if (PXR_Plugin.System.UserPresenceChangedAction != null)
+                    {
+                        PXR_Plugin.System.UserPresenceChangedAction(isUserPresent);
+                    }
+
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_KEY_EVENT:
+                    if (PXR_Plugin.System.RecenterSuccess != null)
+                    {
+                        PXR_Plugin.System.RecenterSuccess();
+                    }
+
+                    break;
+                
+                case XrStructureType.XR_TYPE_EVENT_DATA_ENVIRONMENT_BLEND_MODE_CHANGED_EXT:
+                    if (PXR_Manager.VstDisplayStatusChanged != null)
+                    {
+                        int status_ = BitConverter.ToInt32(eventDB.data, 8);
+                        PXR_Manager.VstDisplayStatusChanged(status_==1?PxrVstStatus.Disabled:PxrVstStatus.Enabled);
+                    }
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_SENSE_DATA_PROVIDER_STATE_CHANGED:
+                case XrStructureType.XR_TYPE_EVENT_DATA_SENSE_DATA_UPDATED:
+                case XrStructureType.XR_TYPE_EVENT_DATA_AUTO_SCENE_CAPTURE_UPDATE_PICO:
+                {
+                    PXR_Manager.Instance.PollEvent(eventDB);
+                    break;
+                }
+                case XrStructureType.XR_TYPE_EVENT_DATA_REQUEST_MOTION_TRACKER_COMPLETE:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.RequestMotionTrackerCompleteAction != null)
+                    {
+                        RequestMotionTrackerCompleteEventData requestMotionTrackerCompleteEventData = new RequestMotionTrackerCompleteEventData();
+                        requestMotionTrackerCompleteEventData.trackerCount = BitConverter.ToUInt32(eventDB.data, 0);
+                        requestMotionTrackerCompleteEventData.trackerIds = new long[requestMotionTrackerCompleteEventData.trackerCount];
+                        for (int i = 0; i < requestMotionTrackerCompleteEventData.trackerCount; i++)
+                        {
+                            requestMotionTrackerCompleteEventData.trackerIds[i] = BitConverter.ToInt16(eventDB.data, 8+ 8 * i);
+                        }
+
+                        requestMotionTrackerCompleteEventData.result =
+                            (PxrResult)BitConverter.ToInt32(eventDB.data, 4 + 8 * (int)requestMotionTrackerCompleteEventData.trackerCount);
+                        PXR_MotionTracking.RequestMotionTrackerCompleteAction(requestMotionTrackerCompleteEventData);
+                    }
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_MOTION_TRACKER_CONNECTION_STATE_CHANGED:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.MotionTrackerConnectionAction != null)
+                    {
+                        Int64 trackerId = BitConverter.ToInt64(eventDB.data, 0);
+                        int state =  BitConverter.ToInt32(eventDB.data, 8);
+                        PXR_MotionTracking.MotionTrackerConnectionAction(trackerId, state);
+                    }
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_MOTION_TRACKER_POWER_KEY_EVENT:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.MotionTrackerPowerKeyAction != null)
+                    {
+                        Int64 trackerId = BitConverter.ToInt64(eventDB.data, 0);
+                        bool state =  BitConverter.ToBoolean(eventDB.data, 8);
+                        PXR_MotionTracking.MotionTrackerPowerKeyAction(trackerId, state);
+                    }
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_EXPAND_DEVICE_CONNECTION_STATE_CHANGED:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.ExpandDeviceConnectionAction != null)
+                    {
+                        UInt64 trackerId = BitConverter.ToUInt64(eventDB.data, 0);
+                        int state =  BitConverter.ToInt32(eventDB.data, 8);
+                        PXR_MotionTracking.ExpandDeviceConnectionAction((long)trackerId, state);
+                    }
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_EXPAND_DEVICE_BATTERY_STATE_CHANGED:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.ExpandDeviceBatteryAction != null)
+                    {
+                        
+                        ExpandDeviceBatteryEventData expandDevice = new ExpandDeviceBatteryEventData();
+                        expandDevice.deviceId = BitConverter.ToUInt64(eventDB.data, 0);
+                        expandDevice.batteryLevel = BitConverter.ToSingle(eventDB.data, 8);
+                        expandDevice.chargingState = (XrBatteryChargingState)BitConverter.ToInt32(eventDB.data, 12);
+                      
+                        PXR_MotionTracking.ExpandDeviceBatteryAction(expandDevice);
+                    }
+#endif
+                    break;
+                case XrStructureType.XR_TYPE_EVENT_DATA_EXPAND_DEVICE_CUSTOM_DATA_STATE_CHANGED:
+#if PICO_OPENXR_SDK
+#else
+                    if (PXR_MotionTracking.ExtDevPassDataAction != null)
+                    {
+                        status = BitConverter.ToInt32(eventDB.data, 0);
+                        PXR_MotionTracking.ExtDevPassDataAction(status);
+                    }
+#endif
+                    break;
+            }
+        }
+
+        public PXR_Settings GetSettings()
+        {
+            PXR_Settings settings = null;
+#if UNITY_EDITOR
+            UnityEditor.EditorBuildSettings.TryGetConfigObject<PXR_Settings>("Unity.XR.PXR.Settings", out settings);
+#endif
+#if UNITY_ANDROID && !UNITY_EDITOR
+            settings = PXR_Settings.settings;
+#endif
+            return settings;
+        }
+
+#if UNITY_EDITOR
+        public string GetPreInitLibraryName(BuildTarget buildTarget, BuildTargetGroup buildTargetGroup)
+        {
+            return "PxrPlatform";
+        }
+#endif
+
+#if UNITY_ANDROID && !UNITY_EDITOR
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
+        static void RuntimeLoadPicoPlugin()
+        {
+            string version = "UnityXR_" + PXR_Plugin.System.UPxr_GetSDKVersion() + "_" + Application.unityVersion;
+            PXR_Plugin.System.UPxr_SetConfigString( ConfigType.EngineVersion, version );
+        }
+#endif
+
+        private static bool _isSessionActive = false;
+        public static void OnSessionStateChanged(XrSessionState state)
+        {
+            PLog.i(TAG, $"OnSessionStateChanged Session state changed to: {state}");
+#if XR_COMPOSITION_LAYERS
+            if (state == XrSessionState.Focused && !_isSessionActive)
+            {
+                if (CompositionLayerManager.Instance != null)
+                {
+                    PLog.i(TAG, $"OnSessionBegin OpenXRLayerProvider");
+                    CompositionLayerManager.Instance.LayerProvider ??= new PXR_LayerProvider();
+                    _isSessionActive = true;
+                }
+            }
+            else if (state == XrSessionState.Stopping && _isSessionActive)
+            {
+                if (CompositionLayerManager.Instance?.LayerProvider is PXR_LayerProvider)
+                {
+                    PLog.i(TAG, $"OnSessionEnd OpenXRLayerProvider");
+                    ((PXR_LayerProvider)CompositionLayerManager.Instance.LayerProvider).Dispose();
+                    CompositionLayerManager.Instance.LayerProvider = null;
+                    _isSessionActive = false;
+                }
+            }
+#endif
+        }        
+    }
+}