static public bool BeginSession(IntPtr sessionHandle)
        {
            if (SRDProjectSettings.IsRunWithoutSRDisplayMode())
            {
                return(true);
            }
            if (sessionHandle == IntPtr.Zero)
            {
                return(false);
            }

            SrdXrResult xrResult = SRDCorePlugin.BeginSession(sessionHandle);

            if (xrResult == SrdXrResult.SUCCESS)
            {
                SRDCorePlugin.SetGraphicsAPI(sessionHandle, SystemInfo.graphicsDeviceType);
                SRDCorePlugin.SetColorSpaceSettings(sessionHandle, QualitySettings.desiredColorSpace);
                return(true);
            }

            var errorToMessage = new Dictionary <SrdXrResult, string>()
            {
                { SrdXrResult.ERROR_USB_NOT_CONNECTED, SRDHelper.SRDMessages.DeviceConnectionError },
                { SrdXrResult.ERROR_DEVICE_NOT_FOUND, SRDHelper.SRDMessages.DeviceNotFoundError },
                { SrdXrResult.ERROR_SESSION_RUNNING, SRDHelper.SRDMessages.AppConflictionError },
                { SrdXrResult.ERROR_USB_3_NOT_CONNECTED, SRDHelper.SRDMessages.USB3ConnectionError },
            };
            var msg = errorToMessage.ContainsKey(xrResult) ? errorToMessage[xrResult] : string.Format("Fail to begin seesion {0}", xrResult);

            SRDHelper.PopupMessageAndForceToTerminate(msg);
            return(false);
        }
        static public bool CreateSession(out IntPtr sessionHandle)
        {
            SRDCorePlugin.ShowNativeLog();
            if (SRDProjectSettings.IsRunWithoutSRDisplayMode())
            {
                sessionHandle = IntPtr.Zero;
                return(true);
            }
            SrdXrResult xrResult = SRDCorePlugin.CreateSession(out sessionHandle);

            if (xrResult == SrdXrResult.SUCCESS)
            {
                return(true);
            }

            var errorToMessage = new Dictionary <SrdXrResult, string>()
            {
                { SrdXrResult.ERROR_DISPLAY_NOT_FOUND, SRDHelper.SRDMessages.DisplayConnectionError },
                { SrdXrResult.ERROR_FORM_FACTOR_UNAVAILABLE, SRDHelper.SRDMessages.DisplayConnectionError },
                { SrdXrResult.ERROR_RUNTIME_NOT_FOUND, SRDHelper.SRDMessages.DLLNotFoundError },
            };
            // Should be set all possible message to the dict
            var msg = errorToMessage.ContainsKey(xrResult) ? errorToMessage[xrResult] : string.Format("Fail to create seesion {0}", xrResult);

            SRDHelper.PopupMessageAndForceToTerminate(msg);
            if (DestroySession(sessionHandle))
            {
                sessionHandle = IntPtr.Zero;
            }
            return(false);
        }
예제 #3
0
        public MouseBasedFaceTracker()
        {
            _facePose = SRDFaceTracker.CreateDefaultFacePose();
            _focus    = Utils.SRDSettings.DeviceInfo.BodyBounds.Center;

            var dispCenterPose = new Pose(Utils.SRDSettings.DeviceInfo.BodyBounds.Center, Quaternion.Euler(-45f, 180f, 0f));

            _posTrackCoordTdispCenerCoord = SRDHelper.PoseToMatrix(dispCenterPose);
            _dispCenerCoordTposTrackCoord = SRDHelper.PoseToMatrix(SRDHelper.InvPose(dispCenterPose));
        }
