コード例 #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();
        }
コード例 #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);
    }
コード例 #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();
        }
コード例 #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();
    }
コード例 #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);
            }
        }
コード例 #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();
        }
コード例 #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);
        }
    }
コード例 #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();
        }
コード例 #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();
        }
コード例 #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();
    }
コード例 #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();
        }
    }
コード例 #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();
    }
コード例 #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();
    }
コード例 #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);
        }
コード例 #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();
        }
コード例 #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();
    }
コード例 #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();
    }
コード例 #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();
        }
コード例 #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);
        }
コード例 #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();
        }
コード例 #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);
            }
        }
コード例 #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);
    }
コード例 #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;
            }
        }
コード例 #24
0
        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();
            }
        }
コード例 #25
0
        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();
            }
        }
コード例 #26
0
    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();
    }
コード例 #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();
        }