예제 #1
0
            public void UpdateAdditiveAnimation(SteamVR_Action_Skeleton skeletonAction, SteamVR_Input_Sources inputSource)
            {
                SteamVR_Skeleton_PoseSnapshot snapshot = GetHandSnapshot(inputSource);
                SteamVR_Skeleton_Pose_Hand    poseHand = pose.GetHand(inputSource);

                for (int boneIndex = 0; boneIndex < snapshotL.bonePositions.Length; boneIndex++)
                {
                    int fingerIndex = SteamVR_Skeleton_JointIndexes.GetFingerForBone(boneIndex);
                    SteamVR_Skeleton_FingerExtensionTypes extensionType = poseHand.GetMovementTypeForBone(boneIndex);

                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Free)
                    {
                        snapshot.bonePositions[boneIndex] = skeletonAction.bonePositions[boneIndex];
                        snapshot.boneRotations[boneIndex] = skeletonAction.boneRotations[boneIndex];
                    }
                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Extend)
                    {
                        // lerp to open pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], skeletonAction.bonePositions[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], skeletonAction.boneRotations[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                    }
                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Contract)
                    {
                        // lerp to closed pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], skeletonAction.bonePositions[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], skeletonAction.boneRotations[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                    }
                }
            }
            public void UpdateAdditiveAnimation(SteamVR_Action_Skeleton skeletonAction, SteamVR_Input_Sources inputSource)
            {
                if (skeletonAction.GetSkeletalTrackingLevel() == EVRSkeletalTrackingLevel.VRSkeletalTracking_Estimated)
                {
                    //do not apply additive animation on low fidelity controllers, eg. Vive Wands and Touch
                    return;
                }

                SteamVR_Skeleton_PoseSnapshot snapshot = GetHandSnapshot(inputSource);
                SteamVR_Skeleton_Pose_Hand    poseHand = pose.GetHand(inputSource);

                for (int boneIndex = 0; boneIndex < snapshotL.bonePositions.Length; boneIndex++)
                {
                    int fingerIndex = SteamVR_Skeleton_JointIndexes.GetFingerForBone(boneIndex);
                    SteamVR_Skeleton_FingerExtensionTypes extensionType = poseHand.GetMovementTypeForBone(boneIndex);

                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Free)
                    {
                        snapshot.bonePositions[boneIndex] = skeletonAction.bonePositions[boneIndex];
                        snapshot.boneRotations[boneIndex] = skeletonAction.boneRotations[boneIndex];
                    }
                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Extend)
                    {
                        // lerp to open pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], skeletonAction.bonePositions[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], skeletonAction.boneRotations[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                    }
                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Contract)
                    {
                        // lerp to closed pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], skeletonAction.bonePositions[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], skeletonAction.boneRotations[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                    }
                }
            }
예제 #3
0
            public void UpdateAdditiveAnimation(SteamVR_Action_Skeleton skeletonAction, HandType inputSource)
            {
                SteamVR_Skeleton_PoseSnapshot snapshot = GetHandSnapshot(inputSource);
                SteamVR_Skeleton_Pose_Hand    poseHand = pose.GetHand(inputSource);

                //setup mirrored pose buffers
                if (additivePositionBuffer == null)
                {
                    additivePositionBuffer = new Vector3[skeletonAction.boneCount];
                }
                if (additiveRotationBuffer == null)
                {
                    additiveRotationBuffer = new Quaternion[skeletonAction.boneCount];
                }


                for (int boneIndex = 0; boneIndex < snapshotL.bonePositions.Length; boneIndex++)
                {
                    // if ((boneIndex == 1) || (boneIndex == 0))
                    //     continue;

                    int fingerIndex = SteamVR_Skeleton_JointIndexes.GetFingerForBone(boneIndex);
                    SteamVR_Skeleton_FingerExtensionTypes extensionType = poseHand.GetMovementTypeForBone(boneIndex);

                    //do target pose mirroring on left hand
                    if (inputSource == HandType.LeftHand)
                    {
                        SteamVR_Behaviour_Skeleton.MirrorBonePosition(ref skeletonAction.bonePositions[boneIndex], ref additivePositionBuffer[boneIndex], boneIndex);
                        SteamVR_Behaviour_Skeleton.MirrorBoneRotation(ref skeletonAction.boneRotations[boneIndex], ref additiveRotationBuffer[boneIndex], boneIndex);
                    }
                    else
                    {
                        additivePositionBuffer[boneIndex] = skeletonAction.bonePositions[boneIndex];
                        additiveRotationBuffer[boneIndex] = skeletonAction.boneRotations[boneIndex];
                    }



                    if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Free)
                    {
                        snapshot.bonePositions[boneIndex] = additivePositionBuffer[boneIndex];
                        snapshot.boneRotations[boneIndex] = additiveRotationBuffer[boneIndex];
                    }
                    else if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Extend)
                    {
                        // lerp to open pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], additivePositionBuffer[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], additiveRotationBuffer[boneIndex], 1 - skeletonAction.fingerCurls[fingerIndex]);
                    }
                    else if (extensionType == SteamVR_Skeleton_FingerExtensionTypes.Contract)
                    {
                        // lerp to closed pose by fingercurl
                        snapshot.bonePositions[boneIndex] = Vector3.Lerp(poseHand.bonePositions[boneIndex], additivePositionBuffer[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                        snapshot.boneRotations[boneIndex] = Quaternion.Lerp(poseHand.boneRotations[boneIndex], additiveRotationBuffer[boneIndex], skeletonAction.fingerCurls[fingerIndex]);
                    }
                }
            }
