Beispiel #1
0
        private void Fold_DrawEyesModule()
        {
            GUILayout.BeginHorizontal();

            if (Get.UseEyes)
            {
                if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawEyesSettings, 10, "►") + "  " + Lang("Eyes Module"), _TexEyesIcon, "Enabling possibility for using eye bones with look animator, check my other package 'Eyes Animator' for more advanced motion for eyes"), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
                {
                    drawEyesSettings = !drawEyesSettings;
                }
                Get.UseEyes = EditorGUILayout.Toggle(Get.UseEyes, GUILayout.Width(16));
            }
            else
            {
                GUILayout.Button(new GUIContent("  " + Lang("Eyes Module"), _TexEyesIcon, "Enabling possibility for using eye bones with look animator, check my other package 'Eyes Animator' for more advanced motion for eyes"), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle);
                Get.UseEyes = EditorGUILayout.Toggle(Get.UseEyes, GUILayout.Width(16));
            }

            GUILayout.EndHorizontal();

            if (drawEyesSettings && Get.UseEyes)
            {
                GUILayout.Space(5f);
                Fold_Eyes_DrawSetup();

                Fold_Eyes_DrawMotion();

                GUILayout.Space(1f);
                EditorGUILayout.HelpBox("Eyes clamp ranges limit settings are inside '" + Lang("Character Setup") + "' tab", MessageType.None);
                GUILayout.Space(4f);
            }

            GUILayout.EndVertical();
        }
Beispiel #2
0
    private void Fold_DrawAdditionalSetup()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

        if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawAdditionalSetup, 10, "►") + "  " + Lang("Optimization And More"), FGUI_Resources.TexAddIcon), FGUI_Resources.FoldStyle))
        {
            drawAdditionalSetup = !drawAdditionalSetup;
        }

        if (drawAdditionalSetup)
        {
            //if (animatorAnimPhys && Get.AnimatePhysics == false)
            //{
            //    FGUI_Inspector.DrawWarning(" Unity's Animator is using 'Animate Physics'!");
            //    GUI.color = new Color(.9f, .9f, 0.6f, 1f);
            //}

            GUILayout.Space(5);
            EditorGUILayout.BeginHorizontal();

            EditorGUIUtility.labelWidth = 80; EditorGUIUtility.fieldWidth = 0;
            EditorGUILayout.PropertyField(sp_DeltaType);

            EditorGUIUtility.labelWidth = 40;
            EditorGUIUtility.fieldWidth = Get.UpdateRate == 0 ? 10 : 30;
            EditorGUILayout.PropertyField(sp_UpdateRate, new GUIContent("Rate", sp_UpdateRate.tooltip), GUILayout.Width(Get.UpdateRate == 0 ? 60 : 70));

            GUI.color = new Color(1f, 1f, 1f, 0.75f);
            EditorGUILayout.LabelField(Get.UpdateRate == 0 ? "Unlimited" : "FPS", GUILayout.Width(Get.UpdateRate == 0 ? 60 : 28));
            GUI.color = c;

            EditorGUILayout.EndHorizontal();
            EditorGUIUtility.labelWidth = 0; EditorGUIUtility.fieldWidth = 0;

            GUILayout.Space(3);

            EditorGUILayout.BeginHorizontal();

            if (animator)
            {
                if (animator.updateMode == AnimatorUpdateMode.AnimatePhysics)
                {
                    GUI.color = new Color(0.6f, 1f, 0.6f, 1f);
                }
            }
            EditorGUILayout.PropertyField(sp_PhysicalClock);
            GUI.color = c;
            //GUILayout.Space(3);
            EditorGUILayout.PropertyField(sp_UpdateAsLast);
            EditorGUILayout.EndHorizontal();
            GUILayout.Space(3);
            El_DrawOptimizeWithMesh();

            GUILayout.Space(4f);
        }


        GUILayout.EndVertical();
        GUILayout.Space(-5);
    }
Beispiel #3
0
        private void Fold_DrawHidden()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

            if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawHidden, 10, "►") + "  " + Lang("Hidden Rare Settings"), FGUI_Resources.Tex_HiddenIcon), FGUI_Resources.FoldStyle))
            {
                drawHidden = !drawHidden;
            }

            if (drawHidden)
            {
                GUILayout.Space(5);

                EditorGUILayout.PropertyField(sp_ModelForwardAxis);
                EditorGUILayout.PropertyField(sp_ModelUpAxis);


                GUILayout.Space(5f);
                EditorGUIUtility.labelWidth = 278;
                EditorGUILayout.PropertyField(sp_DestroyMomentTransformOnMaxDistance);
                EditorGUIUtility.labelWidth = 0;

                GUILayout.Space(6f);
                //EditorGUILayout.PropertyField(sp_AnimationStyle);
                EditorGUILayout.PropertyField(sp_DeltaType);
                EditorGUILayout.PropertyField(sp_SimulationSpeed);

                GUILayout.Space(4f);
            }

            GUILayout.Space(2f);

            GUILayout.EndVertical();
        }
Beispiel #4
0
    void El_DrawBending()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);

        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawBending, 8, "►") + "  " + Lang("Limiting Angles"), FGUI_Resources.Tex_Knob), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawBending = !drawBending;
        }

        if (drawBending)
        {
            GUILayout.Space(3f);
            //GUI.color = new Color(1f, 1f, 1f, 0.85f); EditorGUILayout.LabelField("Bending", FGUI_Resources.HeaderStyle); GUI.color = c;

            EditorGUILayout.PropertyField(sp_AngleLimit);
            if (Get.AngleLimit < 91)
            {
                EditorGUILayout.PropertyField(sp_LimitingAngleSmoother);
            }
            GUILayout.Space(3f);
            EditorGUILayout.PropertyField(sp_Slithery);
            GUILayout.Space(3f);
        }

        GUILayout.EndVertical();
    }
Beispiel #5
0
        private void Fold_DrawMomentTargets()
        {
            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawMomentTargets, 10, "►") + "  " + "Moment Targets", FGUI_Resources.TexWaitIcon, sp_bird.tooltip), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle, GUILayout.Height(26)))
            {
                drawMomentTargets = !drawMomentTargets;
            }

            if (drawMomentTargets)
            {
                if (!Application.isPlaying)
                {
                    EditorGUILayout.HelpBox("You can use momoent targets through custom coding or events using methods like 'SetMomentTarget' etc.", MessageType.Info);
                }
                else
                {
                    GUI.enabled = false;
                    EditorGUILayout.ObjectField("Moment Target", Get.MomentLookTransform, typeof(Transform), true);
                    GUI.enabled = true;
                }

                GUILayout.Space(5f);
                EditorGUIUtility.labelWidth = 278;
                EditorGUILayout.PropertyField(sp_DestroyMomentTransformOnMaxDistance);
                EditorGUIUtility.labelWidth = 0;

                GUILayout.Space(5f);
            }
        }
Beispiel #6
0
        private void Fold_DrawTargeting()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawTargeting, 10, "►") + "  " + Lang("Targeting"), FGUI_Resources.TexTargetingIcon, ""), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
            {
                drawTargeting = !drawTargeting;
            }

            if (drawTargeting)
            {
                GUILayout.Space(4f);
                EditorGUIUtility.labelWidth = 146;
                EditorGUILayout.PropertyField(sp_eyespos);
                GUILayout.Space(2f);
                EditorGUIUtility.labelWidth = 168;
                EditorGUILayout.PropertyField(sp_ancheyes);

                if (Application.isPlaying)
                {
                    if (Get.AnchorStartLookPoint)
                    {
                        GUILayout.Space(2f);
                        EditorGUI.indentLevel++;
                        EditorGUILayout.PropertyField(sp_anchrefr); GUILayout.Space(2);
                        EditorGUI.indentLevel--;
                    }
                }

                GUILayout.Space(9f);

                EditorGUIUtility.labelWidth = 172;
                if (Get.LookAtPositionSmoother <= 0f)
                {
                    GUI.color = unchangedC;
                }
                EditorGUILayout.PropertyField(sp_LookAtPositionSmoother);
                GUI.color = c; EditorGUIUtility.labelWidth = 0;

                GUILayout.Space(5);
                EditorGUIUtility.labelWidth = 172;
                if (Get.ChangeTargetSmoothing == 0f)
                {
                    GUI.color = unchangedC;
                }
                EditorGUILayout.PropertyField(sp_chretspeed);
                GUI.color = c;
                EditorGUIUtility.labelWidth = 0;

                GUILayout.Space(6);
            }

            GUILayout.EndVertical();
        }
Beispiel #7
0
    void El_DrawSmoothing()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);

        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawSmoothing, 8, "►") + "   " + Lang("Smoothing Motion"), FGUI_Resources.TexSmallOptimizeIcon), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawSmoothing = !drawSmoothing;
        }

        if (drawSmoothing)
        {
            GUILayout.Space(6f);
            EditorGUILayout.PropertyField(sp_PositionsSmoother);

            if (Get.PosSmoother > 0f)
            {
                if (!Get.LastBoneLeading)
                {
                    if (Get.Springiness > 0)
                    {
                        if (Get.MaxStretching > 0.4f)
                        {
                            GUI.color = new Color(0.75f, 0.9f, 1f, 0.95f);
                        }
                    }
                }
                EditorGUILayout.PropertyField(sp_MaxStretching);
            }

            GUILayout.Space(4f);
            EditorGUILayout.PropertyField(sp_RotationsSmoother); GUILayout.Space(1f);
            if (Get.RotSmoother > 0f)
            {
                EditorGUILayout.PropertyField(sp_MotionInfluence);
            }

            GUI.color = c;
            GUILayout.Space(3f);
        }

        GUILayout.EndVertical();

        if (!Get.LastBoneLeading)
        {
            GUILayout.Space(3f);
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);

            EditorGUILayout.PropertyField(sp_Springiness, true);
            GUILayout.EndVertical();
            GUILayout.Space(3f);
        }
    }
