private void UpdateMainCamTracking()
        {
            if (VIUSettings.simulatorAutoTrackMainCamera)
            {
                if (!m_autoTrackMainCam)
                {
                    m_autoTrackMainCam = true;
                    m_mainCamStartPose = new RigidPose(Camera.main.transform, true);
                }

                if (Camera.main != null)
                {
                    var hmd = VRModule.GetDeviceState(VRModule.HMD_DEVICE_INDEX);
                    if (hmd.isConnected)
                    {
                        RigidPose.SetPose(Camera.main.transform, hmd.pose);
                    }
                }
            }
            else
            {
                if (m_autoTrackMainCam)
                {
                    m_autoTrackMainCam = false;

                    if (Camera.main != null)
                    {
                        RigidPose.SetPose(Camera.main.transform, m_mainCamStartPose);
                    }
                }
            }
        }
        public virtual void OnNewPoses()
        {
            var deviceIndex = m_viveRole.GetDeviceIndex();

            if (VRModule.IsValidDeviceIndex(deviceIndex))
            {
                m_staticExCamPose = VivePose.GetPose(deviceIndex);
            }

            if (isQuadViewActive)
            {
                RigidPose.SetPose(transform, m_staticExCamPose, m_origin);
            }
        }
 public static void SetPose(Transform target, uint deviceIndex, Transform origin = null)
 {
     RigidPose.SetPose(target, GetPose(deviceIndex), origin);
 }
Exemple #4
0
 protected void TrackPose(RigidPose pose, Transform origin = null)
 {
     pose = pose * new RigidPose(posOffset, Quaternion.Euler(rotOffset));
     ModifyPose(ref pose, origin);
     RigidPose.SetPose(transform, pose, origin);
 }
        private void UpdatePoses()
        {
            if (!m_isValidModel)
            {
                return;
            }

            var deviceIndex = m_viveRole.GetDeviceIndex();

            if (!VRModule.IsValidDeviceIndex(deviceIndex))
            {
                return;
            }

            var deviceState = VRModule.GetCurrentDeviceState(deviceIndex);

            if (deviceState.GetValidHandJointCount() <= 0)
            {
                return;
            }

            // Store last pose
            foreach (var pair in m_modelJoints.EnumValues)
            {
                if (pair.Value)
                {
                    s_lastJointPoses[pair.Key] = new JointPose(pair.Value.position, pair.Value.rotation);
                }
                else
                {
                    s_lastJointPoses[pair.Key] = default(JointPose);
                }
            }

            var roomSpaceJoints           = deviceState.readOnlyHandJoints;
            var roomSpaceWristPose        = roomSpaceJoints[HandJointName.Wrist].pose;
            var roomSpaceWristPoseInverse = roomSpaceWristPose.GetInverse();
            var roomSpaceHandPoseInverse  = deviceState.pose.GetInverse();
            var wristTransform            = m_modelJoints[HandJointName.Wrist];

            wristTransform.localScale = Vector3.one;

            RigidPose wristLocalPose = roomSpaceHandPoseInverse * roomSpaceWristPose * m_modelOffsetInverse;

            wristTransform.localPosition = wristLocalPose.pos;
            wristTransform.localRotation = wristLocalPose.rot;

            var palmTransform = m_modelJoints[HandJointName.Palm];

            if (palmTransform != null)
            {
                var data = roomSpaceJoints[HandJointName.Palm];
                if (data.isValid)
                {
                    UpdateJointTransformLocal(wristTransform, palmTransform, roomSpaceWristPoseInverse * data.pose);
                }
            }

            UpdateFingerJoints(roomSpaceJoints, wristTransform, roomSpaceWristPoseInverse, HandJointName.ThumbTrapezium, HandJointName.ThumbTip);
            UpdateFingerJoints(roomSpaceJoints, wristTransform, roomSpaceWristPoseInverse, HandJointName.IndexMetacarpal, HandJointName.IndexTip);
            UpdateFingerJoints(roomSpaceJoints, wristTransform, roomSpaceWristPoseInverse, HandJointName.MiddleMetacarpal, HandJointName.MiddleTip);
            UpdateFingerJoints(roomSpaceJoints, wristTransform, roomSpaceWristPoseInverse, HandJointName.RingMetacarpal, HandJointName.RingTip);
            UpdateFingerJoints(roomSpaceJoints, wristTransform, roomSpaceWristPoseInverse, HandJointName.PinkyMetacarpal, HandJointName.PinkyTip);

            if (m_rigMode == RigMode.RotateAndScale)
            {
                wristTransform.localScale = Vector3.one * (CalculateJointLength(deviceState.readOnlyHandJoints) / m_modelLength);
            }

            // Stabilize
            if (m_stabilizerAngleThreshold > 0)
            {
                foreach (var pair in m_modelJoints.EnumValues)
                {
                    if (!pair.Value)
                    {
                        continue;
                    }

                    Quaternion lastRotation    = s_lastJointPoses[pair.Key].pose.rot;
                    Quaternion currentRotation = pair.Value.rotation;
                    float      diffAngle       = Quaternion.Angle(lastRotation, currentRotation);
                    if (diffAngle < m_stabilizerAngleThreshold)
                    {
                        if (m_stabilizerSlerpSpeedCoef > 0)
                        {
                            pair.Value.rotation = Quaternion.Slerp(lastRotation, currentRotation, m_stabilizerSlerpSpeedCoef * Time.deltaTime);
                        }
                        else
                        {
                            pair.Value.rotation = lastRotation;
                        }
                    }
                    else
                    {
                        pair.Value.rotation = Quaternion.RotateTowards(currentRotation, lastRotation, m_stabilizerAngleThreshold);
                    }
                }
            }

            if (m_debugJoint != null)
            {
                foreach (var joint in deviceState.readOnlyHandJoints.EnumValues)
                {
                    var index    = joint.Key;
                    var poseData = joint.Value;

                    if (poseData.isValid && TryInitDebugJoints())
                    {
                        var debugJointTransform = m_debugJoints[index];
                        if (debugJointTransform == null)
                        {
                            var obj = Instantiate(m_debugJoint);
                            obj.name = index.ToString();
                            obj.transform.SetParent(m_debugJointRoot.transform, false);
                            m_debugJoints[index] = debugJointTransform = obj.transform;
                        }

                        RigidPose.SetPose(debugJointTransform, roomSpaceHandPoseInverse * poseData.pose);
                    }
                }
            }
        }