예제 #4
0
        protected virtual Quaternion GetBlendPoseForBone(int boneIndex, Quaternion skeletonRotation)
        {
            SteamVR_Skeleton_FingerExtensionTypes movementType = blendToPose.GetMovementTypeForBone(boneIndex);
            Quaternion poseRotation = blendToPose.boneRotations[boneIndex];

            if (movementType == SteamVR_Skeleton_FingerExtensionTypes.Free)
            {
                return(skeletonRotation);
            }
            else if (movementType == SteamVR_Skeleton_FingerExtensionTypes.Static)
            {
                return(poseRotation);
            }
            else
            {
                Vector3 localForward = bones[boneIndex].localRotation * Vector3.forward;
                //z rotation is curl
                Vector3 poseForward     = poseRotation * localForward;
                Vector3 skeletonForward = skeletonRotation * localForward;

                float poseAngle     = Mathf.Atan2(poseForward.x, poseForward.y) * Mathf.Rad2Deg;
                float skeletonAngle = Mathf.Atan2(skeletonForward.x, skeletonForward.y) * Mathf.Rad2Deg;

                float angleDifference = Mathf.DeltaAngle(poseAngle, skeletonAngle);

                if (movementType == SteamVR_Skeleton_FingerExtensionTypes.Contract)
                {
                    if (angleDifference > 0)
                    {
                        return(poseRotation * Quaternion.Euler(0, 0, -angleDifference));
                    }
                    else
                    {
                        return(poseRotation);
                    }
                }
                else if (movementType == SteamVR_Skeleton_FingerExtensionTypes.Extend)
                {
                    if (angleDifference < 0)
                    {
                        return(poseRotation * Quaternion.Euler(0, 0, -angleDifference));
                    }
                    else
                    {
                        return(poseRotation);
                    }
                }
            }

            return(Quaternion.identity);
        }
        protected void DrawHand(SteamVR_Skeleton_Pose_Hand handData, SteamVR_Skeleton_Pose_Hand otherData) //, bool getFromOpposite)
        {
            EditorGUIUtility.labelWidth = 120;
            SteamVR_Skeleton_FingerExtensionTypes newThumb  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Thumb", handData.thumbFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newIndex  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Index", handData.indexFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newMiddle = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Middle", handData.middleFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newRing   = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Ring", handData.ringFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newPinky  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Pinky", handData.pinkyFingerMovementType);

            EditorGUIUtility.labelWidth = 0;

            if (newThumb != handData.thumbFingerMovementType || newIndex != handData.indexFingerMovementType ||
                newMiddle != handData.middleFingerMovementType || newRing != handData.ringFingerMovementType ||
                newPinky != handData.pinkyFingerMovementType)
            {
                handData.thumbFingerMovementType  = newThumb;
                handData.indexFingerMovementType  = newIndex;
                handData.middleFingerMovementType = newMiddle;
                handData.ringFingerMovementType   = newRing;
                handData.pinkyFingerMovementType  = newPinky;

                EditorUtility.SetDirty(poserBehavior);//.skeletonMainPose);
            }
        }
        protected void DrawHand(bool showHand, SteamVR_Skeleton_Pose_Hand handData, SteamVR_Skeleton_Pose_Hand otherData, bool getFromOpposite, SerializedProperty showPreviewProperty)
        {
            SteamVR_Behaviour_Skeleton thisSkeleton;
            SteamVR_Behaviour_Skeleton oppositeSkeleton;
            string thisSourceString;
            string oppositeSourceString;

            if (handData.inputSource == SteamVR_Input_Sources.LeftHand)
            {
                thisSkeleton         = leftSkeleton;
                thisSourceString     = "Left Hand";
                oppositeSourceString = "Right Hand";
                oppositeSkeleton     = rightSkeleton;
            }
            else
            {
                thisSkeleton         = rightSkeleton;
                thisSourceString     = "Right Hand";
                oppositeSourceString = "Left Hand";
                oppositeSkeleton     = leftSkeleton;
            }


            if (showHand)
            {
                if (getFromOpposite)
                {
                    bool confirm = EditorUtility.DisplayDialog("SteamVR", string.Format("This will overwrite your current {0} skeleton data. (with data from the {1} skeleton)", thisSourceString, oppositeSourceString), "Overwrite", "Cancel");
                    if (confirm)
                    {
                        Vector3 reflectedPosition = new Vector3(-oppositeSkeleton.transform.localPosition.x, oppositeSkeleton.transform.localPosition.y, oppositeSkeleton.transform.localPosition.z);
                        thisSkeleton.transform.localPosition = reflectedPosition;

                        Quaternion oppositeRotation  = oppositeSkeleton.transform.localRotation;
                        Quaternion reflectedRotation = new Quaternion(-oppositeRotation.x, oppositeRotation.y, oppositeRotation.z, -oppositeRotation.w);
                        thisSkeleton.transform.localRotation = reflectedRotation;


                        for (int boneIndex = 0; boneIndex < SteamVR_Action_Skeleton.numBones; boneIndex++)
                        {
                            Transform boneThis     = thisSkeleton.GetBone(boneIndex);
                            Transform boneOpposite = oppositeSkeleton.GetBone(boneIndex);

                            boneThis.localPosition = boneOpposite.localPosition;
                            boneThis.localRotation = boneOpposite.localRotation;
                        }

                        handData.thumbFingerMovementType  = otherData.thumbFingerMovementType;
                        handData.indexFingerMovementType  = otherData.indexFingerMovementType;
                        handData.middleFingerMovementType = otherData.middleFingerMovementType;
                        handData.ringFingerMovementType   = otherData.ringFingerMovementType;
                        handData.pinkyFingerMovementType  = otherData.pinkyFingerMovementType;

                        EditorUtility.SetDirty(poser.skeletonMainPose);
                    }
                }
            }

            EditorGUIUtility.labelWidth = 120;
            SteamVR_Skeleton_FingerExtensionTypes newThumb  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Thumb movement", handData.thumbFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newIndex  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Index movement", handData.indexFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newMiddle = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Middle movement", handData.middleFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newRing   = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Ring movement", handData.ringFingerMovementType);
            SteamVR_Skeleton_FingerExtensionTypes newPinky  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Pinky movement", handData.pinkyFingerMovementType);

            EditorGUILayout.Space();

            EditorGUILayout.PropertyField(showPreviewProperty);
            EditorGUIUtility.labelWidth = 0;

            if (newThumb != handData.thumbFingerMovementType || newIndex != handData.indexFingerMovementType ||
                newMiddle != handData.middleFingerMovementType || newRing != handData.ringFingerMovementType ||
                newPinky != handData.pinkyFingerMovementType)
            {
                handData.thumbFingerMovementType  = newThumb;
                handData.indexFingerMovementType  = newIndex;
                handData.middleFingerMovementType = newMiddle;
                handData.ringFingerMovementType   = newRing;
                handData.pinkyFingerMovementType  = newPinky;

                EditorUtility.SetDirty(poser.skeletonMainPose);
            }
        }
