Esempio n. 1
0
        public BonePose AddBone(Bone _boneId, bool useSideBones = false)
        {
            BonePose newBonePose = new BonePose();

            SideBone sideBone = BoneReference.HumanoidSideBone(_boneId);

            if (sideBone == SideBone.None)
            {
                newBonePose.boneRef = new BoneReference()
                {
                    type   = BoneType.AllBones,
                    boneId = _boneId
                };
            }
            else
            {
                newBonePose.boneRef = new BoneReference()
                {
                    type       = BoneType.SideBones,
                    sideBoneId = sideBone
                };
            }
            newBonePose.translation = Vector3.zero;
            newBonePose.rotation    = Quaternion.identity;
            bonePoses.Add(newBonePose);

            return(newBonePose);
        }
Esempio n. 2
0
        private void UpdatePose(HumanoidControl humanoid, Bone boneId)
        {
            BonePose poseTargetBone = CheckBone(boneId);

            poseTargetBone.UpdateTranslation(humanoid);
            poseTargetBone.UpdateRotation(humanoid);
        }
Esempio n. 3
0
 private static void ResetBoneButton(BonePose selectedBone, HumanoidControl humanoid)
 {
     if (GUILayout.Button("Reset Bone", GUILayout.Width(100)))
     {
         Debug.Log("Got it to work.");
         selectedBone.setRotation = false;
         selectedBone.rotation    = Quaternion.identity;
         HumanoidTarget.TargetedBone targetedBone = humanoid.GetBone(selectedBone.boneRef.boneId);
         targetedBone.target.transform.localRotation = selectedBone.rotation;
     }
 }
Esempio n. 4
0
        public override void OnInspectorGUI()
        {
            for (int i = 0; i < pose.bonePoses.Count; i++)
            {
                BonePose bonePoses = pose.bonePoses[i];
                if (bonePoses == null)
                {
                    continue;
                }

                if (bonePoses.boneRef.type == BoneType.SideBones && bonePoses.boneRef.side == Side.AnySide)
                {
                    EditorGUILayout.HelpBox("Configure AnySide like Left Side", MessageType.Info);
                }
                EditorGUILayout.BeginHorizontal();
                bonePoses.boneRef.type = (BoneType)EditorGUILayout.EnumPopup(bonePoses.boneRef.type, GUILayout.Width(159));
                Bone     oldBoneId     = bonePoses.boneRef.boneId;
                SideBone oldSideBoneId = bonePoses.boneRef.sideBoneId;
                BoneSelector(ref bonePoses.boneRef);
                EditorGUILayout.EndHorizontal();

                if (bonePoses.boneRef.boneId != oldBoneId || bonePoses.boneRef.sideBoneId != oldSideBoneId)
                {
                    PresetReferenceBone(bonePoses.boneRef, ref bonePoses.referenceBoneRef);
                }

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.LabelField("Reference", GUILayout.MaxWidth(65));
                bonePoses.referenceBoneRef.type = (BoneType)EditorGUILayout.EnumPopup(bonePoses.referenceBoneRef.type, GUILayout.Width(90));

                BoneSelector(ref bonePoses.referenceBoneRef); EditorGUILayout.EndHorizontal();

                EditorGUI.indentLevel++;

                EditorGUILayout.BeginHorizontal();
                bonePoses.setTranslation = EditorGUILayout.ToggleLeft("Translation", bonePoses.setTranslation, GUILayout.MaxWidth(131));
                if (bonePoses.setTranslation)
                {
                    bonePoses.translation = EditorGUILayout.Vector3Field("", bonePoses.translation);
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                bonePoses.setRotation = EditorGUILayout.ToggleLeft("Rotation", bonePoses.setRotation, GUILayout.MaxWidth(131));
                if (bonePoses.setRotation)
                {
                    Vector3 eulerAngles = EditorGUILayout.Vector3Field("", bonePoses.rotation.eulerAngles);
                    if (eulerAngles != bonePoses.rotation.eulerAngles)
                    {
                        bonePoses.rotation.eulerAngles = eulerAngles;
                    }
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                bonePoses.setScale = EditorGUILayout.ToggleLeft("Scale", bonePoses.setScale, GUILayout.MaxWidth(131));
                if (bonePoses.setScale)
                {
                    bonePoses.scale = EditorGUILayout.Vector3Field("", bonePoses.scale);
                }
                EditorGUILayout.EndHorizontal();

                EditorGUI.indentLevel--;
            }
            Buttons();
            EditorUtility.SetDirty(pose);
        }
Esempio n. 5
0
        public static void UpdateScene(HumanoidControl humanoid, ITarget target, PoseMixer poseMixer, ref BonePose selectedBone, Side side = Side.AnySide)
        {
            //if (!Application.isPlaying)
            //    poseMixer.ShowPose(humanoid);

            MixedPose currentPose = poseMixer.GetEditedPose();

            if (currentPose == null || !currentPose.isEdited)
            {
                Tools.hidden = false;
                return;
            }

            Tools.hidden = true;

            HumanoidTarget.TargetedBone[] bones = target.GetBones();
            int[]  controlIds = new int[bones.Length];
            Bone[] boneIds    = new Bone[bones.Length];

            for (int i = 0; i < bones.Length; i++)
            {
                if (bones[i] == null || bones[i].bone == null || bones[i].bone.transform == null)
                {
                    continue;
                }

                Handles.FreeMoveHandle(bones[i].bone.transform.position, bones[i].bone.transform.rotation, 0.002F, Vector3.zero, DotHandleCapSaveID);
                controlIds[i] = lastControlID;
                boneIds[i]    = bones[i].boneId;
            }

            FindSelectedHandle(controlIds, boneIds, ref boneIndex);
            if (boneIndex == -1)
            {
                return;
            }

            HumanoidTarget.TargetedBone targetedBone = FindTargetedBone(bones, boneIds[boneIndex]);
            if (targetedBone == null || targetedBone.bone.transform == null)
            {
                return;
            }

            GUIStyle style = new GUIStyle();

            style.normal.textColor = Color.yellow;
            Handles.Label(targetedBone.bone.transform.position + Vector3.up * 0.01F, targetedBone.name, style);
            Handles.color = Color.white;

            switch (Tools.current)
            {
            case Tool.Move:
                selectedBone = currentPose.pose.CheckBone(boneIds[boneIndex], true);
                Vector3 handlePosition = Handles.PositionHandle(targetedBone.target.transform.position, targetedBone.bone.transform.rotation);
                targetedBone.target.transform.position = handlePosition;
                selectedBone.setTranslation            = true;
                selectedBone.SetReferenceLocal(humanoid, side);
                selectedBone.UpdateTranslation(humanoid, side);
                break;

            case Tool.Rotate:
                selectedBone = currentPose.pose.CheckBone(boneIds[boneIndex], true);
                Quaternion handleRotation = Handles.RotationHandle(targetedBone.target.transform.rotation, targetedBone.bone.transform.position);
                targetedBone.target.transform.rotation = handleRotation;
                selectedBone.setRotation = true;
                selectedBone.SetReferenceLocal(humanoid, side);
                selectedBone.UpdateRotation(humanoid, side);
                break;

            case Tool.Scale:
                //Handles.ScaleHandle(selectedBone.transform.localScale, selectedBone.transform.position, selectedBone.transform.rotation, HandleUtility.GetHandleSize(selectedBone.transform.position));
                // need to all morphScale first...
                break;
            }

            Handles.BeginGUI();
            ResetBoneButton(selectedBone, humanoid);
            Handles.EndGUI();
        }