コード例 #1
0
        private void SetUpCapsuleTriggerLogic()
        {
            if (_allCapsules.Count == 0)
            {
                Debug.LogError("Ensure EnableCapsulePhysics is enabled in the OVRSkeleton");
                return;
            }

            List <OVRBoneCapsule> _tipCapsules = new List <OVRBoneCapsule>();

            foreach (var tipBone in TIP_BONES)
            {
                OVRBoneCapsule capsule = _allCapsules.Find(c => c.BoneIndex == (short)tipBone);
                _tipCapsules.Add(capsule);

                capsule.CapsuleCollider.isTrigger = true;
                TriggerRelay relay = capsule.CapsuleRigidbody.gameObject.AddComponent <TriggerRelay>();
                relay.Grabber = grabber;
            }

            if (disableRest)
            {
                var midCapsules = _allCapsules.Except(_tipCapsules);
                foreach (var midCapsule in midCapsules)
                {
                    midCapsule.CapsuleCollider.enabled = false;
                }
            }
        }
コード例 #2
0
    private IEnumerator Start()
    {
        while (!HandsManager.Instance || !HandsManager.Instance.IsInitialized())
        {
            yield return(null);
        }

        _handManager  = HandsManager.Instance;
        _handSkeleton = GetComponentInParent <OVRSkeleton>();
        _hand         = GetComponentInParent <OVRHand>();

        if (!_handSkeleton || !_hand)
        {
            yield break;
        }

        switch (fingerToFollow)
        {
        case OVRPlugin.HandFinger.Thumb:
            _boneId = OVRSkeleton.BoneId.Hand_Thumb3;
            break;

        case OVRPlugin.HandFinger.Index:
            _boneId = OVRSkeleton.BoneId.Hand_Index3;
            break;

        case OVRPlugin.HandFinger.Middle:
            _boneId = OVRSkeleton.BoneId.Hand_Middle3;
            break;

        case OVRPlugin.HandFinger.Ring:
            _boneId = OVRSkeleton.BoneId.Hand_Ring3;
            break;

        case OVRPlugin.HandFinger.Pinky:
            _boneId = OVRSkeleton.BoneId.Hand_Pinky3;
            break;

        default:
            _boneId = OVRSkeleton.BoneId.Hand_Index3;
            break;
        }

//        var capsuleTriggers = new List<BoneCapsuleTriggerLogic>();
        var boneCapsules = HandsManager.GetCapsulesPerBone(_handSkeleton, _boneId);

//        foreach (var capsule in boneCapsules)
//        {
//            var capsuleTrigger = capsule.CapsuleRigidbody.gameObject.AddComponent<BoneCapsuleTriggerLogic>();
//            capsule.CapsuleCollider.isTrigger = true;
//            capsuleTriggers.Add(capsuleTrigger);
//        }

        if (boneCapsules.Count > 0)
        {
            _capsuleToTrack = boneCapsules[0];
        }

        _isInitialized = true;
    }
