예제 #1
0
        void Gizmos_DrawArrowGuide()
        {
            if (SpineBones.Count <= 0)
            {
                return;
            }
            Transform LeadBone      = GetHeadBone();
            Transform BaseTransform = GetBaseTransform();

            if (_editor_arrowsAlpha > 0f)
            {
                float   d          = Vector3.Distance(LeadBone.position, GetBaseTransform().position);
                Vector3 arrowStart = Vector3.Lerp(GetBaseTransform().position, LeadBone.position, 0.75f);

                Handles.color = new Color(0.05f, 0.225f, 1f, 0.9f * _editor_arrowsAlpha);
                FGUI_Handles.DrawArrow(GetBaseTransform().TransformDirection(ModelForwardAxis) * d * 1.25f + arrowStart, Quaternion.LookRotation(GetBaseTransform().TransformDirection(ModelForwardAxis), BaseTransform.TransformDirection(ModelUpAxis)), d * 0.8f);

                Handles.color = new Color(0.05f, 0.8f, 0.05f, 0.75f * _editor_arrowsAlpha);
                arrowStart    = LeadBone.position + GetBaseTransform().TransformDirection(ModelUpAxis) * d * .95f;
                FGUI_Handles.DrawArrow(arrowStart, Quaternion.LookRotation(GetBaseTransform().TransformDirection(ModelUpAxis), GetBaseTransform().TransformDirection(ModelForwardAxis)), d * 0.7f, 4f, 0.5f);
            }

            if (_editor_arrowsAlpha > -0.1f)
            {
                _editor_arrowsAlpha -= 0.01f;
            }
        }
예제 #2
0
        void Gizmos_DrawEndBoneJoint()
        {
            // Drawing auto end joint offset
            if (FEngineering.VIsZero(EndBoneJointOffset))
            {
                Transform t = _TransformsGhostChain[_TransformsGhostChain.Count - 1];
                Transform p = _TransformsGhostChain[_TransformsGhostChain.Count - 1].parent;

                if (p) // Reference from parent
                {
                    Vector3 worldOffset = t.position - p.position;

                    Handles.color = new Color(0.3f, .3f, 1f, 0.8f);
                    FGUI_Handles.DrawBoneHandle(t.position, t.position + worldOffset, BaseTransform.forward, 1f);
                }
                else // Reference to child
                {
                    if (t.childCount > 0)
                    {
                        Transform ch          = _TransformsGhostChain[0].GetChild(0);
                        Vector3   worldOffset = ch.position - t.position;
                        FGUI_Handles.DrawBoneHandle(t.position, t.position + worldOffset, BaseTransform.forward, 1f);
                    }
                }
            }
            // Drawing custom joint offset
            else
            {
                Transform t = _TransformsGhostChain[_TransformsGhostChain.Count - 1];
                Handles.color = new Color(0.3f, .3f, 1f, 0.8f);
                FGUI_Handles.DrawBoneHandle(t.position, t.position + t.TransformVector(EndBoneJointOffset), BaseTransform.forward, 1f);
            }
        }
예제 #3
0
        private void Gizmos_DrawArrowGuide()
        {
            if (BaseTransform == null)
            {
                return;
            }
            if (LeadBone == null)
            {
                return;
            }

            if (_editor_arrowsAlpha > 0f)
            {
                float   d          = Vector3.Distance(LeadBone.position, BaseTransform.position);
                Vector3 arrowStart = Vector3.Lerp(BaseTransform.position, LeadBone.position, 0.7f);

                Handles.color = new Color(0.05f, 0.225f, 1f, 0.9f * _editor_arrowsAlpha);
                FGUI_Handles.DrawArrow(BaseTransform.TransformDirection(ModelForwardAxis) * d * .22f + arrowStart, Quaternion.LookRotation(BaseTransform.TransformDirection(ModelForwardAxis), BaseTransform.TransformDirection(ModelUpAxis)), d * 0.2f);

                Handles.color = new Color(0.05f, 0.8f, 0.05f, 0.75f * _editor_arrowsAlpha);
                arrowStart    = LeadBone.position + BaseTransform.TransformDirection(ModelUpAxis) * d * .285f;
                FGUI_Handles.DrawArrow(arrowStart, Quaternion.LookRotation(BaseTransform.TransformDirection(ModelUpAxis), BaseTransform.TransformDirection(ModelForwardAxis)), d * 0.15f, 4f, 0.5f);
            }

            if (_editor_arrowsAlpha > -0.1f)
            {
                _editor_arrowsAlpha -= 0.0125f;
            }
        }