예제 #7
0
        protected void DrawHand(bool showHand, SteamVR_Skeleton_Pose_Hand handData, SteamVR_Behaviour_Skeleton leftSkeleton, SteamVR_Behaviour_Skeleton rightSkeleton)
        {
            SteamVR_Behaviour_Skeleton thisSkeleton;
            SteamVR_Behaviour_Skeleton oppositeSkeleton;
            string thisSourceString;
            string oppositeSourceString;

            if (handData.inputSource == SteamVR_Input_Sources.LeftHand)
            {
                thisSkeleton         = leftSkeleton;
                thisSourceString     = "Left Hand";
                oppositeSourceString = "Right Hand";
                oppositeSkeleton     = rightSkeleton;
            }
            else
            {
                thisSkeleton         = rightSkeleton;
                thisSourceString     = "Right Hand";
                oppositeSourceString = "Left Hand";
                oppositeSkeleton     = leftSkeleton;
            }


            if (showHand)
            {
                bool save = GUILayout.Button(string.Format("Save {0}", thisSourceString));
                if (save)
                {
                    SaveHandData(handData, thisSkeleton);
                }

                bool getFromOpposite = GUILayout.Button(string.Format("Mirror {0} pose onto {1} skeleton", oppositeSourceString, thisSourceString));
                if (getFromOpposite)
                {
                    bool confirm = EditorUtility.DisplayDialog("SteamVR", string.Format("This will overwrite your current {0} skeleton data. (with data from the {1} skeleton)", thisSourceString, oppositeSourceString), "Overwrite", "Cancel");
                    if (confirm)
                    {
                        Vector3 reflectedPosition = new Vector3(-oppositeSkeleton.transform.localPosition.x, oppositeSkeleton.transform.localPosition.y, oppositeSkeleton.transform.localPosition.z);
                        thisSkeleton.transform.localPosition = reflectedPosition;

                        Quaternion oppositeRotation  = oppositeSkeleton.transform.localRotation;
                        Quaternion reflectedRotation = new Quaternion(-oppositeRotation.x, oppositeRotation.y, oppositeRotation.z, -oppositeRotation.w);
                        thisSkeleton.transform.localRotation = reflectedRotation;

                        handData.position = reflectedPosition;
                        handData.rotation = reflectedRotation;

                        handData.bonePositions = new Vector3[SteamVR_Action_Skeleton.numBones];
                        handData.boneRotations = new Quaternion[SteamVR_Action_Skeleton.numBones];

                        for (int boneIndex = 0; boneIndex < SteamVR_Action_Skeleton.numBones; boneIndex++)
                        {
                            Transform boneThis     = thisSkeleton.GetBone(boneIndex);
                            Transform boneOpposite = oppositeSkeleton.GetBone(boneIndex);

                            boneThis.localPosition = boneOpposite.localPosition;
                            boneThis.localRotation = boneOpposite.localRotation;

                            handData.bonePositions[boneIndex] = boneThis.localPosition;
                            handData.boneRotations[boneIndex] = boneThis.localRotation;
                        }

                        EditorUtility.SetDirty(poser.skeletonPose);
                    }
                }

                GUILayout.BeginHorizontal();
                GUILayout.Label("Force to reference pose");
                GUILayout.FlexibleSpace();

                forceToReferencePose = (EVRSkeletalReferencePose)EditorGUILayout.EnumPopup(forceToReferencePose);

                GUILayout.FlexibleSpace();
                bool forcePose = GUILayout.Button("set");
                GUILayout.EndHorizontal();
                if (forcePose)
                {
                    bool confirm = EditorUtility.DisplayDialog("SteamVR", string.Format("This will overwrite your current {0} skeleton data. (with data from the {1} reference pose)", thisSourceString, forceToReferencePose.ToString()), "Overwrite", "Cancel");
                    if (confirm)
                    {
                        thisSkeleton.ForceToReferencePose(forceToReferencePose);
                    }
                }

                SteamVR_Skeleton_FingerExtensionTypes newThumb  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Thumb movement", handData.thumbFingerMovementType);
                SteamVR_Skeleton_FingerExtensionTypes newIndex  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Index movement", handData.indexFingerMovementType);
                SteamVR_Skeleton_FingerExtensionTypes newMiddle = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Middle movement", handData.middleFingerMovementType);
                SteamVR_Skeleton_FingerExtensionTypes newRing   = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Ring movement", handData.ringFingerMovementType);
                SteamVR_Skeleton_FingerExtensionTypes newPinky  = (SteamVR_Skeleton_FingerExtensionTypes)EditorGUILayout.EnumPopup("Pinky movement", handData.pinkyFingerMovementType);

                if (newThumb != handData.thumbFingerMovementType || newIndex != handData.indexFingerMovementType ||
                    newMiddle != handData.middleFingerMovementType || newRing != handData.ringFingerMovementType ||
                    newPinky != handData.pinkyFingerMovementType)
                {
                    if ((int)newThumb >= 2 || (int)newIndex >= 2 || (int)newMiddle >= 2 || (int)newRing >= 2 || (int)newPinky >= 2)
                    {
                        Debug.LogError("<b>[SteamVR Input]</b> Unfortunately only Static and Free modes are supported in this beta.");
                        return;
                    }

                    handData.thumbFingerMovementType  = newThumb;
                    handData.indexFingerMovementType  = newIndex;
                    handData.middleFingerMovementType = newMiddle;
                    handData.ringFingerMovementType   = newRing;
                    handData.pinkyFingerMovementType  = newPinky;

                    EditorUtility.SetDirty(poser.skeletonPose);
                }
            }
        }