导入leg插件，完成腿部动画

Assets/FImpossible Creations/All Fimpossible Creations Plugins Assembly Definitions.unitypackage.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1b8d36599035b4548acb3ac78e2106d2
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Directories Description.txt

@@ -0,0 +1,15 @@
+
+This directories are splitted into different categories for Assembly Definitions.
+You can use Assembly Definitions to speed up compilation time.
+Import .unitypackage FImpossible Assembly Definitions to have them prepared automatically.
+
+
+/Editor - Scripts responsible for drawing inspector windows and other gui for plugins
+and also additional editor menus
+
+/Plugins - Animating - All plugins related to animation or procedural animation grouped in one directory
+/Plugins - Audio - All plugins related to Audio grouped in one directory
+/Plugins - Level Design - All plugins related to level design grouped in one directory
+/Plugins - Other - All plugins related to other things like optimization grouped in one directory
+/Plugins - Shared - Demos plugins or my other free packages used in shared way for rest of the packages
+/Shared Tools - Shared tools for inspector windows or shared math logics

Assets/FImpossible Creations/Directories Description.txt.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: df998983f5754e14ea9d470a9a2e8477
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8decbbc1489ab42499556e78ab5e1e32
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/AD_Fimpos.Editor.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "AD_Fimpos.Editor",
+    "references": [
+        "GUID:0e6b1f35d8416da46a5e09a445db4184",
+        "GUID:4d3c0eb3c5c6f2243952516f8611fff4",
+        "GUID:103829f02546ce64db83be245c91a2cc"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/FImpossible Creations/Editor/AD_Fimpos.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: cc00d04e0a0104949875050b6f122a51
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 98531866a7661d34e817ebf3b96260c9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 505cfa9eacb239c4cab04a64cb91877a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Components.cs

@@ -0,0 +1,187 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.AI;
+
+namespace FIMSpace.FEditor
+{
+    /// <summary>
+    /// FM: Class with basic tools for working in Unity Editor level
+    /// </summary>
+    public static partial class FEditor_MenuAddOptions
+    {
+
+        [MenuItem("CONTEXT/Collider/Generate NavMesh Obstacle")]
+        private static void GenerateNavMeshObstacle(MenuCommand menuCommand)
+        {
+            Collider targetComponent = (Collider)menuCommand.context;
+
+            if (targetComponent)
+            {
+                NavMeshObstacle obstacle = targetComponent.gameObject.GetComponent<NavMeshObstacle>();
+                if (obstacle == null) obstacle = targetComponent.gameObject.AddComponent<NavMeshObstacle>();
+                obstacle.center = targetComponent.bounds.center;
+                obstacle.size = targetComponent.bounds.size;
+                obstacle.carving = true;
+
+                EditorUtility.SetDirty(targetComponent.gameObject);
+            }
+        }
+
+
+        [MenuItem("CONTEXT/Transform/Fit child objects to bottom origin")]
+        private static void ChildBottomOrigin(MenuCommand menuCommand)
+        {
+            Transform t = (Transform)menuCommand.context;
+            FitToBottom(t);
+        }
+
+        [MenuItem("CONTEXT/Transform/Hide Transform In The Inspector View (Use Components Hider to unhide)")]
+        private static void HideTransformInInspector(MenuCommand menuCommand)
+        {
+            Transform t = (Transform)menuCommand.context;
+
+            if (t)
+            {
+                t.hideFlags = HideFlags.HideInInspector;
+                EditorUtility.SetDirty(t);
+            }
+        }
+
+        private static void FitToBottom(Transform t)
+        {
+            if (t.childCount > 0)
+            {
+                float lowestY = float.MaxValue;
+                Renderer rr = null;
+
+                for (int i = 0; i < t.childCount; i++)
+                {
+                    Renderer r = t.GetChild(i).GetComponent<Renderer>();
+
+                    if (r.bounds.min.y < lowestY)
+                    {
+                        lowestY = r.bounds.min.y;
+                        rr = r;
+                    }
+                }
+
+                if (rr)
+                {
+                    Vector3 offset = new Vector3(0, t.position.y - rr.bounds.min.y, 0);
+                    for (int i = 0; i < t.childCount; i++)
+                    {
+                        t.GetChild(i).position += offset;
+                    }
+                }
+
+                EditorUtility.SetDirty(t.gameObject);
+            }
+        }
+
+        [MenuItem("CONTEXT/Transform/Generate parent + Fit objects to bottom")]
+        private static void GenerateParentAndFit(MenuCommand menuCommand)
+        {
+            Transform t = (Transform)menuCommand.context;
+            int sibl = t.GetSiblingIndex();
+            GameObject parent = new GameObject(t.name);
+            parent.transform.SetParent(t.parent);
+            parent.transform.position = t.position;
+            parent.transform.rotation = t.rotation;
+            parent.transform.localScale = t.localScale;
+            t.SetParent(parent.transform);
+            FitToBottom(parent.transform);
+            EditorUtility.SetDirty(t.gameObject);
+            parent.transform.SetSiblingIndex(sibl);
+            if (Selection.activeGameObject == t.gameObject) Selection.activeGameObject = parent;
+        }
+
+        [MenuItem("CONTEXT/AudioReverbZone/Fit To Collider")]
+        private static void AudioReverbZoneFit(MenuCommand menuCommand)
+        {
+            AudioReverbZone targetComponent = (AudioReverbZone)menuCommand.context;
+
+            if (targetComponent)
+            {
+                Collider c = targetComponent.gameObject.GetComponent<Collider>();
+
+                if (c)
+                {
+                    targetComponent.minDistance = Vector3.Distance(c.bounds.min, c.bounds.max) * 0.45f;
+                    targetComponent.maxDistance = targetComponent.minDistance * 1.35f;
+                }
+
+                EditorUtility.SetDirty(targetComponent.gameObject);
+            }
+        }
+
+
+        [MenuItem("CONTEXT/ReflectionProbe/Fit To Collider")]
+        private static void ReflectionProbeFit(MenuCommand menuCommand)
+        {
+            ReflectionProbe targetComponent = (ReflectionProbe)menuCommand.context;
+
+            if (targetComponent)
+            {
+                Collider c = targetComponent.gameObject.GetComponent<Collider>();
+                BoxCollider bc = c as BoxCollider;
+
+                if (c)
+                {
+                    if (bc)
+                    {
+                        targetComponent.center = bc.center;
+                        targetComponent.size = bc.size;
+                    }
+                    else
+                    {
+                        targetComponent.center = c.bounds.center;
+                        targetComponent.size = c.bounds.size;
+                    }
+                }
+
+                EditorUtility.SetDirty(targetComponent.gameObject);
+            }
+        }
+
+        [MenuItem("GameObject/Add Separator", false, 0)]
+        static void AddSeparatorObject()
+        {
+            GameObject go = new GameObject();
+            go.name = "-------------------";
+            go.gameObject.SetActive(false);
+            go.transform.position = Vector3.zero;
+            go.transform.rotation = Quaternion.identity;
+            go.transform.localScale = Vector3.one;
+        }
+
+        [MenuItem("CONTEXT/MeshFilter/Save Mesh As Asset")]
+        private static void SaveFilterMeshAsAsset(MenuCommand menuCommand)
+        {
+            MeshFilter targetComponent = (MeshFilter)menuCommand.context;
+
+            if (targetComponent == null) return;
+            if (targetComponent.sharedMesh == null) return;
+
+            Mesh newMesh = GameObject.Instantiate(targetComponent.sharedMesh) as Mesh;
+
+            string nameFormatted = targetComponent.sharedMesh.name.Replace(":", "-");
+            nameFormatted = nameFormatted.Replace("=", "_");
+
+            string path = EditorUtility.SaveFilePanel("Select Directory", Application.dataPath, nameFormatted, "");
+            if (path == "") return;
+
+            if (path.StartsWith(Application.dataPath))
+            {
+                path = "Assets" + path.Substring(Application.dataPath.Length);
+            }
+
+            AssetDatabase.CreateAsset(newMesh, path + ".asset");
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            var obj = AssetDatabase.LoadAssetAtPath(path + ".asset", typeof(Mesh));
+            if (obj) EditorGUIUtility.PingObject(obj);
+        }
+
+    }
+}

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Components.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: d1bd3c56bdf13284ebc28a5a22890ef6
+timeCreated: 1531406488
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Files.cs

@@ -0,0 +1,111 @@
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FEditor
+{
+    /// <summary>
+    /// FM: Class with basic tools for working in Unity Editor level
+    /// </summary>
+    public static partial class FEditor_MenuAddOptions
+    {
+
+        [MenuItem("Assets/Utilities/Copy Full Path To Directory")]
+        private static void CopyWholePathToDir(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+            string assetPath = AssetDatabase.GetAssetPath(Selection.objects[0]);
+            string fullPath = Path.Combine(Directory.GetCurrentDirectory(), assetPath);
+            GUIUtility.systemCopyBuffer = Path.GetDirectoryName(fullPath);
+        }
+
+
+
+        [MenuItem("CONTEXT/MonoBehaviour/Go To Script's Directory")]
+        private static void GoToBehaviourDirectory(MenuCommand menuCommand)
+        {
+            if (menuCommand.context is MonoBehaviour)
+            {
+                MonoBehaviour targetComponent = (MonoBehaviour)menuCommand.context;
+
+                if (targetComponent)
+                {
+                    MonoScript script = MonoScript.FromMonoBehaviour(targetComponent);
+                    if (script) EditorGUIUtility.PingObject(script);
+                }
+            }
+            else if (menuCommand.context is ScriptableObject)
+            {
+                ScriptableObject targetComponent = (ScriptableObject)menuCommand.context;
+
+                if (targetComponent)
+                {
+                    MonoScript script = MonoScript.FromScriptableObject(targetComponent);
+                    if (script) EditorGUIUtility.PingObject(script);
+                }
+            }
+        }
+
+        [MenuItem("Assets/Utilities/Name iterative selected assets", true)]
+        static bool SetFilenamesCheck(MenuCommand menuCommand)
+        { return Selection.gameObjects.Length > 0; }
+
+        [MenuItem("Assets/Utilities/Name iterative selected assets", false)]
+        private static void SetFilenames(MenuCommand menuCommand)
+        {
+            if (Selection.gameObjects.Length == 0) return;
+
+            string filename = EditorUtility.SaveFilePanelInProject("Type your target filename (no file will be created)", Selection.gameObjects[0].name, "", "Type your target filename (no file will be created)");
+            filename = filename.Replace("Assets/", "");
+            if (string.IsNullOrEmpty(filename)) return;
+
+            List<GameObject> toRename = new List<GameObject>();
+            GameObject ctx = (GameObject)menuCommand.context;
+            if (ctx) toRename.Add(ctx);
+
+            for (int i = 0; i < Selection.gameObjects.Length; i++)
+            {
+                if (!toRename.Contains(Selection.gameObjects[i])) toRename.Add(Selection.gameObjects[i]);
+            }
+
+            int objects = 0;
+            for (int i = 0; i < toRename.Count; i++)
+            {
+                if (toRename[i] == null) continue;
+                string assetPath = AssetDatabase.GetAssetPath(toRename[i]);
+                if (string.IsNullOrEmpty(assetPath)) continue;
+
+                AssetDatabase.RenameAsset(assetPath, filename + "_" + objects + Path.GetExtension(assetPath));
+                objects++;
+            }
+        }
+
+#if UNITY_2019_4_OR_NEWER
+        [MenuItem("Assets/Utilities/Add name prefixes for selection", true)]
+        static bool SetPrefixesCheck(MenuCommand menuCommand)
+        { return Selection.objects.Length > 0; }
+
+        [MenuItem("Assets/Utilities/Add name prefixes for selection", false)]
+        private static void SetPrefixes(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+
+            for (int i = 0; i < Selection.objects.Length; i++)
+            {
+                if (Selection.objects[i] == null) continue;
+
+                string assetPath = AssetDatabase.GetAssetPath(Selection.objects[i]);
+                if (string.IsNullOrEmpty(assetPath)) continue;
+
+                string prefix = GetPrefix(Selection.objects[i], assetPath);
+                if (string.IsNullOrEmpty(prefix)) continue;
+                {
+                    AssetDatabase.RenameAsset(assetPath, prefix + Selection.objects[i].name);
+                }
+            }
+        }
+#endif
+
+    }
+}

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Files.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: b29f5ef3617d5fc4593ec345c43482f8
+timeCreated: 1531406488
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Prefabs.cs

@@ -0,0 +1,180 @@
+#if UNITY_2019_4_OR_NEWER
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FEditor
+{
+    /// <summary>
+    /// FM: Class with basic tools for working in Unity Editor level
+    /// </summary>
+    public static partial class FEditor_MenuAddOptions
+    {
+
+        [MenuItem("Assets/Utilities/Create Prefab and Add Collider", true)]
+        private static bool CreatePrefabOutOfModelAssetCollCheck(MenuCommand menuCommand)
+        { return IsAnyPrefabable(Selection.objects); }
+
+        [MenuItem("Assets/Utilities/Create Prefab", true)]
+        private static bool CreatePrefabOutOfModelAssetCheck(MenuCommand menuCommand)
+        { return IsAnyPrefabable(Selection.objects); }
+
+
+        [MenuItem("Assets/Utilities/Create Prefab and Add Collider")]
+        private static void CreatePrefabOutOfModelAssetColl(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+
+            for (int i = 0; i < Selection.objects.Length; i++)
+            {
+                Object ob = Selection.objects[i];
+                var type = PrefabUtility.GetPrefabAssetType(ob);
+                if (type == PrefabAssetType.NotAPrefab || type == PrefabAssetType.MissingAsset) continue;
+
+                string directory = Path.GetDirectoryName(AssetDatabase.GetAssetPath(ob));
+                GameObject toSave = GeneratePrePrefabObject(ob);
+
+                if (toSave == null) return;
+
+                MeshFilter f = toSave.GetComponentInChildren<MeshFilter>();
+                if (f == null) f = FTransformMethods.FindComponentInAllChildren<MeshFilter>(toSave.transform);
+
+                if (f)
+                    f.gameObject.AddComponent<BoxCollider>();
+                else
+                    toSave.AddComponent<BoxCollider>();
+
+                directory = Path.Combine(directory, toSave.name + ".prefab");
+                PrefabUtility.SaveAsPrefabAsset(toSave, directory);
+
+                if (toSave) GameObject.DestroyImmediate(toSave);
+            }
+        }
+
+
+        [MenuItem("Assets/Utilities/Create Prefab")]
+        private static void CreatePrefabOutOfModelAsset(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+
+            for (int i = 0; i < Selection.objects.Length; i++)
+            {
+                Object ob = Selection.objects[i];
+                var type = PrefabUtility.GetPrefabAssetType(ob);
+                if (type == PrefabAssetType.NotAPrefab || type == PrefabAssetType.MissingAsset) continue;
+
+                string directory = Path.GetDirectoryName(AssetDatabase.GetAssetPath(ob));
+
+                GameObject toSave = GeneratePrePrefabObject(ob);
+
+                directory = Path.Combine(directory, toSave.name + ".prefab");
+                PrefabUtility.SaveAsPrefabAsset(toSave, directory);
+
+                if (toSave) GameObject.DestroyImmediate(toSave);
+            }
+        }
+
+        [MenuItem("Assets/Utilities/Create Material with this as Default Texture", true)]
+        private static bool CreateMaterialWithTexCheck(MenuCommand menuCommand)
+        { return IsAnyTexture(Selection.objects); }
+
+        [MenuItem("Assets/Utilities/Create Material with this as Default Texture", false)]
+        private static void CreateMaterialWithTex(MenuCommand menuCommand)
+        {
+            if (!IsAnyTexture(Selection.objects)) return;
+            if (Selection.objects.Length == 0) return;
+
+            Shader defSh = Shader.Find("Standard");
+
+            if (defSh is null)
+            {
+                UnityEngine.Debug.Log("No Default Shader!");
+                return;
+            }
+
+            for (int i = 0; i < Selection.objects.Length; i++)
+            {
+                Object ob = Selection.objects[i];
+
+                TextureImporter texImp = (TextureImporter)AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(ob));
+                if (texImp is null) continue;
+
+                string directory = Path.GetDirectoryName(AssetDatabase.GetAssetPath(ob));
+
+                Material newMat = new Material(defSh);
+                newMat.SetTexture("_MainTex", (Texture2D)ob);
+                newMat.SetFloat("_Glossiness", 0f);
+
+                newMat.name = ClearMaterialTypeNames(ob.name);
+
+                directory = Path.Combine(directory, newMat.name + ".mat");
+                AssetDatabase.CreateAsset(newMat, directory);
+
+            }
+        }
+
+        [MenuItem("Assets/Utilities/Sub-Assets/Destroy Sub Asset", true)]
+        private static bool DestroySubAssetCheck(MenuCommand menuCommand)
+        { if( Selection.objects.Length == 0 ) return false; return AssetDatabase.IsSubAsset(Selection.objects[0]); }
+
+        [MenuItem("Assets/Utilities/Sub-Assets/Destroy Sub Asset", false)]
+        private static void DestroySubAsset(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+            if (AssetDatabase.IsSubAsset(Selection.objects[0]) == false) return;
+            GameObject.DestroyImmediate(Selection.objects[0], true);
+        }
+
+        [MenuItem("Assets/Utilities/Sub-Assets/Unhide All Sub Assets", false)]
+        private static void UnhideSubAssets(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+            var allAtPath = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(Selection.objects[0]));
+
+            for (int i = 0; i < allAtPath.Length; i++)
+            {
+                if (allAtPath[i].hideFlags != HideFlags.HideInHierarchy) continue;
+                //if (AssetDatabase.IsSubAsset(allAtPath[i]) == false) continue;
+                allAtPath[i].hideFlags = HideFlags.None;
+                EditorUtility.SetDirty(allAtPath[i]);
+            }
+
+            EditorUtility.SetDirty(Selection.objects[0]);
+            AssetDatabase.SaveAssets();
+        }
+
+
+        [MenuItem("Assets/Utilities/Sub-Assets/Hide All Sub Assets", false)]
+        private static void HideSubAssets(MenuCommand menuCommand)
+        {
+            if (Selection.objects.Length == 0) return;
+            var allAtPath = AssetDatabase.LoadAllAssetsAtPath(AssetDatabase.GetAssetPath(Selection.objects[0]));
+
+            for (int i = 0; i < allAtPath.Length; i++)
+            {
+                if (AssetDatabase.IsSubAsset(allAtPath[i]) == false) continue;
+                allAtPath[i].hideFlags = HideFlags.HideInHierarchy;
+                EditorUtility.SetDirty(allAtPath[i]);
+            }
+
+            EditorUtility.SetDirty(Selection.objects[0]);
+            AssetDatabase.SaveAssets();
+        }
+
+
+        private static string ClearMaterialTypeNames(string name)
+        {
+            name = name.Replace("Albedo", "");
+            name = name.Replace("ALBEDO", "");
+            name = name.Replace("Texture", "Material");
+            name = name.Replace("TEXTURE", "MATERIAL");
+            name = name.Replace("Diffuse", "");
+            name = name.Replace("Normal", "");
+            name = name.Replace("TEX", "MAT");
+            name = name.Replace("Tex", "Mat");
+            name = name.Replace("tex", "mat");
+            return name;
+        }
+    }
+}
+#endif

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.Prefabs.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 0cec1e196f2e27048bdc5dd89e35a0eb
+timeCreated: 1531406488
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.cs

@@ -0,0 +1,116 @@
+#if UNITY_2019_4_OR_NEWER
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FEditor
+{
+    /// <summary>
+    /// FM: Class with basic tools for working in Unity Editor level
+    /// </summary>
+    public static partial class FEditor_MenuAddOptions
+    {
+
+#region Prefixes
+
+        private static string GetPrefix(UnityEngine.Object o, string path)
+        {
+            AssetImporter a = AssetImporter.GetAtPath(path);
+            if (a == null) return "";
+
+            if (HaveAnyPrefix(o.name)) return "";
+
+            string targetPrefix = "";
+            if (PrefabUtility.IsPartOfAnyPrefab(o))
+            {
+                PrefabAssetType type = PrefabUtility.GetPrefabAssetType(o);
+                if (type == PrefabAssetType.Regular) return "PR_";
+                else if (type == PrefabAssetType.Variant) return "PR_V_";
+            }
+
+            if (a is TextureImporter) targetPrefix = "TEX_";
+            else if (a is AudioImporter) targetPrefix = "AC_";
+            else if (a is ModelImporter)
+            {
+                PrefabAssetType type = PrefabUtility.GetPrefabAssetType(o);
+                if (type == PrefabAssetType.Regular || type == PrefabAssetType.Variant)
+                    targetPrefix = "PR_";
+                else
+                    targetPrefix = "";// "MDL_";
+            }
+            else if (a is ShaderImporter) targetPrefix = "SH_";
+            else if (o is Material) targetPrefix = "MAT_";
+
+            if (HavePrefix(o.name, targetPrefix)) return "";
+
+            return targetPrefix;
+        }
+
+        private static bool HaveAnyPrefix(string sourceName)
+        {
+            if (sourceName.Length > 3) if (sourceName[2] == '_') return true;
+            if (sourceName.Length > 4) if (sourceName[3] == '_') return true;
+            if (sourceName.Length > 5) if (sourceName[4] == '_') return true;
+            return false;
+        }
+
+        private static bool HavePrefix(string sourceName, string targetPrefix)
+        {
+            if (sourceName.StartsWith(targetPrefix)) return true;
+            return false;
+        }
+
+#endregion
+
+
+#region Helper Prefabs Methods
+
+        static bool IsAnyPrefabable(Object[] list)
+        {
+            if (list.Length == 0) return false;
+
+            for (int i = 0; i < list.Length; i++)
+            {
+                Object ob = Selection.objects[i];
+                var type = PrefabUtility.GetPrefabAssetType(ob);
+                if (type == PrefabAssetType.NotAPrefab || type == PrefabAssetType.MissingAsset) continue;
+                return true;
+            }
+
+            return false;
+        }
+
+        static GameObject GeneratePrePrefabObject(Object ob)
+        {
+            var type = PrefabUtility.GetPrefabAssetType(ob);
+            if (type == PrefabAssetType.NotAPrefab || type == PrefabAssetType.MissingAsset) return null;
+
+            string path = AssetDatabase.GetAssetPath(ob);
+
+            GameObject toSave = (GameObject)PrefabUtility.InstantiatePrefab(ob);
+
+            toSave.name = "PR_" + Path.GetFileNameWithoutExtension(path);
+
+            return toSave;
+        }
+
+        static bool IsAnyTexture(Object[] list)
+        {
+            if (list.Length == 0) return false;
+
+            for (int i = 0; i < list.Length; i++)
+            {
+                Object ob = Selection.objects[i];
+                if (AssetDatabase.Contains(ob) == false) continue;
+                if (ob is Texture2D ) return true;
+            }
+
+            return false;
+        }
+
+
+        #endregion
+
+    }
+}
+#endif

Assets/FImpossible Creations/Editor/Editor Tools/Files and Components Support/FEditor_ScriptMenuAddOptions.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: cf5da5e9bac57f54a9e8033aea6bd9ab
+timeCreated: 1531406488
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 42aa78c1768e06b41af10ebb837be2fb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/AD_FimpAnimating.Editor.asmdef