예제 #4
0
        void Gizmos_DrawSetupChain()
        {
            Handles.color = new Color(0.1f, 1f, 0.9f, gizmosAlpha * 0.5f);
            float distRef = _gizmosDist;

            // Draw Target Chain Ghost
            if (_gizmosEditorStartPreview && _gizmosEditorEndPreview)
            {
                distRef = Vector3.Distance(_gizmosEditorStartPreview.transform.position, _gizmosEditorEndPreview.transform.position) / 7.5f;

                if (_gizmosChainList == null)
                {
                    _GizmosRefreshChainList();
                }
                else
                {
                    if (_gizmosChainList.Count == 0)
                    {
                        _GizmosRefreshChainList();
                    }
                    else
                    {
                        if (_gizmosChainList.Count > 0)
                        {
                            if (_gizmosEditorStartPreview != _gizmosChainList[0])
                            {
                                _GizmosRefreshChainList();
                            }
                        }
                        if (_gizmosChainList.Count > 1)
                        {
                            if (_gizmosEditorEndPreview != _gizmosChainList[_gizmosChainList.Count - 1])
                            {
                                _GizmosRefreshChainList();
                            }
                        }
                    }
                }

                Handles.color = new Color(.1f, .9f, .8f, gizmosAlpha * 0.25f);
                for (int i = 1; i < _gizmosChainList.Count; i++)
                {
                    FGUI_Handles.DrawBoneHandle(_gizmosChainList[i - 1].position, _gizmosChainList[i].position, GetBaseTransform().TransformDirection(ModelUpAxis), 1.2f);
                }
            }

            Handles.color = new Color(0.1f, 1f, 0.9f, gizmosAlpha * 0.5f);

            if (_gizmosEditorStartPreview)
            {
                Handles.color = new Color(0.1f, 1f, 0.9f, gizmosAlpha * 0.1f);
                for (int i = 0; i < _gizmosEditorStartPreview.childCount; i++)
                {
                    if (_gizmosChainList.Count > 1)
                    {
                        if (_gizmosEditorStartPreview.GetChild(i) == _gizmosChainList[1])
                        {
                            continue;
                        }
                    }
                    Handles.DrawDottedLine(_gizmosEditorStartPreview.position, _gizmosEditorStartPreview.GetChild(i).position, 2f);
                    Handles.SphereHandleCap(0, _gizmosEditorStartPreview.GetChild(i).position, Quaternion.identity, distRef * 0.2f, EventType.Repaint);
                }

                Handles.color = new Color(0.1f, 1f, 0.9f, gizmosAlpha * 0.5f);
                Handles.SphereHandleCap(0, _gizmosEditorStartPreview.position, Quaternion.identity, distRef * 0.425f, EventType.Repaint);
                Handles.color = new Color(1f, 1f, 1f, gizmosAlpha * 0.5f);
                string title = _gizmosEditorStartPreview.childCount <= 2 ? "Chain Start (No Legs?)" : "Chain Start";
                Handles.Label(_gizmosEditorStartPreview.position + GetBaseTransform().TransformDirection(ModelUpAxis) * _gizmosDist, new GUIContent(title), FGUI_Resources.HeaderStyle);
            }

            if (_gizmosEditorEndPreview)
            {
                Handles.color = new Color(0.1f, 1f, 0.9f, gizmosAlpha * 0.1f);
                for (int i = 0; i < _gizmosEditorEndPreview.childCount; i++)
                {
                    if (_gizmosChainList.Count > 2)
                    {
                        if (_gizmosEditorEndPreview.GetChild(i) == _gizmosChainList[_gizmosChainList.Count - 2])
                        {
                            continue;
                        }
                    }
                    Handles.DrawDottedLine(_gizmosEditorEndPreview.position, _gizmosEditorEndPreview.GetChild(i).position, 2f);
                    Handles.SphereHandleCap(0, _gizmosEditorEndPreview.GetChild(i).position, Quaternion.identity, distRef * 0.2f, EventType.Repaint);
                }

                Handles.color = new Color(0.15f, 1f, 0.85f, gizmosAlpha * 0.5f);
                Handles.SphereHandleCap(0, _gizmosEditorEndPreview.position, Quaternion.identity, distRef * 0.425f, EventType.Repaint);
                Handles.color = new Color(1f, 1f, 1f, gizmosAlpha * 0.5f);
                Handles.Label(_gizmosEditorEndPreview.position + GetBaseTransform().TransformDirection(ModelUpAxis) * _gizmosDist, new GUIContent("Chain End"), FGUI_Resources.HeaderStyle);
            }
        }