Beispiel #8
0
        private void Fold_Eyes_DrawMotion()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);

            if (GUILayout.Button(new GUIContent("  " + FGUI_Resources.GetFoldSimbol(drawEyesMotion, 10, "►") + "  " + Lang("Additional Motion Settings"), FGUI_Resources.Tex_MiniMotion, ""), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
            {
                drawEyesMotion = !drawEyesMotion;
            }

            EditorGUIUtility.labelWidth = 100;

            if (drawEyesMotion)
            {
                GUILayout.Space(7f);


                EditorGUILayout.BeginHorizontal();

                EditorGUILayout.PropertyField(sp_eyesTarget);
                if (!Get.EyesTarget)
                {
                    GUI.enabled = false;
                    EditorGUILayout.LabelField("(", GUILayout.Width(8));
                    EditorGUILayout.ObjectField(Get.ObjectToFollow, typeof(Transform), true, GUILayout.Width(80));
                    EditorGUILayout.LabelField(")", GUILayout.Width(8));
                    GUI.enabled = true;
                }

                EditorGUILayout.EndHorizontal();


                EditorGUILayout.PropertyField(sp_eyesSpeed);
                EditorGUILayout.PropertyField(sp_eyesBlend);

                GUILayout.Space(5);

                EditorGUIUtility.labelWidth = 144;
                EditorGUILayout.PropertyField(sp_EyesNoKeyframes);
                EditorGUIUtility.labelWidth = 0;
            }


            EditorGUIUtility.labelWidth = 0;
            GUILayout.EndVertical();
        }
Beispiel #9
0
        private void Fold_DrawBehaviourSettings()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);

            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawBehaviourSettings, 10, "►") + "  " + Lang("Animation Behaviour"), FGUI_Resources.TexBehaviourIcon, ""), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
            {
                drawBehaviourSettings = !drawBehaviourSettings;
            }

            if (drawBehaviourSettings)
            {
                GUILayout.Space(6f);
                El_DrawMaxDist();
                GUILayout.Space(6f);

                bool wrongLimit = false;
                if (Mathf.Abs(Get.XRotationLimits.x) > Get.StopLookingAbove)
                {
                    wrongLimit = true;
                }
                if (Mathf.Abs(Get.XRotationLimits.y) > Get.StopLookingAbove)
                {
                    wrongLimit = true;
                }
                El_DrawLimitMaxAngle(wrongLimit);
                GUI.color = c;

                EditorGUIUtility.labelWidth = 148;
                GUILayout.Space(-2);
                El_DrawLookWhenAbove();
                GUILayout.Space(5);
                EditorGUIUtility.labelWidth = 180;
                if (Get.HoldRotateToOppositeUntil <= 0f)
                {
                    GUI.color = unchangedC;
                }
                EditorGUILayout.PropertyField(sp_HoldRotateToOppositeUntil);
                GUI.color = c;
                GUILayout.Space(5);
                EditorGUIUtility.labelWidth = 0;
            }

            GUILayout.EndVertical();
        }
Beispiel #10
0
    void El_DrawRareCorrections()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawRareCorrs, 8, "►") + "  " + Lang("Rare Corrections"), FGUI_Resources.Tex_HiddenIcon), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawRareCorrs = !drawRareCorrs;
        }

        if (drawRareCorrs)
        {
            GUILayout.Space(5f);
            EditorGUILayout.PropertyField(sp_ModelForwardAxis);
            EditorGUILayout.PropertyField(sp_ModelUpAxis);
            GUILayout.Space(5f);
        }

        GUILayout.EndVertical();
    }
Beispiel #11
0
    void El_DrawFullChainCorrections()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

        GUILayout.BeginHorizontal();

        if (Get.UseCorrections)
        {
            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawFullChainCorrs, 8, "►") + "  " + Lang("Spine Chain Corrections"), FGUI_Resources.Tex_GearMain, sp_UseCorrections.tooltip), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
            {
                drawFullChainCorrs = !drawFullChainCorrs;
            }
        }
        else
        if (GUILayout.Button(new GUIContent("  Spine Chain Corrections", FGUI_Resources.Tex_GearMain, sp_UseCorrections.tooltip), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            Get.UseCorrections = !Get.UseCorrections; serializedObject.ApplyModifiedProperties();
        }

        GUILayout.FlexibleSpace();
        EditorGUILayout.PropertyField(sp_UseCorrections, new GUIContent("", sp_UseCorrections.tooltip), GUILayout.Width(22));

        GUILayout.EndHorizontal();


        if (drawFullChainCorrs && Get.UseCorrections)
        {
            GUILayout.Space(4f);
            EditorGUIUtility.labelWidth = 154f;
            EditorGUILayout.PropertyField(sp_SegmentsPivotOffset);
            EditorGUIUtility.labelWidth = 0f;
            GUILayout.Space(4f);
            GUILayout.EndVertical();

            El_DrawManualChainCorrections();
        }
        else
        {
            GUILayout.EndVertical();
        }
    }
Beispiel #12
0
    void El_DrawSelectiveCollision()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawSelectiveColliders, 8, "►") + "  " + Lang("Segments Collision"), FGUI_Resources.Tex_Gear), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawSelectiveColliders = !drawSelectiveColliders;
        }
        ////if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawManualChainCorrs, 8, "►") + "  Manual Chain Corrections", FGUI_Resources.Tex_Gear), FGUI_Resources.FoldStyle, GUILayout.Height(21))) drawManualChainCorrs = !drawManualChainCorrs;

        if (drawSelectiveColliders)
        {
            GUILayout.Space(7);
            //for (int i = 0; i < Get.SpineBones.Count; i++)
            int strt = 0; int cnt = Get.SpineBones.Count;
            if (!Get.LastBoneLeading)
            {
                strt = 1;
            }
            else
            {
                cnt -= 1;
            }
            for (int i = strt; i < cnt; i++)
            {
                EditorGUILayout.BeginVertical(i % 2 == 0 ? FGUI_Resources.BGInBoxLightStyle : FGUI_Resources.BGInBoxStyle);
                EditorGUILayout.BeginHorizontal();
                Get.SpineBones[i].Collide = EditorGUILayout.Toggle("", Get.SpineBones[i].Collide, GUILayout.Width(20));
                GUI.enabled = false; EditorGUILayout.ObjectField(Get.SpineBones[i].transform, typeof(Transform), true); GUI.enabled = true;
                EditorGUILayout.EndHorizontal();
                if (!Get.SpineBones[i].Collide)
                {
                    GUI.enabled = false;
                }
                Get.SpineBones[i].ColliderOffset = EditorGUILayout.Vector3Field("", Get.SpineBones[i].ColliderOffset); GUI.enabled = true;
                EditorGUILayout.EndVertical();
            }
        }

        EditorGUILayout.EndVertical();
    }
Beispiel #13
0
    void El_DrawStraigtening()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawStraigtening, 8, "►") + "  " + Lang("Straigtening Rules"), FGUI_Resources.Tex_Limits), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawStraigtening = !drawStraigtening;
        }

        if (drawStraigtening)
        {
            GUILayout.Space(3f);

            EditorGUILayout.PropertyField(sp_StraighteningSpeed /*, new GUIContent("When Moving", sp_StraighteningSpeed.tooltip)*/, true);

            if (Get.StraightenSpeed > 0f)
            {
                EditorGUILayout.PropertyField(sp_TurboStraighten, true);
            }

            GUILayout.Space(3f);
            if (!Get.LastBoneLeading)
            {
                if (Get.Springiness > 0)
                {
                    if (Get.GoBackSpeed <= 0)
                    {
                        GUI.color = new Color(0.55f, 0.9f, 1f, 1f);
                    }
                }
            }
            EditorGUILayout.PropertyField(sp_GoBackSpeed /*, new GUIContent("Constantly", sp_GoBackSpeed.tooltip)*/, true); GUI.color = c;

            //GUILayout.Space(3f);
            GUILayout.Space(3f);
        }

        GUILayout.EndVertical();
    }
Beispiel #14
0
        private void Fold_DrawAdditionalSetup()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

            if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawAdditionalSetup, 10, "►") + "  Optimization & More", FGUI_Resources.TexAddIcon), FGUI_Resources.FoldStyle))
            {
                drawAdditionalSetup = !drawAdditionalSetup;
            }

            if (drawAdditionalSetup)
            {
                if (animatorAnimPhys && Get.AnimatePhysics == false)
                {
                    FGUI_Inspector.DrawWarning(" Unity's Animator is using 'Animate Physics'!");
                    GUI.color = new Color(.9f, .9f, 0.6f, 1f);
                }

                GUILayout.Space(5);
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PropertyField(sp_animphys);
                GUILayout.FlexibleSpace();
                EditorGUILayout.PropertyField(sp_starttpose);
                EditorGUILayout.EndHorizontal();

                GUI.color = Color.white;
                GUILayout.Space(3);
                El_DrawOptimizeWithMesh();
                //GUILayout.Space(2);
                //if (Get.DetectZeroKeyframes == 0) GUI.color = unchangedC;
                //EditorGUILayout.PropertyField(sp_DetectZeroKeyframes);
                //GUI.color = c;
                GUILayout.Space(4f);
            }


            GUILayout.EndVertical();
            GUILayout.Space(-5);
        }
Beispiel #15
0
        private void Fold_DrawBoneCorrectionRotations()
        {
            //GUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);

            if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawCorrRots, 10, "►") + "  " + Lang("Bones Rotation Corrections"), FGUI_Resources.Tex_GearMain), FGUI_Resources.FoldStyle, new GUILayoutOption[] { GUILayout.Height(24) }))
            {
                drawCorrRots = !drawCorrRots;
            }

            if (drawCorrRots)
            {
                GUILayout.Space(3);

                for (int i = 0; i < Get.LookBones.Count; i++)
                {
                    //string name = Get.LookBones[i].Transform.name.Substring(0, Mathf.Min(16, Get.LookBones[i].Transform.name.Length));
                    //Get.LookBones[i].correctionOffset = Quaternion.Euler(EditorGUILayout.Vector3Field(new GUIContent(name, Get.LookBones[i].Transform.name), Get.LookBones[i].correctionOffset.eulerAngles));

                    EditorGUILayout.BeginHorizontal();
                    GUI.enabled = false;
                    EditorGUILayout.ObjectField(Get.LookBones[i].Transform, typeof(Transform), true);
                    GUI.enabled = true;
                    Get.LookBones[i].correctionOffset = EditorGUILayout.Vector3Field("", Get.LookBones[i].correctionOffset);
                    //Get.LookBones[i].correctionOffset = Quaternion.Euler(EditorGUILayout.Vector3Field("", Get.LookBones[i].correctionOffset.eulerAngles));
                    EditorGUILayout.EndHorizontal();

                    GUILayout.Space(1);
                }

                GUILayout.Space(2f);
            }

            GUILayout.Space(2f);

            //GUILayout.EndVertical();
        }