@@ -0,0 +1,20 @@
+{
+    "name": "AD_FimpAnimating.Editor",
+    "references": [
+        "GUID:f6cd8915a8323e640bef362b6f5dd974",
+        "GUID:0e6b1f35d8416da46a5e09a445db4184",
+        "GUID:4d3c0eb3c5c6f2243952516f8611fff4",
+        "GUID:103829f02546ce64db83be245c91a2cc"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/AD_FimpAnimating.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: dd431e1b1b225a74d975a33adf3a4f62
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Animation Designer.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e307b0b699d686248924b36025830b32
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Animation Designer/AD_Fimp_AnimationDesigner.asmdef

@@ -0,0 +1,20 @@
+{
+    "name": "AD_Fimp_AnimationDesigner",
+    "references": [
+        "GUID:0e6b1f35d8416da46a5e09a445db4184",
+        "GUID:4d3c0eb3c5c6f2243952516f8611fff4",
+        "GUID:103829f02546ce64db83be245c91a2cc",
+        "GUID:67234053b6be56d4680434077ca8fd90"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Animation Designer/AD_Fimp_AnimationDesigner.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 6a0e9fc795e5e51499cd700845a84eef
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 636d5f086052062419c6db3962775a5f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.LegHelpers.cs

@@ -0,0 +1,37 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+        void Leg_Select(int index)
+        {
+            _selected_leg = index;
+            RedrawScene();
+        }
+
+        void Leg_IKSetup_Select(int index)
+        {
+            _setupik_selected_leg = index;
+            RedrawScene();
+        }
+
+        public void Leg_AssignStartBone(LegsAnimator.Leg leg, Transform t)
+        {
+            if ( leg.BoneStart != t)
+            {
+                leg.BoneStart = t;
+                if (t != null) leg.DefineLegSide(Get);
+            }
+        }
+
+        SerializedProperty GetLegProperty(int index)
+        {
+            if (Get.Legs.ContainsIndex(index) == false) return null;
+            return sp_Legs.GetArrayElementAtIndex(index);
+        }
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.LegHelpers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eaeb5285361adc442bd7e0f4201efc83
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.Properties.cs

@@ -0,0 +1,127 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+
+    public partial class LegsAnimatorEditor : Editor
+    {
+        [HideInInspector] public Object ModulesDirectory;
+        [HideInInspector] public Object MotionPresetsDirectory;
+        [HideInInspector] public Object ImpulsesDirectory;
+        [HideInInspector] public Object DemosPackage;
+        [HideInInspector] public Object UserManualFile;
+        [HideInInspector] public Object AssemblyDefinitions;
+        [HideInInspector] public Object AssemblyDefinitionsAll;
+
+
+        public SerializedProperty sp_Debug_IsGrounded;
+        public SerializedProperty sp_BaseTransform;
+        public SerializedProperty sp_LegsAnimatorBlend;
+        public SerializedProperty sp_Hips;
+        public SerializedProperty sp_HipsChildSpineBone;
+        public SerializedProperty sp_DelayedInitialization;
+        public SerializedProperty sp_Legs;
+        public SerializedProperty sp_ImpulsesPowerMultiplier;
+        //public SerializedProperty sp_LegsMainSettings;
+        public SerializedProperty sp_AnimateFoot;
+        public SerializedProperty sp_ScRefMode;
+        public SerializedProperty sp_customScaleReferenceValue;
+        public SerializedProperty sp_GroundMask;
+        public SerializedProperty sp_IKHint;
+        public SerializedProperty sp_CastDistance;
+        public SerializedProperty sp_MaxStepDown;
+        public SerializedProperty sp_StabilityAlgorithm;
+        public SerializedProperty sp_UseHipsRotation;
+        public SerializedProperty sp_Event_OnStep;
+        public SerializedProperty sp_ExtraPelvisOffset;
+        public SerializedProperty sp_Mecanim;
+        public SerializedProperty sp_HipsSetup;
+        public SerializedProperty sp_BaseLegAnimating;
+        public SerializedProperty sp_SmoothSuddenSteps;
+        public SerializedProperty sp_HipsAdjustingBlend;
+        public SerializedProperty sp_GlueBlend;
+        public SerializedProperty sp_GlueMode;
+        public SerializedProperty sp_MotionInfluence;
+        public SerializedProperty sp_StepPointsOverlapRadius;
+
+        public SerializedProperty sp_DisableIfInvisible;
+        public SerializedProperty sp_DisableIfInvisibleArray;
+        public SerializedProperty sp_FadeOffAtDistance;
+        public SerializedProperty sp_SwingHelper;
+        public SerializedProperty sp_AnimationFloorLevel;
+        public SerializedProperty sp_ExtraHipsHubs;
+        public SerializedProperty sp__StepHeatPenaltyCurve;
+        public SerializedProperty sp_RagdolledParameter;
+
+        protected virtual void OnEnable()
+        {
+            Get.Legs_RefreshLegsOwner();
+            Get.DoBackCompatibilityChecks();
+
+            sp_Debug_IsGrounded = serializedObject.FindProperty("Debug_IsGrounded");
+            sp_BaseTransform = serializedObject.FindProperty("baseTransform");
+            sp_LegsAnimatorBlend = serializedObject.FindProperty("LegsAnimatorBlend");
+
+            sp_Hips = serializedObject.FindProperty("Hips");
+            sp_HipsChildSpineBone = serializedObject.FindProperty("HipsChildSpineBone");
+            sp_DelayedInitialization = serializedObject.FindProperty("DelayedInitialization");
+            sp_Legs = serializedObject.FindProperty("Legs");
+            sp_ImpulsesPowerMultiplier = serializedObject.FindProperty("ImpulsesPowerMultiplier");
+            sp_AnimateFoot = serializedObject.FindProperty("AnimateFeet");
+            //sp_LegsMainSettings = serializedObject.FindProperty("LegsMainSettings");
+            sp_ScRefMode = serializedObject.FindProperty("ScaleReferenceMode");
+            sp_customScaleReferenceValue = serializedObject.FindProperty("customScaleReferenceValue");
+            sp_GroundMask = serializedObject.FindProperty("GroundMask");
+            sp_IKHint = serializedObject.FindProperty("IKHintMode");
+            sp_CastDistance = serializedObject.FindProperty("CastDistance");
+            sp_MaxStepDown = serializedObject.FindProperty( "BodyStepDown" );
+            sp_StabilityAlgorithm = serializedObject.FindProperty("StabilityAlgorithm");
+            sp_UseHipsRotation = serializedObject.FindProperty("UseHipsRotation");
+            sp_Event_OnStep = serializedObject.FindProperty("Event_OnStep");
+            sp_ExtraPelvisOffset = serializedObject.FindProperty("ExtraPelvisOffset");
+            sp_Mecanim = serializedObject.FindProperty("Mecanim");
+            sp_HipsSetup = serializedObject.FindProperty("HipsSetup");
+            sp_BaseLegAnimating = serializedObject.FindProperty("BaseLegAnimating");
+            sp_SmoothSuddenSteps = serializedObject.FindProperty("SmoothSuddenSteps");
+            sp_HipsAdjustingBlend = serializedObject.FindProperty("UseHips");
+            //sp_HipsAdjustingBlend = serializedObject.FindProperty("HipsAdjustingBlend");
+            sp_GlueBlend = serializedObject.FindProperty("UseGluing");
+            //sp_GlueBlend = serializedObject.FindProperty("GlueBlend");
+            sp_GlueMode = serializedObject.FindProperty("GlueMode");
+            sp_MotionInfluence = serializedObject.FindProperty("MotionInfluence");
+            sp_StepPointsOverlapRadius = serializedObject.FindProperty("StepPointsOverlapRadius");
+
+            sp_DisableIfInvisible = serializedObject.FindProperty("DisableIfInvisible");
+            sp_DisableIfInvisibleArray = serializedObject.FindProperty("DisableIfInvisibleExtraRenderers");
+            sp_FadeOffAtDistance = serializedObject.FindProperty("FadeOffAtDistance");
+            sp_SwingHelper = serializedObject.FindProperty("SwingHelper");
+            sp_AnimationFloorLevel = serializedObject.FindProperty("AnimationFloorLevel");
+            sp_ExtraHipsHubs = serializedObject.FindProperty("ExtraHipsHubs");
+            sp__StepHeatPenaltyCurve = serializedObject.FindProperty("_StepHeatPenaltyCurve");
+            sp_RagdolledParameter = serializedObject.FindProperty("RagdolledParameter");
+
+            OnChange(false);
+        }
+
+        SerializedProperty GetLegSerializedProperty(int leg)
+        {
+            if (leg < 0) return null;
+            if (leg >= Get.Legs.Count) return null;
+            return sp_Legs.GetArrayElementAtIndex(leg);
+        }
+
+
+
+        protected virtual void OnChange(bool dirty = true)
+        {
+            if ( dirty) EditorUtility.SetDirty(Get);
+            _perf_lastMin = long.MaxValue;
+            _perf_lastMax = long.MinValue;
+            _perf_totalSteps = 0;
+        }
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.Properties.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: db6e9f8d594b1b4438a8d6f940d65c00
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 154245
+  packageName: Legs Animator
+  packageVersion: 1.0
+  assetPath: Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs
+    Animator/LAE.Properties.cs
+  uploadId: 603299

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.Resources.cs

@@ -0,0 +1,80 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor 
+    {
+        // -------------------------------------------------
+
+        public static Texture2D Tex_smLegStart { get { if (__texsmlegstrt != null) return __texsmlegstrt; __texsmlegstrt = Resources.Load<Texture2D>("Legs Animator/SPR_smStartLeg"); return __texsmlegstrt; } }
+        private static Texture2D __texsmlegstrt = null;
+
+        public static Texture2D Tex_smLegMid { get { if (__texsmlegmid != null) return __texsmlegmid; __texsmlegmid = Resources.Load<Texture2D>("Legs Animator/SPR_smMidLeg"); return __texsmlegmid; } }
+        private static Texture2D __texsmlegmid = null;
+
+        public static Texture2D Tex_smLegEnd { get { if (__texsmLegEnd != null) return __texsmLegEnd; __texsmLegEnd = Resources.Load<Texture2D>("Legs Animator/SPR_smEndLeg"); return __texsmLegEnd; } }
+        private static Texture2D __texsmLegEnd = null;
+
+        // -------------------------------------------------
+
+        public static Texture2D Tex_LegStart { get { if (__texlegstart != null) return __texlegstart; __texlegstart = Resources.Load<Texture2D>("Legs Animator/SPR_StartLeg"); return __texlegstart; } }
+        private static Texture2D __texlegstart = null;
+
+        public static Texture2D Tex_LegMid { get { if (__texlegmid != null) return __texlegmid; __texlegmid = Resources.Load<Texture2D>("Legs Animator/SPR_MidLeg"); return __texlegmid; } }
+        private static Texture2D __texlegmid = null;
+
+        public static Texture2D Tex_LegEnd { get { if (__texlegend != null) return __texlegend; __texlegend = Resources.Load<Texture2D>("Legs Animator/SPR_EndLeg"); return __texlegend; } }
+        private static Texture2D __texlegend = null;
+
+        // -------------------------------------------------
+
+        public static Texture2D Tex_OppositeSide { get { if (__texOpposite != null) return __texOpposite; __texOpposite = Resources.Load<Texture2D>("Legs Animator/SPR_Opposite"); return __texOpposite; } }
+        private static Texture2D __texOpposite = null;
+
+        public static Texture2D Tex_LeftSide { get { if (__texleftside != null) return __texleftside; __texleftside = Resources.Load<Texture2D>("Legs Animator/SPR_LLeg"); return __texleftside; } }
+        private static Texture2D __texleftside = null;
+
+        public static Texture2D Tex_RightSide { get { if (__texrightside != null) return __texrightside; __texrightside = Resources.Load<Texture2D>("Legs Animator/SPR_RLeg"); return __texrightside; } }
+        private static Texture2D __texrightside = null;
+
+        public static Texture2D Tex_LeftSideOff { get { if (__texleftsideoff != null) return __texleftsideoff; __texleftsideoff = Resources.Load<Texture2D>("Legs Animator/SPR_LLegOff"); return __texleftsideoff; } }
+        private static Texture2D __texleftsideoff = null;
+
+        public static Texture2D Tex_RightSideOff { get { if (__texrightsideoff != null) return __texrightsideoff; __texrightsideoff = Resources.Load<Texture2D>("Legs Animator/SPR_RLegOff"); return __texrightsideoff; } }
+        private static Texture2D __texrightsideoff = null;
+
+        // -------------------------------------------------
+
+        public static Texture2D Tex_FootRotate { get { if (__texfootrot != null) return __texfootrot; __texfootrot = Resources.Load<Texture2D>("Legs Animator/SPR_FootRotate"); return __texfootrot; } }
+        private static Texture2D __texfootrot = null;
+
+        public static Texture2D Tex_FootStep { get { if (__texfootStep != null) return __texfootStep; __texfootStep = Resources.Load<Texture2D>("Legs Animator/FootStep"); return __texfootStep; } }
+        private static Texture2D __texfootStep = null;
+        public static Texture2D Tex_LegStep { get { if (__texLegStp != null) return __texLegStp; __texLegStp = Resources.Load<Texture2D>("Legs Animator/Stepping"); return __texLegStp; } }
+        private static Texture2D __texLegStp = null;        
+        public static Texture2D Tex_LegMotion { get { if (__texLegMot != null) return __texLegMot; __texLegMot = Resources.Load<Texture2D>("Legs Animator/SPR_LegMot2"); return __texLegMot; } }
+        private static Texture2D __texLegMot = null;
+        public static Texture2D Tex_Hips { get { if (__texHps != null) return __texHps; __texHps = Resources.Load<Texture2D>("Legs Animator/StepDown"); return __texHps; } }
+        private static Texture2D __texHps = null;
+        public static Texture2D Tex_Stabilize { get { if (__texStabil != null) return __texStabil; __texStabil = Resources.Load<Texture2D>("Legs Animator/Stabilize"); return __texStabil; } }
+        private static Texture2D __texStabil = null;
+        public static Texture2D Tex_Glue { get { if (__texGlue != null) return __texGlue; __texGlue = Resources.Load<Texture2D>("Legs Animator/SPR_LegGl"); return __texGlue; } }
+        private static Texture2D __texGlue = null;
+        public static Texture2D Tex_FootGlue { get { if (__texfootglue != null) return __texfootglue; __texfootglue = Resources.Load<Texture2D>("Legs Animator/FootGlue"); return __texfootglue; } }
+        private static Texture2D __texfootglue = null;
+
+        public static Texture2D Tex_AutoMotion { get { if (__texAutoMot != null) return __texAutoMot; __texAutoMot = Resources.Load<Texture2D>("Legs Animator/AutoMotion"); return __texAutoMot; } }
+        private static Texture2D __texAutoMot = null;
+        public static Texture2D Tex_EventIcon { get { if (__texEvt != null) return __texEvt; __texEvt = (Texture2D)EditorGUIUtility.IconContent("EventSystem Icon").image; return __texEvt; } }
+        private static Texture2D __texEvt = null;
+        public static Texture2D Tex_IK { get { if (__texIK != null) return __texIK; __texIK = Resources.Load<Texture2D>("Legs Animator/SPR_IK"); return __texIK; } }
+        private static Texture2D __texIK = null;
+
+        public static Texture2D Tex_HipsMotion { get { if (__texHipsMot != null) return __texHipsMot; __texHipsMot = Resources.Load<Texture2D>("Legs Animator/DynamicHips"); return __texHipsMot; } }
+        private static Texture2D __texHipsMot = null;
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.Resources.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 296f09617eb1e9a41833116688d200a7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.SceneHelpers.cs

@@ -0,0 +1,866 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+        public bool IsSceneViewVisible { get { return SceneView.lastActiveSceneView != null; } }
+        public SceneView ScView { get { return SceneView.lastActiveSceneView; } }
+
+        public void SceneHelper_FocusOnInSceneView(Transform t, float scale = 1f)
+        {
+            if (t == null) return;
+            SceneView.lastActiveSceneView.Frame(new Bounds(t.position, Vector3.one * scale * 0.6f), false);
+        }
+
+        public Transform SceneHelper_FocusOnBone = null;
+
+        void SceneHelper_DrawBoneFocus()
+        {
+            if (SceneHelper_FocusOnBone == null) return;
+
+            Vector3 bonePos = SceneHelper_FocusOnBone.position;
+            Vector3 lookDir = ScView.camera.transform.position - bonePos;
+            Quaternion cameraLook = Quaternion.identity;
+            if (lookDir != Vector3.zero) cameraLook = Quaternion.LookRotation(lookDir);
+
+            float sideOff = Get.Util_SideMul(SceneHelper_FocusOnBone);
+
+            Handles.color = new Color(0.4f, 1f, 0.65f, 0.5f);
+
+            float avLength = 0f;
+            for (int c = 0; c < SceneHelper_FocusOnBone.childCount; c++)
+            {
+                Vector3 childPos = SceneHelper_FocusOnBone.GetChild(c).position;
+                FGUI_Handles.DrawBoneHandle(bonePos, childPos, 1f);
+                avLength += Vector3.Distance(childPos, bonePos);
+            }
+
+            if (SceneHelper_FocusOnBone.childCount > 0) avLength /= (float)SceneHelper_FocusOnBone.childCount;
+            else avLength = 0.65f;
+
+            //Handles.color = new Color(0.4f, 1f, 0.65f, 0.2f);
+            Handles.DrawWireDisc(bonePos, cameraLook * Vector3.forward, avLength * 0.3f);
+
+            // Draw children
+            Handles.color = new Color(0.4f, 1f, 0.65f, 0.125f);
+            for (int c = 0; c < SceneHelper_FocusOnBone.childCount; c++)
+            {
+                Transform child = SceneHelper_FocusOnBone.GetChild(c);
+
+                for (int i = 0; i < child.childCount; i++)
+                {
+                    Vector3 childPos = child.GetChild(i).position;
+                    FGUI_Handles.DrawBoneHandle(child.position, childPos, 0.2f);
+                }
+            }
+
+            Handles.color = new Color(0.7f, 0.7f, 0.7f, 0.25f);
+            float off = Mathf.Lerp(editorScaleRef, avLength, 0.4f);
+            lookDir.y = 0f; lookDir.Normalize();
+            cameraLook = ScView.camera.transform.rotation;
+            Vector3 helperPos = bonePos + cameraLook * Vector3.right * sideOff * off * 0.8f + Vector3.up * off * 0.2f;
+            Handles.DrawLine(bonePos, helperPos);
+
+            Handles.color = Color.white;
+            Handles.Label(helperPos + Vector3.up * off * 0.08f, SceneHelper_FocusOnBone.name, FGUI_Resources.HeaderStyle);
+
+        }
+
+        void SceneHelper_DrawHipsHubs()
+        {
+            if (Get.Hips == null) return;
+            if (Get.ExtraHipsHubs == null) return;
+            if (Get.ExtraHipsHubs.Count == 0) return;
+
+            for (int i = 0; i < Get.ExtraHipsHubs.Count; i++)
+            {
+                if (Get.ExtraHipsHubs[i] == null) continue;
+
+                Handles.SphereHandleCap(0, Get.ExtraHipsHubs[i].position, Quaternion.identity, editorScaleRef * 0.1f, EventType.Repaint);
+
+                if (!Get.LegsInitialized)
+                {
+                    Handles.DrawAAPolyLine(2, Get.Hips.position, Get.ExtraHipsHubs[i].position);
+                }
+                else
+                {
+                    if (Get.HipsHubs[i].HubBackBones?.Count > 0)
+                    {
+                        Handles.DrawAAPolyLine(2, Get.ExtraHipsHubs[i].position, Get.HipsHubs[i].HubBackBones[0].bone.position, Get.HipsHubs[i].HubBackBones[0].bone.position + Get.Up * editorScaleRef * 0.1f);
+
+                        for (int b = 1; b < Get.HipsHubs[i].HubBackBones.Count; b++)
+                        {
+                            Handles.DrawAAPolyLine(2, Get.HipsHubs[i].HubBackBones[b - 1].bone.position, Get.HipsHubs[i].HubBackBones[b].bone.position, Get.HipsHubs[i].HubBackBones[b].bone.position + Get.Up * editorScaleRef * 0.1f);
+                        }
+                    }
+                }
+
+            }
+        }
+
+
+        void SceneHelper_DrawLegStartBoneSelector(LegsAnimator.Leg leg, float drawScale, Transform legsHub)
+        {
+            if (legsHub == null) return;
+
+            for (int c = 0; c < legsHub.childCount; c++)
+            {
+                Transform cc = legsHub.GetChild(c);
+                bool should = Util_Leg_ShouldDraw(cc);
+
+                if (should)
+                    Handles.color = new Color(0.4f, 1f, 0.65f, 0.225f);
+                else
+                    Handles.color = new Color(0.4f, 0.4f, 0.4f, 0.225f);
+
+                Vector3 childPos = cc.position;
+                FGUI_Handles.DrawBoneHandle(legsHub.position, childPos, 1f);
+
+                if (!should) continue;
+
+
+                if (cc.childCount > 0)
+                {
+                    float hSize = HandleUtility.GetHandleSize(childPos);
+                    if (hSize > 0.01f)
+                    {
+                        float scaler = 1f / hSize;
+                        float mouseOnDistance = Vector2.Distance(Event.current.mousePosition, HandleUtility.WorldToGUIPoint(childPos));
+                        if (mouseOnDistance < 2.85f * scaler) FGUI_Handles.DrawBoneHandle(childPos, cc.GetChild(0).position, .7f);
+                        //if ( c == 0) UnityEngine.Debug.Log("scaler = " + hSize); //UnityEngine.Debug.Log("drawScale = " + editorScaleRef + "   :  mouse pos = " + Event.current.mousePosition + " : wpoint =" + HandleUtility.WorldToGUIPoint(childPos) + "mose distance = " + mouseOnDistance);
+                    }
+                }
+
+                if (Handles.Button(childPos, Quaternion.identity, drawScale, drawScale, Handles.CircleHandleCap))
+                {
+                    leg.BoneStart = cc;
+                }
+
+                Util_DrawBoneIndicator(cc, drawScale);
+            }
+        }
+
+
+        void SceneHelper_DrawLegSelectorHelper()
+        {
+            if (Get.LegsInitialized) return;
+            if (_selected_leg < 0) return;
+            if (Get.Hips == null) return;
+
+            //SceneHelper_FocusOnBone = null;
+            Get.User_RefreshHelperVariablesOnParametersChange();
+
+            if (Get.Legs.ContainsIndex(_selected_leg) == false)
+            {
+                _selected_leg = -1;
+                return;
+            }
+
+            Quaternion viewRot = ScView.camera.transform.rotation;
+            var leg = Get.Legs[_selected_leg];
+
+            float drawScaleRaw = editorScaleRef * 0.06f;
+            float drawScale = drawScaleRaw;
+
+            if (leg.BoneStart == null)
+            {
+
+                #region Start bone selector
+
+                Handles.BeginGUI();
+                GUI.Label(new Rect(0, 10, Screen.width, 40), "Select Start Leg Bone", FGUI_Resources.HeaderStyleBig);
+                Handles.EndGUI();
+
+                SceneHelper_DrawLegStartBoneSelector(leg, drawScaleRaw, Get.Hips);
+
+                for (int i = 0; i < Get.ExtraHipsHubs.Count; i++)
+                {
+                    SceneHelper_DrawLegStartBoneSelector(leg, drawScaleRaw, Get.ExtraHipsHubs[i]);
+                }
+
+                #endregion
+
+            }
+            else
+            {
+                Handles.BeginGUI();
+
+                float sideWidth = Mathf.Max(180, Screen.width * 0.33f);
+
+                GUI.Label(new Rect(0, 10, Screen.width, 40), leg.BoneStart.name.ToUpper() + " - Side: " + leg.Side.ToString(), FGUI_Resources.HeaderStyle);
+
+                if (leg.BoneStart && leg.BoneMid && leg.BoneEnd)
+                {
+                    GUI.color = Color.black;
+                    GUI.Box(new Rect(5, 8, sideWidth + 35, 124), GUIContent.none, FGUI_Resources.HeaderBoxStyleH);
+                    GUI.Box(new Rect(5, 8, sideWidth + 35, 124), GUIContent.none, FGUI_Resources.HeaderBoxStyleH);
+                    GUI.color = Color.white;
+
+                    //GUI.color = new Color(1f, 1f, 1f, 0.8f);
+                    GUI.color = Color.white * 1.4f;
+
+                    if (GUI.Button(new Rect(20, 22, 22, 19), new GUIContent(FGUI_Resources.TexTargetingIcon, "Ping start leg in the hierarchy to easily find other legs 'Top Bones'"), FGUI_Resources.ButtonStyle)) { PingObject(leg.BoneStart); }
+                    GUI.Label(new Rect(20, 12, sideWidth, 40), "Use " + leg.BoneStart.name + " setup for:", EditorStyles.centeredGreyMiniLabel);
+
+                    if (GUI.Button(new Rect(20, 46, sideWidth, 32), "Try Automatically Setup\nRest Of The Legs in Hips", FGUI_Resources.ButtonStyle))
+                    {
+                        Get.Setup_TryAutoLegsSetup(leg, Get.Hips);
+                        _selected_leg = -1;
+                    }
+
+                    GUI.Label(new Rect(20, 72, sideWidth, 40), "Apply Auto-Setup for Selective Leg Bone:", EditorStyles.centeredGreyMiniLabel);
+                    EditorGUIUtility.labelWidth = 96;
+                    Transform toSetup = (Transform)EditorGUI.ObjectField(new Rect(20, 104, sideWidth, 20), new GUIContent("Leg Top Bone", "Drag & Drop there leg start/thigh bone from hierarchy window to try automatically set it up with the same patter as the first bone was set up."), null, typeof(Transform), true);
+                    if (toSetup != null) { Get.Setup_TryAutoLegSetup(leg, toSetup); _selected_leg = Get.Legs.Count - 1; }
+
+                    EditorGUIUtility.labelWidth = 0;
+
+                    GUI.color = Color.white;
+                }
+
+
+                Handles.EndGUI();
+
+
+                Vector3 buttonOff = ScView.camera.transform.rotation * Vector3.right * Get.Util_SideMul(leg.BoneStart) * drawScale * 0.8f;
+                //Vector3.up * drawScale
+                if (Util_DrawButton(new GUIContent(Tex_smLegStart), buttonOff + leg.BoneStart.position + 2f * LabelIndicatorHelperOffset(leg.BoneStart, drawScale, false, true), 1f, false))
+                { PingObject(leg.BoneStart); }
+                Util_DrawBoneIndicator(leg.BoneStart, drawScale * 1.65f, true, "", false, true);
+
+                Handles.color = new Color(0.5f, 1f, 0.55f, 0.75f);
+                if (leg.BoneMid != null) FGUI_Handles.DrawBoneHandle(leg.BoneStart.position, leg.BoneMid.position, 1f);
+                else Util_DrawChildBoneOf(leg.BoneStart, 0.6f);
+
+                Transform legBone = leg.BoneStart;
+
+
+                // Drawing buttons for target bones to be selected
+                if (leg.BoneMid == null || leg.BoneEnd == null)
+                {
+                    int i = 1;
+                    while (legBone.childCount > 0)
+                    {
+                        legBone = Get.Finders_GetRelevantChildOf(legBone);
+
+                        bool already = false;
+                        for (int l = 0; l < Get.Legs.Count; l++)
+                        {
+                            var lg = Get.Legs[l];
+                            if (lg.BoneStart == legBone) { already = true; break; }
+                            if (lg.BoneMid == legBone) { already = true; break; }
+                            if (lg.BoneEnd == legBone) { already = true; break; }
+                        }
+
+                        if (already) continue;
+
+                        Util_DrawLegSegmentSelectorButton(leg, legBone, drawScale, i % 2 == 0, true);
+                        i += 1;
+                    }
+                }
+
+
+                // Drawing icons of already choosen leg bones
+                if (leg.BoneMid != null)
+                {
+                    Util_DrawBoneIndicator(leg.BoneMid, drawScale * 1.65f, true, "", true, true);
+
+                    Handles.color = new Color(0.35f, .925f, 0.65f, 0.65f);
+                    FGUI_Handles.DrawBoneHandle(leg.BoneMid.position, leg.BoneMid.position, 1f);
+                    if (Util_DrawButton(new GUIContent(Tex_smLegMid), buttonOff + leg.BoneMid.position + 1.7f * LabelIndicatorHelperOffset(leg.BoneMid, drawScale, true, true), 1f, false))
+                    { PingObject(leg.BoneMid); }
+
+                    if (leg.BoneEnd != null) FGUI_Handles.DrawBoneHandle(leg.BoneMid.position, leg.BoneEnd.position, 1f);
+                    else Util_DrawChildBoneOf(leg.BoneMid, 0.6f);
+                }
+
+                if (leg.BoneEnd != null)
+                {
+                    Util_DrawBoneIndicator(leg.BoneEnd, drawScale * 1.65f, true, "", false, true);
+
+                    Handles.color = new Color(0.1f, .8f, 0.9f, 0.65f);
+                    if (leg.BoneMid) FGUI_Handles.DrawBoneHandle(leg.BoneMid.position, leg.BoneEnd.position, 1f);
+                    if (Util_DrawButton(new GUIContent(Tex_smLegEnd), buttonOff + leg.BoneEnd.position + 2f * LabelIndicatorHelperOffset(leg.BoneEnd, drawScale, false, true), 1f, false))
+                    { PingObject(leg.BoneEnd); }
+
+                    Util_DrawChildBoneOf(leg.BoneEnd, 0.6f);
+                }
+
+                //Transform lastP = AnimationTools.SkeletonRecognize.GetBottomMostChildTransform(leg.BoneStart);
+
+            }
+
+
+
+            if (leg.OppositeLegIndex != -1)
+                if (Get.Legs.ContainsIndex(leg.OppositeLegIndex))
+                {
+                    var oppositeLeg = Get.Legs[leg.OppositeLegIndex];
+
+                    if (oppositeLeg != null)
+                    {
+                        Handles.color = new Color(0.7f, 0.7f, 0.2f, 0.25f);
+                        SceneHelper_Leg_DrawBones(oppositeLeg);
+
+                        Handles.color = new Color(1f, 1f, 1f, 0.4f);
+                        SceneHelper_DrawLegAsLines(oppositeLeg);
+                    }
+                }
+
+        }
+
+
+        void SceneHelper_DrawLegAsLines(LegsAnimator.Leg leg, float lineWidth = 4f)
+        {
+            if (leg.BoneStart == null) return;
+            if (leg.BoneMid == null) return;
+            Handles.DrawAAPolyLine(lineWidth, leg.BoneStart.position, leg.BoneMid.position);
+            if (leg.BoneEnd == null) return;
+            Handles.DrawAAPolyLine(lineWidth, leg.BoneMid.position, leg.BoneEnd.position);
+        }
+
+        void SceneHelper_DrawScaleReference()
+        {
+            float rScale = editorScaleRef;
+            Handles.color = new Color(0.3f, 0.9f, 0.35f, 0.55f);
+
+            Vector3 offsetSide = Get.transform.right * rScale * 0.8f;
+            Vector3 offsetForw = Get.transform.forward * rScale * 0.2f;
+            Vector3 sidePos = Get.transform.position + offsetSide;
+            Vector3 sidePosU = Get.transform.position + offsetSide + Get.Up * editorScaleRef;
+
+            Handles.DrawAAPolyLine(2f + rScale, sidePos + offsetForw, sidePos - offsetForw);
+            Handles.DrawAAPolyLine(2f + rScale, sidePosU + offsetForw, sidePosU - offsetForw);
+            Handles.DrawAAPolyLine(2f + rScale, sidePos, sidePosU);
+
+            if (Application.isPlaying == false)
+                Handles.Label(sidePos, new GUIContent(" [i]", "Scale reference height. It should be about half of the height of the chracter, if it's two-legs character.\nIf it's quadruped/spider, it should be around height of hips of the creature."));
+        }
+
+
+        void SceneHelper_DrawRaycastingCastRange()
+        {
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting) return;
+
+            float rScale = Get.ScaleReference;
+            Handles.color = new Color(0.3f, 0.9f, 0.35f, 0.65f);
+
+            Vector3 offsetSide = -Get.transform.right * rScale * 0.8f;
+            Vector3 offsetRight = Get.transform.right * rScale * 0.2f;
+            Vector3 sidePos = Get.Hips.position + offsetSide;
+            Vector3 grnd = Get.BaseTransform.position;
+
+            if (Get.RaycastStartHeight == LegsAnimator.ERaycastStartHeight.StaticScaleReference)
+            {
+                sidePos = Get.transform.position + offsetSide + Get.transform.up * Get.ScaleReference * Get.RaycastStartHeightMul;
+            }
+            else
+            {
+                grnd = Get.Hips.position;
+                grnd = Get.BaseTransform.InverseTransformPoint(grnd);
+                grnd.y = 0f;
+                grnd = Get.BaseTransform.TransformPoint(grnd);
+            }
+
+            Vector3 sidePosGrnd = grnd + offsetSide;
+            Vector3 sidePosArr = Vector3.LerpUnclamped(sidePos, sidePosGrnd, 0.8f);
+
+            if (Get.RaycastStyle != LegsAnimator.ERaycastStyle.AlongBones)
+            {
+                Handles.DrawDottedLine(sidePos, Get.Hips.position, 3f);
+                Handles.DrawWireDisc(sidePos, Get.Up, rScale * 0.2f);
+                Handles.DrawWireDisc(sidePosGrnd, Get.Up, rScale * 0.2f);
+            }
+
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.StraightDown)
+            {
+                Handles.DrawAAPolyLine(2f + rScale, sidePos, sidePosGrnd);
+                Handles.DrawAAPolyLine(2f + rScale, sidePosGrnd, sidePosArr + offsetRight);
+                Handles.DrawAAPolyLine(2f + rScale, sidePosGrnd, sidePosArr - offsetRight);
+            }
+
+            if (Get.RaycastStyle != LegsAnimator.ERaycastStyle.StraightDown && Get.RaycastStyle != LegsAnimator.ERaycastStyle.AlongBones)
+            {
+                Handles.DrawAAPolyLine(2f + rScale, Get.Hips.position, sidePosGrnd);
+                Vector3 dir = sidePosGrnd - Get.Hips.position;
+                Quaternion towards = Quaternion.LookRotation(dir, Get.Up);
+                Handles.DrawAAPolyLine(2f + rScale, sidePosGrnd, sidePosGrnd - dir * 0.1f + towards * Vector3.up * Get.ScaleReference * 0.125f);
+                Handles.DrawAAPolyLine(2f + rScale, sidePosGrnd, sidePosGrnd - dir * 0.1f + towards * Vector3.down * Get.ScaleReference * 0.125f);
+            }
+
+            Vector3 castEnd = sidePosGrnd;
+            castEnd += -Get.Up * rScale * Get.CastDistance;
+
+            if (Get.RaycastStyle != LegsAnimator.ERaycastStyle.OriginToFoot && Get.RaycastStyle != LegsAnimator.ERaycastStyle.AlongBones)
+            {
+                Handles.DrawDottedLine(sidePosGrnd, castEnd, 3f);
+                Handles.DrawWireDisc(castEnd, Get.Up, rScale * 0.2f);
+            }
+
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.AlongBones)
+            {
+                if (Get.Legs.Count > 0)
+                {
+                    for (int i = 0; i < Get.Legs.Count; i++)
+                    {
+                        if (Get.Legs[i].BoneStart && Get.Legs[i].BoneMid && Get.Legs[i].BoneEnd)
+                        {
+                            Handles.DrawAAPolyLine(Get.Legs[i].BoneStart.position, Get.Legs[i].BoneMid.position, Get.Legs[i].BoneEnd.position);
+                            Handles.DrawDottedLine(Get.Legs[i].BoneEnd.position, Get.Legs[i].BoneEnd.position - Get.Up * rScale * Get.CastDistance, 3f);
+                        }
+                    }
+                }
+            }
+
+            // Drawing spherecast guides
+
+            if (Get.RaycastShape == LegsAnimator.ERaycastMode.Spherecast)
+            {
+                Handles.color = new Color(0.3f, 1f, 0.3f, 0.11f);
+
+                float sphRadius = Get.ScaleReference * 0.065f * Get.SpherecastResize;
+
+                for (int l = 0; l < Get.Legs.Count; l++)
+                {
+                    var leg = Get.Legs[l];
+                    if (leg.BoneEnd == null || leg.BoneMid == null) continue;
+                    Vector3 legDir = (leg.BoneEnd.position - leg.BoneMid.position).normalized;
+                    Handles.SphereHandleCap(0, leg.BoneEnd.position - (legDir * sphRadius * 0.5f), Quaternion.identity, sphRadius, EventType.Repaint);
+                }
+            }
+
+        }
+
+
+        void SceneHelper_DrawGlueFloorLevel()
+        {
+            Handles.matrix = Get.BaseTransform.localToWorldMatrix;
+            float f = Get.ScaleReferenceNoScale;
+            float h = Get.GluingFloorLevelUseOnMoving ? Mathf.Lerp(Get.GluingFloorLevel, Get.GluingFloorLevelOnMoving, Get.IsMovingBlend) : Get.GluingFloorLevel;
+            Vector3 a = new Vector3(f, h, f);
+            Vector3 b = new Vector3(f, h, -f);
+            Vector3 c = new Vector3(-f, h, -f);
+            Vector3 d = new Vector3(-f, h, f);
+            Handles.DrawAAPolyLine(3f, a, b, c, d, a);
+            Handles.matrix = Matrix4x4.identity;
+        }
+
+
+        void SceneHelper_DrawRaycastingStepDown()
+        {
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting) return;
+
+            float rScale = Get.ScaleReference;
+            Handles.color = new Color(0.6f, 0.4f, 0.1f, 0.4f);
+
+            Vector3 hipsPos = Get.Hips.position;
+            if (Get.LegsInitialized)
+            {
+                hipsPos = Get.RootToWorldSpace(Get.HipsSetup.InitHipsPositionRootSpace);
+            }
+
+            Vector3 offsetSide = Get.transform.right * rScale * 0.8f;
+            Vector3 offsetRight = Get.transform.right * rScale * 0.2f;
+            Vector3 offsetForw = Get.transform.forward * rScale * 0.2f;
+            Vector3 sidePos = hipsPos + offsetSide;
+
+            Vector3 bodyEnd = sidePos;
+            bodyEnd += -Get.Up * rScale * Get.BodyStepDown;
+
+            float hipsToGround = Get.HipsToGroundDistance();
+            if (Get.LegsInitialized) hipsToGround = Get.HipsSetup.InitialHipsHeightLocal * Get.BaseTransform.lossyScale.y;
+
+            Vector3 bodyEndLeg = bodyEnd - Get.Up * hipsToGround;
+
+            if (Get.BodyStepDown > 0f)
+            {
+                Handles.DrawDottedLine(sidePos, hipsPos, 3f);
+                Handles.SphereHandleCap(0, sidePos, Quaternion.identity, rScale * 0.1f, EventType.Repaint);
+
+
+                Handles.DrawAAPolyLine(2f + rScale, sidePos, bodyEnd);
+                Handles.DrawWireDisc(bodyEnd, Get.Up, rScale * 0.2f);
+
+                Handles.DrawAAPolyLine(3f + rScale, bodyEnd + offsetRight, bodyEndLeg + offsetRight, bodyEndLeg + offsetRight + offsetForw);
+                Handles.DrawAAPolyLine(3f + rScale, bodyEnd - offsetRight, bodyEndLeg - offsetRight, bodyEndLeg - offsetRight + offsetForw);
+            }
+
+            if (Get.MaxBodyStepUp > 0f)
+            {
+                Vector3 bodyUpper = sidePos + offsetSide;
+                bodyUpper += Get.Up * rScale * Get.MaxBodyStepUp;
+                Handles.DrawDottedLine(bodyUpper, sidePos + offsetSide, 3f);
+                Handles.DrawDottedLine(sidePos + offsetSide, sidePos, 3f);
+
+                Handles.SphereHandleCap(0, bodyUpper, Quaternion.identity, rScale * 0.1f, EventType.Repaint);
+                bodyEndLeg = bodyUpper - Get.Up * hipsToGround;
+                Handles.DrawWireDisc(bodyUpper, Get.Up, rScale * 0.2f);
+
+                Handles.DrawAAPolyLine(3f + rScale, bodyUpper + offsetRight, bodyEndLeg + offsetRight, bodyEndLeg + offsetRight + offsetForw);
+                Handles.DrawAAPolyLine(3f + rScale, bodyUpper - offsetRight, bodyEndLeg - offsetRight, bodyEndLeg - offsetRight + offsetForw);
+            }
+
+        }
+
+        protected void SceneHelper_DrawExtraControll()
+        {
+            Handles.matrix = Get.BaseTransform.localToWorldMatrix;
+
+            //if (Get.FloorLevel != 0f)
+            {
+                float planeScale = Get.ScaleReference * 0.425f;
+                float yl = Get.GluingFloorLevel;
+
+                Handles.color = new Color(0.4f, 0.45f, 1f, 0.5f);
+
+                Handles.DrawAAPolyLine(2, new Vector3(-planeScale, yl, -planeScale),
+                    new Vector3(planeScale, yl, -planeScale),
+                    new Vector3(planeScale, yl, planeScale),
+                    new Vector3(-planeScale, yl, planeScale),
+                    new Vector3(-planeScale, yl, -planeScale));
+
+                planeScale *= 0.5f;
+                Handles.color *= 0.75f;
+                Handles.DrawWireDisc(Vector3.zero, Get.Up, planeScale);
+                Handles.DrawLine(new Vector3(0f, yl, planeScale), new Vector3(0f, yl, -planeScale));
+                Handles.DrawLine(new Vector3(planeScale, yl, 0f), new Vector3(-planeScale, yl, 0f));
+            }
+
+            Handles.matrix = Matrix4x4.identity;
+        }
+
+        void SceneHelper_DrawRaycastingPreview(Color baseColor)
+        {
+            if (Application.isPlaying == false) return;
+
+            float scaleRefSm = Get.ScaleReference * 0.1f;
+
+            Handles.color = baseColor;
+            for (int l = 0; l < Get.Legs.Count; l++)
+            {
+                var leg = Get.Legs[l];
+
+                if (!leg.RaycastHitted)
+                {
+                    Handles.DrawWireDisc(leg.BoneEnd.position, Get.Up, scaleRefSm);
+                    break;
+                }
+
+                RaycastHit hit = leg.LastGroundHit;
+
+                Handles.DrawWireDisc(hit.point, hit.normal, scaleRefSm);
+                Handles.DrawLine(hit.point, hit.point + hit.normal * scaleRefSm);
+                Handles.SphereHandleCap(0, hit.point + hit.normal * scaleRefSm, Quaternion.identity, scaleRefSm * 0.5f, EventType.Repaint);
+            }
+        }
+
+
+        void SceneHelper_DrawFeetLength()
+        {
+            //if (_setupik_selected_leg < 0)
+            //    Handles.color = Color.green * 0.9f;
+            //else
+            //    Handles.color = Color.green * 0.4f;
+
+            //for (int l = 0; l < Get.Legs.Count; l++)
+            //{
+            //    var leg = Get.Legs[l];
+            //    if (leg.BoneEnd == null) continue;
+
+            //    Vector3 heelStart = leg.BoneEnd.TransformPoint(leg.AnkleToHeel);
+            //    Vector3 footEnd = leg.BoneEnd.TransformPoint(leg.AnkleToFeetEnd);
+            //    Vector3 toEnd = footEnd - heelStart;
+            //    Vector3 right = leg.BoneEnd.TransformDirection(leg.AnkleRight).normalized * toEnd.magnitude * 0.4f;
+            //    Vector3 end = footEnd + toEnd * Get.FeetLengthAdjust;
+
+            //    Handles.DrawAAPolyLine(3f, heelStart + right, end + right, end - right, heelStart - right);
+            //}
+        }
+
+        void SceneHelper_DrawIKSetup(Color mainColor, int selected)
+        {
+            float scaleRef = Get.ScaleReference;
+            float scaleRefShort = Get.ScaleReference * 0.2f;
+            float scaleRefShort2 = scaleRefShort * 0.25f;
+
+            for (int i = 0; i < Get.Legs.Count; i++)
+            {
+                var leg = Get.Legs[i];
+                if (leg.HasAllBonesSet() == false) continue;
+
+                bool isSel = selected == i;
+                if (selected < -1) isSel = true;
+
+                Handles.color = mainColor * (isSel ? 1f : 0.5f);
+                Handles.DrawLine(leg.BoneStart.position, Get.Hips.position);
+                FGUI_Handles.DrawBoneHandle(leg.BoneStart.position, leg.BoneMid.position, 0.6f);
+                FGUI_Handles.DrawBoneHandle(leg.BoneMid.position, leg.BoneEnd.position, 0.6f);
+
+                Vector3 heel = leg.BoneEnd.TransformPoint(leg.AnkleToHeel);
+
+                if (Get.AnimateFeet)
+                {
+                    Handles.color = mainColor * (isSel ? 0.8f : 0.3f);
+
+                    //Vector3 heelForw = heel + leg.BoneEnd.TransformDirection(leg.AnkleForward * scaleRefShort);
+                    Vector3 footEnd = leg.BoneEnd.TransformPoint(leg.AnkleToFeetEnd);
+                    Vector3 heelForw = footEnd + (footEnd - heel) * Get.FeetLengthAdjust;
+
+                    Vector3 heelUp = heelForw + leg.BoneEnd.TransformDirection(leg.AnkleUp * scaleRefShort2);
+
+                    Handles.DrawAAPolyLine(2 + scaleRef, leg.BoneEnd.position, heel, heelForw, heelUp, leg.BoneEnd.position);
+                    Handles.DrawAAPolyLine(2 + scaleRef, heelForw, heel + leg.BoneEnd.TransformDirection(leg.AnkleRight * scaleRefShort2), heel - leg.BoneEnd.TransformDirection(leg.AnkleRight * scaleRefShort2), heelForw);
+
+                    scaleRefShort2 *= 2f;
+                    Vector3 feetEnd = Vector3.LerpUnclamped(heel, heelForw, leg.FootMiddlePosition);
+                    Handles.DrawAAPolyLine(2 + scaleRef, feetEnd - Get.BaseTransform.right * scaleRefShort2, feetEnd + Get.BaseTransform.right * scaleRefShort2);
+                    Handles.DrawAAPolyLine(2 + scaleRef, feetEnd, heel);
+                }
+                else
+                {
+                    Handles.DrawAAPolyLine(2 + scaleRef, leg.BoneEnd.position, heel);
+
+                    Handles.color *= 0.6f;
+                    Handles.DrawWireDisc(heel, Get.Up, scaleRefShort2);
+
+                    if (isSel && selected > -2)
+                    {
+                        Handles.color *= 0.7f;
+                        Handles.DrawWireDisc(leg.BoneEnd.position, Get.Up, scaleRefShort2);
+                    }
+                }
+
+            }
+        }
+
+
+        void SceneHelper_DrawDefinedBones(Color? customColor = null)
+        {
+            if (_selected_leg >= 0) return;
+            if (Get.Hips == null) return;
+
+            Handles.color = new Color(0.25f, 0.9f, 0.7f, 0.8f);
+            if (customColor != null) Handles.color = customColor.Value;
+
+            for (int i = 0; i < Get.Legs.Count; i++)
+            {
+                var leg = Get.Legs[i];
+                SceneHelper_Leg_DrawBones(leg);
+            }
+
+            if (SceneHelper_FocusOnBone == null)
+            {
+                Handles.SphereHandleCap(0, Get.Hips.position, Quaternion.identity, editorScaleRef * 0.07f, EventType.Repaint);
+            }
+        }
+
+
+        void SceneHelper_DrawDefinedBonesHipsLink(Color? customColor = null)
+        {
+            if (_selected_leg >= 0) return;
+            if (Get.Hips == null) return;
+
+            Handles.color = new Color(0.3f, 0.9f, 0.75f, 0.4f);
+            if (customColor != null) Handles.color = customColor.Value;
+
+            for (int i = 0; i < Get.Legs.Count; i++)
+            {
+                var leg = Get.Legs[i];
+                if (leg.BoneEnd == null) continue;
+                Handles.DrawDottedLine(leg.BoneEnd.position, Get.Hips.position, 3f);
+            }
+
+        }
+
+        void SceneHelper_Leg_DrawBones(LegsAnimator.Leg leg)
+        {
+            if (leg.BoneStart)
+            {
+                if (leg.BoneMid) FGUI_Handles.DrawBoneHandle(leg.BoneStart.position, leg.BoneMid.position);
+                else Util_DrawChildBoneOf(leg.BoneStart);
+
+                Handles.DrawDottedLine(leg.BoneStart.position, Get.Hips.position, 2f);
+            }
+
+            if (leg.BoneMid)
+            {
+                if (leg.BoneEnd) FGUI_Handles.DrawBoneHandle(leg.BoneMid.position, leg.BoneEnd.position);
+                else Util_DrawChildBoneOf(leg.BoneMid);
+            }
+
+            if (leg.BoneEnd)
+            {
+                Util_DrawChildBoneOf(leg.BoneEnd);
+            }
+        }
+
+
+        void Util_DrawLegSegmentSelectorButton(LegsAnimator.Leg leg, Transform t, float drawScale, bool mirror = false, bool upMode = false)
+        {
+            Handles.color = new Color(0.4f, 1f, 0.65f, 0.3f);
+            Util_DrawChildBoneOf(t.parent, 0.4f);
+
+            float mul = 1f;
+            if (leg.BoneMid == t || leg.BoneEnd == t) mul = -1f;
+
+            Util_DrawBoneIndicator(t, drawScale * mul * 0.7f, false, mul == -1f ? "Change" : "", mirror, upMode);
+
+            Vector3 off = LabelIndicatorHelperOffset(t, drawScale, mirror) * 0.6f;
+            float hSize = HandleUtility.GetHandleSize(t.position);
+            float scaler = 1f / hSize;
+
+            if (leg.BoneMid == null)
+            {
+                Handles.color = new Color(1f, 1f, 1f, 1f);
+                if (Util_DrawButton(new GUIContent(Tex_LegMid), t.position + off * 0.2f, 1f))
+                {
+                    leg.BoneMid = t;
+                    OnChange();
+                }
+
+            }
+
+            if (leg.BoneEnd == null && leg.BoneMid != null)
+            {
+                Handles.color = new Color(1f, 1f, 1f, 1f);
+                if (Util_DrawButton(new GUIContent(Tex_LegEnd), t.position + off * 0.2f, 1f, true, new Vector2(1, 0)))
+                {
+                    leg.BoneEnd = t;
+                    leg.DefineLegSide(Get);
+                    leg.RefreshLegAnkleToHeelAndFeetAndAxes(Get.BaseTransform);
+                    OnChange();
+                }
+            }
+
+
+            if (hSize > 0.01f)
+            {
+                float mouseOnDistance = 1000f;
+
+                int sel = 0;
+                if (leg.BoneMid == null)
+                {
+                    mouseOnDistance = Vector2.Distance(Event.current.mousePosition, HandleUtility.WorldToGUIPoint(t.position /*+ off*/));
+                    sel = 1;
+                }
+                else
+                if (leg.BoneEnd == null)
+                {
+                    float dist2 = Vector2.Distance(Event.current.mousePosition, HandleUtility.WorldToGUIPoint(t.position /*+ off + ScView.camera.transform.rotation * Vector3.right * drawScale * 1.25f*/));
+                    if (dist2 < mouseOnDistance) { mouseOnDistance = dist2; sel = 2; }
+                }
+
+                if (mouseOnDistance < 1f * scaler)
+                {
+                    Util_DrawChildBoneOf(t, .6f);
+
+                    if (t.childCount > 0)
+                        if (sel > 0)
+                        {
+                            string label = sel == 1 ? "? Is it Lower Leg ?" : "? IS it Foot Bone ?";
+                            Vector3 labelPos = Vector3.Lerp(t.position, t.GetChild(0).position, 0.35f);
+                            labelPos += ScView.camera.transform.rotation * Vector3.right * drawScale * 0.15f;
+                            Handles.Label(labelPos, label, EditorStyles.boldLabel);
+                        }
+                }
+            }
+
+        }
+
+
+        void Util_DrawBoneIndicator(Transform b, float drawScale, bool drawSphere = false, string customString = "", bool mirror = false, bool upMode = false)
+        {
+            if (b == null) return;
+
+            Handles.color = new Color(0.6f, 0.6f, 0.7f, 0.65f);
+
+            if (drawSphere)
+            {
+                Handles.SphereHandleCap(0, b.position, Quaternion.identity, drawScale * 0.5f, EventType.Repaint);
+            }
+
+            Vector3 labelPos = b.position + LabelIndicatorHelperOffset(b, drawScale, mirror, upMode);
+            labelPos += Vector3.up * drawScale * 0.4f;
+
+            Handles.DrawLine(b.position, labelPos);
+            Handles.color = Color.white;
+            Handles.Label(labelPos + Vector3.up * drawScale * 0.5f, string.IsNullOrEmpty(customString) ? b.name : customString);
+        }
+
+
+        Vector3 LabelIndicatorHelperOffset(Transform b, float drawScale, bool mirror = false, bool upMode = false)
+        {
+            if (upMode) return ScView.camera.transform.rotation * new Vector3(mirror ? 0.2f : -.2f, mirror ? 0.8f : -0.8f, 0.3f) * Get.Util_SideMul(b) * drawScale * 3f;
+
+            return ScView.camera.transform.rotation * new Vector3(mirror ? 0.9f : -.8f, 0.33f, 0f) * Get.Util_SideMul(b) * drawScale * 3f;
+        }
+
+        void Util_DrawChildBoneOf(Transform t, float fatness = 1f)
+        {
+            if (t.childCount <= 0) return;
+            FGUI_Handles.DrawBoneHandle(t.position, Get.Finders_GetRelevantChildOf(t).position, fatness);
+        }
+
+
+        bool Util_Leg_ShouldDraw(Transform t)
+        {
+            //if (t == SceneHelper_FocusOnBone) return false;
+
+            for (int i = 0; i < Get.Legs.Count; i++)
+            {
+                var leg = Get.Legs[i];
+                if (leg.BoneStart == t) return false;
+                if (leg.BoneMid == t) return false;
+                if (leg.BoneEnd == t) return false;
+            }
+
+            return true;
+        }
+
+        public static GUIStyle ButtonStyle { get { if (__buttStyleHard != null) return __buttStyleHard; __buttStyleHard = new GUIStyle(EditorStyles.miniButton); __buttStyleHard.fixedHeight = 0; __buttStyleHard.padding = new RectOffset(3, 3, 3, 3); __buttStyleHard.normal.background = Resources.Load<Texture2D>("Fimp/Backgrounds/FbuttonH"); __buttStyleHard.hover.background = Resources.Load<Texture2D>("Fimp/FbuttonHover"); __buttStyleHard.focused.background = __buttStyleHard.hover.background; __buttStyleHard.active.background = Resources.Load<Texture2D>("Fimp/Backgrounds/ButtonStyle"); return __buttStyleHard; } }
+        private static GUIStyle __buttStyleHard = null;
+
+        bool Util_DrawButton(GUIContent content, Vector3 pos, float size, bool buttonBG = true, Vector2? rectOffset = null)
+        {
+            float sc = HandleUtility.GetHandleSize(pos);
+            float hSize = Mathf.Sqrt(size) * 32 - sc * 16;
+
+            if (hSize > 0f)
+            {
+                Handles.BeginGUI();
+                Vector2 pos2D = HandleUtility.WorldToGUIPoint(pos);
+                float hhSize = hSize / 2f;
+
+                GUIStyle style = buttonBG ? ButtonStyle : EditorStyles.label;
+
+                if (rectOffset != null) pos2D += rectOffset.Value * hSize;
+
+                if (GUI.Button(new Rect(pos2D.x - hhSize, pos2D.y - hhSize, hSize, hSize), content, style))
+                {
+                    Handles.EndGUI();
+                    return true;
+                }
+
+                Handles.EndGUI();
+            }
+
+            return false;
+        }
+
+        Color Util_IndexColor(int index, float s = 0.3f, float v = 0.45f, float hueOff = 0f, float hueMul = 1f)
+        {
+            float h = ((float)index * 0.1f * hueMul + 0.2f + hueOff) % 1;
+            return Color.HSVToRGB(h, s, v);
+        }
+
+        void PingObject(UnityEngine.Object g)
+        {
+            EditorGUIUtility.PingObject(g);
+        }
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.SceneHelpers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d110962f38103524299e49ce5a01b68e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.SetupPose.cs

@@ -0,0 +1,97 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+        public AnimationClip HumanoidTPose;
+        float referencePoseTime = 0f;
+        AnimationClip referencePose = null;
+
+        public void DisplaySetupPoseGUI()
+        {
+            if (Get.LegsInitialized) GUI.enabled = false;
+
+            FGUI_Inspector.DrawUILineCommon(12);
+
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
+
+            EditorGUILayout.LabelField("Setup Pose (Optional)", FGUI_Resources.HeaderStyle);
+            GUILayout.Space(3);
+            EditorGUILayout.HelpBox("Store the setup pose to ensure that the initialization process performs correctly in various circumstances.", MessageType.None);
+            GUILayout.Space(3);
+
+            string title = " Store Setup Pose";
+            if (Get.SetupPose.IsSet(Get))
+            {
+                title = " Refresh Setup Pose";
+            }
+            else
+            {
+                GUI.backgroundColor = new Color(1f, 1f, 0.825f, 1f);
+            }
+
+            EditorGUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(new GUIContent(title, FGUI_Resources.Tex_Save), GUILayout.Height(19)))
+            {
+                Get.StoreSetupPose();
+                OnChange();
+            }
+
+            if (Get.SetupPose.IsSet(Get))
+            {
+                if (GUILayout.Button(new GUIContent(" Check Setup Pose", FGUI_Resources.Tex_Debug), GUILayout.Height(19))) { Get.RestoreSetupPose(); }
+
+                GUILayout.Space(2);
+                FGUI_Inspector.RedGUIBackground();
+                if (GUILayout.Button(new GUIContent(FGUI_Resources.Tex_Remove, "Clear the stored reference pose if you don't want to use it."), FGUI_Resources.ButtonStyle, FGUI_Inspector._button_w20h18)) { Get.SetupPose.Clear(); OnChange(); }
+                FGUI_Inspector.RestoreGUIBackground();
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+
+            GUILayout.Space(3);
+
+            if (Get.Mecanim && Get.Mecanim.isHuman && HumanoidTPose)
+            {
+                if (GUILayout.Button(new GUIContent(" Force Character To T-Pose", EditorGUIUtility.IconContent("AnimationClip Icon").image), GUILayout.Height(19)))
+                {
+                    referencePose = HumanoidTPose;
+                    HumanoidTPose.SampleAnimation(Get.Mecanim.gameObject, 0f);
+                    Get.StoreSetupPose();
+                    OnChange();
+                }
+            }
+
+            if (Get.Mecanim)
+            {
+                GUILayout.Space(3);
+                EditorGUILayout.BeginHorizontal();
+                EditorGUIUtility.labelWidth = 200;
+                referencePose = EditorGUILayout.ObjectField("Force Character Into Clip Pose:", referencePose, typeof(AnimationClip), false) as AnimationClip;
+                EditorGUIUtility.labelWidth = 0;
+                if (referencePose != null)
+                {
+                    float preTime = referencePoseTime;
+                    referencePoseTime = GUILayout.HorizontalSlider(referencePoseTime, 0f, 1f);
+                    if (preTime != referencePoseTime) { referencePose.SampleAnimation(Get.Mecanim.gameObject, referencePoseTime * referencePose.length); }
+                }
+                EditorGUILayout.EndHorizontal();
+
+                if (referencePose != null)
+                    EditorGUILayout.HelpBox("Use current scene pose to save it as setup pose.", MessageType.None);
+            }
+
+            GUI.backgroundColor = Color.white;
+            GUILayout.Space(3);
+            EditorGUILayout.EndVertical();
+
+            GUI.enabled = true;
+        }
+
+    }
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.SetupPose.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 4d3d1e0a9a3581c43bf1c9dc86c38650
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 154245
+  packageName: Legs Animator
+  packageVersion: 1.0
+  assetPath: Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs
+    Animator/LAE.Properties.cs
+  uploadId: 603299

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Detection.cs

@@ -0,0 +1,384 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+
+        protected void View_Setup_Physics()
+        {
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);
+
+            SerializedProperty sp_cast = sp_CastDistance.Copy();
+
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting) GUI.color = new Color(1f, 1f, 1f, 0.6f);
+            View_Setup_GroundLayerMask();
+
+            FGUI_Inspector.DrawUILineCommon(11);
+
+            EditorGUIUtility.labelWidth = 148;
+            EditorGUIUtility.fieldWidth = 25;
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUIUtility.labelWidth = 98;
+            EditorGUILayout.PropertyField(sp_cast); // Cast Distance
+
+            bool raycastDropDraw = Get.RaycastStyle != LegsAnimator.ERaycastStyle.OriginToFoot && Get.RaycastStyle != LegsAnimator.ERaycastStyle.NoRaycasting;
+
+            sp_cast.Next(false);
+            _cont.text = "Origin:"; _cont.tooltip = sp_cast.tooltip; _cont.image = null;
+            EditorGUIUtility.labelWidth = 48;
+            GUILayout.Space(6);
+            if (raycastDropDraw) EditorGUILayout.PropertyField(sp_cast, _cont, GUILayout.Width(100)); // Raycast Start Height
+
+            EditorGUILayout.EndHorizontal();
+
+            sp_cast.Next(false);
+            if (raycastDropDraw)
+                if (Get.RaycastStartHeight == LegsAnimator.ERaycastStartHeight.StaticScaleReference)
+                {
+                    GUILayout.Space(3);
+                    EditorGUI.indentLevel++;
+                    EditorGUIUtility.labelWidth = 172;
+                    EditorGUIUtility.fieldWidth = 38;
+                    EditorGUILayout.PropertyField(sp_cast); // Raycast Start Height mul
+                    EditorGUI.indentLevel--;
+                }
+
+            EditorGUIUtility.labelWidth = 140;
+            EditorGUIUtility.fieldWidth = 25;
+
+            GUILayout.Space(9);
+            sp_cast.Next(false);
+
+            GUI.color = Color.white;
+            EditorGUILayout.PropertyField(sp_cast); // Raycasting style
+            sp_cast.Next(false);
+            if (Get.RaycastStyle != LegsAnimator.ERaycastStyle.NoRaycasting) EditorGUILayout.PropertyField(sp_cast); // Raycasting shape
+            sp_cast.Next(false);
+            if (Get.RaycastShape == LegsAnimator.ERaycastMode.Spherecast)
+            {
+                EditorGUI.indentLevel++;
+                EditorGUILayout.PropertyField(sp_cast);
+                sp_cast.Next(false);
+                if (sp_cast.floatValue > 2.99999f) EditorGUILayout.PropertyField(sp_cast); else EditorGUILayout.Slider(sp_cast, 0f, 3f);
+                EditorGUI.indentLevel--;
+            }
+            else
+                sp_cast.Next(false);
+
+
+            if (Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting)
+            {
+                GUILayout.Space(4);
+                EditorGUILayout.HelpBox("No raycasting means that the algorithm will simulate floor on zero level of the character. Gluing and modules will work, but aligning/legs elevate/smooth step/hips height adjusting will not be used.", UnityEditor.MessageType.Info);
+            }
+            else
+            {
+                GUILayout.Space(4);
+
+                EditorGUI.BeginChangeCheck();
+
+                sp_cast.Next(false);
+                EditorGUIUtility.labelWidth = 180;
+                EditorGUILayout.PropertyField(sp_cast); // No hit behaviour
+                sp_cast.Next(false);
+
+                if (Get.NoRaycastGroundBehaviour == LegsAnimator.ENoRaycastBehviour.KeepAttached)
+                {
+                    EditorGUI.indentLevel++;
+                    sp_cast.Next(false);
+                    EditorGUILayout.PropertyField(sp_cast, new GUIContent("Keep Until Stretch:", sp_cast.tooltip)); // Keep Attached until
+                    EditorGUI.indentLevel--;
+                }
+            }
+
+            //GUILayout.Space(4);
+            //FGUI_Inspector.DrawUILineCommon(6);
+
+            //sp_cast.Next(false);
+            //_cont.text = "  " + sp_cast.displayName; _cont.tooltip = sp_cast.tooltip; _cont.image = Tex_Hips;
+            //EditorGUILayout.PropertyField(sp_cast, _cont, GUILayout.Height(16)); // Step Down
+            //_cont.image = null; _cont.tooltip = "";
+            //sp_cast.Next(false); EditorGUILayout.PropertyField(sp_cast); // Step Up
+
+            //FGUI_Inspector.DrawUILineCommon(6);
+            //GUILayout.Space(4);
+            //sp_cast.Next(false); sp_cast.Next(false);
+            //sp_cast.Next(false); EditorGUILayout.PropertyField(sp_cast); // Unground Speed
+
+            //GUILayout.Space(5);
+            //sp_cast.Next(false); EditorGUILayout.PropertyField(sp_cast); // Raycast Mode
+
+            //EditorGUIUtility.labelWidth = 108;
+            //View_Setup_BaseTransform();
+            //View_Setup_Hips();
+            EditorGUIUtility.labelWidth = 0;
+            EditorGUIUtility.fieldWidth = 0;
+            EditorGUILayout.EndVertical();
+            GUILayout.Space(-3);
+        }
+
+
+        protected void View_Setup_IKSetup()
+        {
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);
+
+            SerializedProperty sp_ik = sp_IKHint.Copy();
+
+            EditorGUILayout.PropertyField(sp_ik); // Hint mode
+            sp_ik.Next(false);
+            EditorGUILayout.PropertyField(sp_ik); // Max Stretch
+
+            GUILayout.Space(5);
+            sp_ik.Next(false); EditorGUILayout.PropertyField(sp_ik); // Foot Y Offset
+            //sp_ik.Next(false); if (!Get.AnimateFeet) GUI.color = Color.white * 0.75f; EditorGUILayout.PropertyField(sp_ik); // Foots Length
+            GUI.color = Color.white;
+
+            FGUI_Inspector.DrawUILineCommon(9);
+            View_Setup_IKLegstListHeader();
+
+            if (Get.Legs.ContainsIndex(_setupik_selected_leg) == false) _setupik_selected_leg = -1;
+            if (_setupik_selected_leg != -1)
+            {
+                var leg = Get.Legs[_setupik_selected_leg];
+                var legsp = GetLegProperty(_setupik_selected_leg);
+                SerializedProperty sp;
+
+                EditorGUI.indentLevel++;
+
+                GUILayout.Space(3);
+                EditorGUILayout.BeginHorizontal();
+                _setupik_indivFoldout = EditorGUILayout.Foldout(_setupik_indivFoldout, " Individual Parameters", true);
+
+                if (_setupik_indivFoldout)
+                {
+                    if (GUILayout.Button(FGUI_Resources.Tex_Random, FGUI_Resources.ButtonStyle, GUILayout.Height(18), GUILayout.Width(23)))
+                    {
+                        leg.RandomizeIndividualSettings(0.8f, 1f);
+                    }
+
+                    EditorGUILayout.EndHorizontal();
+
+                    EditorGUI.indentLevel++;
+
+                    sp = legsp.FindPropertyRelative("LegBlendWeight");
+                    EditorGUILayout.PropertyField(sp); // Leg Blend
+                    GUILayout.Space(3);
+
+                    EditorGUIUtility.labelWidth = 210;
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Duration
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Raise
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Glue Threshold
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Glue Point
+                    Vector2 v2v = sp.vector2Value;
+                    v2v.x = Mathf.Clamp(v2v.x, -0.5f, 0.5f);
+                    v2v.y = Mathf.Clamp(v2v.y, -0.5f, 0.5f);
+                    sp.vector2Value = v2v;
+
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Leg Stretch 
+                    sp.Next(false); EditorGUILayout.PropertyField(sp); // Preset
+                    EditorGUI.indentLevel--;
+                }
+                else
+                {
+                    EditorGUILayout.EndHorizontal();
+                }
+
+                FGUI_Inspector.DrawUILineCommon(12);
+                EditorGUILayout.LabelField("Internal Algorithm Parameters Correction:", EditorStyles.boldLabel);
+                GUILayout.Space(2);
+
+                if (Application.isPlaying == false)
+                    Get._EditorAllowAutoUpdateFeetParams = EditorGUILayout.Toggle(new GUIContent("Auto Update Params", "Allowing to automatically refresh parameters below, when changing legs bones in the inspector window (Editor Only Feature).\nDisable if you want to adjust feet axes fully manually."), Get._EditorAllowAutoUpdateFeetParams);
+
+                sp = legsp.FindPropertyRelative("InverseHint");
+                EditorGUILayout.PropertyField(sp);//
+                sp.Next(false);
+                //sp = legsp.FindPropertyRelative("AnkleToHeel");
+
+                EditorGUIUtility.fieldWidth = 24;
+
+                EditorGUILayout.BeginHorizontal(); EditorGUIUtility.labelWidth = 130;
+                EditorGUILayout.PropertyField(sp);
+                if (Button_Refresh()) { leg.RefreshLegAnkleToHeelAndFeet(Get.BaseTransform); }
+                EditorGUILayout.EndHorizontal();
+                sp.Next(false); if (Get.AnimateFeet) EditorGUILayout.PropertyField(sp);
+
+                if (Get.AnimateFeet)
+                {
+                    GUILayout.Space(5);
+
+                    EditorGUILayout.BeginHorizontal();
+                    _setupik_axisFoldout = EditorGUILayout.Foldout(_setupik_axisFoldout, " Foot Axis Setup", true);
+                    if (Button_Refresh()) { leg.RefreshLegAnkleToHeelAndFeetAndAxes(Get.BaseTransform); _setupik_axisFoldout = true; OnChange(); }
+                    EditorGUILayout.EndHorizontal();
+
+                    EditorGUIUtility.labelWidth = 140;
+
+                    if (_setupik_axisFoldout)
+                    {
+                        EditorGUI.indentLevel++;
+                        sp.Next(false); EditorGUILayout.PropertyField(sp);
+                        sp.Next(false); EditorGUILayout.PropertyField(sp);
+                        sp.Next(false); EditorGUILayout.PropertyField(sp);
+
+                        GUILayout.Space(4);
+                        sp.Next(false); EditorGUIUtility.labelWidth = 160; EditorGUILayout.PropertyField(sp);
+                        sp.Next(false);
+                        sp.Next(false);
+
+                        EditorGUI.BeginChangeCheck();
+                        EditorGUILayout.PropertyField(sp);
+                        if (EditorGUI.EndChangeCheck()) { sp.serializedObject.ApplyModifiedProperties(); leg.RefreshLegAnkleToHeelAndFeetAndAxes(Get.BaseTransform); _requestRepaint = true; sp.serializedObject.Update(); OnChange(); }
+
+                        EditorGUI.indentLevel--;
+                    }
+                    else { sp.Next(false); sp.Next(false); sp.Next(false); sp.Next(false); }
+                }
+
+                EditorGUI.indentLevel--;
+                GUILayout.Space(3);
+                EditorGUIUtility.fieldWidth = 0;
+                EditorGUIUtility.labelWidth = 0;
+            }
+
+            EditorGUILayout.EndVertical();
+
+            DisplaySetupPoseGUI();
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+
+        void View_Setup_OptimSetup()
+        {
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);
+
+            GUILayout.Space(-5);
+            EditorGUILayout.LabelField("Optimization Settings", FGUI_Resources.HeaderStyle);
+            FGUI_Inspector.DrawUILineCommon();
+
+            GUILayout.Space(4);
+
+            EditorGUILayout.PropertyField(sp_DisableIfInvisible);
+            if ( Get.DisableIfInvisible != null) EditorGUILayout.PropertyField(sp_DisableIfInvisibleArray);
+            
+            if (Application.isPlaying) if (Get.DisableIfInvisible) EditorGUILayout.HelpBox("The Renderer is " + (Get.DisableIfInvisible.isVisible ? "Visible" : "Invisible!"), UnityEditor.MessageType.None);
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PropertyField(sp_FadeOffAtDistance);
+            if (sp_FadeOffAtDistance.floatValue < 0f) sp_FadeOffAtDistance.floatValue = 0f;
+            if (sp_FadeOffAtDistance.floatValue == 0f) EditorGUILayout.HelpBox("Zero = not using", UnityEditor.MessageType.None);
+            EditorGUILayout.EndHorizontal();
+            if (Application.isPlaying) if (sp_FadeOffAtDistance.floatValue > 0f) EditorGUILayout.LabelField("Camera Distance = " + Get.FadeOff_lastCameraDistance + "   Fade = " + System.Math.Round(Get.GetCurrentCullingBlend(), 2), EditorStyles.centeredGreyMiniLabel);
+
+            FGUI_Inspector.DrawUILineCommon(16);
+
+            GUILayout.Space(4);
+            EditorGUILayout.HelpBox("LODS ARE NOT YET IMPLEMENTED", UnityEditor.MessageType.Info);
+            GUILayout.Space(4);
+
+            GUI.enabled = false;
+            int lHeight = 26;
+
+            GUILayout.Space(4);
+            EditorGUILayout.FloatField("LOD Max Distance", 100f);
+            GUILayout.Space(4);
+
+            EditorGUILayout.BeginHorizontal();
+            if (GUILayout.Button("LOD 0", FGUI_Resources.ButtonStyle, GUILayout.Height(lHeight))) { }
+            if (GUILayout.Button("LOD 1", FGUI_Resources.ButtonStyle, GUILayout.Height(lHeight))) { }
+            if (GUILayout.Button("LOD 2", FGUI_Resources.ButtonStyle, GUILayout.Height(lHeight))) { }
+            if (GUILayout.Button("Culled", FGUI_Resources.ButtonStyle, GUILayout.Height(lHeight))) { }
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space(4);
+            EditorGUILayout.LabelField("LOD 1 : Distances  =  25  to  50");
+
+            GUILayout.Space(4);
+            EditorGUILayout.IntSlider("Main Update Rate", 60, 0, 90);
+            EditorGUILayout.IntSlider("Raycating Rate", 30, 0, 90);
+
+            GUILayout.Space(4);
+            EditorGUILayout.Toggle("Disable Raycast", false);
+            EditorGUILayout.Toggle("Fade Off Modules", false);
+            EditorGUILayout.Toggle("Fade Off Gluing", false);
+
+            GUI.enabled = true;
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+
+        bool _setupik_axisFoldout = false;
+        bool _setupik_indivFoldout = false;
+        int _setupik_selected_leg = -1;
+        void View_Setup_IKLegstListHeader()
+        {
+            GUI.backgroundColor = new Color(0.7f, 0.7f, 0.7f, 1f);
+            EditorGUILayout.BeginVertical(FGUI_Resources.HeaderBoxStyle);
+            GUI.backgroundColor = Color.white;
+
+            EditorGUILayout.BeginVertical(FGUI_Resources.ViewBoxStyle);
+            GUILayout.Space(3);
+            EditorGUILayout.BeginHorizontal();
+
+            if (GUILayout.Button(" IK Leg Details:  " + Get.Legs.Count, EditorStyles.boldLabel)) { }
+
+            string selectTitle = "[" + (_setupik_selected_leg + 1).ToString() + "]";
+            if (_setupik_selected_leg == -1) selectTitle = "None Selected";
+            else
+            {
+                if (Get.Legs.ContainsIndex(_setupik_selected_leg))
+                {
+                    var leg = Get.Legs[_setupik_selected_leg];
+                    if (leg.BoneStart) selectTitle += " " + leg.BoneStart.name;
+                }
+            }
+
+            if (GUILayout.Button(selectTitle, EditorStyles.popup))
+            {
+                GenericMenu menu = new GenericMenu();
+
+                menu.AddItem(new GUIContent("Unselect"), _setupik_selected_leg == -1, () => { Leg_IKSetup_Select(-1); });
+
+                for (int l = 0; l < Get.Legs.Count; l++)
+                {
+                    string title = "Select [" + (l + 1) + "]";
+                    if (Get.Legs[l].BoneStart != null) title += " " + Get.Legs[l].BoneStart.name.ToUpper();
+
+                    int cInd = l;
+                    menu.AddItem(new GUIContent(title), _setupik_selected_leg == cInd, () => { Leg_IKSetup_Select(cInd); });
+                }
+
+                menu.ShowAsContext();
+            }
+
+            if (_setupik_selected_leg == -1)
+                if (Button_Refresh())
+                {
+                    RefreshAllLegsAnkleAxes();
+                }
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUILayout.EndVertical();
+        }
+
+        protected void RefreshAllLegsAnkleAxes()
+        {
+            for (int l = 0; l < Get.Legs.Count; l++)
+            {
+                var leg = Get.Legs[l];
+                leg.RefreshLegAnkleToHeelAndFeetAndAxes(Get.BaseTransform);
+            }
+
+            OnChange();
+        }
+
+    }
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Detection.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b74997fc7da7cab49bcac1f1d7623fcb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Extra.cs