コード例 #3
0
    private void InitializeCapsules(OVRPlugin.Skeleton skeleton)
    {
        if (_enablePhysicsCapsules)
        {
            _capsules = new List <OVRBoneCapsule>(new OVRBoneCapsule[skeleton.NumBoneCapsules]);
            Capsules  = _capsules.AsReadOnly();

            if (!_capsulesGO)
            {
                _capsulesGO = new GameObject("Capsules");
                _capsulesGO.transform.SetParent(transform, false);
                _capsulesGO.transform.localPosition = Vector3.zero;
                _capsulesGO.transform.localRotation = Quaternion.identity;
            }

            _capsules = new List <OVRBoneCapsule>(new OVRBoneCapsule[skeleton.NumBoneCapsules]);
            Capsules  = _capsules.AsReadOnly();

            for (int i = 0; i < skeleton.NumBoneCapsules; ++i)
            {
                var       capsule = skeleton.BoneCapsules[i];
                Transform bone    = Bones[capsule.BoneIndex].Transform;

                var capsuleRigidBodyGO = new GameObject((_bones[capsule.BoneIndex].Id).ToString() + "_CapsuleRigidBody");
                capsuleRigidBodyGO.transform.SetParent(_capsulesGO.transform, false);
                capsuleRigidBodyGO.transform.position = bone.position;
                capsuleRigidBodyGO.transform.rotation = bone.rotation;

                var capsuleRigidBody = capsuleRigidBodyGO.AddComponent <Rigidbody>();
                capsuleRigidBody.mass        = 1.0f;
                capsuleRigidBody.isKinematic = true;
                capsuleRigidBody.useGravity  = false;
#if UNITY_2018_3_OR_NEWER
                capsuleRigidBody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
#else
                capsuleRigidBody.collisionDetectionMode = CollisionDetectionMode.Continuous;
#endif

                var capsuleColliderGO = new GameObject((_bones[capsule.BoneIndex].Id).ToString() + "_CapsuleCollider");
                capsuleColliderGO.transform.SetParent(capsuleRigidBodyGO.transform, false);
                var capsuleCollider = capsuleColliderGO.AddComponent <CapsuleCollider>();
                var p0    = capsule.Points[0].FromFlippedXVector3f();
                var p1    = capsule.Points[1].FromFlippedXVector3f();
                var delta = p1 - p0;
                var mag   = delta.magnitude;
                var rot   = Quaternion.FromToRotation(Vector3.right, delta);
                capsuleCollider.radius    = capsule.Radius;
                capsuleCollider.height    = mag + capsule.Radius * 2.0f;
                capsuleCollider.isTrigger = false;                 //Edit
                capsuleCollider.direction = 0;
                capsuleColliderGO.transform.localPosition = p0;
                capsuleColliderGO.transform.localRotation = rot;
                capsuleCollider.center = Vector3.right * mag * 0.5f;



                _capsules[i] = new OVRBoneCapsule(capsule.BoneIndex, capsuleRigidBody, capsuleCollider);
            }
        }
    }
コード例 #4
0
        private IEnumerator AttachTriggerLogic()
        {
            while (!HandsManager.Instance || !HandsManager.Instance.IsInitialized())
            {
                yield return(null);
            }

            OVRSkeleton handSkeleton = IsRightHandedTool ? HandsManager.Instance.RightHandSkeleton : HandsManager.Instance.LeftHandSkeleton;

            OVRSkeleton.BoneId boneToTestCollisions = OVRSkeleton.BoneId.Hand_Pinky3;
            switch (_fingerToFollow)
            {
            case OVRPlugin.HandFinger.Thumb:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Thumb3;
                break;

            case OVRPlugin.HandFinger.Index:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Index3;
                break;

            case OVRPlugin.HandFinger.Middle:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Middle3;
                break;

            case OVRPlugin.HandFinger.Ring:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Ring3;
                break;

            case OVRPlugin.HandFinger.Pinky:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Pinky3;
                break;

            default:
                boneToTestCollisions = OVRSkeleton.BoneId.Hand_Index3;
                break;
            }

            List <BoneCapsuleTriggerLogic> boneCapsuleTriggerLogic = new List <BoneCapsuleTriggerLogic>();
            List <OVRBoneCapsule>          boneCapsules            = HandsManager.GetCapsulesPerBone(handSkeleton, boneToTestCollisions);

            foreach (var ovrCapsuleInfo in boneCapsules)
            {
                var boneCapsuleTrigger = ovrCapsuleInfo.CapsuleRigidbody.gameObject.AddComponent <BoneCapsuleTriggerLogic>();
                ovrCapsuleInfo.CapsuleCollider.isTrigger = true;
                boneCapsuleTrigger.ToolTags = ToolTags;
                boneCapsuleTriggerLogic.Add(boneCapsuleTrigger);
            }

            _boneCapsuleTriggerLogic = boneCapsuleTriggerLogic.ToArray();
            // finger tip should have only one capsule
            if (boneCapsules.Count > 0)
            {
                _capsuleToTrack = boneCapsules[0];
            }

            _isInitialized = true;
        }