예제 #5
0
        void Gizmos_DrawBonesChainPlayMode()
        {
            if (!_editorSetupDrawing)
            {
                return;
            }

            Color c         = Handles.color;
            Color boneColor = new Color(0.075f, .85f, 0.3f, gizmosAlpha * 0.2f);

            Handles.color = boneColor;

            if (LastBoneLeading == false)
            {
                Handles.color = new Color(.9f, .9f, .9f, gizmosAlpha * 0.2f);
                for (int i = 1; i < SpineBones.Count; i++)
                {
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ReferencePosition, SpineBones[i - 1].ReferencePosition, GetBaseTransform().TransformDirection(ModelUpAxis), 0.6f);
                }

                for (int i = 1; i < SpineBones.Count; i++)
                {
                    Handles.color = new Color(0.075f, .85f, 0.3f, gizmosAlpha * 0.5f * SpineBones[i].MotionWeight);
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ProceduralPosition, SpineBones[i - 1].ProceduralPosition, GetBaseTransform().TransformDirection(ModelUpAxis), 1.2f);
                }
            }
            else
            {
                Handles.color = new Color(.9f, .9f, .9f, gizmosAlpha * 0.2f);
                for (int i = SpineBones.Count - 2; i >= 0; i--)
                {
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ReferencePosition, SpineBones[i + 1].ReferencePosition, GetBaseTransform().TransformDirection(ModelUpAxis), 0.6f);
                }

                for (int i = SpineBones.Count - 2; i >= 0; i--)
                {
                    Handles.color = new Color(0.075f, .85f, 0.3f, gizmosAlpha * 0.5f * SpineBones[i].MotionWeight);
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ProceduralPosition, SpineBones[i + 1].ProceduralPosition, GetBaseTransform().TransformDirection(ModelUpAxis), 1.2f);
                }
            }

            if (DebugGizmos)
            {
                for (int i = 0; i < SpineBones.Count; i++)
                {
                    Gizmos.color = new Color(1f, .1f, 0.1f, gizmosAlpha * 0.75f);
                    Gizmos.DrawRay(SpineBones[i].ProceduralPosition, SpineBones[i].ProceduralRotation * Vector3.right);

                    Gizmos.color = new Color(.1f, 1f, 0.1f, gizmosAlpha * 0.75f);
                    Gizmos.DrawRay(SpineBones[i].ProceduralPosition, SpineBones[i].ProceduralRotation * Vector3.up);

                    Gizmos.color = new Color(.1f, .1f, 1f, gizmosAlpha * 0.75f);
                    Gizmos.DrawRay(SpineBones[i].ProceduralPosition, SpineBones[i].ProceduralRotation * Vector3.forward);
                }
            }

            Handles.color = boneColor;
            Gizmos_DrawHead(GetLeadBone().ProceduralPosition, GetBaseTransform(), ModelForwardAxis * (ReverseForward ? -1f : 1f), ModelUpAxis, _gizmosDist * 1.1f);

            Handles.color = c;
        }
