コード例 #1
0
 void UpdateMasterBonePos(MasterBoneModel masterBone, AbstractTsf inputData, float maxSpeed)
 {
     if (inputData.space == Space.World)
     {
         if (maxSpeed > 0.0f)
         {
             masterBone.transformRef.position += Vector3.ClampMagnitude(inputData.position - masterBone.transformRef.position, maxSpeed * Time.deltaTime);
         }
         else
         {
             masterBone.transformRef.position = inputData.position;
         }
     }
     else
     {
         if (maxSpeed > 0.0f)
         {
             // Clamp is relative to scale (!)
             masterBone.transformRef.localPosition += Vector3.ClampMagnitude(inputData.position - masterBone.transformRef.localPosition, maxSpeed * Time.deltaTime);
         }
         else
         {
             masterBone.transformRef.localPosition = inputData.position;
         }
     }
 }
コード例 #2
0
 void UpdateMasterBoneRot(MasterBoneModel masterBone, AbstractTsf inputData, float maxSpeed)
 {
     if (inputData.space == Space.World)
     {
         if (maxSpeed > 0.0f)
         {
             masterBone.transformRef.localRotation = BasicHelpers.ClampQuaternion(masterBone.transformRef.localRotation, Quaternion.Inverse(masterBone.transformRef.parent.rotation) * inputData.rotation, maxSpeed * Time.deltaTime);
         }
         else
         {
             masterBone.transformRef.rotation = inputData.rotation;
         }
     }
     else
     {
         if (maxSpeed > 0.0f)
         {
             masterBone.transformRef.localRotation = BasicHelpers.ClampQuaternion(masterBone.transformRef.localRotation, inputData.rotation, maxSpeed * Time.deltaTime);
         }
         else
         {
             masterBone.transformRef.localRotation = inputData.rotation;
         }
     }
 }
コード例 #3
0
    public void ApplyToArmature()
    {
        if (!hand)
        {
            return;
        }

        if (!hand.proxyHand)
        {
            Debug.LogError("Hand.ProxyHand is NULL!");
            return;
        }

        if (hand.fingers.Length != hand.proxyHand.master.fingers.Length)
        {
            Debug.LogError("Hand.fingers and Hand.proxyHand.master.fingers have to have the same length!");
            return;
        }

        MasterBoneModel masterWristBone = hand.proxyHand.master.wrist as MasterBoneModel;

        if (masterWristBone.armatureBone)
        {
            if (space == Space.World)
            {
                masterWristBone.armatureBone.rotation = hand.wrist.transformRef.rotation * masterWristBone.relativeToOriginalArmatureWorld;
            }
            else
            {
                /* unsupported */

                Debug.LogError("Local space is not supported!");
                return;
            }
        }


        for (int f = 0; f < hand.fingers.Length; f++)
        {
            for (int b = 0; b < hand.fingers[f].bones.Length; b++)
            {
                BoneModel bone = hand.fingers[f].bones[b];

                MasterBoneModel masterBone = hand.proxyHand.master.fingers[f].bones[b] as MasterBoneModel;

                if (masterBone.armatureBone)
                {
                    if (space == Space.World)
                    {
                        masterBone.armatureBone.rotation = bone.transformRef.rotation * masterBone.relativeToOriginalArmatureWorld;
                    }
                    else
                    {
                        /* unreachable */
                    }
                }
            }
        }
    }
コード例 #4
0
    public MasterBoneModel CastBone(BoneModel bone)
    {
        MasterBoneModel masterBone = bone.gameObject.AddComponent <MasterBoneModel>();

        masterBone.transformRef = bone.transformRef;
        Destroy(bone);
        return(masterBone);
    }
コード例 #5
0
 void UpdateMasterBonePos(MasterBoneModel masterBone, AbstractTsf inputData)
 {
     if (inputData.space == Space.World)
     {
         masterBone.transformRef.position = inputData.position;
     }
     else
     {
         masterBone.transformRef.localPosition = inputData.position;
     }
 }
コード例 #6
0
 void UpdateMasterBoneRot(MasterBoneModel masterBone, AbstractTsf inputData)
 {
     if (inputData.space == Space.World)
     {
         masterBone.transformRef.rotation = inputData.rotation;
     }
     else
     {
         masterBone.transformRef.localRotation = inputData.rotation;
     }
 }
コード例 #7
0
ファイル: AutomaticHandSetup.cs プロジェクト: guptam/HPTK
    void SetupMasterHandModel(MasterHandModel handModel, Transform masterWrist, Transform masterWristOffset)
    {
        // CustomHand > [Modules] > ProxyHandModule > ProxyHandModel > Master > Wrist
        GameObject wristBoneModelObj = BasicHelpers.InstantiateEmptyChild(handModel.gameObject);

        wristBoneModelObj.name = "Wrist";

        MasterBoneModel wristBone = wristBoneModelObj.AddComponent <MasterBoneModel>();

        wristBone.transformRef = masterWrist;
        handModel.wrist        = wristBone;

        /* SLAVE BONE MODEL SPECIFIC
         */

        wristBone.offset = masterWristOffset;

        /*
         */

        // Set SkinnedMR
        handModel.skinnedMR = masterWrist.GetComponent <SkinnedMeshRenderer>();

        List <FingerModel> fingers = new List <FingerModel>();

        for (int f = 0; f < masterWristOffset.childCount; f++)
        {
            // If childCount is 0, then it's not a finger
            if (masterWristOffset.GetChild(f).childCount == 0)
            {
                continue;
            }

            // CustomHand > [Modules] > ProxyHandModule > ProxyHandModel > Master > Finger
            GameObject fingerModelObj = BasicHelpers.InstantiateEmptyChild(handModel.gameObject);
            fingerModelObj.name = "Finger" + f;

            FingerModel fingerModel = fingerModelObj.AddComponent <FingerModel>();

            List <BoneModel> bones = new List <BoneModel>();

            Transform[] fingerTransforms = GetFingerTransforms(masterWristOffset.GetChild(f));
            for (int b = 0; b < fingerTransforms.Length; b++)
            {
                // If childCount is 0, then it's a fingerTip
                if (fingerTransforms[b].childCount == 0)
                {
                    fingerModel.fingerTip = fingerTransforms[b];
                    continue;
                }

                // CustomHand > [Modules] > ProxyHandModule > ProxyHandModel > Master > Finger > Bone

                GameObject boneModelObj = BasicHelpers.InstantiateEmptyChild(fingerModelObj);
                boneModelObj.transform.name = "Bone" + b;

                MasterBoneModel masterBone = boneModelObj.AddComponent <MasterBoneModel>();
                masterBone.transformRef = fingerTransforms[b];

                bones.Add(masterBone);
            }

            fingerModel.fingerBase = bones[0].transformRef;
            fingerModel.distal     = bones[bones.Count - 1];

            fingerModel.bones = bones.ToArray();

            /* SLAVE BONE MODEL SPECIFIC
             */

            /*
             */

            fingers.Add(fingerModel);

            if (f == indexSiblingIndex)
            {
                fingerModel.name = "Index";
                handModel.index  = fingerModel;
            }

            if (f == thumbSiblingIndex)
            {
                fingerModel.name = "Thumb";
                handModel.thumb  = fingerModel;
            }
        }

        handModel.fingers = fingers.ToArray();
    }