@@ -0,0 +1,338 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+
+        protected void View_Extra_Main()
+        {
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);
+
+            EditorGUILayout.PropertyField(sp_ExtraPelvisOffset);
+
+            var sp = sp_ExtraPelvisOffset.Copy();
+
+            GUILayout.Space(4);
+            sp.Next(false); EditorGUILayout.PropertyField(sp); // Repose After
+            sp.Next(false); EditorGUILayout.PropertyField(sp); // Glue on idle
+
+            GUILayout.Space(4);
+            sp.Next(false); EditorGUILayout.PropertyField(sp); // Local World Up
+
+            //EditorGUIUtility.labelWidth = 180;
+            //EditorGUILayout.PropertyField(sp_StepPointsOverlapRadius);
+            //EditorGUIUtility.labelWidth = 0;
+
+            GUILayout.Space(7);
+
+            View_Extra_Main_SubMenu(sp);
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+        //int _extraMainSet = -1;
+        void View_Extra_Main_SubMenu(SerializedProperty sp_localup)
+        {
+
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxStyle);
+            GUILayout.Space(2);
+
+            //_cont.text = "   Hips Push Impulses";
+            //_cont.image = Tex_HipsMotion;
+            //EditorGUILayout.LabelField(_cont, FGUI_Resources.HeaderStyle);
+
+            EditorGUILayout.HelpBox("You can trigger hips push impulses with coding or using Legs Animator events.", UnityEditor.MessageType.None);
+
+            GUILayout.Space(4);
+
+            EditorGUIUtility.labelWidth = 170;
+            var sp = sp_ImpulsesPowerMultiplier.Copy();
+            EditorGUILayout.PropertyField(sp); // Impulses mul
+            sp.Next(false); EditorGUILayout.PropertyField(sp);
+            sp.Next(false); EditorGUILayout.PropertyField(sp); // Damp up
+
+            //GUILayout.Space(5);
+            //EditorGUILayout.LabelField("Helper Features", FGUI_Resources.HeaderStyle);
+            //sp.Next(false); EditorGUILayout.PropertyField(sp); // On grounded change impulse
+            //sp.Next(false); EditorGUILayout.PropertyField(sp); // On Stop impulse
+
+            GUILayout.Space(4);
+            GUI.enabled = Application.isPlaying;
+
+            if (GUILayout.Button("Test Pelvis Push Impulse"))
+            {
+                Get.DebugPushHipsImpulse.LocalTranslation = _testImpulse;
+                Get.DebugPushHipsImpulse.ImpulseDuration = _testImpulseDuration;
+                Get.DebugPushHipsImpulse.InheritElasticness = _testImpulseElastic;
+                Get.User_AddImpulse(Get.DebugPushHipsImpulse);
+            }
+
+            GUILayout.Space(2);
+            if (GUI.enabled)
+            {
+                _testImpulse = EditorGUILayout.Vector3Field("Impulse Power", _testImpulse);
+                _testImpulseDuration = EditorGUILayout.FloatField("Impulse Duration", _testImpulseDuration);
+                _testImpulseElastic = EditorGUILayout.Slider("Hips Elasticity Blend", _testImpulseElastic, 0f, 1f);
+            }
+
+            GUI.enabled = true;
+
+            EditorGUIUtility.labelWidth = 0;
+
+            GUILayout.Space(2);
+            EditorGUILayout.EndVertical();
+
+        }
+
+        Vector3 _testImpulse = new Vector3(0f, -.1f, 0f);
+        float _testImpulseDuration = 0.35f;
+        float _testImpulseElastic = 0.75f;
+
+        protected void View_Extra_Events()
+        {
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+            // Step Event Trigger
+            EditorGUILayout.PropertyField( sp_Event_OnStep );
+            GUILayout.Space( 4 );
+
+            EditorGUIUtility.labelWidth = 170;
+            var sp = sp_Event_OnStep.Copy();
+
+            GUILayout.Space( 6 );
+            EditorGUIUtility.labelWidth = 150;
+
+            sp.Next( false );
+            EditorGUILayout.PropertyField( sp ); // Step Delay
+
+            EditorGUILayout.BeginHorizontal();
+            sp.Next( false );
+
+            EditorGUILayout.PropertyField( sp ); // Step Send on land
+            EditorGUIUtility.labelWidth = 120;
+            GUILayout.FlexibleSpace();
+            sp.Next( false );
+
+            EditorGUILayout.PropertyField( sp ); // Step Prevent
+            EditorGUILayout.EndHorizontal();
+            EditorGUIUtility.labelWidth = 0;
+
+            sp.Next( false );
+            EditorGUILayout.PropertyField( sp ); // Step Events On Moving
+
+            bool receiverDetected = false;
+            if( Get.StepInfoReceiver )
+            {
+                if( Get.StepInfoReceiver.gameObject.GetComponent<LegsAnimator.ILegStepReceiver>() == null ) receiverDetected = false; else receiverDetected = true;
+            }
+
+            sp.Next( false );
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PropertyField( sp ); // Step Info Receiver
+
+            if( receiverDetected )
+            {
+                GUILayout.Space( 4 );
+                EditorGUILayout.LabelField( new GUIContent( FGUI_Resources.Tex_FCorrect, "ILegStepReceiver found" ), GUILayout.Width( 20 ), GUILayout.Height( 18 ) );
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            if( receiverDetected == false && Get.StepInfoReceiver != null )
+            {
+                EditorGUILayout.BeginHorizontal( EditorStyles.helpBox );
+                EditorGUILayout.LabelField( new GUIContent( FGUI_Resources.Tex_Warning ), GUILayout.Width( 20 ) );
+                GUILayout.Space( 6 );
+                EditorGUILayout.LabelField( "ILegStepReceiver not found in " + Get.StepInfoReceiver.name );
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.HelpBox( "Receiver needs to implement 'ILegStepReceiver' interface", UnityEditor.MessageType.None );
+                if( GUILayout.Button( new GUIContent( EditorGUIUtility.IconContent( "Clipboard" ).image, "Copy full interface name to the clipboard" ), FGUI_Resources.ButtonStyle, GUILayout.Width( 20 ) ) ) { GUIUtility.systemCopyBuffer = "FIMSpace.FProceduralAnimation.LegsAnimator.ILegStepReceiver"; }
+                EditorGUILayout.EndHorizontal();
+            }
+
+            EditorGUIUtility.labelWidth = 0;
+            EditorGUILayout.EndVertical();
+        }
+
+        GUIContent _guic_animatorParam = new GUIContent();
+
+        void GUI_PropertyWithAnimatorVariableSelector(SerializedProperty prop, UnityEngine.AnimatorControllerParameterType type, bool floatOrBoolParam = false)
+        {
+            GUILayout.BeginHorizontal();
+            EditorGUILayout.PropertyField(prop);
+
+            if (_guic_animatorParam.image == null) _guic_animatorParam = new GUIContent(" >", EditorGUIUtility.IconContent("AnimatorController Icon").image);
+            if (GUILayout.Button(_guic_animatorParam, EditorStyles.boldLabel, GUILayout.Width(28), GUILayout.Height(18)))
+            {
+                GenericMenu menu = new GenericMenu();
+                menu.AddItem(new GUIContent("None"), prop.stringValue == "", () => { prop.stringValue = ""; prop.serializedObject.ApplyModifiedProperties(); });
+                var sp = prop.Copy();
+
+                if (Get.Mecanim.runtimeAnimatorController != null)
+                {
+                    for (int i = 0; i < Get.Mecanim.parameterCount; i++)
+                    {
+                        var param = Get.Mecanim.parameters[i];
+
+                        if (param.type == type)
+                        {
+                            menu.AddItem(new GUIContent(param.name + " (" + param.type.ToString() + ")"), sp.stringValue == param.name, () => { sp.stringValue = param.name; sp.serializedObject.ApplyModifiedProperties(); });
+                            continue;
+                        }
+
+                        if (floatOrBoolParam)
+                            if (param.type == AnimatorControllerParameterType.Bool || param.type == AnimatorControllerParameterType.Float)
+                            {
+                                menu.AddItem(new GUIContent(param.name + " (" + param.type.ToString() + ")"), sp.stringValue == param.name, () => { sp.stringValue = param.name; sp.serializedObject.ApplyModifiedProperties(); });
+                            }
+                    }
+                }
+
+                menu.ShowAsContext();
+            }
+
+            GUILayout.EndHorizontal();
+        }
+
+        protected void View_Extra_Controll(bool drawExtras = true)
+        {
+            EditorGUILayout.BeginVertical(FGUI_Resources.BGInBoxBlankStyle);
+
+            if (drawExtras)
+            {
+                _cont.text = sp_Mecanim.displayName + " (Optional)"; _cont.tooltip = sp_Mecanim.tooltip; _cont.image = null;
+                EditorGUILayout.PropertyField(sp_Mecanim, _cont);
+            }
+
+            var sp = sp_Mecanim.Copy();
+            if (drawExtras)
+            {
+                sp.Next(false); if (Get.Mecanim) GUI_PropertyWithAnimatorVariableSelector(sp, AnimatorControllerParameterType.Bool); // EditorGUILayout.PropertyField(sp); // Grounded Param
+                sp.Next(false); if (Get.Mecanim) GUI_PropertyWithAnimatorVariableSelector(sp, AnimatorControllerParameterType.Float, true); // Movings Param
+
+                sp.Next(false);
+
+                if (string.IsNullOrWhiteSpace(Get.MovingParameter) == false)
+                    if (Get.Mecanim && Get.Mecanim.runtimeAnimatorController != null)
+                    {
+                        bool movIsFloat = false;
+                        int hash = Animator.StringToHash(Get.MovingParameter);
+
+                        for (int i = 0; i < Get.Mecanim.parameterCount; i++)
+                        {
+                            if (Get.Mecanim.GetParameter(i).nameHash == hash)
+                                if (Get.Mecanim.GetParameter(i).type == AnimatorControllerParameterType.Float) movIsFloat = true;
+                        }
+
+                        if (movIsFloat)
+                        {
+                            EditorGUILayout.LabelField("Movement Param is Float, assign Not-Moving Threshold", EditorStyles.centeredGreyMiniLabel);
+                            GUILayout.Space(-4);
+                            EditorGUILayout.PropertyField(sp, new GUIContent("Stop/Move Threshold:", sp.tooltip));
+                            GUILayout.Space(5);
+                        }
+                    }
+
+                GUILayout.Space(7);
+
+                sp.Next(false); _cont.text = sp.displayName + " (Optional)"; _cont.tooltip = sp.tooltip; _cont.image = null;
+                EditorGUILayout.PropertyField(sp, _cont); // Rigidbody
+                EditorGUIUtility.labelWidth = 240;
+                sp.Next(false); if (string.IsNullOrWhiteSpace(Get.MovingParameter)) EditorGUILayout.PropertyField(sp); // rigidbody ismoving
+                sp.Next(false); if (string.IsNullOrWhiteSpace(Get.GroundedParameter)) EditorGUILayout.PropertyField(sp); // grounding with raycasts
+                EditorGUIUtility.labelWidth = 0;
+                _cont.text = "Current Desired Move Direction: " + Get.DesiredMovementDirection; _cont.tooltip = "(world space move direction)\n(When rigidbody is assigned, rigidbody velocity is used here)\n Control value which helps animation based gluing detection";
+                EditorGUILayout.LabelField(_cont, EditorStyles.helpBox);
+                // Desired Direction
+                GUILayout.Space(7);
+            }
+            else
+            {
+                sp.Next(false); sp.Next(false); sp.Next(false); sp.Next(false);
+            }
+
+
+            bool asksSpine = false;
+            for (int m = 0; m < Get.CustomModules.Count; m++)
+            {
+                if (Get.CustomModules[m].ModuleReference == null) continue;
+                if (Get.CustomModules[m].ModuleReference.AskForSpineBone) { asksSpine = true; break; }
+            }
+
+
+            sp.Next(false); if (Get.Mecanim) GUI_PropertyWithAnimatorVariableSelector(sp, AnimatorControllerParameterType.Bool); // Sliding
+            if (Get.Mecanim) GUI_PropertyWithAnimatorVariableSelector(sp_RagdolledParameter, AnimatorControllerParameterType.Bool); // Ragdolled
+
+            sp.Next(false);
+            if (asksSpine) EditorGUILayout.PropertyField(sp);
+
+            bool asksChest = false;
+            for (int m = 0; m < Get.CustomModules.Count; m++)
+            {
+                if (Get.CustomModules[m].ModuleReference == null) continue;
+                if (Get.CustomModules[m].ModuleReference.AskForChestBone) { asksChest = true; break; }
+            }
+
+            sp.Next(false);
+            if (asksChest) EditorGUILayout.PropertyField(sp);
+
+            //sp.Next(false); EditorGUILayout.PropertyField(sp); // Swing Helper
+            //sp.Next(false); EditorGUILayout.PropertyField(sp); // Floor Level
+            ////sp.Next(false); EditorGUILayout.PropertyField(sp); // IK Point Overlap
+            //if (sp.floatValue < -0.2f) sp.floatValue = 0f;
+
+            sp.Next(false);
+
+            //if (Get.FootStepDetection == LegsAnimator.EFootStepDetection.AnimationCurves)
+            //{
+            //    EditorGUILayout.TextField("[0] Leg Height Param:", "LLegH");
+            //    EditorGUILayout.TextField("[1] Leg Height Param:", "RLegH");
+            //}
+
+            if (Application.isPlaying)
+            {
+                GUILayout.Space(5);
+                EditorGUILayout.LabelField("Controll Report:", FGUI_Resources.HeaderStyle);
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Is Grounded: " + Get.IsGrounded, FGUI_Resources.HeaderBoxStyle);
+                EditorGUILayout.LabelField("Grounded Time: " + Rnd(Get.GroundedTime), FGUI_Resources.HeaderBoxStyle);
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField("Is Moving: " + Get.IsMoving, FGUI_Resources.HeaderBoxStyle);
+                EditorGUILayout.LabelField("Moving Time: " + Rnd(Get.MovingTime), FGUI_Resources.HeaderBoxStyle);
+                EditorGUILayout.EndHorizontal();
+            }
+            else
+            {
+                GUILayout.Space(8);
+                EditorGUILayout.HelpBox("During playmode there will be displayed debug parameters.", UnityEditor.MessageType.None);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+        protected void View_Extra_HeatmapControls()
+        {
+            //_HeatmapDebugLeg = EditorGUILayout.IntField("Heatmap Debug Leg", _HeatmapDebugLeg);
+            //EditorGUILayout.PropertyField(sp__StepHeatPenaltyCurve);
+            //var sp = sp__StepHeatPenaltyCurve.Copy(); sp.Next(false);
+            //EditorGUILayout.PropertyField(sp);
+        }
+
+
+        float Rnd(float v)
+        {
+            return (float)System.Math.Round(v, 2);
+        }
+
+    }
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Extra.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0afa5ef81a4777542bfb74ecb268a7d9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Motion.cs

@@ -0,0 +1,909 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+        //int _motionMainSet = 0;
+        int _hipsMainSet = 0;
+        int _glueMainSet = 0;
+
+        Rect _legAnimRect;
+        float _sim_leg = 0f;
+        readonly Color motionBSelCol = new Color( 0.7f, 0.8f, 1.1f, 1f );
+
+        protected void View_Motion_Main()
+        {
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+            EditorGUIUtility.labelWidth = 146;
+
+            GUI.backgroundColor = new Color( 0.5f, 1f, 0.65f, 1f );
+            EditorGUILayout.PropertyField( sp_LegsAnimatorBlend, new GUIContent( "  " + sp_LegsAnimatorBlend.displayName, FGUI_Resources.Tex_MiniMotion, sp_LegsAnimatorBlend.tooltip ) );
+            GUI.backgroundColor = Color.white;
+
+            //EditorGUIUtility.labelWidth = 0;
+            FGUI_Inspector.DrawUILineCommon( 12 );
+
+            EditorGUILayout.PropertyField( sp_AnimateFoot, new GUIContent( "  Animate Feet:", Tex_FootRotate, sp_AnimateFoot.tooltip ), true );
+            SerializedProperty sp;
+
+            if( Get.AnimateFeet )
+            {
+                sp = sp_AnimateFoot.Copy();
+                sp.Next( false );
+                EditorGUILayout.PropertyField( sp );
+            }
+
+            View_Motion_Main_SubMenu();
+
+
+            GUILayout.Space( 7 );
+            EditorGUILayout.BeginHorizontal();
+            EditorGUIUtility.labelWidth = 180;
+            sp = sp_StepPointsOverlapRadius.Copy();
+            EditorGUILayout.PropertyField( sp );
+            if( sp.floatValue < -0.5f ) sp.floatValue = 0f;
+
+            sp.Next( false );
+            GUILayout.Space( 6 );
+            EditorGUIUtility.labelWidth = 70;
+            EditorGUILayout.PropertyField( sp, new GUIContent( "On Moving:", "You can blend step overlap radius to different size during running, which is recommended to set it lower during running animations." ), GUILayout.MaxWidth( 90 ) );
+            sp.Next( false );
+            if( Get.UseStepPointsOverlapRadiusOnMoving )
+                EditorGUILayout.PropertyField( sp, GUIContent.none, GUILayout.MaxWidth( 48 ) );
+            EditorGUIUtility.labelWidth = 0;
+            if( sp.floatValue < -0.5f ) sp.floatValue = 0f;
+
+            EditorGUILayout.EndHorizontal();
+            EditorGUIUtility.labelWidth = 0;
+
+        }
+
+        bool _align_drawAdv = false;
+        void View_Motion_Main_SubMenu()
+        {
+
+            EditorGUILayout.EndVertical();
+            GUILayout.Space( 5 );
+
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+
+            if( Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting )
+            {
+                EditorGUILayout.HelpBox( "Using No Raycasting mode : so feet adjustements will not be applied!", UnityEditor.MessageType.Info );
+                GUI.color = new Color( 1f, 1f, 1f, 0.7f );
+            }
+            else
+            {
+                GUILayout.Space( -2 );
+                EditorGUILayout.LabelField( "Leg-Foot Align Settings", EditorStyles.centeredGreyMiniLabel );
+                GUILayout.Space( -4 );
+            }
+
+            EditorGUIUtility.labelWidth = 146;
+
+            GUILayout.Space( 2 );
+            var sp = sp_SmoothSuddenSteps.Copy();
+            EditorGUILayout.PropertyField( sp ); // Aling blend in speed
+
+            EditorGUILayout.BeginHorizontal();
+            sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Leg Elevate
+            sp.Next( false ); /*if (Get.LegElevateBlend > 0f) EditorGUILayout.PropertyField(sp); */ // Leg Elevate Height Limit
+            if( _align_drawAdv ) GUI.backgroundColor = selCol;
+            if( GUILayout.Button( new GUIContent( FGUI_Resources.Tex_Expose, "Few more feet align settings (optional and more details related)" ), FGUI_Resources.ButtonStyle, GUILayout.Width( 22 ), GUILayout.Height( 19 ) ) ) _align_drawAdv = !_align_drawAdv;
+            GUI.backgroundColor = Color.white;
+            EditorGUILayout.EndHorizontal();
+
+            if( _align_drawAdv )
+            {
+                EditorGUILayout.PropertyField( sp_AnimationFloorLevel );
+            }
+
+            bool anyFoot = false;
+            for( int i = 0; i < Get.Legs.Count; i++ ) if( Get.AnimateFeet ) { anyFoot = true; break; }
+
+            GUI.enabled = anyFoot;
+
+            sp.Next( false );
+            GUILayout.Space( 4 );
+            _cont.text = "  Foot Align Blend"; _cont.tooltip = sp.tooltip; _cont.image = Tex_FootRotate;
+            EditorGUILayout.PropertyField( sp, _cont ); // Foot Rotation Blend
+
+            if( anyFoot )
+            {
+                //sp.Next(false); EditorGUILayout.PropertyField(sp); // Foot Angle Limit
+                //sp.Next(false); EditorGUILayout.PropertyField(sp); // Roll Blend
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Foot Rotation Rapidity
+            }
+            else
+            {
+                GUILayout.Space( 4 );
+                EditorGUILayout.HelpBox( "Foot Animating is disabled", UnityEditor.MessageType.None );
+            }
+
+            GUI.enabled = true;
+            EditorGUIUtility.labelWidth = 0;
+            GUILayout.Space( 2 );
+            EditorGUILayout.EndVertical();
+        }
+
+
+
+        protected void View_Motion_Hips()
+        {
+            EditorGUIUtility.labelWidth = 141;
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+            var sp = sp_HipsAdjustingBlend.Copy();
+
+            EditorGUILayout.PropertyField( sp );
+
+            if( Get.UseHips == false )
+            {
+                GUI.enabled = false;
+                _hipsMainSet = -1;
+            }
+
+            EditorGUILayout.EndVertical();
+            EditorGUIUtility.labelWidth = 0;
+
+            View_Motion_Hips_SubMenu( sp );
+        }
+
+
+        void View_Motion_Hips_SubMenu( SerializedProperty sp_hipsAdjBlend )
+        {
+            GUILayout.Space( 4 );
+
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+            GUILayout.Space( 2 );
+
+            EditorGUILayout.BeginHorizontal();
+
+            _cont.text = "  Body Adjust";
+            _cont.tooltip = "Whole body height-level adaptation with current legs placement on the ground.";
+            _cont.image = Tex_Hips;
+            if( _hipsMainSet == 0 ) GUI.backgroundColor = motionBSelCol;
+            if( GUILayout.Button( _cont, EditorStyles.miniButtonLeft, GUILayout.Height( 16 ) ) ) { if( _hipsMainSet == 0 ) _hipsMainSet = -1; else _hipsMainSet = 0; }
+
+            _cont.text = "  Stability";
+            _cont.tooltip = "Changing position of pelvis bone to be synced with legs apart.";
+            _cont.image = Tex_Stabilize;
+            if( _hipsMainSet == 1 ) GUI.backgroundColor = motionBSelCol; else GUI.backgroundColor = Color.white;
+            if( GUILayout.Button( _cont, EditorStyles.miniButtonMid, GUILayout.Height( 16 ) ) ) { if( _hipsMainSet == 1 ) _hipsMainSet = -1; else _hipsMainSet = 1; }
+            GUI.backgroundColor = Color.white;
+
+            _cont.text = "  Elasticity";
+            _cont.tooltip = "Extra animating process for the hips motion, making it more realistic - less artificial and less stiff.\nUsed in many parts of the legs animator system.";
+            _cont.image = Tex_HipsMotion;
+            if( _hipsMainSet == 2 ) GUI.backgroundColor = motionBSelCol; else GUI.backgroundColor = Color.white;
+            if( GUILayout.Button( _cont, EditorStyles.miniButtonRight, GUILayout.Height( 16 ) ) ) { if( _hipsMainSet == 2 ) _hipsMainSet = -1; else _hipsMainSet = 2; }
+            GUI.backgroundColor = Color.white;
+            _cont.tooltip = "";
+
+
+            _cont.image = null;
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space( 2 );
+
+            if( _hipsMainSet == 0 )
+            {
+                GUILayout.Space( 5 );
+                EditorGUIUtility.labelWidth = 144;
+
+                if( Get.RaycastStyle == LegsAnimator.ERaycastStyle.NoRaycasting )
+                {
+                    EditorGUILayout.HelpBox( "Using No Raycasting mode : so body adjustements will not be applied!", UnityEditor.MessageType.Info );
+                    GUI.color = new Color( 1f, 1f, 1f, 0.7f );
+                }
+
+                var sp = sp_hipsAdjBlend.Copy();
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Anim speed
+                EditorGUILayout.BeginHorizontal();
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Anim speed
+                sp.Next( false ); EditorGUILayout.PropertyField( sp, GUIContent.none, GUILayout.Width( 50 ) ); // adjust Style
+                EditorGUILayout.EndHorizontal();
+                GUILayout.Space( 4 );
+
+                FGUI_Inspector.DrawUILineCommon( 8 );
+
+                // Step Params from Setup
+                sp = sp_MaxStepDown.Copy();
+                EditorGUILayout.PropertyField( sp ); // Max Step Down
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Max Step Up
+
+                FGUI_Inspector.DrawUILineCommon( 8 );
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Unground Speed
+
+                if( Application.isPlaying )
+                {
+                    EditorGUILayout.LabelField( "Grounded Blend = " + Get.IsGroundedBlend, EditorStyles.helpBox );
+                }
+
+                GUILayout.Space( 4 );
+            }
+            else if( _hipsMainSet == 1 )
+            {
+                EditorGUIUtility.labelWidth = 150;
+
+                GUILayout.Space( 5 );
+
+                EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+
+                if( Get.UseGluing == false )
+                {
+                    EditorGUILayout.HelpBox( "Stability is Chained with GLUING. Enable Gluing to see stability effect.", UnityEditor.MessageType.Info );
+                }
+
+                GUILayout.Space( 2 );
+                EditorGUILayout.PropertyField( sp_StabilityAlgorithm, true );
+                GUILayout.Space( 5 );
+
+
+                var sp = sp_hipsAdjBlend.Copy();
+                sp.Next( false );
+                sp.Next( false );
+                sp.Next( false );
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Stabilize Center of mass
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Keyfr Anim is stable
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Speed
+
+                EditorGUILayout.EndVertical();
+
+
+                sp.Next( false );
+                GUILayout.Space( 5 );
+
+
+                EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUIUtility.fieldWidth = 30;
+                EditorGUILayout.PropertyField( sp ); // Push Hips on legs
+                EditorGUIUtility.fieldWidth = 0;
+
+                EditorGUIUtility.labelWidth = 24; sp.Next( false );
+                _cont.text = " N:"; _cont.tooltip = "Normalize Pushes: " + sp.tooltip;
+                //if (Get.Legs.Count > 2)
+                EditorGUILayout.PropertyField( sp, _cont, GUILayout.Width( 44 ) );
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUIUtility.labelWidth = 0;
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Y Blend
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Push Reaction Rapidity
+
+                EditorGUILayout.EndVertical();
+
+
+                GUILayout.Space( 5 );
+                EditorGUILayout.BeginHorizontal();
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Hips Stretch
+
+                GUILayout.Space( 5 );
+                EditorGUIUtility.labelWidth = 44;
+                sp.Next( false ); EditorGUILayout.PropertyField( sp, new GUIContent( "Speed:", "Smooth reaction speed of the hips stretch preventer" ), GUILayout.Width( 72 ) ); // Hips Stretch
+                sp.floatValue = Mathf.Clamp01( sp.floatValue );
+                EditorGUIUtility.labelWidth = 0;
+
+                EditorGUILayout.EndHorizontal();
+
+                //GUILayout.Space(4);
+
+                //EditorGUILayout.BeginHorizontal();
+                //if (GUILayout.Button(FGUI_Resources.GetFoldSimbolTex(_extraHipsSettingsFoldout, true), EditorStyles.label, GUILayout.Height(17), GUILayout.Width(22)))
+                //    _extraHipsSettingsFoldout = !_extraHipsSettingsFoldout;
+                //if (GUILayout.Button("Extra Hips Settings", EditorStyles.boldLabel))
+                //    _extraHipsSettingsFoldout = !_extraHipsSettingsFoldout;
+                //EditorGUILayout.EndHorizontal();
+
+                //if (_extraHipsSettingsFoldout)
+                //{
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Stabilize on move
+
+                // Hips Rotation // UseHipsRotation
+                //    GUILayout.Space(5);
+                //    sp = sp_UseHipsRotation.Copy();
+                //    EditorGUILayout.PropertyField(sp); // Hips Rotation
+                //    sp.Next(false); EditorGUILayout.PropertyField(sp); // Spine Child
+                //    sp.Next(false); if (Get.HipsChildSpineBone != null) EditorGUILayout.PropertyField(sp); // Child compensate
+                //}
+
+                if( Get.CustomModules.Count == 0 )
+                {
+                    GUILayout.Space( 4 );
+                    EditorGUILayout.HelpBox( "Consider using 'Extra/Rotation Stability' module to improve stability animation!", UnityEditor.MessageType.Info );
+                }
+
+            }
+            else if( _hipsMainSet == 2 )
+            {
+                GUILayout.Space( 2 );
+
+                var sp = sp_HipsSetup.Copy();
+                sp.Next( true );
+                EditorGUIUtility.labelWidth = 134;
+
+                EditorGUILayout.PropertyField( sp );
+                //sp.Next(true); EditorGUILayout.PropertyField(sp);
+                MotionInfluenceProcessor._EditorDrawGUI( sp_MotionInfluence );
+
+                if( Get.HipsSetup.HipsElasticityBlend > 0f )
+                {
+                    GUILayout.Space( 3 );
+                    FGUI_Inspector.DrawUILineCommon();
+
+                    sp = sp_HipsSetup.Copy();
+                    sp.Next( true ); sp.NextVisible( false ); sp.Next( true ); sp.NextVisible( false );
+                    EditorGUILayout.PropertyField( sp );
+                    sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+                    sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+                    sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+                }
+            }
+
+            EditorGUIUtility.labelWidth = 0;
+            GUILayout.Space( 2 );
+            EditorGUILayout.EndVertical();
+
+        }
+
+        //bool _extraHipsSettingsFoldout = false;
+
+        protected void View_Motion_Glue()
+        {
+            EditorGUIUtility.labelWidth = 92;
+            EditorGUIUtility.fieldWidth = 28;
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+            var sp = sp_GlueBlend.Copy();
+
+            EditorGUILayout.BeginHorizontal();
+            EditorGUILayout.PropertyField( sp, GUILayout.Width( 142 ) ); // Glue Enable
+
+            if( Get.UseGluing == false )
+            {
+                GUI.enabled = false;
+                _glueMainSet = -1;
+            }
+
+            sp.Next( false );
+            EditorGUIUtility.labelWidth = 50;
+            if( Get.UseGluing ) EditorGUILayout.PropertyField( sp, new GUIContent( "Blend:", sp.tooltip ) ); // Glue Blend
+            else EditorGUILayout.Slider( "Blend:", 0f, 0f, 1f );
+            EditorGUILayout.EndHorizontal();
+
+            if( Get.IsSlidingBlend > 0f )
+            {
+                EditorGUILayout.LabelField( "Is Sliding gluing fade = " + ( 1f - Get.IsSlidingBlend ), EditorStyles.centeredGreyMiniLabel );
+            }
+
+            EditorGUIUtility.labelWidth = 137;
+
+            bool areOpposites = false;
+            for( int l = 0; l < Get.Legs.Count; l++ ) if( Get.Legs[l].OppositeLegIndex != -1 ) { areOpposites = true; break; }
+            if( !areOpposites )
+            {
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.HelpBox( "No Opposite Legs! It will result in raising all legs in the same time instead of moving them step by step", UnityEditor.MessageType.Warning );
+                if( GUILayout.Button( "Go to setup" ) )
+                { Get._EditorCategory = LegsAnimator.EEditorCategory.Setup; Get._EditorSetupCategory = LegsAnimator.EEditorSetupCategory.Main; }
+                EditorGUILayout.EndHorizontal();
+            }
+
+            EditorGUIUtility.fieldWidth = 28;
+            sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Glue Range Treshold
+            sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Glue Blend In Speed
+
+            EditorGUILayout.EndVertical();
+            EditorGUIUtility.fieldWidth = 0;
+            EditorGUIUtility.labelWidth = 0;
+
+            View_Motion_Glue_SubMenu( sp );
+
+            if( Get.UseGluing == false ) GUI.enabled = true;
+        }
+
+
+        bool _showSpherize = false;
+
+        void View_Motion_Glue_SubMenu( SerializedProperty sp_blendinspd )
+        {
+            GUILayout.Space( 3 );
+
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+            GUILayout.Space( 5 );
+
+            EditorGUILayout.BeginHorizontal();
+
+            _cont.text = "  Main Glue";
+            _cont.tooltip = "";
+            _cont.image = Tex_FootGlue;
+            if( _glueMainSet == 0 ) GUI.backgroundColor = motionBSelCol;
+            if( GUILayout.Button( _cont, EditorStyles.miniButtonLeft, GUILayout.Height( 16 ) ) ) { if( _glueMainSet == 0 ) _glueMainSet = -1; else _glueMainSet = 0; }
+
+            _cont.text = "  Idle Glue Motion";
+            _cont.image = Tex_LegMotion;
+            _cont.tooltip = "Settings for the automatic leg animation, when character is during Idle mode.";
+            if( _glueMainSet == 1 ) GUI.backgroundColor = motionBSelCol; else GUI.backgroundColor = Color.white;
+            if( GUILayout.Button( _cont, EditorStyles.miniButtonRight, GUILayout.Height( 16 ) ) ) { if( _glueMainSet == 1 ) _glueMainSet = -1; else _glueMainSet = 1; }
+            GUI.backgroundColor = Color.white;
+
+            _cont.image = null;
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space( 2 );
+
+            if( _glueMainSet == 0 )
+            {
+                EditorGUIUtility.labelWidth = 134;
+                GUILayout.Space( 4 );
+                var sp = sp_blendinspd.Copy();
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Glue Below Foot
+                sp.Next( false ); EditorGUILayout.PropertyField( sp ); // Glue Fade out speed
+                sp.Next( false ); /*if (Get.AnimateFeet) */EditorGUILayout.PropertyField( sp ); // Unglue On
+
+                GUILayout.Space( 4 );
+                sp.Next( false );
+
+                // Allow Drag
+                sp.floatValue = EditorGUILayout.Slider( new GUIContent( sp.displayName, sp.tooltip ), sp.floatValue, 0f, sp.floatValue > 1f ? 2f : 1.00001f );
+
+                //sp.Next(false); EditorGUILayout.PropertyField(sp); // Speedup on rot
+
+                GUILayout.Space( 6 );
+                EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+                GUILayout.Space( -4 );
+                EditorGUILayout.LabelField( "Extra, Optional Prameters", EditorStyles.centeredGreyMiniLabel );
+                GUILayout.Space( -5 );
+                sp = sp_SwingHelper.Copy();
+                // Swing Helper
+                EditorGUILayout.PropertyField( sp ); sp.Next( false );
+                if( Get.LegsInitialized ) EditorGUILayout.HelpBox( "Swing[0] = " + Get.Legs[0]._G_RefernceSwing, UnityEditor.MessageType.None );
+                // Glue Floor Level
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUILayout.PropertyField( sp );
+                if( sp.floatValue < -0.5f ) sp.floatValue = 0f;
+
+                sp.Next( false );
+                GUILayout.Space( 6 );
+                EditorGUIUtility.labelWidth = 70;
+                EditorGUILayout.PropertyField( sp, new GUIContent( "On Moving:", "You can blend floor height to be lower/higher when moving, to ease feet's floor level detection." ), GUILayout.MaxWidth( 90 ) );
+                sp.Next( false );
+                if( Get.GluingFloorLevelUseOnMoving )
+                    EditorGUILayout.PropertyField( sp, GUIContent.none, GUILayout.MaxWidth( 48 ) );
+                EditorGUIUtility.labelWidth = 0;
+                if( sp.floatValue < -0.5f ) sp.floatValue = 0f;
+
+                EditorGUILayout.EndHorizontal();
+
+                EditorGUILayout.EndVertical();
+
+
+            }
+            else if( _glueMainSet == 1 )
+            {
+
+                #region Leg Adjust Animation Display
+
+                EditorGUIUtility.labelWidth = 152;
+                EditorGUILayout.BeginVertical();
+
+                GUILayout.Space( 4 );
+                var sp = sp_BaseLegAnimating.Copy();
+
+                EditorGUILayout.BeginHorizontal();
+                sp.Next( true ); EditorGUILayout.PropertyField( sp );
+                _cont.text = ""; _cont.tooltip = "Refresh all curves to default";
+                _cont.image = FGUI_Resources.Tex_Refresh;
+
+                bool rmb = Event.current.button == 1;
+                if( GUILayout.Button( _cont, FGUI_Resources.ButtonStyle, GUILayout.Height( 18 ), GUILayout.Width( 24 ) ) )
+                {
+                    if( rmb )
+                    {
+                        Get.LegAnimatingSettings.LogCurve( "PushHipsOnMoveCurve", Get.LegAnimatingSettings.PushHipsOnMoveCurve );
+                        Get.LegAnimatingSettings.LogCurve( "FootRotationCurve", Get.LegAnimatingSettings.FootRotationCurve );
+                        Get.LegAnimatingSettings.LogCurve( "SpherizeTrack", Get.LegAnimatingSettings.SpherizeTrack );
+                        Get.LegAnimatingSettings.LogCurve( "RaiseYAxisCurve", Get.LegAnimatingSettings.RaiseYAxisCurve );
+                        Get.LegAnimatingSettings.LogCurve( "MoveToGoalCurve", Get.LegAnimatingSettings.MoveToGoalCurve );
+                    }
+                    else
+                        Get.LegAnimatingSettings.RefreshDefaultCurves();
+
+                    OnChange();
+                }
+
+                EditorGUILayout.EndHorizontal();
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+
+                EditorGUILayout.BeginVertical();
+
+                EditorGUILayout.BeginHorizontal();
+
+                GUI.color = Color.gray;
+                if( GUILayout.Button( _showSpherize ? FGUI_Resources.Tex_DownFold : FGUI_Resources.Tex_RightFold, EditorStyles.label, GUILayout.Width( 18 ), GUILayout.Height( 18 ) ) )
+                    _showSpherize = !_showSpherize;
+                GUI.color = Color.white;
+
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Spherize track
+                EditorGUILayout.EndHorizontal();
+
+                if( _showSpherize )
+                {
+                    sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Spherize multiply
+                }
+                else
+                {
+                    sp.NextVisible( false );
+                }
+
+                EditorGUILayout.EndVertical();
+
+                FGUI_Inspector.DrawUILineCommon();
+
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Min max step height
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Height curve
+                FGUI_Inspector.DrawUILineCommon();
+
+
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Speedup
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // Detach sooner
+
+                //_cont.text = sp.displayName; _cont.tooltip = sp.tooltip; _cont.image = null;
+                //Vector2 counterRange = sp.vector2Value; EditorGUIUtility.labelWidth = 182;
+                //EditorGUILayout.MinMaxSlider(_cont, ref counterRange.x, ref counterRange.y, 0f, 1f);
+                //sp.vector2Value = counterRange; EditorGUIUtility.labelWidth = 152;
+
+                FGUI_Inspector.DrawUILineCommon();
+
+
+
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp );
+                sp.NextVisible( false ); if( Get.AnimateFeet ) EditorGUILayout.PropertyField( sp );
+                sp.NextVisible( false ); EditorGUILayout.PropertyField( sp ); // DoStepAnimationOnDistanceFactor
+
+                EditorGUILayout.EndVertical();
+
+                _legAnimRect = GUILayoutUtility.GetLastRect();
+
+                var sett = Get.LegAnimatingSettings;
+                if( sett.StepMoveDuration <= 0f ) sett.StepMoveDuration = 0.7f;
+
+                //GUI.Box(_legAnimRect, GUIContent.none, FGUI_Resources.BGInBoxStyleH);
+
+                _sim_leg += ( _editorDelta * 0.7f ) / sett.StepMoveDuration;
+                _sim_leg %= 2f;
+
+                Handles.BeginGUI();
+                Handles.color = Color.white * 0.7f;
+
+                float wdth = _legAnimRect.width;
+                float hght = _legAnimRect.height;
+                Vector2 startPos = _legAnimRect.position + new Vector2( wdth * 0.15f, _legAnimRect.size.y );
+                Vector2 endPos = _legAnimRect.position + new Vector2( wdth * 0.6f, _legAnimRect.size.y );
+
+                float hOffset = _legAnimRect.height * -1f * Mathf.LerpUnclamped( Get.LegAnimatingSettings.MinFootRaise, Get.LegAnimatingSettings.MaxFootRaise, 0.5f );
+                Vector2 currHOffset = new Vector2( 0f, hOffset * sett.RaiseYAxisCurve.Evaluate( _sim_leg ) );
+
+                Vector2 currPos;
+
+                if( _sim_leg < 1f ) currPos = Vector2.LerpUnclamped( startPos + currHOffset, endPos + currHOffset, sett.MoveToGoalCurve.Evaluate( _sim_leg ) );
+                else currPos = Vector2.Lerp( endPos, startPos, sett.MoveToGoalCurve.Evaluate( _sim_leg - 1f ) );
+
+
+                Vector2 tighPos = _legAnimRect.position /*+ new Vector2(wdth * 0.2f, 0f);*/ + new Vector2( wdth * 0.2f, currPos.x * ( 0.05f + 0.2f * sett.PushHipsOnMoveCurve.Evaluate( _sim_leg ) ) );
+                Vector2 kneePos = _legAnimRect.center + new Vector2( -wdth * 0.35f + currPos.x * 0.5f, -hght * 0.9f + currPos.y * 0.4f );
+
+                Vector2 footPos = currPos;
+
+                if( Get.AnimateFeet )
+                {
+                    float footLen = wdth * 0.15f;
+                    float rot = 180f + 80f * sett.FootRotationCurve.Evaluate( _sim_leg );
+
+                    Vector2 animP = new Vector2( Mathf.Cos( Mathf.Deg2Rad * rot ), Mathf.Sin( Mathf.Deg2Rad * rot ) ) * footLen;
+                    if( _sim_leg > 1f ) animP = Vector2.Lerp( animP, new Vector2( -footLen, 0f ), ( _sim_leg - 1f ) * 3f );
+                    currPos += animP;
+                }
+                else
+                {
+                    footPos += new Vector2( wdth * 0.035f, 0f );
+                }
+
+
+                Handles.DrawAAPolyLine( 2f, tighPos, kneePos, currPos, footPos );
+
+                Handles.EndGUI();
+
+                #endregion
+
+            }
+
+            EditorGUIUtility.labelWidth = 0;
+
+            GUILayout.Space( 2 );
+            EditorGUILayout.EndVertical();
+
+
+
+            var spg = sp_GlueMode.Copy();
+            GUILayout.Space( 4 );
+            GUI.backgroundColor = selCol * 1.25f;
+            EditorGUILayout.PropertyField( spg );
+            GUI.backgroundColor = Color.white;
+
+            if( Application.isPlaying )
+            {
+                if( Get.GlueMode == LegsAnimator.EGlueMode.Automatic )
+                {
+                    GUI.enabled = false;
+                    EditorGUILayout.EnumPopup( "Current Mode:", Get._glueModeExecuted );
+                    GUI.enabled = true;
+                    GUILayout.Space( 4 );
+                }
+            }
+
+            GUILayout.Space( 2 );
+
+            spg.Next( false );
+            EditorGUILayout.PropertyField( spg );
+            GUILayout.Space( 4 );
+
+        }
+
+
+
+        protected void View_Motion_Modules()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+            GUILayout.Space( -5 );
+            EditorGUILayout.BeginHorizontal();
+
+            bool reverseDisable = Get.DisableCustomModules;
+            reverseDisable = !reverseDisable;
+            reverseDisable = EditorGUILayout.Toggle( reverseDisable, GUILayout.Width( 22 ) );
+            Get.DisableCustomModules = !reverseDisable;
+            GUILayout.Space( 44 );
+
+            GUI.enabled = !Application.isPlaying;
+
+            EditorGUILayout.LabelField( "Extra Features using Modules", FGUI_Resources.HeaderStyle );
+
+            GUI.backgroundColor = selCol;
+            if( GUILayout.Button( new GUIContent( FGUI_Resources.Tex_SearchDirectory, "Select available feature module, to be added to this Legs Animator" ), FGUI_Resources.ButtonStyle, GUILayout.Width( 44 ), GUILayout.Height( 18 ) ) )
+                View_Motion_Modules_BuiltInSelector();
+
+            if( GUILayout.Button( new GUIContent( " + ", "Add field for new Legs Animator Module" ), FGUI_Resources.ButtonStyle, GUILayout.Width( 22 ), GUILayout.Height( 18 ) ) )
+            {
+                LegsAnimator.LegsAnimatorCustomModuleHelper helper = new LegsAnimator.LegsAnimatorCustomModuleHelper( Get );
+                Get.CustomModules.Add( helper );
+            }
+
+            GUI.enabled = true;
+            GUI.backgroundColor = Color.white;
+
+            EditorGUILayout.EndHorizontal();
+
+            FGUI_Inspector.DrawUILineCommon( 8 );
+
+            if( Get.CustomModules != null )
+                if( !Get.CustomModules.ContainsIndex( _selectedModuleIndex ) ) _selectedModuleIndex = -1;
+
+            if( Get.DisableCustomModules )
+            {
+                EditorGUILayout.HelpBox( "  All Custom Modules are Disabled", UnityEditor.MessageType.Info );
+            }
+            else if( Get.CustomModules.Count == 0 )
+            {
+                EditorGUILayout.LabelField( "No Modules Added Yet", EditorStyles.centeredGreyMiniLabel );
+            }
+            else
+            {
+                View_Motion_Modules_DisplayModulesList();
+            }
+
+            EditorGUILayout.EndVertical();
+            EditorGUIUtility.fieldWidth = 0;
+            EditorGUIUtility.labelWidth = 0;
+
+            if( EditorGUI.EndChangeCheck() ) OnChange();
+        }
+
+        static int _selectedModuleIndex = -1;
+
+        void View_Motion_Modules_DisplayModulesList()
+        {
+            for( int i = 0; i < Get.CustomModules.Count; i++ )
+            {
+                var mod = Get.CustomModules[i];
+
+                if( _selectedModuleIndex == i ) EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxStyle );
+                else EditorGUILayout.BeginVertical( FGUI_Resources.BGInBoxBlankStyle );
+
+                View_Motion_Modules_DisplayModuleField( i, mod );
+
+                if( _selectedModuleIndex == i )
+                {
+                    FGUI_Inspector.DrawUILineCommon();
+                    View_Motion_Modules_DisplaySelectedModulePanel( mod );
+                    //FGUI_Inspector.DrawUILineCommon(2);
+                }
+
+                EditorGUILayout.EndVertical();
+            }
+
+            if( _customModuleToRemove > -1 )
+            {
+                Get.CustomModules.RemoveAt( _customModuleToRemove );
+                _customModuleToRemove = -1;
+            }
+        }
+
+        int _customModuleToRemove = -1;
+        void View_Motion_Modules_DisplayModuleField( int index, LegsAnimator.LegsAnimatorCustomModuleHelper module )
+        {
+            string disp = "";
+            int wdth = 22;
+
+            if( module.ModuleReference == null )
+            {
+                if( index > -1 ) disp = index.ToString();
+            }
+            else
+            {
+                if( string.IsNullOrWhiteSpace( module.formattedName ) )
+                {
+                    int ind = module.ModuleReference.name.IndexOf( "_" );
+
+                    if( ind > 0 )
+                        module.formattedName = module.ModuleReference.name.Substring( ind + 1, module.ModuleReference.name.Length - ( ind + 1 ) );
+                    else
+                        module.formattedName = module.ModuleReference.name;
+
+                    if( module.formattedName.Length > 24 )
+                    {
+                        module.formattedName = module.formattedName.Substring( 0, 20 ) + "...";
+                    }
+                }
+
+                disp = module.formattedName;
+                wdth = 170;
+            }
+
+            EditorGUILayout.BeginHorizontal();
+
+            module.Enabled = EditorGUILayout.Toggle( module.Enabled, GUILayout.Width( 18 ) );
+            GUILayout.Space( 4 );
+
+
+            if( _selectedModuleIndex == index ) GUI.backgroundColor = selCol;
+            if( GUILayout.Button( disp, FGUI_Resources.ButtonStyle, GUILayout.MaxWidth( wdth ), GUILayout.Height( 18 ) ) )
+            {
+                if( _selectedModuleIndex == index )
+                    _selectedModuleIndex = -1;
+                else
+                    _selectedModuleIndex = index;
+            }
+
+            GUI.backgroundColor = Color.white;
+
+
+
+            if( !Application.isPlaying )
+                module.ModuleReference = (LegsAnimatorControlModuleBase)EditorGUILayout.ObjectField( module.ModuleReference, typeof( LegsAnimatorControlModuleBase ), false );
+            else
+            {
+                EditorGUILayout.ObjectField( module.ModuleReference, typeof( LegsAnimatorControlModuleBase ), false, GUILayout.Width( 48 ) );
+                GUILayout.Space( 4 );
+                EditorGUIUtility.labelWidth = 70;
+                EditorGUILayout.ObjectField( "Playmode:", module.PlaymodeModule, typeof( LegsAnimatorControlModuleBase ), true );
+                EditorGUIUtility.labelWidth = 0;
+            }
+
+
+            if( index > -1 )
+            {
+                GUI.backgroundColor = new Color( 1f, 0.75f, 0.75f, 1f );
+                GUI.enabled = !Application.isPlaying;
+
+                if( GUILayout.Button( FGUI_Resources.GUIC_Remove, FGUI_Resources.ButtonStyle, GUILayout.Width( 22 ), GUILayout.Height( 18 ) ) )
+                {
+                    _customModuleToRemove = index;
+                }
+
+                GUI.backgroundColor = Color.white;
+                GUI.enabled = true;
+            }
+
+            EditorGUILayout.EndHorizontal();
+        }
+
+        void View_Motion_Modules_DisplaySelectedModulePanel( LegsAnimator.LegsAnimatorCustomModuleHelper module )
+        {
+            if( module.CurrentModule == null )
+            {
+                EditorGUILayout.HelpBox( "First choose some module file for this slot", UnityEditor.MessageType.None );
+                return;
+            }
+
+            module.CurrentModule.Editor_InspectorGUI( Get, module );
+
+            //FGUI_Inspector.DrawUILineCommon(6);
+            //if (GUILayout.Button("Close Module Settings Panel", FGUI_Resources.ButtonStyle, GUILayout.Height(16)))
+            //{
+            //    _selectedModuleIndex = -1;
+            //}
+        }
+
+        void View_Motion_Modules_BuiltInSelector()
+        {
+            if( ModulesDirectory == null )
+            {
+                EditorUtility.DisplayDialog( "Not Found Presets Directory!", "Can't find Modules Presets directory. You probably removed it from the project. Please try importing the Legs Animator plugin again.", "Ok" );
+                return;
+            }
+
+            string path = AssetDatabase.GetAssetPath( ModulesDirectory );
+            var files = System.IO.Directory.GetFiles( path, "*.asset" );
+
+            if( files != null )
+            {
+                if( files.Length == 0 )
+                {
+                    EditorUtility.DisplayDialog( "Not Found Presets in the Directory!", "Can't find Modules Preset files. You probably removed them from the project. Please try importing the Legs Animator plugin again.", "Ok" );
+                    return;
+                }
+
+                // Reorder
+                for( int i = files.Length - 1; i >= 0; i-- )
+                {
+                    if( System.IO.Path.GetFileNameWithoutExtension( files[i] ).Contains( "_" ) )
+                    {
+                        for( int o = files.Length - 1; o >= 0; o-- )
+                            if( !System.IO.Path.GetFileNameWithoutExtension( files[o] ).Contains( "_" ) )
+                            {
+                                string swap = files[o];
+                                files[o] = files[i];
+                                files[i] = swap;
+                                break;
+                            }
+                    }
+                }
+
+                GenericMenu draftsMenu = new GenericMenu();
+
+                for( int i = 0; i < files.Length; i++ )
+                {
+                    LegsAnimatorControlModuleBase modl = AssetDatabase.LoadAssetAtPath<LegsAnimatorControlModuleBase>( files[i] );
+                    if( modl )
+                    {
+                        string displayName = modl.name;
+                        displayName = displayName.Replace( "_", "/" );
+
+                        draftsMenu.AddItem( new GUIContent( displayName ), false, (GenericMenu.MenuFunction)( () =>
+                        {
+                            LegsAnimator.LegsAnimatorCustomModuleHelper helper = new LegsAnimator.LegsAnimatorCustomModuleHelper( Get );
+                            helper.ModuleReference = modl;
+                            Get.CustomModules.Add( helper );
+                            _selectedModuleIndex = Get.CustomModules.Count - 1;
+                            this.OnChange();
+                        } ) );
+                    }
+                }
+
+                draftsMenu.ShowAsContext();
+            }
+        }
+
+    }
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Motion.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 90494409cd925304593fa67c75f28874
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.View.Setup.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5d98f0d2e2e17694aab175534977d9b4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.ViewHelpers.cs