예제 #6
0
        //bool prepared = false;
        void Gizmos_DrawBonesChainEditorMode()
        {
            if (LastBoneLeading == false)
            {
                for (int i = 0; i < SpineBones.Count; i++)
                {
                    SpineBones[i].ProceduralPosition = SpineBones[i].transform.position;
                }

                for (int i = 1; i < SpineBones.Count; i++)
                {
                    SpineBones[i].Editor_SetLength((SpineBones[i].transform.position - SpineBones[i - 1].transform.position).magnitude);
                    SpineBones[i].ProceduralRotation = Quaternion.LookRotation(SpineBones[i].transform.position - SpineBones[i - 1].transform.position, GetBaseTransform().up);

                    Vector3 dir = SpineBones[i].transform.position - SpineBones[i - 1].transform.position; Quaternion look = Quaternion.LookRotation(dir.normalized, GetBaseTransform().up);

                    // To bone position
                    SpineBones[i].ProceduralPosition = SpineBones[i - 1].ProceduralPosition + dir.normalized * SpineBones[i].BoneLength * DistancesMultiplier /* SpineBones[i].transform.lossyScale.z*/;

                    if (ManualAffectChain)
                    {
                        SpineBones[i].ProceduralPosition += look * (SpineBones[i].ManualPosOffset) * SpineBones[i].BoneLength;
                    }
                }

                // Backrotation
                SpineBones[0].ProceduralRotation = SpineBones[1].ProceduralRotation;
                SpineBones[0].Editor_SetLength(SpineBones[1].BoneLength);

                if (!ManualAffectChain)
                {
                    for (int i = 0; i < SpineBones.Count; i++)
                    {
                        SpineBones[i].ProceduralPosition += SpineBones[i].ProceduralRotation * (SpineBones[i].ManualPosOffset) * SpineBones[i].BoneLength;
                    }
                }

                for (int i = 0; i < SpineBones.Count; i++)
                {
                    SpineBones[i].ProceduralPosition += SpineBones[i].ProceduralRotation * -SegmentsPivotOffset * SpineBones[i].BoneLength;
                }
            }
            else
            {
                for (int i = 0; i < SpineBones.Count; i++)
                {
                    SpineBones[i].ProceduralPosition = SpineBones[i].transform.position;
                }

                for (int i = SpineBones.Count - 2; i >= 0; i--)
                {
                    SpineBones[i].Editor_SetLength((SpineBones[i].transform.position - SpineBones[i + 1].transform.position).magnitude);
                    Vector3 target = SpineBones[i].transform.position - SpineBones[i + 1].transform.position;
                    SpineBones[i].ProceduralRotation = target.sqrMagnitude == 0 ? Quaternion.identity : Quaternion.LookRotation(target, GetBaseTransform().up);

                    Vector3 dir = SpineBones[i].transform.position - SpineBones[i + 1].transform.position; Quaternion look = dir.sqrMagnitude == 0 ? Quaternion.identity : Quaternion.LookRotation(dir.normalized, GetBaseTransform().up);

                    // To bone position
                    SpineBones[i].ProceduralPosition = SpineBones[i + 1].ProceduralPosition + dir.normalized * SpineBones[i].BoneLength * DistancesMultiplier /* SpineBones[i].transform.lossyScale.z*/;

                    if (ManualAffectChain)
                    {
                        SpineBones[i].ProceduralPosition += look * (SpineBones[i].ManualPosOffset) * SpineBones[i].BoneLength;
                    }
                }

                // Backrotation
                SpineBones[SpineBones.Count - 1].ProceduralRotation = SpineBones[SpineBones.Count - 2].ProceduralRotation;
                SpineBones[SpineBones.Count - 1].Editor_SetLength(SpineBones[SpineBones.Count - 2].BoneLength);

                if (!ManualAffectChain)
                {
                    for (int i = SpineBones.Count - 1; i >= 0; i--)
                    {
                        SpineBones[i].ProceduralPosition += SpineBones[i].ProceduralRotation * (SpineBones[i].ManualPosOffset) * SpineBones[i].BoneLength;
                    }
                }

                for (int i = SpineBones.Count - 1; i >= 0; i--)
                {
                    SpineBones[i].ProceduralPosition += SpineBones[i].ProceduralRotation * -SegmentsPivotOffset * SpineBones[i].BoneLength;
                }
            }


            if (!_editorSetupDrawing)
            {
                return;
            }

            Color c         = Handles.color;
            Color boneColor = new Color(0.075f, .85f, 0.3f, gizmosAlpha * 1f);

            Handles.color = boneColor;

            //if (!prepared)
            //    for (int i = 0; i < SpineBones.Count; i++)
            //        SpineBones[i].PrepareBone(GetBaseTransform(), SpineBones, i);

            //if (MainPivotOffset != Vector3.zero)
            //    Handles.matrix = Matrix4x4.Translate(GetBaseTransform().TransformDirection(MainPivotOffset));

            // Calculating preview bone chain
            if (LastBoneLeading == false)
            {
                // Drawing preview spine chain
                for (int i = 1; i < SpineBones.Count; i++)
                {
                    Handles.color = new Color(0.075f, .85f, 0.3f, gizmosAlpha * SpineBones[i].MotionWeight);
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ProceduralPosition, SpineBones[i - 1].ProceduralPosition, GetBaseTransform().TransformDirection(ModelUpAxis), 1.0f);
                }
            }
            else
            {
                // Drawing preview spine chain
                for (int i = SpineBones.Count - 2; i >= 0; i--)
                {
                    Handles.color = new Color(0.075f, .85f, 0.3f, gizmosAlpha * SpineBones[i].MotionWeight);
                    FGUI_Handles.DrawBoneHandle(SpineBones[i].ProceduralPosition, SpineBones[i + 1].ProceduralPosition, GetBaseTransform().TransformDirection(ModelUpAxis), 1.0f);
                }
            }

            Handles.color = boneColor;
            Gizmos_DrawHead(GetLeadBone().ProceduralPosition, GetBaseTransform(), ModelForwardAxis * (ReverseForward ? -1f : 1f), ModelUpAxis, _gizmosDist * 1.1f);

            Handles.matrix = Matrix4x4.identity;
            Handles.color  = c;
        }