コード例 #5
0
    private void FixedUpdate()
    {
        if (!IsInitialized || _dataProvider == null)
        {
            IsDataValid          = false;
            IsDataHighConfidence = false;

            return;
        }

        Update();

        if (_enablePhysicsCapsules)
        {
            var data = _dataProvider.GetSkeletonPoseData();

            IsDataValid          = data.IsDataValid;
            IsDataHighConfidence = data.IsDataHighConfidence;

            for (int i = 0; i < _capsules.Count; ++i)
            {
                OVRBoneCapsule capsule   = _capsules[i];
                var            capsuleGO = capsule.CapsuleRigidbody.gameObject;

                if (data.IsDataValid && data.IsDataHighConfidence)
                {
                    Transform bone = _bones[(int)capsule.BoneIndex].Transform;

                    if (capsuleGO.activeSelf)
                    {
                        capsuleGO.SetActive(false);                        //fixing the physic capsule delay
                        capsuleGO.SetActive(true);                         //fixing the physic capsule delay
                        capsule.CapsuleRigidbody.MovePosition(bone.position);
                        capsule.CapsuleRigidbody.MoveRotation(bone.rotation);
                    }
                    else
                    {
                        capsuleGO.SetActive(true);
                        capsule.CapsuleRigidbody.position = bone.position;
                        capsule.CapsuleRigidbody.rotation = bone.rotation;
                    }
                }
                else
                {
                    if (capsuleGO.activeSelf)
                    {
                        capsuleGO.SetActive(false);
                    }
                }
            }
        }
    }
コード例 #6
0
    private void FixedUpdate()
    {
        if (_enablePhysicsCapsules)
        {
            for (int i = 0; i < _capsules.Count; ++i)
            {
                OVRBoneCapsule capsule = _capsules[i];
                Transform      bone    = _bones[(int)capsule.BoneIndex].Transform;

                capsule.CapsuleRigidbody.MovePosition(bone.position);
                capsule.CapsuleRigidbody.MoveRotation(bone.rotation);
            }
        }
    }
コード例 #7
0
ファイル: OVRSkeletonRenderer.cs プロジェクト: EV0320/hack
        public CapsuleVisualization(GameObject rootGO,
                                    Material renderMat,
                                    Material systemGestureMat,
                                    float scale,
                                    OVRBoneCapsule boneCapsule)
        {
            RenderMaterial        = renderMat;
            SystemGestureMaterial = systemGestureMat;

            BoneCapsule = boneCapsule;

            CapsuleGO = GameObject.CreatePrimitive(PrimitiveType.Capsule);
            CapsuleCollider collider = CapsuleGO.GetComponent <CapsuleCollider>();

            Destroy(collider);
            Renderer = CapsuleGO.GetComponent <MeshRenderer>();
            Renderer.sharedMaterial = RenderMaterial;

            capsuleScale   = Vector3.one;
            capsuleScale.y = boneCapsule.CapsuleCollider.height / 2;
            capsuleScale.x = boneCapsule.CapsuleCollider.radius * 2;
            capsuleScale.z = boneCapsule.CapsuleCollider.radius * 2;
            CapsuleGO.transform.localScale = capsuleScale * scale;
        }