Beispiel #16
0
    private void HeaderBoxMain(string title, ref bool drawGizmos, ref bool defaultInspector, Texture2D scrIcon, MonoBehaviour target, int height = 22)
    {
        EditorGUILayout.BeginVertical(FGUI_Resources.HeaderBoxStyle);

        EditorGUILayout.BeginHorizontal();

        if (GUILayout.Button(new GUIContent(scrIcon), EditorStyles.label, new GUILayoutOption[2] {
            GUILayout.Width(height - 2), GUILayout.Height(height - 2)
        }))
        {
            MonoScript script = MonoScript.FromMonoBehaviour(target);
            if (script)
            {
                EditorGUIUtility.PingObject(script);
            }
            drawHeaderFoldout = !drawHeaderFoldout;
        }

        if (GUILayout.Button(title, FGUI_Resources.GetTextStyle(14, true, TextAnchor.MiddleLeft), GUILayout.Height(height)))
        {
            MonoScript script = MonoScript.FromMonoBehaviour(target);
            if (script)
            {
                EditorGUIUtility.PingObject(script);
            }
            drawHeaderFoldout = !drawHeaderFoldout;
        }

        if (EditorGUIUtility.currentViewWidth > 326)
        {
            // Youtube channel button
            if (GUILayout.Button(new GUIContent(FGUI_Resources.Tex_Tutorials, "Open FImpossible Creations Channel with tutorial videos in your web browser"), FGUI_Resources.ButtonStyle, new GUILayoutOption[2] {
                GUILayout.Width(height), GUILayout.Height(height)
            }))
            {
                Application.OpenURL("https://www.youtube.com/c/FImpossibleCreations");
            }
        }

        if (EditorGUIUtility.currentViewWidth > 292)
        {
            // Store site button
            if (GUILayout.Button(new GUIContent(FGUI_Resources.Tex_Website, "Open FImpossible Creations Asset Store Page inside your web browser"), FGUI_Resources.ButtonStyle, new GUILayoutOption[2] {
                GUILayout.Width(height), GUILayout.Height(height)
            }))
            {
                Application.OpenURL("https://assetstore.unity.com/publishers/37262");
            }
        }

        // Manual file button
        if (_manualFile == null)
        {
            _manualFile = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(System.IO.Path.GetDirectoryName(AssetDatabase.GetAssetPath(MonoScript.FromMonoBehaviour(target))) + "/Spine Animator User Manual.pdf");
        }
        if (_manualFile)
        {
            if (GUILayout.Button(new GUIContent(FGUI_Resources.Tex_Manual, "Open .PDF user manual file for Spine Animator"), FGUI_Resources.ButtonStyle, new GUILayoutOption[2] {
                GUILayout.Width(height), GUILayout.Height(height)
            }))
            {
                EditorGUIUtility.PingObject(_manualFile);
                Application.OpenURL(Application.dataPath + "/" + AssetDatabase.GetAssetPath(_manualFile).Replace("Assets/", ""));
            }
        }

        FGUI_Inspector.DrawSwitchButton(ref drawGizmos, FGUI_Resources.Tex_GizmosOff, FGUI_Resources.Tex_Gizmos, "Toggle drawing gizmos on character in scene window", height, height, true);
        FGUI_Inspector.DrawSwitchButton(ref drawHeaderFoldout, FGUI_Resources.Tex_LeftFold, FGUI_Resources.Tex_DownFold, "Toggle to view additional options for foldouts", height, height);

        EditorGUILayout.EndHorizontal();

        if (drawHeaderFoldout)
        {
            FGUI_Inspector.DrawUILine(0.07f, 0.1f, 1, 4, 0.99f);

            EditorGUILayout.BeginHorizontal();

            EditorGUI.BeginChangeCheck();
            choosedLang = (ELangs)EditorGUILayout.EnumPopup(choosedLang, new GUIStyle(EditorStyles.layerMaskField)
            {
                fixedHeight = 0
            }, new GUILayoutOption[2] {
                GUILayout.Width(80), GUILayout.Height(22)
            });
            if (EditorGUI.EndChangeCheck())
            {
                PlayerPrefs.SetInt("FimposLang", (int)choosedLang);
                SetupLangs();
            }

            GUILayout.FlexibleSpace();

            bool hierSwitchOn = PlayerPrefs.GetInt("AnimsH", 1) == 1;
            FGUI_Inspector.DrawSwitchButton(ref hierSwitchOn, FGUI_Resources.Tex_HierSwitch, null, "Switch drawing small icons in hierarchy", height, height, true);
            PlayerPrefs.SetInt("AnimsH", hierSwitchOn ? 1 : 0);

            if (GUILayout.Button(new GUIContent(FGUI_Resources.Tex_Rename, "Change component title to yours (current: '" + Get._editor_Title + "'"), FGUI_Resources.ButtonStyle, new GUILayoutOption[2] {
                GUILayout.Width(height), GUILayout.Height(height)
            }))
            {
                string filename = EditorUtility.SaveFilePanelInProject("Type your title (no file will be created)", Get._editor_Title, "", "Type your title (no file will be created)");
                if (!string.IsNullOrEmpty(filename))
                {
                    filename = System.IO.Path.GetFileNameWithoutExtension(filename);
                    if (!string.IsNullOrEmpty(filename))
                    {
                        Get._editor_Title = filename; serializedObject.ApplyModifiedProperties();
                    }
                }
            }

            // Default inspector switch
            FGUI_Inspector.DrawSwitchButton(ref drawNewInspector, FGUI_Resources.Tex_AB, null, "Switch GUI Style to old / new", height, height, true);
            if (!drawNewInspector && drawDefaultInspector)
            {
                drawDefaultInspector = false;
            }

            // Old new UI Button
            FGUI_Inspector.DrawSwitchButton(ref defaultInspector, FGUI_Resources.Tex_Default, null, "Toggle inspector view to default inspector.\n\nIf you ever edit source code of Look Animator and add custom variables, you can see them by entering this mode, also sometimes there can be additional/experimental variables to play with.", height, height);
            if (!drawNewInspector && drawDefaultInspector)
            {
                drawNewInspector = false;
            }

            EditorGUILayout.EndHorizontal();
        }

        EditorGUILayout.EndVertical();
    }
Beispiel #17
0
    void El_DrawAnchoring()
    {
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);
        if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawAnchoring, 8, "►") + "  " + Lang("Lead Bone Behaviour"), FGUI_Resources.TexMotionIcon), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            drawAnchoring = !drawAnchoring;
        }
        if (drawAnchoring)
        {
            GUILayout.Space(4f);

            GUILayout.BeginHorizontal();
            EditorGUILayout.PropertyField(sp_LeadBoneRotationOffset, true);

            EditorGUIUtility.labelWidth = 14;
            EditorGUILayout.PropertyField(sp_LeadBoneOffsetReference, new GUIContent("A", sp_LeadBoneOffsetReference.tooltip), GUILayout.Width(38));
            EditorGUIUtility.labelWidth = 0;

            GUILayout.EndHorizontal();

            GUILayout.Space(4f);

            GUILayout.BeginHorizontal();
            if (Application.isPlaying)
            {
                GUI.enabled = false;
            }
            if (anchoringWarning)
            {
                if (Get.HeadAnchor == null)
                {
                    GUI.color = new Color(1f, 1f, 0f, 1f);
                }
                else
                {
                    GUI.color = new Color(.7f, 1f, .7f, 1f);
                }
            }

            if (Get.HeadAnchor == null && !anchoringWarning)
            {
                EditorGUIUtility.labelWidth = 150; EditorGUILayout.PropertyField(sp_HeadAnchor, new GUIContent("Head Anchor (Optional)", sp_HeadAnchor.tooltip)); EditorGUIUtility.labelWidth = 0;
            }
            else
            {
                EditorGUILayout.PropertyField(sp_HeadAnchor);
            }

            GUI.enabled = true; GUI.color = c;

            if (Get.SpineBones.Count > 0)
            {
                if (Get.HeadAnchor != Get.GetLeadingBone().transform)
                {
                    if (GUILayout.Button("Use Head", new GUILayoutOption[] { GUILayout.Width(70), GUILayout.Height(16) }))
                    {
                        Get.HeadAnchor = Get.GetLeadingBone().transform; Get.UpdateAsLast = true; serializedObject.ApplyModifiedProperties();
                    }
                }
            }

            if (Get.HeadAnchor)
            {
                EditorGUIUtility.labelWidth = 14;
                EditorGUILayout.PropertyField(sp_AnimateAnchor, new GUIContent("A", sp_AnimateAnchor.tooltip), GUILayout.Width(38));
                EditorGUIUtility.labelWidth = 0;
            }

            GUILayout.EndHorizontal();

            GUILayout.Space(4f);
        }

        GUILayout.EndVertical();
    }