@@ -0,0 +1,208 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+    public partial class LegsAnimatorEditor
+    {
+        protected Color preC;
+        protected Color preBG;
+        protected float width;
+
+        public static GUIStyle BGInBoxStyle { get { if (__inBoxStyle != null) return __inBoxStyle; __inBoxStyle = new GUIStyle(); __inBoxStyle.border = new RectOffset(4, 4, 4, 4); __inBoxStyle.padding = new RectOffset(10, 10, 6, 6); __inBoxStyle.margin = new RectOffset(0, 0, 0, 0); return __inBoxStyle; } }
+        private static GUIStyle __inBoxStyle = null;
+        public static Texture2D Tex_Pixel { get { if (__texpixl != null ) return __texpixl; __texpixl = new Texture2D(1, 1); __texpixl.SetPixel(0, 0, Color.white); __texpixl.Apply(false, true); return __texpixl; } }
+        private static Texture2D __texpixl = null;
+        public static GUIStyle StyleColorBG { get { if (__StlcolBG != null) { if (__StlcolBG.normal.background != null) return __StlcolBG; } __StlcolBG = new GUIStyle(EditorStyles.label); Texture2D bg = Tex_Pixel; __StlcolBG.focused.background = bg; __StlcolBG.active.background = bg; __StlcolBG.normal.background = bg; __StlcolBG.border = new RectOffset(0, 0, 0, 0); return __StlcolBG; } }
+        private static GUIStyle __StlcolBG = null;
+        protected GUIContent _guic_autoFind { get { if (__guic_autoFind == null || __guic_autoFind.image == null) __guic_autoFind = new GUIContent("  Try Auto-Find All Needed Bones", FGUI_Resources.Tex_Bone); return __guic_autoFind; } }
+        GUIContent __guic_autoFind = null;
+
+
+        void GUI_Prepare()
+        {
+            if (Get.Legs == null) Get.Legs = new System.Collections.Generic.List<LegsAnimator.Leg>();
+
+            preC = GUI.color;
+            preBG = GUI.backgroundColor;
+            width = EditorGUIUtility.currentViewWidth;
+        }
+
+        /// <summary> Begin horizontal </summary>
+        void BH(GUIStyle style = null)
+        {
+            if (style == null)
+                EditorGUILayout.BeginHorizontal();
+            else
+                EditorGUILayout.BeginHorizontal(style);
+        }
+
+        /// <summary> End horizontal </summary>
+        void EH() { EditorGUILayout.EndHorizontal(); }
+        
+        /// <summary> Begin horizontal </summary>
+        void BV(GUIStyle style = null)
+        {
+            if (style == null)
+                EditorGUILayout.BeginHorizontal();
+            else
+                EditorGUILayout.BeginHorizontal(style);
+        }
+
+        /// <summary> End horizontal </summary>
+        void EV() { EditorGUILayout.EndVertical(); }
+
+
+        bool Button_Refresh()
+        {
+            _requestRepaint = true;
+            return GUILayout.Button(FGUI_Resources.Tex_Refresh, FGUI_Resources.ButtonStyle, GUILayout.Height(18), GUILayout.Width(23));
+        }
+
+        void Helper_Header(string title, Texture tex)
+        {
+            EditorGUILayout.BeginHorizontal(FGUI_Resources.ViewBoxStyle);
+            if (tex != null) EditorGUILayout.LabelField(new GUIContent(tex), GUILayout.Height(18), GUILayout.Width(20));
+            GUILayout.Space(3);
+            EditorGUILayout.LabelField(title, FGUI_Resources.HeaderStyle);
+            GUILayout.Space(3);
+            if (tex != null) EditorGUILayout.LabelField(new GUIContent(tex), GUILayout.Height(18), GUILayout.Width(20));
+            EditorGUILayout.EndHorizontal();
+        }
+
+        protected Color selCol = new Color(0.2f, 1f, 0.3f, 1f);
+        protected readonly Color selCol1 = new Color(0.2f, 1f, 0.3f, 1f);
+        protected readonly Color selCol2 = new Color(0.5f, 0.6f, 1.1f, 1f);
+        protected readonly Color selCol3 = new Color(0.3f, .75f, 1f, 1f);
+
+
+        #region Cateogry Buttons Methods
+
+
+        protected void DrawCategoryButton(LegsAnimator.EEditorCategory target, Texture icon, string lang)
+        {
+            if (Get._EditorCategory == target) GUI.backgroundColor = selCol;
+
+            int height = 28;
+            int lim = 367;
+            //if (choosedLang == ELangs.русский) lim = 500;
+
+            if (EditorGUIUtility.currentViewWidth > lim)
+            {
+                if (GUILayout.Button(new GUIContent("  " + Lang(lang), icon), FGUI_Resources.ButtonStyle, GUILayout.Height(height)))
+                {
+                    Get._EditorCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10;
+                    _requestRepaint = true;
+                }
+            }
+            else
+                if (GUILayout.Button(new GUIContent(icon, Lang(lang)), FGUI_Resources.ButtonStyle, GUILayout.Height(height))) { Get._EditorCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10; _requestRepaint = true; }
+
+            GUI.backgroundColor = preBG;
+        }
+
+
+        protected void DrawCategoryButton(LegsAnimator.EEditorSetupCategory target, Texture icon, string lang, float overrideWidth = 0f)
+        {
+            if (Get._EditorSetupCategory == target) GUI.backgroundColor = selCol;
+            int height = 20; int lim = 357;
+            bool narrow = EditorGUIUtility.currentViewWidth < lim;
+            if (overrideWidth != 0f && overrideWidth < 60f) narrow = true;
+            
+            if (!narrow)
+            {
+                if (_DrawCatButton(new GUIContent("  " + Lang(lang), icon), height, overrideWidth))
+                {
+                    Get._EditorSetupCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10;
+                    _requestRepaint = true;
+                }
+            }
+            else
+                if (_DrawCatButton(new GUIContent(icon, Lang(lang)), height, overrideWidth))
+            {
+                Get._EditorSetupCategory = target;
+                if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10;
+                _requestRepaint = true;
+            }
+
+            GUI.backgroundColor = preBG;
+        }
+
+        bool _DrawCatButton(GUIContent cont, float height, float overrideWidth)
+        {
+            if (overrideWidth != 0f)
+            {
+                if (GUILayout.Button(cont, FGUI_Resources.ButtonStyle, GUILayout.Height(height), GUILayout.Width(overrideWidth)))
+                {
+                    return true;
+                }
+            }
+            else
+            {
+                if (GUILayout.Button(cont, FGUI_Resources.ButtonStyle, GUILayout.Height(height)))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+
+        protected void DrawCategoryButton(LegsAnimator.EEditorMotionCategory target, Texture icon, string lang)
+        {
+            if (Get._EditorMotionCategory == target) GUI.backgroundColor = selCol;
+            int height = 20; int lim = 247;
+
+            if (EditorGUIUtility.currentViewWidth > lim)
+            {
+                if (GUILayout.Button(new GUIContent("  " + Lang(lang), icon), FGUI_Resources.ButtonStyle, GUILayout.Height(height)))
+                {
+                    Get._EditorMotionCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10;
+                    _requestRepaint = true;
+                }
+            }
+            else
+                if (GUILayout.Button(new GUIContent(icon, Lang(lang)), FGUI_Resources.ButtonStyle, GUILayout.Height(height))) { Get._EditorMotionCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10; _requestRepaint = true; }
+
+            GUI.backgroundColor = preBG;
+        }
+
+
+        protected void DrawCategoryButton(LegsAnimator.EEditorExtraCategory target, Texture icon, string lang)
+        {
+            if (Get._EditorExtraCategory == target) GUI.backgroundColor = selCol;
+            int height = 20; int lim = 288;
+
+            if (EditorGUIUtility.currentViewWidth > lim)
+            {
+                if (GUILayout.Button(new GUIContent("  " + Lang(lang), icon), FGUI_Resources.ButtonStyle, GUILayout.Height(height)))
+                {
+                    Get._EditorExtraCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10;
+                    _requestRepaint = true;
+                }
+            }
+            else
+                if (GUILayout.Button(new GUIContent(icon, Lang(lang)), FGUI_Resources.ButtonStyle, GUILayout.Height(height))) { Get._EditorExtraCategory = target; if (GUI.backgroundColor == selCol && Event.current.button == 1) Get._EditorCategory -= 10; _requestRepaint = true; }
+
+            GUI.backgroundColor = preBG;
+        }
+
+
+        #endregion
+
+
+        protected string Lang(string s)
+        {
+            return s;
+        }
+
+        protected void RedrawScene()
+        {
+            SceneView.RepaintAll();
+        }
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LAE.ViewHelpers.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b503668332f055347a8875f0a8703e1c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LegsAnimatorEditor.cs

@@ -0,0 +1,543 @@
+using FIMSpace.FEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace FIMSpace.FProceduralAnimation
+{
+
+    [CanEditMultipleObjects]
+    [CustomEditor( typeof( LegsAnimator ), true )]
+    public partial class LegsAnimatorEditor : Editor
+    {
+        public LegsAnimator Get { get { if( _get == null ) _get = (LegsAnimator)target; return _get; } }
+        private LegsAnimator _get;
+
+        protected bool _requestRepaint = false;
+
+        public override bool UseDefaultMargins()
+        {
+            return false;
+        }
+
+        [MenuItem( "CONTEXT/LegsAnimator/Switch Runtime Performance Debugging", true )]
+        static bool IsDebuggingPerformance( MenuCommand menuCommand )
+        {
+            if( Application.isPlaying == false ) return false;
+
+            if( menuCommand.context is LegsAnimator )
+            {
+                LegsAnimator targetComponent = (LegsAnimator)menuCommand.context;
+                if( targetComponent ) return true;
+            }
+
+            return false;
+        }
+
+        [MenuItem( "CONTEXT/LegsAnimator/Switch Runtime Performance Debugging" )]
+        static void SwitchDebug( MenuCommand menuCommand )
+        {
+            if( menuCommand.context is LegsAnimator )
+            {
+                LegsAnimator targetComponent = (LegsAnimator)menuCommand.context;
+
+                if( targetComponent )
+                {
+                    if( targetComponent == null ) return;
+                    if( targetComponent._perf_main == null ) return;
+                    targetComponent._perf_main.Editor_SwitchFoldout();
+                }
+            }
+        }
+
+        public override bool RequiresConstantRepaint()
+        {
+            if( Application.isPlaying ) return true;
+
+            if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion )
+                if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Glue )
+                    if( _glueMainSet == 1 )
+                    {
+                        return true;
+                    }
+
+            return false;
+        }
+
+
+        System.DateTime _lastUpdateTime = new System.DateTime();
+        float _editorDelta = 0.1f;
+        void UpdateDelta()
+        {
+            if( Event.current.type == EventType.Repaint )
+            {
+                _editorDelta = (float)( System.DateTime.Now - _lastUpdateTime ).TotalSeconds;
+                _lastUpdateTime = System.DateTime.Now;
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.BeginVertical( BGInBoxStyle );
+
+            LegsAnimator._Editor_LastSelectedLA = Get;
+
+            UpdateDelta();
+            GUI_Prepare();
+
+            if( Get._Editor_OnValidateTrigger )
+            {
+                Get._Editor_OnValidateTrigger = false;
+                OnChange( false );
+            }
+
+            serializedObject.Update();
+
+            DrawLegsAnimatorGUI();
+
+            serializedObject.ApplyModifiedProperties();
+
+            if( _requestRepaint )
+            {
+                _requestRepaint = false;
+                SceneView.RepaintAll();
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+
+        protected virtual void DrawLegsAnimatorGUI()
+        {
+            wasWalid = Get.IsSetupValid();
+
+            if( wasWalid == false )
+            {
+                Helper_Header( "Setup", FGUI_Resources.Tex_GearSetup );
+                View_Setup();
+
+                if( Get.Hips != null )
+                {
+                    EditorGUILayout.Space( 8 );
+                    EditorGUILayout.HelpBox( "The setup is not valid yet.\nPrepare LEG BONES FIRST! Then more options will be unlocked!", UnityEditor.MessageType.Warning );
+
+                    EditorGUILayout.Space( 4 );
+
+                    GUI.backgroundColor = new Color( 0.4f, 1f, 0.4f, 1f );
+                    if( GUILayout.Button( _guic_autoFind, FGUI_Resources.ButtonStyle, GUILayout.Height( 28 ) ) )
+                    {
+                        Get.Finding_LegBonesByNamesAndParenting();
+                        OnChange();
+                    }
+
+                    GUI.backgroundColor = Color.white;
+                }
+
+                //FGUI_Inspector.DrawUILineCommon(32);
+                GUILayout.Space( 20 );
+
+                EditorGUILayout.BeginHorizontal();
+
+                if( GUILayout.Button( new GUIContent( "  Watch Tutorials", FGUI_Resources.Tex_Tutorials, "Opening link to the tutorials playlist on the youtube" ), FGUI_Resources.ButtonStyle, GUILayout.Height( 22 ) ) )
+                {
+                    Application.OpenURL( "https://www.youtube.com/playlist?list=PL6MURe5By90lCAwLGntwMrcad4XAAvUNl" );
+                }
+
+                if( UserManualFile )
+                    if( GUILayout.Button( new GUIContent( "  User Manual", FGUI_Resources.Tex_Manual, "Opening User Manual .pdf file" ), FGUI_Resources.ButtonStyle, GUILayout.Height( 22 ) ) )
+                    {
+                        EditorGUIUtility.PingObject( UserManualFile );
+                        Application.OpenURL( Application.dataPath + AssetDatabase.GetAssetPath( UserManualFile ).Replace( "Assets", "" ) );
+                    }
+
+                EditorGUILayout.EndHorizontal();
+
+                GUILayout.Space( 4 );
+
+                if( DemosPackage )
+                {
+                    bool loaded = false;
+                    string demosPath = AssetDatabase.GetAssetPath( DemosPackage );
+                    if( AssetDatabase.LoadAssetAtPath( demosPath.Replace( "Legs Animator - Demos.unitypackage", "Demos - Legs Animator" ), typeof( UnityEngine.Object ) ) != null ) loaded = true;
+
+                    if( loaded == false )
+                    {
+                        EditorGUILayout.BeginHorizontal();
+                        if( GUILayout.Button( new GUIContent( " Import Legs Animator Demos", EditorGUIUtility.IconContent( "UnityLogo" ).image ), GUILayout.Height( 22 ) ) ) AssetDatabase.ImportPackage( demosPath, true );
+                        if( GUILayout.Button( new GUIContent( FGUI_Resources.TexTargetingIcon, "Go to legs animator directory in the project window." ), GUILayout.Width( 24 ), GUILayout.Height( 22 ) ) ) { EditorGUIUtility.PingObject( DemosPackage ); }
+                        EditorGUILayout.EndHorizontal();
+                    }
+                }
+
+                if( Get.Hips == null )
+                    if( AssemblyDefinitions || AssemblyDefinitionsAll )
+                    {
+                        GUI.color = new Color( 1f, 1f, 1f, 0.5f );
+                        EditorGUILayout.BeginHorizontal();
+                        if( GUILayout.Button( "Import Assembly Definitions" ) ) AssetDatabase.ImportPackage( AssetDatabase.GetAssetPath( AssemblyDefinitions ), true );
+                        if( GUILayout.Button( new GUIContent( "All Fimpossible AssemDefs", "Importing all fimpossible creations assembly definitions, if you use multiple plugins from Fimpossible Creations." ) ) ) AssetDatabase.ImportPackage( AssetDatabase.GetAssetPath( AssemblyDefinitionsAll ), true );
+                        EditorGUILayout.EndHorizontal();
+                        GUI.color = Color.white;
+                    }
+            }
+            else
+            {
+                Rect selRect = new Rect();
+
+                selCol = selCol1;
+                EditorGUILayout.BeginHorizontal();
+                DrawCategoryButton( LegsAnimator.EEditorCategory.Setup, FGUI_Resources.Tex_GearSetup, "Setup" );
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Setup ) selRect = GUILayoutUtility.GetLastRect();
+
+
+                var rect = GUILayoutUtility.GetLastRect();
+                rect.width = 10;
+                rect.position = new Vector2( 2, rect.position.y );
+                if( GUI.Button( rect, "", FGUI_Resources.ButtonStyle ) )
+                {
+                    GenericMenu menu = new GenericMenu();
+                    menu.AddItem( new GUIContent( "--- Quick Category Selector ---" ), false, () => { } );
+                    menu.AddItem( new GUIContent( "Setup/Main" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Setup; Get._EditorSetupCategory = LegsAnimator.EEditorSetupCategory.Main; } );
+                    menu.AddItem( new GUIContent( "Setup/Detection" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Setup; Get._EditorSetupCategory = LegsAnimator.EEditorSetupCategory.Physics; } );
+                    menu.AddItem( new GUIContent( "Setup/IK" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Setup; Get._EditorSetupCategory = LegsAnimator.EEditorSetupCategory.IK; } );
+                    menu.AddItem( new GUIContent( "Setup/Optimizing" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Setup; Get._EditorSetupCategory = LegsAnimator.EEditorSetupCategory.Optimizing; } );
+
+                    menu.AddItem( new GUIContent( "Motion/Main" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Main; } );
+                    //menu.AddItem(new GUIContent("Motion/Hips"), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Hips; });
+                    menu.AddItem( new GUIContent( "Motion/Hips/Body Adjust" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Hips; _hipsMainSet = 0; } );
+                    menu.AddItem( new GUIContent( "Motion/Hips/Stability" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Hips; _hipsMainSet = 1; } );
+                    menu.AddItem( new GUIContent( "Motion/Hips/Elasticity" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Hips; _hipsMainSet = 2; } );
+                    //menu.AddItem(new GUIContent("Motion/Gluing"), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Glue; _glueMainSet = 0; });
+                    menu.AddItem( new GUIContent( "Motion/Gluing/Main Glue" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Glue; _glueMainSet = 0; } );
+                    menu.AddItem( new GUIContent( "Motion/Gluing/Idle Gluing Motion" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Glue; _glueMainSet = 1; } );
+                    menu.AddItem( new GUIContent( "Motion/Modules" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Motion; Get._EditorMotionCategory = LegsAnimator.EEditorMotionCategory.Extra; } );
+
+                    menu.AddItem( new GUIContent( "Extra/Helpers" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Extra; Get._EditorExtraCategory = LegsAnimator.EEditorExtraCategory.Main; } );
+                    menu.AddItem( new GUIContent( "Extra/Events" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Extra; Get._EditorExtraCategory = LegsAnimator.EEditorExtraCategory.Events; } );
+                    menu.AddItem( new GUIContent( "Extra/Control" ), false, () => { Get._EditorCategory = LegsAnimator.EEditorCategory.Extra; Get._EditorExtraCategory = LegsAnimator.EEditorExtraCategory.Control; } );
+
+                    menu.ShowAsContext();
+                }
+
+
+                selCol = selCol2;
+                DrawCategoryButton( LegsAnimator.EEditorCategory.Motion, FGUI_Resources.TexMotionIcon, "Motion" );
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion ) selRect = GUILayoutUtility.GetLastRect();
+
+                selCol = selCol3;
+                DrawCategoryButton( LegsAnimator.EEditorCategory.Extra, FGUI_Resources.Tex_Extension, "Extra" );
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Extra ) selRect = GUILayoutUtility.GetLastRect();
+
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Setup ) selCol = selCol1;
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion ) selCol = selCol2;
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Extra ) selCol = selCol3;
+
+
+                EditorGUILayout.EndHorizontal();
+
+                selRect.position += new Vector2( selRect.width / 2f - 6, 31 );
+                selRect.width = 16; selRect.height = 6;
+                //if ( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion) selRect.height += 6;
+                Color cc = selCol; cc.a = 0.3f;
+                GUI.color = cc;
+                GUI.DrawTexture( selRect, Tex_Pixel );
+                GUI.color = Color.white;
+
+                GUILayout.Space( 9 );
+
+
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Setup ) GUI.color = new Color( 0f, 1f, 0f, 0.0f );
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion ) GUI.color = new Color( 0.2f, 0.2f, 1f, 0.11f );
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Extra ) GUI.color = new Color( 0.3f, .75f, 1f, 0.06f );
+
+
+                if( Get._EditorCategory == LegsAnimator.EEditorCategory.Setup )
+                {
+                    EditorGUILayout.BeginVertical( StyleColorBG );
+                    GUI.color = Color.white;
+
+                    //GUI.color = selCol * 0.62f;
+                    EditorGUILayout.BeginHorizontal(); // FGUI_Resources.HeaderBoxStyleH
+                    GUI.color = Color.white;
+                    DrawCategoryButton( LegsAnimator.EEditorSetupCategory.Main, FGUI_Resources.Tex_GearMain, "Main" );
+                    DrawCategoryButton( LegsAnimator.EEditorSetupCategory.Physics, FGUI_Resources.Tex_Physics, "Detection" );
+                    DrawCategoryButton( LegsAnimator.EEditorSetupCategory.IK, Tex_IK, "IK" );
+                    DrawCategoryButton( LegsAnimator.EEditorSetupCategory.Optimizing, FGUI_Resources.TexSmallOptimizeIcon, "Optimizing", 32 );
+                    EditorGUILayout.EndHorizontal();
+                    GUILayout.Space( 5 );
+                    FGUI_Inspector.DrawUILineCommon( 1 );
+
+                    if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.Main )
+                        View_Setup();
+                    else if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.Physics )
+                        View_Setup_Physics();
+                    else if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.IK )
+                        View_Setup_IKSetup();
+                    else if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.Optimizing )
+                        View_Setup_OptimSetup();
+                }
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion )
+                {
+
+                    if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Main )
+                        selCol = new Color( .5f, 1f, .65f, 1f );
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Hips )
+                        selCol = new Color( .5f, .7f, 1f, 1f );
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Glue )
+                        selCol = new Color( .7f, .8f, 1f, 1f );
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Extra )
+                        selCol = new Color( 0.5f, 1f, 1f, 1f );
+
+                    Color bCol = selCol * 0.8f;
+                    bCol.a = 0.06f;
+                    GUI.color = bCol;
+                    EditorGUILayout.BeginVertical( StyleColorBG );
+                    GUI.color = Color.white;
+
+                    //GUI.color = selCol * 0.8f;
+                    EditorGUILayout.BeginHorizontal();
+                    GUI.color = Color.white;
+
+                    DrawCategoryButton( LegsAnimator.EEditorMotionCategory.Main, Tex_LegStep, "Main" );
+                    //DrawCategoryButton(LegsAnimator.EEditorMotionCategory.Foot, Tex_FootStep, "Step");
+                    DrawCategoryButton( LegsAnimator.EEditorMotionCategory.Hips, Tex_Hips, "Hips" );
+                    DrawCategoryButton( LegsAnimator.EEditorMotionCategory.Glue, Tex_Glue, "Gluing" );
+                    DrawCategoryButton( LegsAnimator.EEditorMotionCategory.Extra, FGUI_Resources.Tex_Module, "Modules" );
+
+                    EditorGUILayout.EndHorizontal();
+                    GUILayout.Space( 5 );
+                    FGUI_Inspector.DrawUILineCommon( 1 );
+
+                    if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Main )
+                        View_Motion_Main();
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Hips )
+                        View_Motion_Hips();
+                    //else if (Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Foot)
+                    //    View_Motion_Foots();
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Glue )
+                        View_Motion_Glue();
+                    else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Extra )
+                        View_Motion_Modules();
+                }
+                else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Extra )
+                {
+
+                    EditorGUILayout.BeginVertical( StyleColorBG );
+                    GUI.color = Color.white;
+
+
+                    //GUI.color = selCol * 0.8f;
+                    EditorGUILayout.BeginHorizontal();
+                    GUI.color = Color.white;
+                    DrawCategoryButton( LegsAnimator.EEditorExtraCategory.Main, FGUI_Resources.Tex_Sliders, "Helpers" );
+                    DrawCategoryButton( LegsAnimator.EEditorExtraCategory.Events, Tex_EventIcon, "Events" );
+                    DrawCategoryButton( LegsAnimator.EEditorExtraCategory.Control, Tex_AutoMotion, "Control" );
+                    EditorGUILayout.EndHorizontal();
+                    GUILayout.Space( 5 );
+                    FGUI_Inspector.DrawUILineCommon( 1 );
+
+                    if( Get._EditorExtraCategory == LegsAnimator.EEditorExtraCategory.Main )
+                        View_Extra_Main();
+                    else if( Get._EditorExtraCategory == LegsAnimator.EEditorExtraCategory.Events )
+                        View_Extra_Events();
+                    else if( Get._EditorExtraCategory == LegsAnimator.EEditorExtraCategory.Control )
+                        View_Extra_Controll();
+
+                    View_Extra_HeatmapControls();
+                }
+
+                if( Get._EditorCategory >= 0 ) EditorGUILayout.EndVertical();
+            }
+
+            if( Application.isPlaying ) DrawPerformance();
+        }
+
+        long _perf_totalT = 0;
+        long _perf_lastMin = 0;
+        long _perf_lastMax = 0;
+        dynamic _perf_totalMS = 0;
+        int _perf_totalSteps = 0;
+        protected void DrawPerformance()
+        {
+            Get._perf_main.Editor_DisplayFoldoutButton( -9, -5 );
+            if( Get._perf_main._foldout )
+            {
+                bool upd = Get._perf_preUpd.Editor_DisplayAlways( "Preparation:" );
+                Get._perf_preLate.Editor_DisplayAlways( "Pre-Processing:" );
+                Get._perf_main.Editor_DisplayAlways( "Main Algorithm:" );
+
+                if( upd )
+                {
+                    _perf_totalT = 0;
+                    _perf_totalT += Get._perf_preUpd.AverageTicks;
+                    _perf_totalT += Get._perf_preLate.AverageTicks;
+                    _perf_totalT += Get._perf_main.AverageTicks;
+                    _perf_totalMS = 0;
+                    _perf_totalMS += Get._perf_preUpd.AverageMS;
+                    _perf_totalMS += Get._perf_preLate.AverageMS;
+                    _perf_totalMS += Get._perf_main.AverageMS;
+
+                    _perf_totalSteps += 1;
+                    if( _perf_totalSteps > 6 )
+                    {
+                        if( _perf_totalT > _perf_lastMax ) _perf_lastMax = _perf_totalT;
+                        if( _perf_totalT < _perf_lastMin ) _perf_lastMin = _perf_totalT;
+                    }
+                }
+
+                EditorGUILayout.BeginHorizontal();
+                EditorGUILayout.LabelField( "Total = " + _perf_totalT + " ticks  " + _perf_totalMS + "ms" );
+                GUILayout.Space( 8 );
+                if( _perf_lastMax != long.MinValue && _perf_lastMin != long.MaxValue ) EditorGUILayout.LabelField( "Min = " + _perf_lastMin + " ticks  :   Max = " + _perf_lastMax + " ticks" );
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        float editorScaleRef = 0.5f;
+        void RefreshEditorScaleRef()
+        {
+            if( Get.Legs == null ) return;
+            if( Get.Hips == null ) return;
+
+            bool validated = false;
+            if( Get.Legs.Count > 0 )
+            {
+                if( Get.Legs[0].BoneStart && Get.Legs[0].BoneMid && Get.Legs[0].BoneEnd ) validated = true;
+            }
+
+            editorScaleRef = Get.ScaleReference;
+            if( !validated ) editorScaleRef = Get.HipsToGroundDistanceLocal() * 2f + 0.05f;
+        }
+
+
+        protected virtual void OnSceneGUI()
+        {
+            RefreshEditorScaleRef();
+
+            if( Get._EditorCategory == LegsAnimator.EEditorCategory.Setup )
+            {
+                if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.Main )
+                {
+                    SceneHelper_DrawBoneFocus();
+                    if( _displayHipsHubs ) SceneHelper_DrawHipsHubs();
+                    SceneHelper_DrawLegSelectorHelper();
+                    SceneHelper_DrawDefinedBones();
+                    SceneHelper_DrawDefinedBonesHipsLink( new Color( 0.3f, 0.9f, 0.75f, 0.3f ) );
+                    SceneHelper_DrawScaleReference();
+                }
+                else if( Get._EditorSetupCategory == LegsAnimator.EEditorSetupCategory.Physics )
+                {
+                    SceneHelper_DrawDefinedBones( new Color( 0.2f, 0.6f, 0.3f, 0.3f ) );
+                    SceneHelper_DrawRaycastingCastRange();
+                    SceneHelper_DrawRaycastingStepDown();
+                    SceneHelper_DrawRaycastingPreview( Color.magenta * 0.6f );
+                }
+                else // IK
+                {
+                    SceneHelper_DrawIKSetup( Color.yellow, _setupik_selected_leg );
+                    SceneHelper_DrawDefinedBonesHipsLink();
+                    SceneHelper_DrawFeetLength();
+
+                    if( _setupik_selected_leg >= 0 )
+                        if( _setupik_indivFoldout )
+                        {
+                            var leg = Get.Leg_GetLeg( _setupik_selected_leg );
+                            if( leg != null ) leg._Editor_Glue_DrawControls();
+                        }
+
+                    if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Main )
+                    {
+                        for( int l = 0; l < Get.Legs.Count; l++ ) Get.Legs[l]._Editor_Raycasting_DrawControls();
+                    }
+                }
+            }
+            else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Motion )
+            {
+                SceneHelper_DrawIKSetup( new Color( 0.2f, 1f, 0.3f, 0.2f ), -2 );
+
+                if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Main )
+                {
+                    for( int l = 0; l < Get.Legs.Count; l++ )
+                    {
+                        Get.Legs[l]._Editor_Align_DrawControls();
+
+                        if( Get.LegsInitialized )
+                        {
+                            Handles.color = new Color( 1f, 1f, 0.0f, 0.6f );
+                            Handles.DrawAAPolyLine( 3f, Get.Legs[l].AnkleIK.srcPosition, Get.Legs[l].ankleAlignedOnGroundHitWorldPos, Get.Legs[l].ankleAlignedOnGroundHitWorldPos + Vector3.forward * 0.1f );
+                        }
+                    }
+
+                    float rad = Get.LegsInitialized ? Get._stepPointsOverlapRadius : Get.StepPointsOverlapRadius;
+
+                    if( rad > 0f )
+                    {
+                        Handles.matrix = Get.BaseTransform.localToWorldMatrix;
+                        Handles.color = new Color( 0.4f, 0.9f, 0.4f, 0.3f );
+                        for( int l = 0; l < Get.Legs.Count; l++ )
+                        {
+                            var leg = Get.Legs[l];
+                            if( leg.BoneEnd == null ) continue;
+                            float radius = rad * leg.GlueThresholdMultiplier;
+                            Handles.DrawSolidDisc( Get.transform.InverseTransformPoint( leg.BoneEnd.position ), Get.transform.up, radius * 0.35f );
+                        }
+                        Handles.matrix = Matrix4x4.identity;
+                    }
+                }
+                else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Hips )
+                {
+                    SceneHelper_DrawRaycastingStepDown();
+
+                    for( int l = 0; l < Get.Legs.Count; l++ )
+                    {
+                        Get.Legs[l]._Editor_Raycasting_DrawControls();
+                        Get.Legs[l]._Editor_Hips_DrawControls();
+                    }
+                }
+                else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Glue )
+                {
+                    if( _glueMainSet == 0 )
+                    {
+                        SceneHelper_DrawGlueFloorLevel();
+                    }
+
+                    for( int l = 0; l < Get.Legs.Count; l++ )
+                    {
+                        Get.Legs[l]._Editor_Glue_DrawControls();
+                        Get.Legs[l]._Editor_Raycasting_DrawControls();
+                        //Get.Legs[l]._Editor_Raycasting_DrawSwingReference();
+                    }
+                }
+                else if( Get._EditorMotionCategory == LegsAnimator.EEditorMotionCategory.Extra )
+                {
+                    Get._Editor_ModulesOnSceneGUI();
+                }
+
+            }
+            else if( Get._EditorCategory == LegsAnimator.EEditorCategory.Extra )
+            {
+                //if (_HeatmapDebugLeg > -2)
+                //{
+                //    Get.StepHeatmap_DebugOnSceneView(_HeatmapDebugLeg);
+                //    return;
+                //}
+
+                SceneHelper_DrawIKSetup( new Color( 0.8f, 0.3f, 0.1f, 0.4f ), -2 );
+
+                for( int l = 0; l < Get.Legs.Count; l++ )
+                {
+                    Get.Legs[l]._Editor_Raycasting_DrawControls();
+                }
+
+                if( Get._EditorExtraCategory == LegsAnimator.EEditorExtraCategory.Control || Get._EditorExtraCategory == LegsAnimator.EEditorExtraCategory.Main )
+                {
+                    SceneHelper_DrawExtraControll();
+                }
+
+            }
+        }
+
+        //public static int _HeatmapDebugLeg = -1;
+
+    }
+
+}

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/LegsAnimatorEditor.cs.meta