コード例 #8
0
    private void InitializeCapsules()
    {
        bool flipX = (_skeletonType == SkeletonType.HandLeft || _skeletonType == SkeletonType.HandRight);

        if (_enablePhysicsCapsules)
        {
            if (!_capsulesGO)
            {
                _capsulesGO = new GameObject("Capsules");
                _capsulesGO.transform.SetParent(transform, false);
                _capsulesGO.transform.localPosition = Vector3.zero;
                _capsulesGO.transform.localRotation = Quaternion.identity;
            }

            if (_capsules == null || _capsules.Count != _skeleton.NumBoneCapsules)
            {
                _capsules = new List <OVRBoneCapsule>(new OVRBoneCapsule[_skeleton.NumBoneCapsules]);
                Capsules  = _capsules.AsReadOnly();
            }

            for (int i = 0; i < _capsules.Count; ++i)
            {
                OVRBone        bone    = _bones[_skeleton.BoneCapsules[i].BoneIndex];
                OVRBoneCapsule capsule = _capsules[i] ?? (_capsules[i] = new OVRBoneCapsule());
                capsule.BoneIndex = _skeleton.BoneCapsules[i].BoneIndex;

                if (capsule.CapsuleRigidbody == null)
                {
                    capsule.CapsuleRigidbody                        = new GameObject((bone.Id).ToString() + "_CapsuleRigidbody").AddComponent <Rigidbody>();
                    capsule.CapsuleRigidbody.mass                   = 1.0f;
                    capsule.CapsuleRigidbody.isKinematic            = true;
                    capsule.CapsuleRigidbody.useGravity             = false;
                    capsule.CapsuleRigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
                }

                GameObject rbGO = capsule.CapsuleRigidbody.gameObject;
                rbGO.transform.SetParent(_capsulesGO.transform, false);
                rbGO.transform.position = bone.Transform.position;
                rbGO.transform.rotation = bone.Transform.rotation;

                if (capsule.CapsuleCollider == null)
                {
                    capsule.CapsuleCollider           = new GameObject((bone.Id).ToString() + "_CapsuleCollider").AddComponent <CapsuleCollider>();
                    capsule.CapsuleCollider.isTrigger = false;
                }

                var p0    = flipX ? _skeleton.BoneCapsules[i].StartPoint.FromFlippedXVector3f() : _skeleton.BoneCapsules[i].StartPoint.FromFlippedZVector3f();
                var p1    = flipX ? _skeleton.BoneCapsules[i].EndPoint.FromFlippedXVector3f() : _skeleton.BoneCapsules[i].EndPoint.FromFlippedZVector3f();
                var delta = p1 - p0;
                var mag   = delta.magnitude;
                var rot   = Quaternion.FromToRotation(Vector3.right, delta);
                capsule.CapsuleCollider.radius    = _skeleton.BoneCapsules[i].Radius;
                capsule.CapsuleCollider.height    = mag + _skeleton.BoneCapsules[i].Radius * 2.0f;
                capsule.CapsuleCollider.direction = 0;
                capsule.CapsuleCollider.center    = Vector3.right * mag * 0.5f;

                GameObject ccGO = capsule.CapsuleCollider.gameObject;
                ccGO.transform.SetParent(rbGO.transform, false);
                ccGO.transform.localPosition = p0;
                ccGO.transform.localRotation = rot;
            }
        }
    }
