Exemplo n.º 1
0
        private void UpdateCapabilities()
        {
            var newCapabilities = ComputeInterfacesCapabilities() | enforcedCapabilities;

            if (currentCapabilities != newCapabilities)
            {
                var removedCaps = currentCapabilities & ~newCapabilities;
                if (removedCaps != ClientCapabilities.None)
                {
                    UnityFuncs.UnregisterCapabilities(removedCaps);
                    Headset.UnregisterCapabilities(removedCaps);
                }

                var addedCaps = newCapabilities & ~currentCapabilities;
                if (addedCaps != ClientCapabilities.None)
                {
                    UnityFuncs.RegisterCapabilities(addedCaps);
                    Headset.RegisterCapabilities(addedCaps);
                }

                currentCapabilities = newCapabilities;
            }
        }
        private IEnumerator FoveUpdateCoroutine()
        {
            if (FoveSettings.ShouldForceCalibration)
            {
                var err = m_headset.EnsureEyeTrackingCalibration();
                if (err != ErrorCode.None)
                {
                    Debug.Log("Error on EnsureEyeTrackingCalibration: " + err);
                }
            }

            var endOfFrameWait = new WaitForEndOfFrame();

            while (Application.isPlaying)
            {
                yield return(endOfFrameWait);

                ErrorCode err;
                err = m_headset.IsHardwareConnected(out m_isHmdConnected);
                if (err != ErrorCode.None)
                {
                    Debug.Log("Error checking hardware connection state: " + err);
                    break;
                }

                if (!m_isHmdConnected)
                {
                    Debug.Log("HMD was disconnected.");
                    break;
                }

                // update the headset capabilities if changed
                var newCapabilities = ComputeRequiredCapabilities();
                if (currentCapabilities != newCapabilities)
                {
                    var removedCaps = currentCapabilities & ~newCapabilities;
                    if (removedCaps != ClientCapabilities.None)
                    {
                        UnregisterCapabilities(removedCaps);
                        m_headset.UnregisterCapabilities(removedCaps);
                    }

                    var addedCaps = newCapabilities & ~currentCapabilities;
                    if (addedCaps != ClientCapabilities.None)
                    {
                        RegisterCapabilities(addedCaps);
                        m_headset.RegisterCapabilities(addedCaps);
                    }

                    currentCapabilities = newCapabilities;
                }

                UpdateHmdData();
                PoseUpdate.Invoke(m_sHeadPosition, m_sStandingPosition, m_sHeadRotation);
                EyePositionUpdate.Invoke(m_sLeftEyeOffset, m_sRightEyeOffset);
                EyeProjectionUpdate.Invoke();
                GazeUpdate.Invoke(m_sConvergenceData, m_sEyeVecLeft, m_sEyeVecRight);

                // Don't do any rendering code (below) if the compositor isn't ready
                if (!CompositorReadyCheck())
                {
                    continue;
                }

                // On first run and in case any new FoveInterfaces have been created
                if (unregisteredInterfaces.Count > 0)
                {
                    foreach (var reg in unregisteredInterfaces)
                    {
                        RegisterHelper(reg);
                    }
                    unregisteredInterfaces.Clear();
                }

                // Render all cameras, one eye at a time
                RenderTexture oldCurrent = RenderTexture.active;
                foreach (var list in m_interfaceStacks)
                {
                    int layerId = list.Key;
                    var eyeTx   = GetEyeTextures(layerId);

                    SetPoseForSubmit(layerId, _sLastPose);

                    if (eyeTx.areNew)
                    {
                        var texPtrLeft  = eyeTx.left.GetNativeTexturePtr();
                        var texPtrRight = eyeTx.right.GetNativeTexturePtr();

                        // texture native ptr get valid only after first flush
                        if (texPtrLeft != IntPtr.Zero && texPtrRight != IntPtr.Zero)
                        {
                            SetLeftEyeTexture(layerId, texPtrLeft);
                            SetRightEyeTexture(layerId, texPtrRight);
                            eyeTx.areNew = false;
                        }
                        else
                        {
                            // force the creation of the new render targets
                            Graphics.SetRenderTarget(eyeTx.left);
                            Graphics.SetRenderTarget(eyeTx.right);
                            GL.Flush();
                            break;
                        }
                    }

                    Graphics.SetRenderTarget(eyeTx.left);
                    GL.Clear(true, true, Color.clear);
                    Graphics.SetRenderTarget(eyeTx.right);
                    GL.Clear(true, true, Color.clear);

                    foreach (var interfaceInfo in list.Value)
                    {
                        interfaceInfo.xface.RenderEye(Eye.Left, eyeTx.left);
                        interfaceInfo.xface.RenderEye(Eye.Right, eyeTx.right);
                    }

                    GL.Flush();
                    GL.IssuePluginEvent(m_submitNativeFunc, layerId);

                    if (!FoveSettings.CustomDesktopView)
                    {
                        // this code works only because we only have one single layer (base) allowed for the moment
                        // TODO: Adapt this code as soon as we allow several layers
                        RenderTexture.active = oldCurrent;
                        m_screenBlitMaterial.SetTexture("_TexLeft", eyeTx.left);
                        m_screenBlitMaterial.SetTexture("_TexRight", eyeTx.right);
                        Graphics.Blit(null, m_screenBlitMaterial);
                    }
                }
                GL.Flush();

                // Wait for render pose
                GL.IssuePluginEvent(m_wfrpNativeFunc, 0);
            }

            StartCoroutine(CheckForHeadsetCoroutine());
        }