@@ -0,0 +1,25 @@
+fileFormatVersion: 2
+guid: faef2b1a86bcca846a9d51eba379393d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - ModulesDirectory: {fileID: 102900000, guid: 31c3993e0695a5149ac5de051e1895e8,
+      type: 3}
+  - MotionPresetsDirectory: {fileID: 102900000, guid: d4ad1ffdea45c444dbcf23b831a57c21,
+      type: 3}
+  - ImpulsesDirectory: {fileID: 102900000, guid: 2dabc31881e9120499f671e29955d41c,
+      type: 3}
+  - DemosPackage: {fileID: 102900000, guid: 905ddb52e3f15314d937bf23713161a0, type: 3}
+  - UserManualFile: {fileID: 102900000, guid: 5a95b18dcb99c914c933e12843092f47, type: 3}
+  - AssemblyDefinitions: {fileID: 102900000, guid: 567d0977835eabd48805d30b4001e4fe,
+      type: 3}
+  - AssemblyDefinitionsAll: {fileID: 102900000, guid: 1b8d36599035b4548acb3ac78e2106d2,
+      type: 3}
+  - SceneHelper_FocusOnBone: {instanceID: 0}
+  - HumanoidTPose: {fileID: 7400000, guid: e605d77184e9c5145bf97d6474c229dc, type: 2}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 608124ce347d0354fa3428b24c9aceb0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/ArmSway.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: c87d53dbc9371ae43b8766f58cb04d7b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 32e7a41077ae11e48b25f0d591cf1770
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/AutoMotion.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 59bc9ae354746b74fa746e7d70fa6614
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/DynamicHips.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 2d5881533989ff24cbb653b8b254ff1b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/FootGlue.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 5c99dd8b6a95b0a4386f1c5f1701a3c8
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/FootStep.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 9dddd56676b8dcf4a936828a4297dd60
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/LegCast.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: ed8cacccaa3cb9e478ae11701225861a
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/LegMove.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 9523849764ed07344864ed080a3c47b0
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/LegsAnimator_Langs.xml