예제 #7
0
        void OnDrawGizmosSelected()
        {
            RefreshTransformsList();
            if (_TransformsGhostChain.Count == 0)
            {
                return;
            }
            if (!DrawGizmos)
            {
                return;
            }

            if (UseIK)
            {
                Gizmos_DrawIK();
            }

            if (UseMaxDistance)
            {
                Gizmos_DrawMaxDistance();
            }

            if (Application.isPlaying)
            {
                if (!initialized)
                {
                    return;
                }

                if (!IncludeParent)
                {
                    Editor_TailCalculations_RefreshArtificialParentBone();
                }

                if (_Editor_Category == ETailCategory.Shaping || fDebug)
                {
                    Handles.color = new Color(0.2f, .2f, 0.85f, 0.5f);
                    Handles.SphereHandleCap(0, TailSegments[0].transform.position, Quaternion.identity, HandleUtility.GetHandleSize(TailSegments[0].transform.position) * 0.05f, EventType.Repaint);

                    Handles.color = new Color(0.5f, 1f, 0.35f, 0.3f);

                    for (int i = 1; i < TailSegments.Count; i++)
                    {
                        Handles.SphereHandleCap(0, TailSegments[i].ProceduralPosition, Quaternion.identity, HandleUtility.GetHandleSize(TailSegments[i].ProceduralPosition) * 0.09f, EventType.Repaint);
                        Handles.DrawDottedLine(TailSegments[i].ProceduralPosition, TailSegments[i].ParentBone.ProceduralPosition, 2f);
                    }

                    if (IncludeParent)
                    {
                        Handles.color = new Color(1f, .2f, 0.6f, 1f);
                    }
                    Handles.DrawDottedLine(TailSegments[0].ProceduralPosition, TailSegments[0].ParentBone.ProceduralPosition, 2f);

                    Handles.color = new Color(1f, .2f, 0.6f, 1f);
                    Handles.DrawDottedLine(GhostChild.ProceduralPosition, GhostChild.ParentBone.ProceduralPosition, 2f);

                    Handles.SphereHandleCap(0, GhostParent.ProceduralPosition, Quaternion.identity, HandleUtility.GetHandleSize(GhostParent.ProceduralPosition) * 0.09f, EventType.Repaint);
                    Handles.SphereHandleCap(0, GhostChild.ProceduralPosition, Quaternion.identity, HandleUtility.GetHandleSize(GhostParent.ProceduralPosition) * 0.09f, EventType.Repaint);
                }


                if (fDebug)
                {
                    Vector3 uoff;

                    if (PostProcessingNeeded() && _pp_initialized)
                    {
                        uoff         = Vector3.up * _TC_TailLength * 0.065f;
                        Gizmos.color = new Color(0.8f, 0.2f, 0.5f, 0.4f); // Post processing reference line (transparent dark pinnk)
                        for (int i = 0; i < _pp_reference.Count; i++)
                        {
                            Gizmos.DrawSphere(_pp_reference[i].ProceduralPosition, .3f);

                            Gizmos.DrawLine(_pp_reference[i].ParentBone.ProceduralPosition + uoff, _pp_reference[i].ProceduralPosition + uoff);
                        }

                        Handles.color = new Color(0.8f, 0.2f, 0.5f, 0.4f); // Deflection source segment sphere
                        for (int i = 0; i < _defl_source.Count; i++)
                        {
                            Handles.SphereHandleCap(0, _defl_source[i].ParentBone.ProceduralPosition + uoff, Quaternion.identity, HandleUtility.GetHandleSize(_defl_source[i].ProceduralPosition) * 0.09f, EventType.Repaint);
                        }

                        Handles.color = new Color(0.55f, .2f, 0.8f, 0.6f); // Deflection source segment sphere
                        for (int i = 0; i < _defl_source.Count; i++)
                        {
                            Handles.SphereHandleCap(0, Vector3.LerpUnclamped(TailSegments[_defl_source[i].Index].ParentBone.ProceduralPosition, TailSegments[_defl_source[i].Index].ProceduralPosition, 0.5f) + uoff, Quaternion.identity, HandleUtility.GetHandleSize(_defl_source[i].ProceduralPosition) * 0.09f, EventType.Repaint);
                        }


                        #region Debug

                        //Handles.color = new Color(0.55f, .2f, 0.8f, 0.8f);
                        //for (int i = 0; i < _defl_source.Count; i++)
                        //    Handles.DrawDottedLine(_defl_source[i].ProceduralPosition + uoff, _defl_source[i].DeflectionWorldPosition + uoff, 2f);

                        //Handles.color = new Color(0.0f, 1f, 1f, 0.8f);
                        //for (int i = 0; i < _defl_source.Count; i++)
                        //{
                        //    int backRange = _tc_startI; if (i > 0) backRange = _defl_source[i - 1].Index;

                        //    for (int k = _defl_source[i].Index; k >= backRange; k--)
                        //        Handles.DrawDottedLine(TailBones[k].ProceduralPosition + uoff, _defl_source[i].DeflectionWorldPosition + uoff, 2f);
                        //}

                        #endregion

                        Gizmos.color = new Color(1f, 0.1f, 0.35f, 0.6f); // Deflection push focus (magenta)
                        for (int i = 0; i < _defl_source.Count; i++)
                        {
                            Gizmos.DrawLine(_defl_source[i].DeflectionWorldPosition + uoff, _defl_source[i].ParentBone.ProceduralPosition + uoff);
                            //Handles.Label(_pp_reference[_defl_source[i].Index].ParentBone.ProceduralPosition + uoff + transform.right * _tc_tailLength * 0.032f + uoff, "b.par=[" + _defl_source[i].Index + "]");
                            Handles.DrawDottedLine(_pp_reference[_defl_source[i].Index].ParentBone.ProceduralPosition + uoff + transform.right * _TC_TailLength * 0.032f + uoff, TailSegments[_defl_source[i].Index].ProceduralPosition + uoff, 3f);
                        }


                        uoff         = Vector3.up * _TC_TailLength * 0.044f;
                        Gizmos.color = new Color(0.2f, 0.9f, 0.4f, 0.5f); // True position line
                        for (int i = 0; i < _pp_reference.Count; i++)
                        {
                            Gizmos.DrawLine(TailSegments[i].ParentBone.ProceduralPosition + uoff, TailSegments[i].ProceduralPosition + uoff);
                        }

                        Gizmos.DrawLine(_pp_ref_lastChild.ParentBone.ProceduralPosition + uoff, _pp_ref_lastChild.ProceduralPosition + uoff);


                        // All segments debug draw
                        uoff          = Vector3.up * _TC_TailLength * 0.065f;
                        Handles.color = new Color(1f, 1f, 1f, 0.4f);
                        for (int i = 0; i < TailSegments.Count; i++)
                        {
                            Handles.SphereHandleCap(0, TailSegments[i].ProceduralPosition, Quaternion.identity, HandleUtility.GetHandleSize(TailSegments[i].ProceduralPosition) * 0.09f, EventType.Repaint);
                            Handles.Label(TailSegments[i].ProceduralPosition - transform.right * _TC_TailLength * 0.02f + uoff, "[" + i + "]");
                        }
                    }
                }
            }

            if (_Editor_Category == ETailCategory.Setup)
            {
                if (_TransformsGhostChain != null)
                {
                    if (_TransformsGhostChain.Count > 1)
                    {
                        if (!IncludeParent)
                        {
                            Handles.color = new Color(.9f, .4f, .7f, .9f);
                        }
                        else
                        {
                            Handles.color = new Color(0.5f, 1f, 0.35f, 0.8f);
                        }

                        if (_TransformsGhostChain.Count > 1)
                        {
                            FGUI_Handles.DrawBoneHandle(_TransformsGhostChain[0].position, _TransformsGhostChain[1].position, BaseTransform.forward, 1f);
                            Handles.SphereHandleCap(0, _TransformsGhostChain[0].position, Quaternion.identity, HandleUtility.GetHandleSize(_TransformsGhostChain[0].position) * 0.09f, EventType.Repaint);
                        }


                        for (int i = 1; i < _TransformsGhostChain.Count - 1; i++) // -1 because we painting bones from i to i+1
                        {
                            Handles.color = new Color(0.5f, 1f, 0.35f, 0.8f);
                            FGUI_Handles.DrawBoneHandle(_TransformsGhostChain[i].position, _TransformsGhostChain[i + 1].position, BaseTransform.forward, 1f);

                            Handles.color = new Color(0.5f, 1f, 0.35f, 0.3f);
                            Handles.SphereHandleCap(0, _TransformsGhostChain[i].position, Quaternion.identity, HandleUtility.GetHandleSize(_TransformsGhostChain[i].position) * 0.09f, EventType.Repaint);
                        }

                        if (_TransformsGhostChain.Count > 1)
                        {
                            if (IncludeParent)
                            {
                                if (_TransformsGhostChain[0].parent)
                                {
                                    Handles.color = new Color(1f, .2f, 0.6f, 0.3f);
                                    FGUI_Handles.DrawBoneHandle(_TransformsGhostChain[0].parent.position, _TransformsGhostChain[0].position, BaseTransform.forward, 1f);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (_TransformsGhostChain.Count > 0)
                        {
                            if (_TransformsGhostChain[0].parent)
                            {
                                Transform t = _TransformsGhostChain[0]; Transform p = _TransformsGhostChain[0].parent;

                                Handles.color = new Color(0.8f, .8f, 0.2f, 0.8f);
                                FGUI_Handles.DrawBoneHandle(_TransformsGhostChain[0].parent.position, _TransformsGhostChain[0].position, BaseTransform.forward, 1f);
                                Handles.color = new Color(0.8f, .8f, 0.2f, 0.3f);
                                Handles.SphereHandleCap(0, _TransformsGhostChain[0].position, Quaternion.identity, HandleUtility.GetHandleSize(_TransformsGhostChain[0].position) * 0.135f, EventType.Repaint);
                                Handles.Label(t.position + Vector3.Cross(t.forward, p.forward).normalized *(t.position - p.position).magnitude / 2f, new GUIContent("[i]", "Tail chain with one bone setup - try using End Bone Offset in 'Setup' tab"));
                            }
                        }
                    }
                }
            }


            if (_TransformsGhostChain.Count < 2)
            {
                Handles.color = new Color(1f, 1f, 1f, 0.5f);
                Handles.SphereHandleCap(0, _TransformsGhostChain[0].position, Quaternion.identity, HandleUtility.GetHandleSize(_TransformsGhostChain[0].position) * 0.135f, EventType.Repaint);

                if (_TransformsGhostChain.Count > 0)
                {
                    if (!_TransformsGhostChain[0].parent)
                    {
                        Handles.color = new Color(1f, .2f, 0.2f, 0.8f);
                        Vector3 infoPos = _TransformsGhostChain[0].position + (_TransformsGhostChain[0].up + _TransformsGhostChain[0].right) * 0.2f;
                        Handles.DrawDottedLine(_TransformsGhostChain[0].position, infoPos, 2f);
                        Handles.DrawDottedLine(_TransformsGhostChain[0].position, transform.position, 2f);
                        Handles.Label(infoPos, new GUIContent(FGUI_Resources.Tex_Warning, "No parent in this bone, tail chain can't be created"));
                    }
                }
            }


            if (_Editor_Category == ETailCategory.Setup)
            {
                Handles.color = new Color(1f, .2f, 0.2f, 0.8f);
                Gizmos_DrawEndBoneJoint();
            }


            if (_editor_IsInspectorViewingColliders && _Editor_Category == ETailCategory.Features)
            {
                Gizmos_DrawColliders();
            }
        }
예제 #8
0
        private void Gizmos_DrawBones()
        {
            if (LeadBone == null)
            {
                return;
            }

            Color c         = Handles.color;
            Color boneColor = new Color(0.075f, .85f, 0.3f, gizmosAlpha * 0.7f);

            Handles.color = boneColor;

            Vector3 f = BaseTransform.TransformDirection(ModelForwardAxis);

            if (LeadBone.childCount > 0)
            {
                FGUI_Handles.DrawBoneHandle(LeadBone.position, LeadBone.position + BaseTransform.TransformDirection(ModelUpAxis) * Vector3.Distance(LeadBone.position, LeadBone.parent.position) / 2f, f);
            }

            if (LookBones.Count > 0)
            {
                // Drawing back-bones
                for (int i = 1; i < LookBones.Count; i++)
                {
                    if (LookBones[i].Transform != null)
                    {
                        if (LookBones[i] == null)
                        {
                            continue;
                        }
                        FGUI_Handles.DrawBoneHandle(LookBones[i].Transform.position, LookBones[i - 1].Transform.position, f);
                    }
                }

                if (LookBones.Count > 1)
                {
                    FGUI_Handles.DrawBoneHandle(LookBones[1].Transform.position, LeadBone.position, f);
                }
            }

            Handles.SphereHandleCap(0, LeadBone.position, Quaternion.identity, _gizmosDist * 0.025f, EventType.Repaint);

            for (int i = 0; i < LeadBone.childCount; i++)
            {
                Handles.color = new Color(0.8f, .8f, 0.8f, gizmosAlpha * 0.25f);
                Handles.DrawDottedLine(LeadBone.position, LeadBone.GetChild(i).position, 2.5f);
                Handles.color = new Color(0.8f, .8f, 0.8f, gizmosAlpha * 0.1f);
                Handles.SphereHandleCap(0, LeadBone.GetChild(i).position, Quaternion.identity, _gizmosDist * 0.01f, EventType.Repaint);
            }

            if (LookBones.Count > 1)
            {
                if (LookBones[LookBones.Count - 1].Transform.parent)
                {
                    Handles.color = new Color(0.8f, .8f, 0.8f, gizmosAlpha * 0.25f);
                    Handles.DrawDottedLine(LookBones[LookBones.Count - 1].Transform.position, LookBones[LookBones.Count - 1].Transform.parent.position, 3f);
                    Handles.color = new Color(0.8f, .8f, 0.8f, gizmosAlpha * 0.1f);
                    Handles.SphereHandleCap(0, LookBones[LookBones.Count - 1].Transform.parent.position, Quaternion.identity, _gizmosDist * 0.01f, EventType.Repaint);
                }
            }

            Handles.color = c;
        }