예제 #4
0
        /// <summary>
        /// Transform a point from screen space that Unity provides into actual Spatial Reality Display screen space.
        /// The inverse transform of <see cref="SRDCameras.SRDScreenToScreen">
        /// </summary>
        /// <param name="positionInScreen">Position in screen space to get from Unity API. For example, <a href="https://docs.unity3d.com/ScriptReference/Input-mousePosition.html">Input.mousePosition</a></param>
        /// <returns>A position in Spatial Reality Display screen space</returns>
        public Vector2 ScreenToSRDScreen(Vector2 positionInScreen)
        {
            var h = SRDHelper.CalcHomographyMatrix(_srdManager.DisplayEdges.LeftUp.position,
                                                   _srdManager.DisplayEdges.LeftBottom.position,
                                                   _srdManager.DisplayEdges.RightBottom.position,
                                                   _srdManager.DisplayEdges.RightUp.position,
                                                   _watcherCamera);
            var x = positionInScreen.x / Screen.width;
            var y = positionInScreen.y / Screen.height;
            var w = h[6] * x + h[7] * y + h[8];

            return(new Vector2(Screen.width * (h[0] * x + h[1] * y + h[2]) / w,
                               Screen.height * (h[3] * x + h[4] * y + h[5]) / w));
        }
        private SRDSessionHandler()
        {
            var isLinked = SRDCorePlugin.LinkXrLibraryWin64();

            if (!isLinked && _isLibraryLinked)
            {
                SRDHelper.PopupMessageAndForceToTerminate(SRDHelper.SRDMessages.DLLNotFoundError);
                _isLibraryLinked = false;
                return;
            }
            _isLibraryLinked = isLinked;

            _prevState = SrdXrSessionState.SESSION_STATE_MAX_ENUM;

            _srdSubsystems = new List <ISRDSubsystem>();
        }
        public void PollEvent()
        {
            SrdXrEventDataBuffer data;

            while (SRDCorePlugin.PollEvent(_sessionHandle, out data) == SrdXrResult.SUCCESS)
            {
                if ((_prevState == SrdXrSessionState.SESSION_STATE_MAX_ENUM) || (data.state != _prevState))
                {
                    if (OnSessionStateChangedEvent != null)
                    {
                        OnSessionStateChangedEvent.Invoke(_prevState, data.state);
                    }
                    _prevState = data.state;
                }

                if (data.state == SrdXrSessionState.SESSION_STATE_LOSS_PENDING)
                {
                    SrdXrDeviceState device_state;
                    var result = SRDCorePlugin.GetDeviceState(_sessionHandle, out device_state);
                    var msg    = "";
                    if (result != SrdXrResult.SUCCESS)
                    {
                        msg = string.Format("Fail to get DeviceInfo: {0}", result);
                    }
                    else
                    {
                        if (device_state.connection_state == SrdXrDeviceConnectionState.DEVICE_NOT_CONNECTED)
                        {
                            msg += SRDHelper.SRDMessages.DeviceInterruptionError + " ";
                        }
                        if (device_state.power_state == SrdXrDevicePowerState.DEVICE_POWER_OFF)
                        {
                            msg += SRDHelper.SRDMessages.DeviceNotFoundError;
                        }
                    }
                    SRDHelper.PopupMessageAndForceToTerminate(msg);
                }
            }
        }
        private void SetupCameraUpdateCallback(EyeType type)
        {
            var eyeCamera          = _eyeCamera[type];
            var eyeTransform       = _eyeTransform[type];
            var homographyMaterial = _eyeCamMaterial[type];

            Action <Camera> updateState = (camera) =>
            {
                _faceTracker.GetCurrentFacePose(out _currentFacePose);
                var eyePose = _currentFacePose.GetEyePose(type);
                eyeTransform.SetPositionAndRotation(eyePose.position, eyePose.rotation);

                _faceTracker.GetCurrentProjMatrices(eyeCamera.nearClipPlane, eyeCamera.farClipPlane,
                                                    out _currentProjMatrices);
                var projMat = _currentProjMatrices.GetProjectionMatrix(type);

                if (!SRDHelper.HasNanOrInf(projMat))
                {
                    eyeCamera.ResetProjectionMatrix();
                    eyeCamera.fieldOfView      = CalcVerticalFoVFromProjectionMatrix(projMat);
                    eyeCamera.aspect           = CalcAspectWperHFromProjectionMatrix(projMat);
                    eyeCamera.projectionMatrix = projMat;

                    if (_isBoxFrontClippingCache)
                    {
                        var nearClipPlaneTF = _srdManager.DisplayEdges.LeftBottom;
                        eyeCamera.projectionMatrix = CalcObliquedNearClipProjectionMatrix(eyeCamera, nearClipPlaneTF.forward,
                                                                                          nearClipPlaneTF.position + nearClipPlaneTF.forward * ObliquedNearClipOffset * nearClipPlaneTF.lossyScale.x);
                    }
                }

                var homographyMat = SRDHelper.CalcHomographyMatrix(_srdManager.DisplayEdges.LeftUp.position, _srdManager.DisplayEdges.LeftBottom.position,
                                                                   _srdManager.DisplayEdges.RightBottom.position, _srdManager.DisplayEdges.RightUp.position,
                                                                   eyeCamera);
                var invHomographyMat = SRDHelper.CalcInverseMatrix3x3(homographyMat);
                homographyMaterial.SetFloatArray("_Homography", invHomographyMat);
                homographyMaterial.SetFloatArray("_InvHomography", homographyMat);
            };

            if (_isSRPUsed)
            {
#if SRP_AVAILABLE
                SRPCallbackFunc srpCallback = (context, camera) =>
                {
                    if (camera.name != eyeCamera.name)
                    {
                        return;
                    }
                    updateState(camera);
                };
                _eyeCamSRPPreCallback[type] = srpCallback;
                RenderPipelineManager.beginCameraRendering += _eyeCamSRPPreCallback[type];
#endif
            }
            else
            {
                Camera.CameraCallback cameraStateUpdate = (camera) =>
                {
                    if (camera.name != eyeCamera.name)
                    {
                        return;
                    }
                    updateState(camera);
                };
                _eyeCamStateUpdateCallback[type] = cameraStateUpdate;
                // This Should be onPreCull for correct frustum culling, however onPreCull is fired before vblank sometimes.
                // That's why onPreRender is used to make the latency shorter as possible
                Camera.onPreRender += _eyeCamStateUpdateCallback[type];
            }
        }