@@ -0,0 +1,162 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Languages>
+
+  <English>
+    <string name="Main Setup">Main Setup</string>
+    <string name="Tail Chain">Tail Chain</string>
+    <string name="Optimization And More">Optimization &amp; More</string>
+    
+    <string name="Tweak Animation">Tweak Animation</string>
+    <string name="Limiting Motion">Limiting Motion</string>
+    <string name="Smoothing Motion">Smoothing Motion</string>
+    <string name="Additional Parameters">Additional Parameters</string>
+
+    <string name="Additional Modules">Additional Modules</string>
+    <string name="Auto Waving">Auto Waving</string>
+    <string name="Collisions">Collisions</string>
+    <string name="Colliders Setup">Colliders Setup</string>
+    
+    <string name="Partial Blend">Partial Blend</string>
+    <string name="Inverse Kinematics">Inverse Kinematics (IK)</string>
+    <string name="Deflection">Deflection</string>
+    <string name="Disable when Far">Disable when Far</string>
+
+    <string name="Additional Shaping">Additional Shaping</string>
+    
+    <string name="Physical Effectors">Physical Effectors</string>
+    <string name="Wind">Wind Effect</string>
+  </English>
+
+  <Polski>
+    <string name="Main Setup">Konfiguracja</string>
+    <string name="Tail Chain">Łańcuch</string>
+    <string name="Optimization And More">Optymalizacja i Inne</string>
+
+    <string name="Tweak Animation">Przystosowanie Animacji</string>
+    <string name="Limiting Motion">Limitowanie</string>
+    <string name="Smoothing Motion">Wygładzanie Ruchu</string>
+    <string name="Additional Parameters">Parametry Dodatkowe</string>
+
+    <string name="Additional Modules">Dodatkowe Moduły</string>
+    <string name="Auto Waving">Machanie</string>
+    <string name="Collisions">Kolizje</string>
+    <string name="Colliders Setup">Konfiguracja Koliderów</string>
+
+    <string name="Partial Blend">Częściowy Wpływ Animatora</string>
+    <string name="Inverse Kinematics">Odwrócona Kinematyka (IK)</string>
+    <string name="Deflection">Odgięcia</string>
+    <string name="Disable when Far">Wyłącz gdy zbyt daleko</string>
+
+    <string name="Additional Shaping">Dodatkowe Kształtowanie</string>
+
+    <string name="Physical Effectors">Efekty Fizyczne</string>
+    <string name="Wind">Efekt Wiatru</string>
+  </Polski>
+
+  <русский>
+    <string name="Main Setup">Основная настройка</string>
+    <string name="Tail Chain">хвост цепи</string>
+    <string name="Optimization And More">Оптимизация и многое другое</string>
+
+    <string name="Tweak Animation">Настроить анимацию</string>
+    <string name="Limiting Motion">Ограничение движения</string>
+    <string name="Smoothing Motion">Сглаживание движения</string>
+    <string name="Additional Parameters">Дополнительные параметры</string>
+
+    <string name="Additional Modules">Дополнительные модули</string>
+    <string name="Auto Waving">Авто Размахивая</string>
+    <string name="Collisions">Столкновения</string>
+    <string name="Colliders Setup">Коллайдеры Настройка</string>
+
+    <string name="Partial Blend">Частичная смесь</string>
+    <string name="Inverse Kinematics">Обратная кинематика (IK)</string>
+    <string name="Deflection">Отражение</string>
+    <string name="Disable when Far">Выключите, когда далеко</string>
+
+    <string name="Additional Shaping">Дополнительные формы</string>
+
+    <string name="Physical Effectors">Физические эффекторы</string>
+    <string name="Wind">Воздействие ветра</string>
+  </русский>
+
+  <中文>
+    <string name="Main Setup">主设置</string>
+    <string name="Tail Chain">尾链</string>
+    <string name="Optimization And More">优化和更多</string>
+
+    <string name="Tweak Animation">调整动画</string>
+    <string name="Limiting Motion">限制运动</string>
+    <string name="Smoothing Motion">平滑运动</string>
+    <string name="Additional Parameters">附加参数</string>
+
+    <string name="Additional Modules">附加模块</string>
+    <string name="Auto Waving">自动挥动</string>
+    <string name="Collisions">碰撞</string>
+    <string name="Colliders Setup">碰撞器设置</string>
+
+    <string name="Partial Blend">部分混合</string>
+    <string name="Inverse Kinematics">反向运动 (IK)</string>
+    <string name="Deflection">偏转</string>
+    <string name="Disable when Far">远方时关闭</string>
+
+    <string name="Additional Shaping">附加整形</string>
+
+    <string name="Physical Effectors">物理效应器</string>
+    <string name="Wind">风效应</string>
+  </中文>
+  
+
+  <日本語>
+    <string name="Main Setup">メインセットアップ</string>
+    <string name="Tail Chain">テールチェーン</string>
+    <string name="Optimization And More">最適化と、モーションを制限するアニメーション</string>
+
+    <string name="Tweak Animation">スムージングモーション</string>
+    <string name="Limiting Motion">を制限するアニメーションを</string>
+    <string name="Smoothing Motion">ツイークする追加パラメータ</string>
+    <string name="Additional Parameters">追加のパラメータ</string>
+
+    <string name="Additional Modules">コライダの自動</string>
+    <string name="Auto Waving">ウェーブ</string>
+    <string name="Collisions">コライダ設定</string>
+    <string name="Colliders Setup">コライダ設定</string>
+
+    <string name="Partial Blend">部分ブレンド</string>
+    <string name="Inverse Kinematics">インバースキネマティクス (IK)</string>
+    <string name="Deflection">偏向</string>
+    <string name="Disable when Far">遠く離れたときにオフにする</string>
+
+    <string name="Additional Shaping">追加シェーピング</string>
+
+    <string name="Physical Effectors">フィジカルエフェクター</string>
+    <string name="Wind">風の効果</string>
+  </日本語>
+
+
+  <한국어>
+    <string name="Main Setup">메인 설정</string>
+    <string name="Tail Chain">테일 체인</string>
+    <string name="Optimization And More">최적화 및 더 많은</string>
+
+    <string name="Tweak Animation">애니메이션 조정</string>
+    <string name="Limiting Motion">모션 제한</string>
+    <string name="Smoothing Motion">스무딩 모션</string>
+    <string name="Additional Parameters">추가 매개 변수</string>
+
+    <string name="Additional Modules">추가 모듈</string>
+    <string name="Auto Waving">자동 흔들기</string>
+    <string name="Collisions">충돌</string>
+    <string name="Colliders Setup">콜라이더 설정</string>
+
+    <string name="Partial Blend">부분 혼합</string>
+    <string name="Inverse Kinematics">역 역학 (IK)</string>
+    <string name="Deflection">편향</string>
+    <string name="Disable when Far">멀리 떨어져 있을 때 끄기</string>
+
+    <string name="Additional Shaping">추가 성형</string>
+
+    <string name="Physical Effectors">물리 효과</string>
+    <string name="Wind">바람 효과</string>
+  </한국어>
+  
+</Languages>

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/LegsAnimator_Langs.xml.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 04ee627b1a17374498ae47534b9443d2
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_EndLeg.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 7b464c4850df57f438136ff73badd55c
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 12
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_FootRotate.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 17b774a78bb1c8c4bafc91021cacfbf3
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_IK.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 94f8e0bbbaf3a9849b0ed2a1a880f2e3
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LLeg.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 691a6d0464d7e0842aedd119fa258b0b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LLegOff.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 2ecd3dce9cb37bc499f0c7d056e5f5d7
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegAlign1.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: ef62e7330bdac46419589eac141b9588
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegGl.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 71facceabfb39bb48a01e436838a1479
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegIK.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: 4dc5e8114c743224bb3e58b741a75fbd
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegMot.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 11bb8da311e4232449685a0be6555647
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegMot2.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 11806739b23b13240826b7774051a85f
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegMotion1.fw.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: 7803bdfaac5113546958599d80be7d57
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 1
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegsAnimIcon.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: 2800d444f81461d4b817b2b43e4dcc60
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_LegsCrop.png.meta

@@ -0,0 +1,116 @@
+fileFormatVersion: 2
+guid: a5d56514a4a6be14bb151cf321fe54ef
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: 1
+    mipBias: -100
+    wrapU: 1
+    wrapV: 1
+    wrapW: -1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_MidLeg.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: eef4f3df9fc6f0c438da7a5eb5d26bd4
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 12
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_Opposite.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 1de918855d5b52e4fa27eb067cb4f3e5
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_RLeg.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 2ecf98aaeeddb15489c19a9448242db2
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_RLegOff.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: d29346e12a6e9a9448014f18517ea101
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FImpossible Creations/Editor/Plugins - Editor - Animating/Legs Animator/Resources/Legs Animator/SPR_UpperLeg.png.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: 5d1db00121492f84d9f95f405d4824d6
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: 1
+    aniso: 1
+    mipBias: 0
+    wrapU: 1
+    wrapV: 1
+    wrapW: 0
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 2
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: 4
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 1
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: