Example #1
0
        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;
                }

                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 xface in list.Value)
                    {
                        bool isLast = IsLast(layerId, xface);

                        xface.RenderEye(Eye.Left, eyeTx.left);
                        xface.RenderEye(Eye.Right, eyeTx.right);

                        if (isLast)
                        {
                            GL.Flush();
                            GL.IssuePluginEvent(m_submitNativeFunc, layerId);

                            // 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("_Tex1", eyeTx.left);
                            m_screenBlitMaterial.SetTexture("_Tex2", eyeTx.right);
                            Graphics.Blit(null, m_screenBlitMaterial);
                        }
                    }
                }
                GL.Flush();

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

            StartCoroutine(CheckForHeadsetCoroutine());
        }
Example #2
0
 public void AddPoseUpdateCallback(PoseUpdate update, int objectID)
 {
     //PoseUpdateCallbacks[objectID] += update;
     poseUpdate += update;
 }