コード例 #9
0
    private void Initialize()
    {
        var skeleton = new OVRPlugin.Skeleton();

        if (OVRPlugin.GetSkeleton((OVRPlugin.SkeletonType)_skeletonType, out skeleton))
        {
            if (!_bonesGO)
            {
                _bonesGO = new GameObject("Bones");
                _bonesGO.transform.SetParent(transform, false);
                _bonesGO.transform.localPosition = Vector3.zero;
                _bonesGO.transform.localRotation = Quaternion.identity;
            }

            if (!_bindPosesGO)
            {
                _bindPosesGO = new GameObject("BindPoses");
                _bindPosesGO.transform.SetParent(transform, false);
                _bindPosesGO.transform.localPosition = Vector3.zero;
                _bindPosesGO.transform.localRotation = Quaternion.identity;
            }

            if (_enablePhysicsCapsules)
            {
                if (!_capsulesGO)
                {
                    _capsulesGO = new GameObject("Capsules");
                    _capsulesGO.transform.SetParent(transform, false);
                    _capsulesGO.transform.localPosition = Vector3.zero;
                    _capsulesGO.transform.localRotation = Quaternion.identity;
                }
            }

            _bones = new List <OVRBone>(new OVRBone[skeleton.NumBones]);
            Bones  = _bones.AsReadOnly();

            _bindPoses = new List <OVRBone>(new OVRBone[skeleton.NumBones]);
            BindPoses  = _bindPoses.AsReadOnly();

            // pre-populate bones list before attempting to apply bone hierarchy
            for (int i = 0; i < skeleton.NumBones; ++i)
            {
                BoneId     id        = (OVRSkeleton.BoneId)skeleton.Bones[i].Id;
                short      parentIdx = skeleton.Bones[i].ParentBoneIndex;
                Vector3    pos       = skeleton.Bones[i].Pose.Position.FromFlippedZVector3f();
                Quaternion rot       = skeleton.Bones[i].Pose.Orientation.FromFlippedZQuatf();

                var boneGO = new GameObject(id.ToString());
                boneGO.transform.localPosition = pos;
                boneGO.transform.localRotation = rot;
                _bones[i] = new OVRBone(id, parentIdx, boneGO.transform);

                var bindPoseGO = new GameObject(id.ToString());
                bindPoseGO.transform.localPosition = pos;
                bindPoseGO.transform.localRotation = rot;
                _bindPoses[i] = new OVRBone(id, parentIdx, bindPoseGO.transform);
            }

            for (int i = 0; i < skeleton.NumBones; ++i)
            {
                if (((OVRPlugin.BoneId)skeleton.Bones[i].ParentBoneIndex) == OVRPlugin.BoneId.Invalid)
                {
                    _bones[i].Transform.SetParent(_bonesGO.transform, false);
                    _bindPoses[i].Transform.SetParent(_bindPosesGO.transform, false);
                }
                else
                {
                    _bones[i].Transform.SetParent(_bones[_bones[i].ParentBoneIndex].Transform, false);
                    _bindPoses[i].Transform.SetParent(_bindPoses[_bones[i].ParentBoneIndex].Transform, false);
                }
            }

            if (_enablePhysicsCapsules)
            {
                _capsules = new List <OVRBoneCapsule>(new OVRBoneCapsule[skeleton.NumBoneCapsules]);
                Capsules  = _capsules.AsReadOnly();

                for (int i = 0; i < skeleton.NumBoneCapsules; ++i)
                {
                    var       capsule = skeleton.BoneCapsules[i];
                    Transform bone    = Bones[capsule.BoneIndex].Transform;

                    var capsuleRigidBodyGO = new GameObject((_bones[capsule.BoneIndex].Id).ToString() + "_CapsuleRigidBody");
                    capsuleRigidBodyGO.transform.SetParent(_capsulesGO.transform, false);
                    capsuleRigidBodyGO.transform.localPosition = bone.position;
                    capsuleRigidBodyGO.transform.localRotation = bone.rotation;

                    var capsuleRigidBody = capsuleRigidBodyGO.AddComponent <Rigidbody>();
                    capsuleRigidBody.mass        = 1.0f;
                    capsuleRigidBody.isKinematic = true;
                    capsuleRigidBody.useGravity  = false;
#if UNITY_2018_3_OR_NEWER
                    capsuleRigidBody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
#else
                    capsuleRigidBody.collisionDetectionMode = CollisionDetectionMode.Continuous;
#endif

                    var capsuleColliderGO = new GameObject((_bones[capsule.BoneIndex].Id).ToString() + "_CapsuleCollider");
                    capsuleColliderGO.transform.SetParent(capsuleRigidBodyGO.transform, false);
                    var capsuleCollider = capsuleColliderGO.AddComponent <CapsuleCollider>();
                    var p0    = capsule.Points[0].FromFlippedZVector3f();
                    var p1    = capsule.Points[1].FromFlippedZVector3f();
                    var delta = p1 - p0;
                    var mag   = delta.magnitude;
                    var rot   = Quaternion.FromToRotation(capsuleRigidBodyGO.transform.localRotation * Vector3.right, delta);
                    capsuleCollider.radius    = capsule.Radius;
                    capsuleCollider.height    = mag + capsule.Radius * 2.0f;
                    capsuleCollider.isTrigger = false;
                    capsuleCollider.direction = 0;
                    capsuleColliderGO.transform.localPosition = p0;
                    capsuleColliderGO.transform.localRotation = rot;
                    capsuleCollider.center = Vector3.right * mag * 0.5f;

                    _capsules[i] = new OVRBoneCapsule(capsule.BoneIndex, capsuleRigidBody, capsuleCollider);
                }
            }

            _isInitialized = true;
        }
    }