Exemple #1
0
        private static void SetUpAppRemoting(BuildTargetGroup targetGroup)
        {
            Debug.Log($"Setting up app remoting for {targetGroup}");

            const string AppRemotingPlugin  = "Microsoft.MixedReality.OpenXR.Remoting.AppRemotingPlugin";
            Type         appRemotingFeature = typeof(AppRemoting).Assembly.GetType(AppRemotingPlugin);

            if (appRemotingFeature == null)
            {
                Debug.LogError($"Could not find {AppRemotingPlugin}. Has this class been removed or renamed?");
                return;
            }

            FeatureHelpers.RefreshFeatures(targetGroup);
            OpenXRFeature feature = OpenXRSettings.ActiveBuildTargetInstance.GetFeature(appRemotingFeature);

            if (feature == null)
            {
                Debug.LogError($"Could not load {AppRemotingPlugin} as an OpenXR feature. Has this class been removed or renamed?");
                return;
            }
            feature.enabled = true;

            XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(targetGroup);

            if (settings != null)
            {
                settings.InitManagerOnStart = false;
            }
        }
Exemple #2
0
        private bool IsExtensionEnabled(BuildTarget target, BuildTargetGroup group)
        {
            if (!BuildHelperUtils.HasLoader(group, typeof(OpenXRLoaderBase)))
            {
                return(false);
            }

            if (OpenXRSettings.ActiveBuildTargetInstance == null || OpenXRSettings.ActiveBuildTargetInstance.features == null)
            {
                return(false);
            }

            if (_ext == null || _ext.GetType() != featureType)
            {
                foreach (var ext in OpenXRSettings.ActiveBuildTargetInstance.features)
                {
                    if (featureType == ext.GetType())
                    {
                        _ext = ext;
                    }
                }
            }

            if (_ext == null || !_ext.enabled)
            {
                return(false);
            }

            return(true);
        }
        private static void ReceiveNativeEvent(OpenXRFeature.NativeEvent e, ulong payload)
        {
            var loader = Instance;

            if (loader != null)
            {
                loader.currentOpenXRState = e;
            }

            switch (e)
            {
            case OpenXRFeature.NativeEvent.XrRestartRequested:
                OpenXRRestarter.Instance.ShutdownAndRestart();
                break;

            case OpenXRFeature.NativeEvent.XrReady:
                loader.StartInternal();
                break;

            case OpenXRFeature.NativeEvent.XrFocused:
                DiagnosticReport.DumpReport("System Startup Completed");
                break;

            default:
                break;
            }

            OpenXRFeature.ReceiveNativeEvent(e, payload);

            if ((loader == null || !loader.isStarted) && e != OpenXRFeature.NativeEvent.XrInstanceChanged)
            {
                return;
            }

            switch (e)
            {
            case OpenXRFeature.NativeEvent.XrStopping:
                loader.StopInternal();
                break;

            case OpenXRFeature.NativeEvent.XrExiting:
                OpenXRRestarter.Instance.Shutdown();
                break;

            case OpenXRFeature.NativeEvent.XrLossPending:
                OpenXRRestarter.Instance.ShutdownAndRestart();
                break;

            case OpenXRFeature.NativeEvent.XrInstanceLossPending:
                OpenXRRestarter.Instance.Shutdown();
                break;

            default:
                break;
            }
        }
Exemple #4
0
        /// <summary>
        /// Gathers and evaluates validation issues and adds them to a list.
        /// </summary>
        /// <param name="issues">List of validation issues to populate. List is cleared before populating.</param>
        /// <param name="buildTarget">Build target group to check for validation issues</param>
        public static void GetCurrentValidationIssues(List <OpenXRFeature.ValidationRule> issues, BuildTargetGroup buildTargetGroup)
        {
            CachedValidationList.Clear();
            CachedValidationList.AddRange(BuiltinValidationRules);
            OpenXRFeature.GetValidationList(CachedValidationList, buildTargetGroup);

            issues.Clear();
            foreach (var validation in CachedValidationList)
            {
                if (!validation.checkPredicate?.Invoke() ?? false)
                {
                    issues.Add(validation);
                }
            }
        }