Beispiel #18
0
        private void Fold_DrawCompensation()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);

            if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawCompens, 10, "►") + "  Bones Compensation Settings (" + Get.CompensationBones.Count + ")", _TexCompensationIcon, "If you don't want arms to be rotated when character is looking up/down with big angle"), FGUI_Resources.FoldStyle))
            {
                drawCompens = !drawCompens;
            }

            if (drawCompens)
            {
                GUILayout.Space(6f);

                #region Compensation bones list

                if (Get.CompensationBones != null)
                {
                    compensationBonesCount = Get.CompensationBones.Count;
                }
                else
                {
                    compensationBonesCount = 0;
                }

                GUI.color = new Color(1f, 1f, 1f, 0.7f);
                EditorGUILayout.LabelField(new GUIContent("Not affected bones when spine rotates"), FGUI_Resources.HeaderStyle); GUI.color = c;
                GUILayout.Space(3f);

                GUILayout.BeginHorizontal();
                //compensationBonesCount = EditorGUILayout.IntField("Compensation Bones", compensationBonesCount);
                if (GUILayout.Button(new GUIContent("Auto Find", "By pressing this button, algorithm will try to find bones with names 'Shoulder', 'Upper Arm' be aware, because you can have other objects inside including this names"), GUILayout.MaxHeight(15)))
                {
                    FindCompensationBones(Get);
                }
                if (GUILayout.Button("+", new GUILayoutOption[2] {
                    GUILayout.MaxWidth(28), GUILayout.MaxHeight(15)
                }))
                {
                    serializedObject.ApplyModifiedProperties();
                    Get.SetAutoWeightsDefault();
                    compensationBonesCount++;
                    Get.CompensationBones.Add(new FLookAnimator.CompensationBone(null));
                    EditorUtility.SetDirty(target);
                }

                if (GUILayout.Button("-", new GUILayoutOption[2] {
                    GUILayout.MaxWidth(28), GUILayout.MaxHeight(15)
                }))
                {
                    if (Get.CompensationBones.Count == 1)
                    {
                        Get.CompensationBones  = new List <FLookAnimator.CompensationBone>();
                        compensationBonesCount = 0;
                        //Get.BackBonesCount = 0;
                    }
                    else
                    {
                        compensationBonesCount--;
                    }

                    serializedObject.ApplyModifiedProperties();
                    EditorUtility.SetDirty(target);
                }

                GUILayout.EndHorizontal();
                GUILayout.Space(7f);


                if (compensationBonesCount <= 0)
                {
                    compensationBonesCount = 0;

                    GUI.color = new Color(1f, 1f, 1f, 0.7f);
                    EditorGUILayout.LabelField("Compensation List Is Empty", FGUI_Resources.HeaderStyle); GUI.color = c;
                    GUILayout.Space(7f);
                }
                else
                {
                    if (compensationBonesCount > Get.CompensationBones.Count)
                    {
                        for (int i = Get.CompensationBones.Count; i < compensationBonesCount; i++)
                        {
                            Get.CompensationBones.Add(null);
                        }
                    }
                    else if (compensationBonesCount < Get.CompensationBones.Count)
                    {
                        for (int i = Get.CompensationBones.Count - 1; i >= compensationBonesCount; i--)
                        {
                            Get.CompensationBones.RemoveAt(i);
                        }
                    }

                    if (Get.CompensationBones.Count > 0)
                    {
                        //EditorGUI.indentLevel++;

                        for (int i = 0; i < Get.CompensationBones.Count; i++)
                        {
                            EditorGUILayout.BeginHorizontal();
                            GUI.enabled = false; GUILayout.Label("[" + (i + 1) + "]", GUILayout.Width(20)); GUI.enabled = true;
                            Get.CompensationBones[i].Transform = (Transform)EditorGUILayout.ObjectField(Get.CompensationBones[i].Transform, typeof(Transform), true);

                            if (GUILayout.Button("X", new GUILayoutOption[2] {
                                GUILayout.MaxWidth(24), GUILayout.MaxHeight(16)
                            }))
                            {
                                Get.CompensationBones.RemoveAt(i);
                                serializedObject.ApplyModifiedProperties();
                                EditorUtility.SetDirty(target);
                                return;
                            }

                            EditorGUILayout.EndHorizontal();
                        }

                        //EditorGUI.indentLevel--;

                        GUILayout.Space(7f);
                    }
                }


                // Compensation sliders
                if (Get.BigAngleAutomationCompensation)
                {
                    if (drawBigAngleCompensationSettings)
                    {
                        EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
                    }
                    else
                    {
                        EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);
                    }

                    GUILayout.Space(3);
                    GUI.color = new Color(1f, 1f, 1f, 0.75f);
                    EditorGUILayout.LabelField(drawBigAngleCompensationSettings ? Lang("Weight when character looking far back") : Lang("Default look angle bone weights"), new GUIStyle(EditorStyles.label)
                    {
                        alignment = TextAnchor.MiddleCenter, fontStyle = FontStyle.Bold
                    });
                    GUI.color = c;
                    GUILayout.Space(5);
                }

                if (!Get.BigAngleAutomationCompensation || !drawBigAngleCompensationSettings)
                {
                    EditorGUIUtility.labelWidth = 165;
                    EditorGUILayout.PropertyField(sp_compensblend);
                    EditorGUIUtility.labelWidth = 165;
                    EditorGUILayout.PropertyField(sp_poscompens);
                }
                else
                {
                    EditorGUIUtility.labelWidth = 165;
                    EditorGUILayout.PropertyField(sp_compensblendB);
                    EditorGUIUtility.labelWidth = 165;
                    EditorGUILayout.PropertyField(sp_poscompensB);
                }

                if (Get.BigAngleAutomationCompensation)
                {
                    GUILayout.EndVertical();
                }


                #endregion


                GUILayout.Space(5f);

                EditorGUILayout.BeginHorizontal();

                if (Get.BigAngleAutomationCompensation)
                {
                    EditorGUIUtility.labelWidth = 147f;
                }
                else
                {
                    EditorGUIUtility.labelWidth = 154f;
                }

                EditorGUILayout.PropertyField(sp_BigAngleAutomationCompensation, new GUIContent("Big Angle Automation", sp_BigAngleAutomationCompensation.tooltip));;

                if (Get.BigAngleAutomationCompensation)
                {
                    string bigAngleSwitchTitle = drawBigAngleCompensationSettings ? "Show Default Weights" : "Show Big Angle Weights";
                    if (GUILayout.Button(bigAngleSwitchTitle))
                    {
                        drawBigAngleCompensationSettings = !drawBigAngleCompensationSettings;
                    }
                }

                EditorGUILayout.EndHorizontal();

                GUILayout.Space(5f);
            }

            GUILayout.EndVertical();
        }
Beispiel #19
0
        private void Fold_DrawAddMotionSettings()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);

            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawMotionSettings, 10, "►") + "  " + Lang("Additional Motion Settings"), FGUI_Resources.TexMotionIcon, ""), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
            {
                drawMotionSettings = !drawMotionSettings;
            }

            EditorGUIUtility.labelWidth = 140;


            if (drawMotionSettings)
            {
                GUILayout.Space(5f);
                EditorGUILayout.PropertyField(sp_AnimationStyle);

                if (Get.AnimationStyle != FLookAnimator.EFAnimationStyle.Linear)
                {
                    GUILayout.Space(5f);
                    if (Get.MaxRotationSpeed >= 2.5f)
                    {
                        GUI.color = unchangedC;
                    }
                    EditorGUILayout.PropertyField(sp_MaxRotationSpeed);
                    GUI.color = c;
                }

                //GUILayout.Space(3f);
                //El_DrawQuickerRotAbove();

                if (Get.ModelForwardAxis == Vector3.forward && Get.ModelUpAxis == Vector3.up)
                {
                    GUILayout.Space(5f);
                    if (Get.BaseRotationCompensation <= 0f)
                    {
                        GUI.color = unchangedC;
                    }
                    EditorGUIUtility.labelWidth = 178;
                    EditorGUIUtility.fieldWidth = 25;
                    EditorGUILayout.PropertyField(sp_BaseRotationCompensation);
                    EditorGUIUtility.fieldWidth = 0;
                    EditorGUIUtility.labelWidth = 0;
                    GUI.color = c;
                }
                else
                {
                    EditorGUILayout.HelpBox("'Base Rotation Compensation' is not yet avilable when using axis correction!", MessageType.None);
                    GUI.enabled = false;
                    EditorGUIUtility.labelWidth = 178;
                    EditorGUIUtility.fieldWidth = 25;
                    EditorGUILayout.PropertyField(sp_BaseRotationCompensation);
                    EditorGUIUtility.fieldWidth = 0;
                    EditorGUIUtility.labelWidth = 0;
                    GUI.enabled = true;
                }

                GUILayout.Space(5f);
                if (Get.WeightsMultiplier == 1f)
                {
                    GUI.color = unchangedC;
                }
                EditorGUIUtility.labelWidth = 142;
                EditorGUILayout.PropertyField(sp_weighmul);
                EditorGUIUtility.labelWidth = 0;
                GUI.color = c;
                GUILayout.Space(5f);
            }

            EditorGUIUtility.labelWidth = 0;

            GUILayout.EndVertical();
            GUILayout.Space(-5);
        }
Beispiel #20
0
        private void Fold_DrawBackBones()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

            GUILayout.BeginHorizontal();
            int preCount = Get.BackBonesCount;

            EditorGUIUtility.labelWidth = 130f;
            //EditorGUILayout.LabelField(new GUIContent(""Additional Modules" Spine Bones: (" + Get.BackBonesCount + ")"), EditorStyles.boldLabel);
            if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawBackBones, 10, "►") + "  Additional Spine Bones: (" + Get.BackBonesCount + ")", _TexBackbonesIcon, "Adding more neck/spine bones to look animation chain, using this feature can give you much more natural looking effects!\n\nBeware of neck bones for stoop pose, adjust weight of neck bone if needed or go to 'Backing Offset' in 'Corrections' Tab."), FGUI_Resources.FoldStyle))
            {
                drawBackBones = !drawBackBones;
            }
            EditorGUIUtility.labelWidth = 0f;


            if (GUILayout.Button("+", new GUILayoutOption[2] {
                GUILayout.MaxWidth(28), GUILayout.MaxHeight(18)
            }))
            {
                Get.BackBonesCount++;
                serializedObject.ApplyModifiedProperties();
                UpdateCustomInspector(Get, true);// Debug.Log("[LOOK ANIMATOR] Don't change backbones count in playmode");
                EditorUtility.SetDirty(target);
            }

            if (GUILayout.Button("-", new GUILayoutOption[2] {
                GUILayout.MaxWidth(28), GUILayout.MaxHeight(18)
            }))
            {
                if (Get.BackBonesCount > 0)
                {
                    Get.BackBonesCount--;
                    serializedObject.ApplyModifiedProperties();
                    UpdateCustomInspector(Get, true);// Debug.Log("[LOOK ANIMATOR] Don't change backbones count in playmode");
                    EditorUtility.SetDirty(target);
                }
            }

            GUILayout.EndHorizontal();
            int spc = 4;

            if (drawBackBones)
            {
                GUILayout.Space(6f);

                if (Get.BackBonesCount < 0)
                {
                    Get.BackBonesCount = 0;
                }
                if (preCount != Get.BackBonesCount)
                {
                    UpdateCustomInspector(Get);
                }


                #region Backbones array


                if (Get.BigAngleAutomation)
                {
                    if (drawBigAngleWeightsSettings)
                    {
                        EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
                    }
                    else
                    {
                        EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);
                    }
                    GUILayout.Space(3);
                    GUI.color = new Color(1f, 1f, 1f, 0.75f);
                    EditorGUILayout.LabelField(drawBigAngleWeightsSettings ? Lang("Weight when character looking far back") : Lang("Default look angle bone weights"), new GUIStyle(EditorStyles.label)
                    {
                        alignment = TextAnchor.MiddleCenter, fontStyle = FontStyle.Bold
                    });
                    GUI.color = c;
                    GUILayout.Space(5);
                }
                else
                {
                    drawBigAngleWeightsSettings = false;
                }


                EditorGUILayout.EndVertical();

                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
                // Draw leading bone weight settings
                EditorGUILayout.BeginHorizontal();
                GUIStyle rightAlignText = new GUIStyle(EditorStyles.label)
                {
                    alignment = TextAnchor.MiddleRight
                };

                if (Get.LookBones != null)
                {
                    if (Get.LookBones.Count > 0)
                    {
                        GUILayout.Label("Lead Bone", GUILayout.Width(70));
                        GUI.enabled = false; EditorGUILayout.ObjectField(Get.LookBones[0].Transform, typeof(Transform), true); GUI.enabled = true;

                        if (drawBigAngleWeightsSettings)
                        {
                            Get.LookBones[0].lookWeightB = GUILayout.HorizontalSlider(Get.LookBones[0].lookWeightB, 0f, 1f, GUILayout.Width(50f));
                            if (Application.isPlaying)
                            {
                                GUILayout.Label("(" + System.Math.Round(Get.LookBones[0].motionWeight, 1) + ")", rightAlignText, GUILayout.Width(31));
                            }
                            GUILayout.Label(" " + System.Math.Round(Get.LookBones[0].lookWeightB * 100f) + "%", rightAlignText, GUILayout.Width(38));
                        }
                        else
                        {
                            Get.LookBones[0].lookWeight = GUILayout.HorizontalSlider(Get.LookBones[0].lookWeight, 0f, 1f, GUILayout.Width(50f));
                            if (Application.isPlaying)
                            {
                                GUILayout.Label("(" + System.Math.Round(Get.LookBones[0].motionWeight, 1) + ")", rightAlignText, GUILayout.Width(31));
                            }
                            GUILayout.Label(" " + System.Math.Round(Get.LookBones[0].lookWeight * 100f) + "%", rightAlignText, GUILayout.Width(38));
                        }
                    }
                }

                EditorGUILayout.EndHorizontal();
                EditorGUILayout.EndVertical();
                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);

                GUILayout.Space(3);

                if (Get.BackBonesCount > 0)
                {
                    //EditorGUILayout.EndVertical();
                    GUI.color = new Color(1f, 0.94f, 0.94f, 0.5f);
                    //EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyleH);
                    EditorGUILayout.BeginVertical();
                    GUI.color = c;

                    EditorGUIUtility.labelWidth = 138f; EditorGUIUtility.fieldWidth = 33f;
                    EditorGUILayout.BeginHorizontal();
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(sp_AutoBackbonesWeights, new GUIContent("Auto Weights Motion", sp_AutoBackbonesWeights.tooltip), GUILayout.Width(159));
                    if (EditorGUI.EndChangeCheck())
                    {
                        serializedObject.ApplyModifiedProperties();                               /*if (Get.AutoBackbonesWeights) Get.CurveSpread = false;*/
                    }
                    EditorGUIUtility.labelWidth = 0f; EditorGUIUtility.fieldWidth = 0f;

                    // Drawing Falloff Slider
                    if (!Get.BigAngleAutomation)
                    {
                        if (!Get.CurveSpread)
                        {
                            if (Get.AutoBackbonesWeights)
                            {
                                GUILayout.Label(new GUIContent("Falloff", sp_fallvall.tooltip), GUILayout.Width(42));
                                EditorGUI.BeginChangeCheck();
                                Get.FaloffValue = GUILayout.HorizontalSlider(Get.FaloffValue, 0f, 1f);
                                if (EditorGUI.EndChangeCheck())
                                {
                                    Get.SetAutoWeightsDefault(); serializedObject.ApplyModifiedProperties();
                                }
                                GUILayout.Label(new GUIContent(" ", sp_fallvall.tooltip), GUILayout.Width(8));
                            }
                        }
                    }
                    else // Falloff sliders for and b values
                    {
                        if (Get.AutoBackbonesWeights)
                        {
                            if (drawBigAngleWeightsSettings)
                            {
                                GUILayout.Label(new GUIContent("Falloff", sp_fallvall.tooltip), GUILayout.Width(42));
                                EditorGUI.BeginChangeCheck();
                                Get.FaloffValueB = GUILayout.HorizontalSlider(Get.FaloffValueB, 0f, 1.85f);

                                if (EditorGUI.EndChangeCheck())
                                {
                                    float[] tgt = Get.CalculateRotationWeights(Get.FaloffValueB);
                                    for (int i = 1; i < Get.LookBones.Count; i++)
                                    {
                                        Get.LookBones[i].lookWeightB = tgt[i];
                                    }
                                    serializedObject.ApplyModifiedProperties();
                                }

                                GUILayout.Label(new GUIContent(" ", sp_fallvall.tooltip), GUILayout.Width(8));
                            }
                            else
                            {
                                GUILayout.Label(new GUIContent("Falloff", sp_fallvall.tooltip), GUILayout.Width(42));
                                EditorGUI.BeginChangeCheck();
                                Get.FaloffValue = GUILayout.HorizontalSlider(Get.FaloffValue, 0f, 1f);
                                if (EditorGUI.EndChangeCheck())
                                {
                                    Get.SetAutoWeightsDefault(); serializedObject.ApplyModifiedProperties();
                                }
                                GUILayout.Label(new GUIContent(" ", sp_fallvall.tooltip), GUILayout.Width(8));
                            }
                        }
                    }

                    EditorGUILayout.EndHorizontal();

                    GUILayout.Space(5);

                    // Draw backbones list
                    for (int i = 1; i < Get.LookBones.Count; i++)
                    {
                        if (animator)
                        {
                            if (animator.isHuman)
                            {
                                if (animator.GetBoneTransform(HumanBodyBones.Hips) == Get.LookBones[i].Transform)
                                {
                                    GUI.color = new Color(1f, 1f, 0.7f, 1f);
                                }
                            }
                        }


                        EditorGUILayout.BeginHorizontal();
                        GUI.enabled = false; GUILayout.Label("[" + i + "]", GUILayout.Width(20)); GUI.enabled = true;
                        Get.LookBones[i].Transform = (Transform)EditorGUILayout.ObjectField(Get.LookBones[i].Transform, typeof(Transform), true);
                        if (Get.AutoBackbonesWeights == false)
                        {
                            GUI.enabled = true;
                        }
                        else
                        {
                            GUI.enabled = false;
                        }

                        if (drawBigAngleWeightsSettings)
                        {
                            Get.LookBones[i].lookWeightB = GUILayout.HorizontalSlider(Get.LookBones[i].lookWeightB, 0f, 1f, GUILayout.Width(50f));
                            if (Application.isPlaying)
                            {
                                GUILayout.Label("(" + System.Math.Round(Get.LookBones[i].motionWeight, 1) + ")", rightAlignText, GUILayout.Width(31));
                            }
                            GUILayout.Label(" " + System.Math.Round(Get.LookBones[i].lookWeightB * 100f) + "%", rightAlignText, GUILayout.Width(38));
                        }
                        else
                        {
                            Get.LookBones[i].lookWeight = GUILayout.HorizontalSlider(Get.LookBones[i].lookWeight, 0f, 1f, GUILayout.Width(50f));
                            if (Get.BigAngleAutomation)
                            {
                                if (Application.isPlaying)
                                {
                                    GUILayout.Label("(" + System.Math.Round(Get.LookBones[i].motionWeight, 1) + ")", rightAlignText, GUILayout.Width(31));
                                }
                            }
                            GUILayout.Label(" " + System.Math.Round(Get.LookBones[i].lookWeight * 100f) + "%", rightAlignText, GUILayout.Width(38));
                        }

                        EditorGUILayout.EndHorizontal();
                        GUI.enabled = true;
                    }


                    GUI.color = c;
                    EditorGUIUtility.labelWidth = 0f;


                    #endregion

                    if (Get.BigAngleAutomation)
                    {
                        EditorGUILayout.EndVertical();
                    }

                    GUILayout.Space(9f);

                    if (Get.BigAngleAutomation)
                    {
                        EditorGUIUtility.labelWidth = 145f;
                    }
                    else
                    {
                        EditorGUIUtility.labelWidth = 150f;
                    }

                    EditorGUILayout.BeginHorizontal();
                    EditorGUI.BeginChangeCheck();
                    EditorGUILayout.PropertyField(sp_BigAngleAutomation);
                    if (EditorGUI.EndChangeCheck())
                    {
                        serializedObject.ApplyModifiedProperties();
                        float[] tgt = Get.CalculateRotationWeights(Get.FaloffValueB);
                        for (int i = 1; i < Get.LookBones.Count; i++)
                        {
                            Get.LookBones[i].lookWeightB = tgt[i];
                        }
                        if (Get.BigAngleAutomation)
                        {
                            Get.CurveSpread = false;
                        }
                        Get.UpdateAutomationWeights();
                    }

                    if (Get.BigAngleAutomation)
                    {
                        string bigAngleSwitchTitle = drawBigAngleWeightsSettings ? "Show Default Weights" : "Show Big Angle Weights";
                        if (GUILayout.Button(bigAngleSwitchTitle))
                        {
                            drawBigAngleWeightsSettings = !drawBigAngleWeightsSettings;
                        }
                    }

                    EditorGUILayout.EndHorizontal();

                    GUILayout.Space(5f);
                    EditorGUIUtility.labelWidth = 0f;
                    Fold_DrawAdvancedBackBones();
                    EditorGUILayout.EndVertical();
                    spc = 0;
                }
                else
                {
                    GUILayout.Space(4f);
                    EditorGUILayout.HelpBox("Hit '+' to assign spine bones for additional look motion.", MessageType.None);
                    GUILayout.Space(4f);
                }
            }

            GUILayout.Space(spc);

            EditorGUILayout.EndVertical();
        }
Beispiel #21
0
        private void Fold_DrawBirdMode()
        {
            GUILayout.BeginHorizontal();

            if (Get.BirdMode)
            {
                if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawBirdMode, 10, "►") + "  " + Lang("Bird Mode"), _TexBirdIcon, sp_bird.tooltip), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
                {
                    drawBirdMode = !drawBirdMode;
                }
                Get.BirdMode = EditorGUILayout.Toggle(Get.BirdMode, GUILayout.Width(16));
            }
            else
            {
                GUILayout.Button(new GUIContent("  " + Lang("Bird Mode"), _TexBirdIcon, sp_bird.tooltip), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle);
                Get.BirdMode = EditorGUILayout.Toggle(Get.BirdMode, GUILayout.Width(16));
            }

            GUILayout.EndHorizontal();

            if (drawBirdMode && Get.BirdMode)
            {
                //FGUI_Inspector.DrawUILine(0.1f, 0.8f, 1, 4, 1f);
                if (Get.RotationSpeed < 1.85f)
                {
                    GUILayout.Space(3f);

                    GUILayout.BeginHorizontal();
                    EditorGUILayout.HelpBox("To make bird mode look better increase 'Rotation Speed' Parameter under Tweaking Tab", MessageType.Warning);
                    if (GUILayout.Button("Adjust", new GUILayoutOption[] { GUILayout.Width(48), GUILayout.Height(38) }))
                    {
                        Get.MaxRotationSpeed = 2.5f; Get.RotationSpeed = 2.35f;
                    }
                    GUILayout.EndHorizontal();
                }
                else
                if (Get.MaxRotationSpeed < 1.8f)
                {
                    GUILayout.Space(3f);

                    GUILayout.BeginHorizontal();
                    EditorGUILayout.HelpBox("To make bird mode look better increase 'Max Rotation Speed' Parameter under 'Additional Motion Settings' Tab", MessageType.Info);
                    if (GUILayout.Button("Adjust", new GUILayoutOption[] { GUILayout.Width(48), GUILayout.Height(38) }))
                    {
                        Get.MaxRotationSpeed = 2.5f;
                    }
                    GUILayout.EndHorizontal();
                }


                GUILayout.Space(5f);
                EditorGUILayout.PropertyField(sp_birdlag);
                EditorGUILayout.PropertyField(sp_birdfreq);
                FGUI_Inspector.DrawUILine(0.1f, 0.05f, 1, 12, 0.95f);
                EditorGUILayout.PropertyField(sp_birddel);

                if (Get.DelayPosition > 0f)
                {
                    EditorGUILayout.PropertyField(sp_birmaxdist);
                    EditorGUILayout.PropertyField(sp_birddelgospeed);
                }

                GUILayout.Space(5f);
            }
        }
Beispiel #22
0
    void Fold_DrawSpineTransforms()
    {
        EditorGUILayout.BeginHorizontal();

        if (GUILayout.Button(new GUIContent("  " + FGUI_Resources.GetFoldSimbol(drawSpineTransforms, 10, "►") + "  " + Lang("Spine Bones Chain") + " (" + Get.SpineBones.Count + ")", FGUI_Resources.Tex_Bone, "Adjust count of chain bones or limit single bones motion with sliders"), FGUI_Resources.FoldStyle, new GUILayoutOption[] { GUILayout.Height(24) }))
        {
            drawSpineTransforms = !drawSpineTransforms;
        }
        if (GUILayout.Button("Reset", new GUILayoutOption[2] {
            GUILayout.Width(62), GUILayout.Height(18)
        }))
        {
            Get.SpineBones.Clear(); serializedObject.Update(); serializedObject.ApplyModifiedProperties(); Get._GizmosRefreshChainList(true); return;
        }

        EditorGUILayout.EndHorizontal();

        if (drawSpineTransforms)
        {
            GUILayout.Space(3);

            int strt = 0; int cnt = Get.SpineBones.Count;
            if (!Get.LastBoneLeading)
            {
                strt = 1;
            }
            else
            {
                cnt -= 1;
            }


            if (!Get.LastBoneLeading)
            {
                GUILayout.Space(2);
                EditorGUIUtility.labelWidth = 90;
                GUI.enabled = false; EditorGUILayout.ObjectField(new GUIContent("Head Bone: ", "Using sliders you can limit motion of bones or remove with 'X' button"), Get.SpineBones[0].transform, typeof(Transform), true); GUI.enabled = true;
                EditorGUIUtility.labelWidth = 0;
                GUILayout.Space(6);

                if (Get.SpineAnimatorAmount >= 1f)
                {
                    GUILayout.Space(3);
                }
            }
            else
            {
                GUILayout.Space(3);
            }

            if (Get.SpineAnimatorAmount >= 1f)
            {
                GUI.color = new Color(1f, 1f, 1f, 0.8f);
                EditorGUILayout.LabelField(new GUIContent("Spine Amount must be < 100% for weight sliders", "When Spine Animator Amount is 99% or less it enables blending then you can use motion weight blending sliders below"), FGUI_Resources.HeaderStyle);
                GUILayout.Space(3); GUI.color = c;
            }

            for (int i = strt; i < cnt; i++)
            {
                EditorGUILayout.BeginHorizontal();

                Color cc = c; cc.a = Get.SpineBones[i].MotionWeight * 0.8f + 0.2f;
                GUI.color   = cc;
                GUI.enabled = false; EditorGUILayout.ObjectField(new GUIContent("", "Using slider you can limit motion of this bone or remove it with 'X' button"), Get.SpineBones[i].transform, typeof(Transform), true); GUI.enabled = true;
                GUI.color   = c;

                if (Get.SpineAnimatorAmount >= 1f)
                {
                    GUI.enabled = false;
                }
                Get.SpineBones[i].MotionWeight = GUILayout.HorizontalSlider(Get.SpineBones[i].MotionWeight, 0f, 1f, GUILayout.Width(40f));
                GUI.enabled = true;

                if (GUILayout.Button(new GUIContent("X", "Remove bone from chain with this button or limit it's motion weight with slider"), new GUILayoutOption[2] {
                    GUILayout.Width(20), GUILayout.Height(14)
                }))
                {
                    Get.SpineBones.RemoveAt(i);
                    EditorUtility.SetDirty(target);
                    break;
                }

                EditorGUILayout.EndHorizontal();

                GUILayout.Space(1);
            }


            if (Get.LastBoneLeading)
            {
                GUILayout.Space(5);
                EditorGUIUtility.labelWidth = 90;
                GUI.enabled = false; EditorGUILayout.ObjectField(new GUIContent("Head Bone: ", "Using sliders you can limit motion of bones or remove with 'X' button"), Get.SpineBones[Get.SpineBones.Count - 1].transform, typeof(Transform), true); GUI.enabled = true;
                EditorGUIUtility.labelWidth = 0;
            }


            GUILayout.Space(2f);
        }

        GUILayout.Space(2f);
    }