Exemple #5
0
        private void StopInternal()
        {
            OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemStop);

            if (inputSubsystem?.running ?? false)
            {
                StopSubsystem <XRInputSubsystem>();
            }

            if (displaySubsystem?.running ?? false)
            {
                StopSubsystem <XRDisplaySubsystem>();
            }

            OpenXRInput.Stop();

            Internal_EndSession();
        }
        private bool StartInternal()
        {
            // In order to get XrReady, we have to at least attempt to create
            // the session if it isn't already there.
            if (!Internal_CreateSessionIfNeeded())
            {
                return(false);
            }

            if (currentOpenXRState != OpenXRFeature.NativeEvent.XrReady ||
                (currentLoaderState != LoaderState.StartAttempted && currentLoaderState != LoaderState.Started))
            {
                return(true);
            }

            // calls xrBeginSession
            Internal_BeginSession();

            OpenXRInput.AttachActionSets();

            // Note: Display has to be started before Input so that Input can have access to the Session object
            StartSubsystem <XRDisplaySubsystem>();
            if (!displaySubsystem?.running ?? false)
            {
                return(false);
            }

            StartSubsystem <XRInputSubsystem>();
            if (!inputSubsystem?.running ?? false)
            {
                return(false);
            }

            OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemStart);

            return(true);
        }
Exemple #7
0
        private static void ReceiveNativeEvent(OpenXRFeature.NativeEvent e, ulong payload)
        {
            var loader = Instance;

            if (loader != null)
            {
                loader.currentOpenXRState = e;
            }

            switch (e)
            {
            case OpenXRFeature.NativeEvent.XrRestartRequested:
                CreateRestarter(loader, true);
                break;

            case OpenXRFeature.NativeEvent.XrReady:
                loader.StartInternal();
                break;

            case OpenXRFeature.NativeEvent.XrFocused:
                DiagnosticReport.DumpReport("System Startup Completed");
                break;

            default:
                break;
            }

            OpenXRFeature.ReceiveNativeEvent(e, payload);

            if ((loader == null || !loader.isStarted) && e != OpenXRFeature.NativeEvent.XrInstanceChanged)
            {
                return;
            }

            switch (e)
            {
            case OpenXRFeature.NativeEvent.XrInstanceChanged:
                OpenXRInput.InstanceHasChanged();
                OpenXRInput.SendActionDataToProvider();
                break;

            case OpenXRFeature.NativeEvent.XrSessionChanged:
                OpenXRInput.CreateActionsAndSuggestedBindings();
                OpenXRInput.AttachActionSetsToSession();
                break;

            case OpenXRFeature.NativeEvent.XrStopping:
                loader.StopInternal();
                break;

            case OpenXRFeature.NativeEvent.XrExiting:
                CreateRestarter(loader, false);
                break;

            case OpenXRFeature.NativeEvent.XrLossPending:
                CreateRestarter(loader, true);
                break;

            case OpenXRFeature.NativeEvent.XrInstanceLossPending:
                OpenXRLoader.CreateRestarter(loader, false);
                break;

            default:
                break;
            }
        }
Exemple #8
0
        /// <summary>
        /// See [XRLoader.DeInitialize](xref:UnityEngine.XR.Management.XRLoader.Stop)
        /// </summary>
        /// <returns>True if deinitialized, false otherwise.</returns>
        public override bool Deinitialize()
        {
            if (currentLoaderState == LoaderState.Uninitialized)
            {
                return(true);
            }

            if (!validLoaderDeinitStates.Contains(currentLoaderState))
            {
                return(false);
            }

            currentLoaderState = LoaderState.DeinitializeAttempted;

            try
            {
#if TEST_SUPPORT
                if (ShouldExitEarly())
                {
                    return(false);
                }

                // The test hook above will leave the loader in a half initialized state.  To work
                // around this we reset the instance pointer if it is missing.
                if (Instance == null)
                {
                    Instance = this;
                }
#endif
                Application.onBeforeRender -= ProcessOpenXRMessageLoop;

                ProcessOpenXRMessageLoop(); // Drain any remaining events.

                OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemDestroy);

                DestroySubsystem <XRInputSubsystem>();
                DestroySubsystem <XRDisplaySubsystem>();

                DiagnosticReport.DumpReport("System Shutdown");

                Internal_DestroySession();

                ProcessOpenXRMessageLoop();

                Internal_UnloadOpenXRLibrary();

                currentLoaderState = LoaderState.Uninitialized;

                if (unhandledExceptionHandler != null)
                {
                    AppDomain currentDomain = AppDomain.CurrentDomain;
                    currentDomain.UnhandledException -= unhandledExceptionHandler;
                    unhandledExceptionHandler         = null;
                }

                return(base.Deinitialize());
            }
            finally
            {
                // Ensure we always clear the instance reference even if some part of Deinitialize threw an exception
                Instance = null;
            }
        }
Exemple #9
0
        private bool InitializeInternal()
        {
            Instance = this;

            currentLoaderState = LoaderState.InitializeAttempted;

#if TEST_SUPPORT
            if (ShouldExitEarly())
            {
                return(false);
            }
#endif

#if UNITY_EDITOR
            if (!DisableValidationChecksOnEnteringPlaymode)
            {
                if (OpenXRProjectValidation.LogPlaymodeValidationIssues())
                {
                    return(false);
                }
            }
#endif

            OpenXRFeature.Initialize();

            if (!LoadOpenXRSymbols())
            {
                Debug.LogError("Failed to load openxr runtime loader.");
                return(false);
            }

            // Sort the features array by priority in descending order (highest priority first)
            OpenXRSettings.Instance.features = OpenXRSettings.Instance.features
                                               .Where(f => f != null)
                                               .OrderByDescending(f => f.priority)
                                               .ThenBy(f => f.nameUi)
                                               .ToArray();

            OpenXRFeature.HookGetInstanceProcAddr();

            if (!Internal_InitializeSession())
            {
                return(false);
            }

            SetApplicationInfo();
            RequestOpenXRFeatures();
            RegisterOpenXRCallbacks();

            if (null != OpenXRSettings.Instance)
            {
                OpenXRSettings.Instance.ApplySettings();
            }

            if (!CreateSubsystems())
            {
                return(false);
            }

            if (OpenXRFeature.requiredFeatureFailed)
            {
                return(false);
            }

            OpenXRAnalytics.SendInitializeEvent(true);

            OpenXRFeature.ReceiveLoaderEvent(this, OpenXRFeature.LoaderEvent.SubsystemCreate);

            OpenXRInput.Initialize();

            DebugLogEnabledSpecExtensions();

            Application.onBeforeRender += ProcessOpenXRMessageLoop;
            currentLoaderState          = LoaderState.Initialized;
            return(true);
        }
Exemple #10
0
        private void ApplySelectedConfiguration(MixedRealityProjectConfiguration selectedMRConfiguration)
        {
            bool             remoting = false;
            BuildTargetGroup targetGroup;

            switch (selectedMRConfiguration)
            {
            case MixedRealityProjectConfiguration.RunNativelyOnHL2:
                targetGroup = BuildTargetGroup.WSA;
                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.WSA, BuildTarget.WSAPlayer);
                EditorUserBuildSettings.wsaBuildAndRunDeployTarget = WSABuildAndRunDeployTarget.DevicePortal;
                EditorUserBuildSettings.wsaArchitecture            = "ARM64";
                break;

            case MixedRealityProjectConfiguration.RunNativelyOnPCVR:
                targetGroup = BuildTargetGroup.Standalone;
                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.Standalone, BuildTarget.StandaloneWindows64);
                break;

            case MixedRealityProjectConfiguration.RunRemotelyOnUWP:
                remoting    = true;
                targetGroup = BuildTargetGroup.WSA;
                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.WSA, BuildTarget.WSAPlayer);
                EditorUserBuildSettings.wsaBuildAndRunDeployTarget = WSABuildAndRunDeployTarget.LocalMachine;
                EditorUserBuildSettings.wsaArchitecture            = "Intel64";
                // Player Capabilities
                UnityEditor.PlayerSettings.WSA.SetCapability(UnityEditor.PlayerSettings.WSACapability.InternetClient, true);
                UnityEditor.PlayerSettings.WSA.SetCapability(UnityEditor.PlayerSettings.WSACapability.InternetClientServer, true);
                UnityEditor.PlayerSettings.WSA.SetCapability(UnityEditor.PlayerSettings.WSACapability.PrivateNetworkClientServer, true);
                break;

            case MixedRealityProjectConfiguration.RunRemotelyOnWin32:
                remoting    = true;
                targetGroup = BuildTargetGroup.Standalone;
                EditorUserBuildSettings.SwitchActiveBuildTargetAsync(BuildTargetGroup.Standalone, BuildTarget.StandaloneWindows64);
                break;

            default:
                return;
            }

            const string AppRemotingPlugin  = "Microsoft.MixedReality.OpenXR.Remoting.AppRemotingPlugin";
            Type         appRemotingFeature = typeof(AppRemoting).Assembly.GetType(AppRemotingPlugin);

            if (appRemotingFeature == null)
            {
                Debug.LogError($"Could not find {AppRemotingPlugin}. Has this class been removed or renamed?");
                return;
            }

            FeatureHelpers.RefreshFeatures(targetGroup);
            OpenXRFeature feature = OpenXRSettings.ActiveBuildTargetInstance.GetFeature(appRemotingFeature);

            if (feature == null)
            {
                Debug.LogError($"Could not load {AppRemotingPlugin} as an OpenXR feature. Has this class been removed or renamed?");
                return;
            }
            feature.enabled = remoting;

            XRGeneralSettings settings = XRGeneralSettingsPerBuildTarget.XRGeneralSettingsForBuildTarget(targetGroup);

            if (settings != null)
            {
                settings.InitManagerOnStart = !remoting;
            }
            Debug.Log($"Set up complete for {selectedMRConfiguration}");
        }