Beispiel #23
0
        private void El_DrawLookWhenAbove()
        {
            GUILayout.Space(4);

            if (Get.LookWhenAbove > 0f)
            {
                GUILayout.BeginHorizontal();
                if (GUILayout.Button(new GUIContent(FGUI_Resources.GetFoldSimbol(drawLookWhenAbove, 10, "►"), "Click on this arrow to draw more advanced settings"), FGUI_Resources.FoldStyle, GUILayout.Width(16)))
                {
                    drawLookWhenAbove = !drawLookWhenAbove;
                }
                EditorGUILayout.PropertyField(sp_LookWhenAbove, new GUIContent("Look When Above", sp_LookWhenAbove.tooltip));
                GUILayout.EndHorizontal();

                if (drawLookWhenAbove)
                {
                    GUILayout.Space(2);
                    if (Get.LookWhenAboveVertical <= 0)
                    {
                        GUI.color = unchangedC;
                        GUILayout.BeginHorizontal();
                        EditorGUIUtility.labelWidth = 100;
                        EditorGUILayout.PropertyField(sp_LookWhenAboveVertical, new GUIContent("     Vertical", sp_LookWhenAboveVertical.tooltip));
                        EditorGUIUtility.labelWidth = 0;
                        EditorGUILayout.LabelField("(" + Mathf.Round(Get.LookWhenAbove) + ")", GUILayout.Width(36));
                        GUILayout.EndHorizontal();
                        GUI.color = c;
                    }
                    else
                    {
                        EditorGUIUtility.labelWidth = 100;
                        EditorGUILayout.PropertyField(sp_LookWhenAboveVertical, new GUIContent("     Vertical", sp_LookWhenAboveVertical.tooltip));
                        EditorGUIUtility.labelWidth = 0;
                    }

                    GUILayout.Space(2);
                    EditorGUIUtility.labelWidth = 160;
                    if (Get.WhenAboveGoBackAfter <= 0f)
                    {
                        GUI.color = unchangedC;
                    }
                    EditorGUILayout.PropertyField(sp_WhenAboveEraseAfter, new GUIContent("     Go Back After", sp_WhenAboveEraseAfter.tooltip));
                    EditorGUIUtility.labelWidth = 0;
                    GUI.color = c;

                    if (Get.WhenAboveGoBackAfter > 0)
                    {
                        //if (Get.WhenAboveGoBackAfterVertical <= 0)
                        //{
                        //    GUI.color = unchangedC;
                        //    GUILayout.BeginHorizontal();
                        //    EditorGUIUtility.labelWidth = 100;
                        //    EditorGUIUtility.fieldWidth = 10;
                        //    EditorGUILayout.PropertyField(sp_WhenAboveEraseAfterVertical, new GUIContent("     Vertical", sp_WhenAboveEraseAfterVertical.tooltip));
                        //    EditorGUIUtility.fieldWidth = 0;
                        //    EditorGUIUtility.labelWidth = 0;
                        //    EditorGUILayout.LabelField("" + System.Math.Round(Get.WhenAboveGoBackAfter, 2) + "", GUILayout.Width(36));
                        //    GUILayout.EndHorizontal();
                        //    GUI.color = c;
                        //}
                        //else
                        //{
                        //    EditorGUIUtility.labelWidth = 100;
                        //    EditorGUILayout.PropertyField(sp_WhenAboveEraseAfterVertical, new GUIContent("     Vertical", sp_WhenAboveEraseAfterVertical.tooltip));
                        //    EditorGUIUtility.labelWidth = 0;
                        //}

                        EditorGUILayout.PropertyField(sp_WhenAboveGoBackDuration, new GUIContent("     Go Back Duration", sp_WhenAboveGoBackDuration.tooltip));
                    }

                    GUI.color = c;

                    GUILayout.Space(4);
                }
            }
            else
            {
                GUI.color = unchangedC;
                EditorGUILayout.PropertyField(sp_LookWhenAbove, new GUIContent("Look When Above", sp_LookWhenAbove.tooltip));
                GUI.color = c;
            }
        }
        void El_DrawSelectiveCollisionBox2D()
        {
            GUILayout.Space(1f);
            GUI.color = new Color(0.85f, 1f, 0.85f, 1f);
            EditorGUILayout.BeginHorizontal(FGUI_Resources.HeaderBoxStyleH);
            string f = FGUI_Resources.GetFoldSimbol(drawInclud); int inclC = Get.IncludedColliders2D.Count;

            GUI.color = c;

            GUILayout.Label(new GUIContent(" "), GUILayout.Width(1));
            string inclColFoldTitle = "";

            inclColFoldTitle = "2D " + Lang("Collide With") + " (" + (inclC == 0 ? "None" : inclC.ToString()) + ")";

            if (GUILayout.Button(new GUIContent(" " + f + "  " + inclColFoldTitle, FGUI_Resources.TexBehaviourIcon), FGUI_Resources.FoldStyle, GUILayout.Height(24)))
            {
                drawInclud = !drawInclud;
            }

            if (drawInclud)
            {
                if (GUILayout.Button("+", new GUILayoutOption[2] {
                    GUILayout.MaxWidth(24), GUILayout.MaxHeight(22)
                }))
                {
                    Get.IncludedColliders2D.Add(null);
                    serializedObject.Update();
                    serializedObject.ApplyModifiedProperties();
                }
            }

            EditorGUILayout.EndHorizontal();

            if (drawInclud)
            {
                FGUI_Inspector.VSpace(-3, -5);
                GUI.color = new Color(0.6f, .9f, 0.6f, 1f);
                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyleH);
                GUI.color = c;
                GUILayout.Space(5f);

                EditorGUILayout.HelpBox("2D Collision is supported ONLY FOR CIRCLE, CAPSULE, BOX and POLYGON colliders for now!", MessageType.None);

                // Drawing colliders from list
                if (Get.IncludedColliders2D.Count == 0)
                {
                    EditorGUILayout.LabelField("Please add here 2D colliders", FGUI_Resources.HeaderStyle);
                    GUILayout.Space(2f);
                }
                else
                {
                    Get.CheckForColliderDuplicatesAndNulls2D();

                    EditorGUI.BeginChangeCheck();
                    for (int i = 0; i < Get.IncludedColliders2D.Count; i++)
                    {
                        EditorGUILayout.BeginHorizontal();

                        if (Get.IncludedColliders2D[i] != null)
                        {
                            if (!Get.IncludedColliders2D[i].gameObject.activeInHierarchy)
                            {
                                GUI.color = new Color(1f, 1f, 1f, 0.5f);
                            }
                            Get.IncludedColliders2D[i] = (Collider2D)EditorGUILayout.ObjectField(Get.IncludedColliders2D[i], typeof(Collider2D), true);
                            if (!Get.IncludedColliders2D[i].gameObject.activeInHierarchy)
                            {
                                GUI.color = c;
                            }
                        }
                        else
                        {
                            Get.IncludedColliders2D[i] = (Collider2D)EditorGUILayout.ObjectField(Get.IncludedColliders2D[i], typeof(Collider2D), true);
                        }

                        if (GUILayout.Button("X", new GUILayoutOption[2] {
                            GUILayout.MaxWidth(22), GUILayout.MaxHeight(16)
                        }))
                        {
                            Get.IncludedColliders2D.RemoveAt(i);
                            serializedObject.Update();
                            serializedObject.ApplyModifiedProperties();
                            return;
                        }

                        EditorGUILayout.EndHorizontal();
                    }

                    if (EditorGUI.EndChangeCheck())
                    {
                        Get.CheckForColliderDuplicatesAndNulls();
                        serializedObject.Update();
                        serializedObject.ApplyModifiedProperties();
                    }
                }

                GUILayout.Space(3f);

                // Lock button
                GUILayout.BeginVertical();
                if (ActiveEditorTracker.sharedTracker.isLocked)
                {
                    GUI.color = new Color(0.44f, 0.44f, 0.44f, 0.8f);
                }
                else
                {
                    GUI.color = new Color(0.95f, 0.95f, 0.99f, 0.9f);
                }
                if (GUILayout.Button(new GUIContent("Lock Inspector for Drag & Drop Colliders", "Drag & drop colliders to 'Included Colliders' List from the hierarchy"), FGUI_Resources.ButtonStyle, GUILayout.Height(18)))
                {
                    ActiveEditorTracker.sharedTracker.isLocked = !ActiveEditorTracker.sharedTracker.isLocked;
                }
                GUI.color = c;
                GUILayout.EndVertical();

                // Drag and drop box
                El_DrawDragAndDropCollidersBox();

                GUILayout.Space(3f);

                EditorGUILayout.EndVertical();
            }
        }
        void El_DrawSelectiveCollisionBox()
        {
            Get._editor_IsInspectorViewingIncludedColliders = drawInclud;

            GUILayout.Space(1f);
            GUI.color = new Color(0.85f, 1f, 0.85f, 1f);
            EditorGUILayout.BeginHorizontal(FGUI_Resources.HeaderBoxStyleH);
            string f = FGUI_Resources.GetFoldSimbol(drawInclud); int inclC = Get.IncludedColliders.Count;

            GUI.color = c;

            GUILayout.Label(new GUIContent(" "), GUILayout.Width(1));
            string inclColFoldTitle = "";

            if (Get.DynamicWorldCollidersInclusion)
            {
                if (Application.isPlaying)
                {
                    inclColFoldTitle = Lang("Collide With") + " (Dynamic" + " : " + inclC + ")";
                }
                else
                {
                    inclColFoldTitle = "Always Include (" + inclC + ")";
                }
            }
            else
            {
                inclColFoldTitle = Lang("Collide With") + " (" + (inclC == 0 ? "0 !!!" : inclC.ToString()) + ")";
            }

            if (GUILayout.Button(new GUIContent(" " + f + "  " + inclColFoldTitle, FGUI_Resources.TexBehaviourIcon), FGUI_Resources.FoldStyle, GUILayout.Height(24)))
            {
                drawInclud = !drawInclud;
            }

            //if (!Application.isPlaying)
            //    if (Get.DynamicWorldCollidersInclusion) drawInclud = false;

            //bool checkNullIncludColls = true;
            if (drawInclud)
            {
                //if (GUILayout.Button("+", new GUILayoutOption[2] { GUILayout.MaxWidth(24), GUILayout.MaxHeight(22) }))
                //{
                //    Get.IncludedColliders.Add(null);
                //    //Get._editor_checkInclCollidersForNulls = -10;
                //    //checkNullIncludColls = false;
                //    serializedObject.Update();
                //    serializedObject.ApplyModifiedProperties();
                //}
            }

            EditorGUILayout.EndHorizontal();

            if (drawInclud)
            {
                FGUI_Inspector.VSpace(-3, -5);
                GUI.color = new Color(0.6f, .9f, 0.6f, 1f);
                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyleH);
                GUI.color = c;
                GUILayout.Space(5f);


                // Drawing colliders from list
                if (Get.IncludedColliders.Count == 0)
                {
                    EditorGUILayout.LabelField("Please add here colliders", FGUI_Resources.HeaderStyle);
                    GUILayout.Space(2f);
                }
                else
                {
                    Get.CheckForColliderDuplicatesAndNulls();

                    EditorGUI.BeginChangeCheck();
                    for (int i = 0; i < Get.IncludedColliders.Count; i++)
                    {
                        EditorGUILayout.BeginHorizontal();

                        if (Get.IncludedColliders[i] != null)
                        {
                            if (!Get.IncludedColliders[i].gameObject.activeInHierarchy)
                            {
                                GUI.color = new Color(1f, 1f, 1f, 0.5f);
                            }
                            Get.IncludedColliders[i] = (Collider)EditorGUILayout.ObjectField(Get.IncludedColliders[i], typeof(Collider), true);
                            if (!Get.IncludedColliders[i].gameObject.activeInHierarchy)
                            {
                                GUI.color = c;
                            }
                        }

                        if (GUILayout.Button("X", new GUILayoutOption[2] {
                            GUILayout.MaxWidth(22), GUILayout.MaxHeight(16)
                        }))
                        {
                            Get.IncludedColliders.RemoveAt(i);
                            serializedObject.Update();
                            serializedObject.ApplyModifiedProperties();
                            return;
                        }

                        EditorGUILayout.EndHorizontal();
                    }

                    if (EditorGUI.EndChangeCheck())
                    {
                        Get.CheckForColliderDuplicatesAndNulls();
                        serializedObject.Update();
                        serializedObject.ApplyModifiedProperties();
                    }
                }

                GUILayout.Space(6f);

                // Lock button
                GUILayout.BeginVertical();
                if (ActiveEditorTracker.sharedTracker.isLocked)
                {
                    GUI.color = new Color(0.44f, 0.44f, 0.44f, 0.8f);
                }
                else
                {
                    GUI.color = new Color(0.95f, 0.95f, 0.99f, 0.9f);
                }
                if (GUILayout.Button(new GUIContent("Lock Inspector for Drag & Drop Colliders", "Drag & drop colliders to 'Included Colliders' List from the hierarchy"), FGUI_Resources.ButtonStyle, GUILayout.Height(18)))
                {
                    ActiveEditorTracker.sharedTracker.isLocked = !ActiveEditorTracker.sharedTracker.isLocked;
                }
                GUI.color = c;
                GUILayout.EndVertical();

                // Drag and drop box
                El_DrawDragAndDropCollidersBox();

                GUILayout.Space(3f);

                if (Get.IncludedColliders.Count > 0)
                {
                    EditorGUILayout.HelpBox("You can disable collider components on the objects - tail animator will still detect collision. If you deactivate the Game Object with collider - tail animator will not detect collision with it.", MessageType.Info);
                }

                EditorGUILayout.EndVertical();
            }
        }
    private void Tab_DrawPhysics()
    {
        FGUI_Inspector.VSpace(-2, -4);

        GUILayout.BeginVertical(FGUI_Resources.ViewBoxStyle);


        // Gravity power
        GUILayout.Space(7f);
        EditorGUILayout.PropertyField(sp_GravityPower, true);
        GUILayout.Space(5f);


        // Physics switch button
        GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);
        GUILayout.Space(2f);

        // Tab to switch collisions
        GUILayout.BeginHorizontal();

        if (Get.UseCollisions)
        {
            if (GUILayout.Button(new GUIContent(" " + FGUI_Resources.GetFoldSimbol(drawColl, 8, "►") + "  " + Lang("Use Collisions") + " (Experimental)", FGUI_Resources.Tex_Collider, sp_UseCollisions.tooltip), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
            {
                drawColl = !drawColl;
            }
        }
        else
        if (GUILayout.Button(new GUIContent("  " + Lang("Use Collisions") + " (Experimental)", FGUI_Resources.Tex_Collider, sp_UseCollisions.tooltip), FGUI_Resources.FoldStyle, GUILayout.Height(21)))
        {
            Get.UseCollisions = !Get.UseCollisions; serializedObject.ApplyModifiedProperties();
        }

        GUILayout.FlexibleSpace();
        EditorGUILayout.PropertyField(sp_UseCollisions, new GUIContent("", sp_UseCollisions.tooltip), GUILayout.Width(22));

        GUILayout.EndHorizontal();


        //
        if (Get.UseCollisions && drawColl)
        {
            GUILayout.Space(5f);
            GUI.color = new Color(0.85f, 1f, 0.85f, 1f);
            EditorGUILayout.BeginHorizontal(FGUI_Resources.HeaderBoxStyleH);
            string f = FGUI_Resources.GetFoldSimbol(drawInclud); int iconSize = 24; int inclC = Get.IncludedColliders.Count;
            GUI.color = c;

            GUILayout.Label(new GUIContent(" "), GUILayout.Width(1));
            if (GUILayout.Button(new GUIContent(" " + f + "  " + Lang("Collide With") + " (" + (inclC == 0 ? "0 !!!)" : inclC + ")"), FGUI_Resources.TexBehaviourIcon), FGUI_Resources.FoldStyle, GUILayout.Height(24)))
            {
                drawInclud = !drawInclud;
            }

            if (drawInclud)
            {
                if (GUILayout.Button("+", new GUILayoutOption[2] {
                    GUILayout.MaxWidth(24), GUILayout.MaxHeight(22)
                }))
                {
                    Get.IncludedColliders.Add(null);
                    serializedObject.Update();
                    serializedObject.ApplyModifiedProperties();
                }
            }

            EditorGUILayout.EndHorizontal();

            if (drawInclud)
            {
                FGUI_Inspector.VSpace(-3, -5);
                GUI.color = new Color(0.6f, .9f, 0.6f, 1f);
                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyleH);
                GUI.color = c;
                GUILayout.Space(5f);


                // Drawing colliders from list
                if (Get.IncludedColliders.Count == 0)
                {
                    EditorGUILayout.LabelField("Please add here colliders", FGUI_Resources.HeaderStyle);
                    GUILayout.Space(2f);
                }
                else
                {
                    EditorGUI.BeginChangeCheck();
                    for (int i = 0; i < Get.IncludedColliders.Count; i++)
                    {
                        EditorGUILayout.BeginHorizontal();
                        Get.IncludedColliders[i] = (Collider)EditorGUILayout.ObjectField(Get.IncludedColliders[i], typeof(Collider), true);
                        if (GUILayout.Button("X", new GUILayoutOption[2] {
                            GUILayout.MaxWidth(22), GUILayout.MaxHeight(16)
                        }))
                        {
                            Get.IncludedColliders.RemoveAt(i);
                            serializedObject.Update();
                            serializedObject.ApplyModifiedProperties();
                            return;
                        }

                        EditorGUILayout.EndHorizontal();
                    }

                    if (EditorGUI.EndChangeCheck())
                    {
                        Get.CheckForColliderDuplicates();
                        serializedObject.Update();
                        serializedObject.ApplyModifiedProperties();
                    }
                }

                GUILayout.Space(6f);

                // Lock button
                GUILayout.BeginVertical();
                if (ActiveEditorTracker.sharedTracker.isLocked)
                {
                    GUI.color = new Color(0.44f, 0.44f, 0.44f, 0.8f);
                }
                else
                {
                    GUI.color = new Color(0.95f, 0.95f, 0.99f, 0.9f);
                }
                if (GUILayout.Button(new GUIContent("Lock Inspector for Drag & Drop Colliders", "Drag & drop colliders to 'Included Colliders' List from the hierarchy"), FGUI_Resources.ButtonStyle, GUILayout.Height(18)))
                {
                    ActiveEditorTracker.sharedTracker.isLocked = !ActiveEditorTracker.sharedTracker.isLocked;
                }
                GUI.color = c;
                GUILayout.EndVertical();

                // Drag and drop box
                El_DrawDragAndDropCollidersBox();

                GUILayout.Space(3f);
                EditorGUILayout.EndVertical();
            }


            GUILayout.Space(5f);

            f         = FGUI_Resources.GetFoldSimbol(drawCollSetup);
            GUI.color = new Color(1f, .85f, .85f, 1f);
            EditorGUILayout.BeginHorizontal(FGUI_Resources.HeaderBoxStyleH); iconSize = 22;
            GUI.color = c;
            GUILayout.Label(new GUIContent(" "), GUILayout.Width(1));
            if (GUILayout.Button(FGUI_Resources.Tex_GearSetup, EditorStyles.label, new GUILayoutOption[2] {
                GUILayout.Width(iconSize), GUILayout.Height(iconSize)
            }))
            {
                drawCollSetup = !drawCollSetup;
            }
            if (GUILayout.Button(f + "     " + "Colliders Setup" + "     " + f, FGUI_Resources.HeaderStyle, GUILayout.Height(24)))
            {
                drawCollSetup = !drawCollSetup;
            }
            if (GUILayout.Button(FGUI_Resources.Tex_GearSetup, EditorStyles.label, new GUILayoutOption[2] {
                GUILayout.Width(iconSize), GUILayout.Height(iconSize)
            }))
            {
                drawCollSetup = !drawCollSetup;
            }
            GUILayout.Label(new GUIContent(" "), GUILayout.Width(1));
            EditorGUILayout.EndHorizontal();

            if (drawCollSetup)
            {
                FGUI_Inspector.VSpace(-3, -5);
                GUI.color = new Color(1f, .55f, .55f, 1f);
                EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyleH);
                GUI.color = c;
                GUILayout.Space(6f);
                EditorGUILayout.PropertyField(sp_CollidersScaleMul, new GUIContent("Scale Multiplier"));
                EditorGUILayout.PropertyField(sp_CollidersScale, new GUIContent("Scale Curve"));
                EditorGUILayout.PropertyField(sp_CollidersAutoCurve, new GUIContent("Auto Curve"));
                EditorGUILayout.PropertyField(sp_AllCollidersOffset, true);
                GUILayout.Space(6f);


                El_DrawSelectiveCollision();

                GUILayout.Space(3f);
                EditorGUILayout.EndVertical();
            }

            GUILayout.Space(5f);

            if (Get.UseTruePosition)
            {
                GUI.color = new Color(1f, 0.7f, 0.7f, 1f);
            }
            else
            {
                GUI.color = new Color(1f, 1f, 0.7f, 1f);
            }
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxLightStyle);
            GUILayout.Space(2f); EditorGUILayout.PropertyField(sp_UseTruePosition, true); GUILayout.Space(2f);
            GUILayout.EndVertical(); GUI.color = c;

            GUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
            GUILayout.Space(2f); EditorGUILayout.PropertyField(sp_DetailedCollision, true); GUILayout.Space(2f);
            GUILayout.EndVertical();
            GUILayout.Space(2f);
        }


        GUILayout.Space(2f);
        GUILayout.EndVertical();
        GUILayout.Space(-5f);
        GUILayout.EndVertical();
    }
Beispiel #27
0
        private void Fold_Eyes_DrawSetup()
        {
            GUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);

            if (GUILayout.Button(new GUIContent("  " + FGUI_Resources.GetFoldSimbol(drawEyesSetup, 10, "►") + "  " + Lang("Character Setup"), FGUI_Resources.Tex_MiniGear, ""), LangBig() ? FGUI_Resources.FoldStyleBig : FGUI_Resources.FoldStyle))
            {
                drawEyesSetup = !drawEyesSetup;
            }

            EditorGUIUtility.labelWidth = 140;

            if (drawEyesSetup)
            {
                GUILayout.Space(5);
                EditorGUILayout.BeginHorizontal();
                EditorGUIUtility.labelWidth = 55;
                EditorGUILayout.PropertyField(sp_eyeL);
                EditorGUILayout.LabelField(" ", GUILayout.Width(4));
                EditorGUILayout.PropertyField(sp_eyeR);
                EditorGUIUtility.labelWidth = 0;
                EditorGUILayout.EndHorizontal();
                GUILayout.Space(3);

                EditorGUILayout.BeginHorizontal();
                EditorGUIUtility.labelWidth = 98;
                EditorGUILayout.PropertyField(sp_eyeLInv);
                EditorGUILayout.LabelField(" ", GUILayout.Width(4));
                EditorGUILayout.PropertyField(sp_eyeRInv);
                EditorGUIUtility.labelWidth = 0;
                EditorGUILayout.EndHorizontal();
                GUILayout.Space(3);

                EditorGUILayout.PropertyField(sp_EyesOffsetRotation);
                GUILayout.Space(3);



                EditorGUILayout.BeginHorizontal();

                if (!Get.HeadReference)
                {
                    GUI.color = new Color(1f, 1f, .65f, 1f);
                    EditorGUILayout.PropertyField(sp_head);
                    GUI.color = c;

                    GUI.enabled = false;
                    EditorGUILayout.LabelField("(", GUILayout.Width(8));
                    EditorGUILayout.ObjectField(Get.LeadBone, typeof(Transform), true, GUILayout.Width(80));
                    EditorGUILayout.LabelField(")", GUILayout.Width(8));
                    GUI.enabled = true;
                }
                else
                {
                    EditorGUILayout.PropertyField(sp_head);
                }


                EditorGUILayout.EndHorizontal();

                GUILayout.Space(5);
            }

            EditorGUIUtility.labelWidth = 0;
            GUILayout.EndVertical();
        }