修复了选曲的问题 优化了ui

Assets/Airy UI.meta

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

Assets/Airy UI/Documentaion.pdf.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: bc34832782a9bb946ae1d279f2d64b5d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Documentaion.pdf
+  uploadId: 760159

Assets/Airy UI/Editor.meta

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

Assets/Airy UI/Editor/Anchors_Window.cs

@@ -0,0 +1,451 @@
+using UnityEngine;
+using UnityEditor;
+
+
+namespace AiryUI
+{
+
+    public class Anchors_Window : EditorWindow
+    {
+        private static EditorWindow window;
+        private GUIStyle buttonContentStyle;
+
+
+        private bool infoFoldout;
+        private Vector2 windowScroll;
+
+
+        [MenuItem ( "Airy UI/Anchors Window" , priority = 1 )]
+        private static void ShowWindow ()
+        {
+            window = GetWindow<Anchors_Window> ( "Anchors Window" );
+
+            window.maxSize = new Vector2 ( 345 , 430 );
+            window.minSize = new Vector2 ( 345 , 430 );
+            window.Show ();
+        }
+
+
+        private void OnGUI ()
+        {
+            windowScroll = EditorGUILayout.BeginScrollView ( windowScroll , false , false );
+
+            //GUI.color = Color.gray;
+            //WindowTitle_LABEL ();
+            //GUI.color = Color.white;
+
+            EditorGUILayout.Space ( 20 );
+
+            ImportantInfo ();
+
+            GUILayout.Space ( 20 );
+
+            GUI.color = Color.white;
+
+            DrawWindow ();
+
+            DrawRateBox ();
+            DrawYoutube ();
+
+            EditorGUILayout.EndScrollView ();
+        }
+
+
+        private void WindowTitle_LABEL ()
+        {
+            GUILayout.Space ( 10 );
+
+            var titleLabelStyle = new GUIStyle ( GUI.skin.label ) { alignment = TextAnchor.UpperCenter , fontSize = 30 , fontStyle = FontStyle.Bold , fixedHeight = 50 };
+
+            EditorGUILayout.LabelField ( "Anchors Editor" , titleLabelStyle );
+            EditorGUILayout.Space (); EditorGUILayout.Space (); EditorGUILayout.Space ();
+
+            GUILayout.Space ( 30 );
+        }
+
+
+        private void ImportantInfo ()
+        {
+            infoFoldout = EditorGUILayout.BeginFoldoutHeaderGroup ( infoFoldout , "Important Info" );
+            if ( infoFoldout )
+            {
+                GUI.color = Color.white;
+
+                EditorGUILayout.HelpBox ( "Scale of RectTransform must be (1, 1, 1) in order for the anchors to be exact." , MessageType.Warning );
+                EditorGUILayout.HelpBox ( "Sometimes, you may need to set anchors twice if the pivot is not centered." , MessageType.Info );
+                EditorGUILayout.HelpBox ( "You can select multiple Game Objects, and use the shortcut ctrl, shift, q or ctrl, shift, w" , MessageType.Info );
+            }
+        }
+
+
+        [MenuItem ( "Airy UI/Anchors/Set Anchors To Fit Rect %#q" , priority = 2 )]
+        public static void SetAnchorsToRectOnSelectedGameObjects_Shortcut ()
+        {
+            SetAnchorsToRectOnSelectedGameObjects ();
+        }
+
+
+        [MenuItem ( "Airy UI/Anchors/Align Selected To Anchors %#w" , priority = 2 )]
+        public static void SetRectToAnchorsOnSelectedGameObjects_Shortcut ()
+        {
+            SetRectToAnchorsOnSelectedGameObjects ();
+        }
+
+
+        private void DrawWindow ()
+        {
+            EditorGUILayout.BeginHorizontal ();
+
+
+            SetButtonStyle ( new Color ( 0.31f , 0.51f , 1 ) , fontSize: 11 , height: 100 );
+            GUIContent buttonContent = new GUIContent ( "↖ ↗\n↙ ↘\nANCHORS TO RECT\n\nctrl, shift, q" );
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                SetAnchorsToRectOnSelectedGameObjects ();
+            }
+
+
+            SetButtonStyle ( new Color ( 0.74f , 0 , 0.37f ) , fontSize: 11 , height: 100 );
+            buttonContent = new GUIContent ( "↘ ↙\n↗ ↖\nRECT TO ANCHORS\n\nctrl, shift, w" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                SetRectToAnchorsOnSelectedGameObjects ();
+            }
+
+            EditorGUILayout.EndHorizontal ();
+
+            GUILayout.Space ( 10 );
+
+            EditorGUILayout.BeginHorizontal ();
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "↖" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsTopLeft ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "▲" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsTop ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "↗" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsTopRight ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+            EditorGUILayout.EndHorizontal ();
+
+            EditorGUILayout.BeginHorizontal ();
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "◄" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsLeft ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+
+            SetButtonStyle ( new Color ( 1 , 0.46f , 0 ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "●" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsCenter ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "►" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsRight ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+            EditorGUILayout.EndHorizontal ();
+
+            EditorGUILayout.BeginHorizontal ();
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "↙" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsBottomLeft ( rectTransform );
+                    }
+                }
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+
+            }
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "▼" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsBottom ( rectTransform );
+                    }
+                }
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+
+            SetButtonStyle ( new Color ( 0 , 1 , 0.9f ) , fontSize: 11 , 30 );
+            buttonContent = new GUIContent ( "↘" );
+
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( var g in Selection.gameObjects )
+                {
+                    RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                    if ( rectTransform != null )
+                    {
+                        Undo.RecordObject ( rectTransform , "Set Anchors" );
+                        Anchors.SetAnchorsBottomRight ( rectTransform );
+                    }
+                }
+
+                if ( Selection.gameObjects.Length > 0 )
+                    PrintDoneMessage ();
+            }
+
+            EditorGUILayout.EndHorizontal ();
+
+
+            EditorGUILayout.Space ( 20 );
+        }
+
+
+        private void DrawRateBox ()
+        {
+            GUILayout.Label ( "If you like Airy UI, Please Rate it On Asset Store ♡" );
+
+            SetButtonStyle ( new Color ( 0.317f , 1 , 0.43f ) , fontSize: 15 , height: 30 , width: 338 , alignment: TextAnchor.MiddleLeft );
+
+            GUIContent buttonContent = new GUIContent ( " Rate ♡" , SetIcon ( "asset_store.png" ) );
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+                Application.OpenURL ( "https://assetstore.unity.com/packages/tools/gui/airy-ui-easy-ui-animation-135898" );
+
+            GUILayout.Space ( 10 );
+        }
+
+
+        private void DrawYoutube ()
+        {
+            GUILayout.Label ( "And also, take a visit to my GameDev Youtube channel" );
+
+            SetButtonStyle ( new Color ( 0.31f , 0.51f , 1 ) , fontSize: 15 , height: 30 , width: 338 , alignment: TextAnchor.MiddleLeft );
+
+            GUIContent buttonContent = new GUIContent ( " Visit ♡" , SetIcon ( "youtube.png" ) );
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+                Application.OpenURL ( "https://youtube.com/ahmedsabrygamedev" );
+        }
+
+
+        private void SetButtonStyle ( Color backgroundColor , int fontSize = 0 , float height = 0 , float width = 0 , TextAnchor alignment = TextAnchor.MiddleCenter )
+        {
+            GUI.backgroundColor = backgroundColor;
+            buttonContentStyle = null;
+            buttonContentStyle = new GUIStyle ( GUI.skin.button );
+
+            buttonContentStyle.alignment = alignment;
+            buttonContentStyle.normal.textColor = Color.white;
+            buttonContentStyle.hover.textColor = Color.yellow;
+
+            if ( height != 0 )
+                buttonContentStyle.fixedHeight = height;
+
+            if ( width != 0 )
+                buttonContentStyle.fixedWidth = width;
+
+            if ( fontSize != 0 )
+                buttonContentStyle.fontSize = fontSize;
+
+            buttonContentStyle.fontStyle = FontStyle.Bold;
+        }
+
+
+        private Texture2D SetIcon ( string icon )
+        {
+            Texture2D buttonIcon = AssetDatabase.LoadAssetAtPath<Texture2D> ( "Assets/Airy UI/Sprites/Icons/" + icon );
+
+            return buttonIcon;
+        }
+
+
+
+        private static void SetAnchorsToRectOnSelectedGameObjects ()
+        {
+            GameObject [] selectedGameObjects = Selection.gameObjects;
+
+            foreach ( var g in selectedGameObjects )
+            {
+                RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                if ( rectTransform != null )
+                {
+                    Undo.RecordObject ( rectTransform , "Set Anchors" );
+                    Anchors.SetAnchorsToRect ( rectTransform );
+
+                }
+            }
+
+            PrintDoneMessage ();
+        }
+
+
+        private static void SetRectToAnchorsOnSelectedGameObjects ()
+        {
+            GameObject [] selectedGameObjects = Selection.gameObjects;
+
+            foreach ( var g in selectedGameObjects )
+            {
+                RectTransform rectTransform = g.GetComponent<RectTransform> ();
+
+                if ( rectTransform != null )
+                {
+                    Undo.RecordObject ( rectTransform , "Set Anchors" );
+                    Anchors.SetRectToAnchor ( rectTransform );
+
+                }
+            }
+
+            PrintDoneMessage ();
+        }
+
+
+
+        private static void PrintDoneMessage ()
+        {
+            Debug.Log ( "<color=orange><b>[Airy UI]</color></b>" +
+                "<color=green><b>✓</color></b>" +
+                " anchors set for "
+                + Selection.gameObjects.Length +
+                " game object/s" );
+        }
+
+
+
+    }
+
+
+}

Assets/Airy UI/Editor/Anchors_Window.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: b54607e6e292a474491ff4e6f8e143f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 76009eabd85feab4db90da457c751412, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/Anchors_Window.cs
+  uploadId: 760159

Assets/Airy UI/Editor/AnimatedElement_Inspector.cs

@@ -0,0 +1,775 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace AiryUI
+{
+    [CustomEditor(typeof(AnimatedElement))]
+    [CanEditMultipleObjects]
+    public class AnimatedElement_Inspector : Editor
+    {
+
+
+        private AnimatedElement animatedElement;
+
+
+        //===================
+
+
+        private SerializedProperty _isControlledByGroup;
+        private SerializedProperty _group;
+
+
+        //===================
+
+
+        private SerializedProperty _showTimeMode;
+        private SerializedProperty _hideTimeMode;
+
+
+        //===================
+
+
+        private SerializedProperty _disableShowAnimation;
+        private SerializedProperty _disableHideAnimation;
+        private SerializedProperty _containerCanvas;
+        private SerializedProperty _animateOnEnable;
+        private SerializedProperty _animationShowDuration;
+
+
+        //===================
+
+
+        private SerializedProperty _addBounciness;
+        private SerializedProperty _bouncinessPower;
+        private SerializedProperty _bouncinessDuration;
+
+
+        //===================
+
+
+        private SerializedProperty _animationHideDuration;
+        private SerializedProperty _rotateFrom;
+        private SerializedProperty _rotateTo;
+        private SerializedProperty _showAnimationType;
+        private SerializedProperty _hideAnimationType;
+        private SerializedProperty _fadeChildren;
+        private SerializedProperty _animationMoveFrom;
+        private SerializedProperty _animationMoveTo;
+        private SerializedProperty _delayEnabled;
+        private SerializedProperty _showDelay;
+        private SerializedProperty _hideDelay;
+        private SerializedProperty _onShowEvent;
+        private SerializedProperty _onHideEvent;
+        private SerializedProperty _onShowCompleteEvent;
+        private SerializedProperty _onHideCompleteEvent;
+
+
+        //===================
+
+
+        private int currentTabIndex = 0;
+
+
+        //===================
+
+
+        private bool basicFoldout_SHOW;
+        private bool animationFoldout_SHOW;
+        private bool delayFoldout_SHOW;
+        private bool bouncinessFoldout_SHOW;
+        private bool eventsFoldout_SHOW;
+
+
+        //===================
+
+
+        private bool basicFoldout_HIDE;
+        private bool animationFoldout_HIDE;
+        private bool delayFoldout_HIDE;
+        private bool eventsFoldout_HIDE;
+
+
+        //===================
+
+
+        private Color showPropsColor = new Color(0.52f, 1, 0.8f, 1);
+        private Color hidePropsColor = new Color(1, 0.66f, 0.66f, 1);
+
+
+        //===================
+
+
+        private void OnEnable()
+        {
+            GetSavedInspectorValues();
+
+            animatedElement = (AnimatedElement)target;
+
+            _isControlledByGroup = serializedObject.FindProperty("isControlledByGroup");
+            _group = serializedObject.FindProperty("group");
+
+            _disableShowAnimation = serializedObject.FindProperty("disableShowAnimation");
+            _disableHideAnimation = serializedObject.FindProperty("disableHideAnimation");
+
+            _containerCanvas = serializedObject.FindProperty("containerCanvas");
+
+            _showTimeMode = serializedObject.FindProperty("showTimeMode");
+            _hideTimeMode = serializedObject.FindProperty("hideTimeMode");
+
+            _addBounciness = serializedObject.FindProperty("addBounciness");
+            _bouncinessPower = serializedObject.FindProperty("bouncinessPower");
+            _bouncinessDuration = serializedObject.FindProperty("bouncinessDuration");
+
+            _animateOnEnable = serializedObject.FindProperty("animateOnEnable");
+
+            _animationShowDuration = serializedObject.FindProperty("animationShowDuration");
+            _animationHideDuration = serializedObject.FindProperty("animationHideDuration");
+
+            _rotateFrom = serializedObject.FindProperty("rotateFrom");
+            _rotateTo = serializedObject.FindProperty("rotateTo");
+
+            _showAnimationType = serializedObject.FindProperty("showAnimationType");
+            _hideAnimationType = serializedObject.FindProperty("hideAnimationType");
+
+            _fadeChildren = serializedObject.FindProperty("fadeChildren");
+
+            _animationMoveFrom = serializedObject.FindProperty("animationMoveFrom");
+            _animationMoveTo = serializedObject.FindProperty("animationMoveTo");
+
+            _delayEnabled = serializedObject.FindProperty("delayEnabled");
+            _showDelay = serializedObject.FindProperty("showDelay");
+            _hideDelay = serializedObject.FindProperty("hideDelay");
+
+            _onShowEvent = serializedObject.FindProperty("OnShow");
+            _onHideEvent = serializedObject.FindProperty("OnHide");
+            _onShowCompleteEvent = serializedObject.FindProperty("OnShowComplete");
+            _onHideCompleteEvent = serializedObject.FindProperty("OnHideComplete");
+        }
+
+
+        public override void OnInspectorGUI()
+        {
+            if (animatedElement.GetComponent<AnimatedElementsGroup>())
+            {
+                EditorGUILayout.HelpBox("You can't add 'Animated Element' on a game object that has 'Animated Elements Group' !", MessageType.Error);
+
+                animatedElement.enabled = false;
+                animatedElement.disableShowAnimation = true;
+                animatedElement.disableHideAnimation = true;
+
+                // Don't draw anything.
+                return;
+            }
+
+
+            Undo.RecordObject(animatedElement, "animated element");
+            GeneralSettings();
+
+            DrawLinkedGroup();
+
+            DrawTabs();
+
+            if (currentTabIndex == 0)
+            {
+                if (!animatedElement.disableShowAnimation)
+                {
+                    GUI.color = showPropsColor;
+                    basicFoldout_SHOW = EditorGUILayout.BeginFoldoutHeaderGroup(basicFoldout_SHOW, "Basic");
+                    if (basicFoldout_SHOW)
+                    {
+                        GUI.color = Color.white;
+                        DrawAnimateOnEnable_TOGGLE();
+                        DrawAnimationShowTimeMode_DROPDOWN();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = showPropsColor;
+                    animationFoldout_SHOW = EditorGUILayout.BeginFoldoutHeaderGroup(animationFoldout_SHOW, "Animation");
+                    if (animationFoldout_SHOW)
+                    {
+                        GUI.color = Color.white;
+                        DrawShowAnimationType_GRID();
+                        DrawAnimationShowDuration_INPUT();
+                        DrawShowAnimationRotation_PROPERTIES();
+                        DrawFadeChildrenShow_TOGGLE();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = showPropsColor;
+                    delayFoldout_SHOW = EditorGUILayout.BeginFoldoutHeaderGroup(delayFoldout_SHOW, "Delay");
+                    if (delayFoldout_SHOW)
+                    {
+                        GUI.color = Color.white;
+                        DrawShowAnimationDelay_PROPERTIES();
+                        DrawChildrenShowDelays_BUTTONS();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = showPropsColor;
+                    bouncinessFoldout_SHOW = EditorGUILayout.BeginFoldoutHeaderGroup(bouncinessFoldout_SHOW, "Bounciness");
+                    if (bouncinessFoldout_SHOW)
+                    {
+                        GUI.color = Color.white;
+                        DrawAnimationShowBounciness();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = showPropsColor;
+                    eventsFoldout_SHOW = EditorGUILayout.BeginFoldoutHeaderGroup(eventsFoldout_SHOW, "Events");
+                    if (eventsFoldout_SHOW)
+                    {
+                        GUI.color = Color.white;
+                        DrawOnShow_EVENT();
+                        DrawOnShowComplete_EVENT();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+                }
+                else
+                {
+                    GUI.color = Color.white;
+                    DrawOnShowComplete_EVENT();
+                }
+
+                EditorGUILayout.EndFoldoutHeaderGroup();
+                GUILayout.Space(20);
+            }
+            else if (currentTabIndex == 1)
+            {
+                if (!animatedElement.disableHideAnimation)
+                {
+                    GUI.color = hidePropsColor;
+                    basicFoldout_HIDE = EditorGUILayout.BeginFoldoutHeaderGroup(basicFoldout_HIDE, "Basic");
+                    if (basicFoldout_HIDE)
+                    {
+                        GUI.color = Color.white;
+                        DrawAnimationHideTimeMode_DROPDOWN();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = hidePropsColor;
+                    animationFoldout_HIDE = EditorGUILayout.BeginFoldoutHeaderGroup(animationFoldout_HIDE, "Animation");
+                    if (animationFoldout_HIDE)
+                    {
+                        GUI.color = Color.white;
+                        DrawHideAnimationType_GRID();
+                        DrawAnimationHideDuration_INPUT();
+                        DrawHideAnimationRotaion_PROPERTIES();
+                        DrawFadeChildrenHide_TOGGLE();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = hidePropsColor;
+                    delayFoldout_HIDE = EditorGUILayout.BeginFoldoutHeaderGroup(delayFoldout_HIDE, "Delay");
+                    if (delayFoldout_HIDE)
+                    {
+                        GUI.color = Color.white;
+                        DrawHideAnimationDelay_PROPERTIES();
+                        DrawChildrenHideDelays_BUTTONS();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+
+                    GUI.color = hidePropsColor;
+                    eventsFoldout_HIDE = EditorGUILayout.BeginFoldoutHeaderGroup(eventsFoldout_HIDE, "Events");
+                    if (eventsFoldout_HIDE)
+                    {
+                        GUI.color = Color.white;
+                        DrawOnHide_EVENT();
+                        DrawOnHideComplete_EVENT();
+                    }
+
+                    EditorGUILayout.EndFoldoutHeaderGroup();
+                    GUILayout.Space(20);
+
+                    //===================
+                }
+                else
+                {
+                    GUI.color = Color.white;
+                    DrawOnHideComplete_EVENT();
+                }
+            }
+
+            serializedObject.ApplyModifiedProperties();
+            SaveInspectorValues();
+        }
+
+
+        private void GeneralSettings()
+        {
+            //DrawInspectorTitle_LABEL ( "Animated UI Element" , true , false );
+
+            GUILayout.Space(10);
+
+            GUI.color = showPropsColor;
+            EditorGUILayoutExtensions.ToggleLeft(_disableShowAnimation, new GUIContent("Disable Show Animation"));
+
+            GUI.color = hidePropsColor;
+            EditorGUILayoutExtensions.ToggleLeft(_disableHideAnimation, new GUIContent("Disable Hide Animation"));
+
+            GUILayout.Space(10);
+
+            GUI.color = Color.white;
+            DrawContainerCanvas_FIELD();
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawLinkedGroup()
+        {
+            EditorGUILayoutExtensions.ToggleLeft(_isControlledByGroup, new GUIContent("Is Controlled By Group?"));
+            if (animatedElement.isControlledByGroup)
+            {
+                EditorGUILayout.PropertyField(_group);
+            }
+        }
+
+
+        private void DrawTabs()
+        {
+            GUILayout.Space(20);
+
+            currentTabIndex = GUILayout.Toolbar(currentTabIndex, new string[] { "Show Animation", "Hide Animation" });
+
+            GUILayout.Space(20);
+        }
+
+
+        private void DrawContainerCanvas_FIELD()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            EditorGUILayout.PropertyField(_containerCanvas, new GUIContent("Container Canvas"));
+
+            if (GUILayout.Button("Auto Find"))
+            {
+                foreach (var go in Selection.gameObjects)
+                {
+                    go.GetComponent<AnimatedElement>().containerCanvas = go.GetComponentInParent<Canvas>();
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            if (animatedElement.containerCanvas == null)
+            {
+                EditorGUILayout.HelpBox("Please assign the container canvas in order to get the most accurate results and to avoid errors !", MessageType.Warning);
+            }
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawInspectorTitle_LABEL(string text, bool spaceBefore, bool spaceAfter)
+        {
+            if (spaceBefore)
+                GUILayout.Space(20);
+
+            var titleLabelStyle = new GUIStyle(GUI.skin.label) { alignment = TextAnchor.UpperCenter, fontSize = 20, fontStyle = FontStyle.Bold, fixedHeight = 50 };
+
+            EditorGUILayout.LabelField(text, titleLabelStyle);
+
+            if (spaceAfter)
+                GUILayout.Space(20);
+        }
+
+
+        private void DrawAnimationShowTimeMode_DROPDOWN()
+        {
+            EditorGUILayout.PropertyField(_showTimeMode, new GUIContent("Time Mode"));
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawAnimationHideTimeMode_DROPDOWN()
+        {
+            EditorGUILayout.PropertyField(_hideTimeMode, new GUIContent("Time Mode"));
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawAnimateOnEnable_TOGGLE()
+        {
+            EditorGUILayoutExtensions.ToggleLeft(_animateOnEnable, new GUIContent("Animate On Enable"));
+
+            if (animatedElement.isControlledByGroup && animatedElement.group != null)
+            {
+                animatedElement.animateOnEnable = false;
+                EditorGUILayout.HelpBox("You can't enable 'Animate On Enable' because this Animated Element is controlled by an 'Animated Elements Group'", MessageType.None);
+            }
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawShowAnimationType_GRID()
+        {
+            EditorGUILayout.PropertyField(_showAnimationType, new GUIContent("Animation"));
+
+            if (animatedElement.showAnimationType == AnimationType.FadeColor)
+            {
+                EditorGUILayout.HelpBox("Note: This GameObject must have a graphical component (Image, Text,  or RawImage) in order to fade its color !", MessageType.Info);
+
+                GUILayout.Space(10);
+            }
+
+            if (animatedElement.showAnimationType == AnimationType.MoveWithScale || animatedElement.showAnimationType == AnimationType.Move)
+            {
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(_animationMoveFrom, new GUIContent("Start From"));
+
+                GUILayout.Space(5);
+            }
+        }
+
+
+        private void DrawHideAnimationType_GRID()
+        {
+            EditorGUILayout.PropertyField(_hideAnimationType, new GUIContent("Animation"));
+
+            if (animatedElement.hideAnimationType == AnimationType.FadeColor)
+            {
+                EditorGUILayout.HelpBox("Note: This GameObject must have a graphical component (Image, Text,  or RawImage) in order to fade its color !", MessageType.Info);
+
+                GUILayout.Space(10);
+            }
+
+            if (animatedElement.hideAnimationType == AnimationType.MoveWithScale || animatedElement.hideAnimationType == AnimationType.Move)
+            {
+                GUILayout.Space(5);
+                EditorGUILayout.PropertyField(_animationMoveTo, new GUIContent("End To"));
+
+                GUILayout.Space(5);
+            }
+        }
+
+
+        private void DrawFadeChildrenShow_TOGGLE()
+        {
+            if (animatedElement.showAnimationType == AnimationType.FadeColor)
+                // animatedElement.fadeChildren = EditorGUILayout.ToggleLeft("Fade Children Simultaneously", animatedElement.fadeChildren);
+                EditorGUILayoutExtensions.ToggleLeft(_fadeChildren, new GUIContent("Fade Children Simultaneously"));
+        }
+
+
+        private void DrawFadeChildrenHide_TOGGLE()
+        {
+            if (animatedElement.hideAnimationType == AnimationType.FadeColor)
+                // animatedElement.fadeChildren = EditorGUILayout.ToggleLeft("Fade Children Simultaneously", animatedElement.fadeChildren);
+                EditorGUILayoutExtensions.ToggleLeft(_fadeChildren, new GUIContent("Fade Children Simultaneously"));
+        }
+
+
+        private void DrawAnimationShowDuration_INPUT()
+        {
+            EditorGUILayout.Space();
+
+            EditorGUILayout.PropertyField(_animationShowDuration, new GUIContent("Show Duration"));
+
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+
+        private void DrawAnimationShowBounciness()
+        {
+
+            if (animatedElement.showAnimationType == AnimationType.FadeColor)
+            {
+                EditorGUILayout.HelpBox("No Bounciness in color fading!", MessageType.None);
+                return;
+            }
+
+            // EditorGUILayout.PropertyField(_addBounciness, new GUIContent("Add Bounciness"));
+            // animatedElement.addBounciness = EditorGUILayout.ToggleLeft("Add Bounciness", animatedElement.addBounciness,);
+            EditorGUILayoutExtensions.ToggleLeft(_addBounciness, new GUIContent("Add Bounciness"));
+
+            if (animatedElement.addBounciness)
+            {
+                EditorGUILayout.PropertyField(_bouncinessPower, new GUIContent("Bounciness Power"));
+                EditorGUILayout.PropertyField(_bouncinessDuration, new GUIContent("Bounciness Duration"));
+
+                if (animatedElement.showAnimationType == AnimationType.FadeColor)
+                    EditorGUILayout.HelpBox("Bounciness will not affect animation when type is fading color", MessageType.Warning);
+            }
+
+            GUILayout.Space(20);
+
+        }
+
+
+        private void DrawAnimationHideDuration_INPUT()
+        {
+            GUILayout.Space(10);
+
+            EditorGUILayout.PropertyField(_animationHideDuration, new GUIContent("Hide Duration"));
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawShowAnimationDelay_PROPERTIES()
+        {
+            EditorGUILayoutExtensions.ToggleLeft(_delayEnabled, new GUIContent("Enable Delay"));
+
+            if (animatedElement.delayEnabled)
+            {
+                EditorGUILayout.PropertyField(_showDelay, new GUIContent("Delay"));
+            }
+
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+
+        private void DrawShowAnimationRotation_PROPERTIES()
+        {
+            if (animatedElement.showAnimationType == AnimationType.Rotate)
+            {
+                // rotation from angle
+                EditorGUILayout.PropertyField(_rotateFrom, new GUIContent("Rotate From"), true);
+                GUILayout.Space(20);
+            }
+        }
+
+
+        private void DrawHideAnimationRotaion_PROPERTIES()
+        {
+            if (animatedElement.hideAnimationType == AnimationType.Rotate)
+            {
+                EditorGUILayout.PropertyField(_rotateTo, new GUIContent("Rotate To"), true);
+                GUILayout.Space(10);
+
+                #region Future Update
+
+
+                //var titleLabelStyle = new GUIStyle ( GUI.skin.label ) { alignment = TextAnchor.MiddleCenter , fontSize = 13 , fontStyle = FontStyle.Normal };
+
+                //EditorGUILayout.LabelField ( "Rotation Pivot" , titleLabelStyle );
+
+                //rotationPivotGridIndex = GUILayout.SelectionGrid ( rotationPivotGridIndex , new string [] { "↖" , "▲" , "↗" , "◄" , "●" , "►" , "↙" , "▼" , "↘" } , 3 );
+
+                //AnimatedElement.pivotWhileRotating = ( AnimationStartPosition ) rotationPivotGridIndex;
+
+
+                #endregion
+
+                GUILayout.Space(10);
+            }
+        }
+
+
+        private void DrawHideAnimationDelay_PROPERTIES()
+        {
+            EditorGUILayoutExtensions.ToggleLeft(_delayEnabled, new GUIContent("Enable Delay"));
+
+            if (animatedElement.delayEnabled)
+            {
+                EditorGUILayout.PropertyField(_hideDelay, new GUIContent("Delay"));
+            }
+
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+
+        private void DrawOnShow_EVENT()
+        {
+            EditorGUILayout.PropertyField(_onShowEvent, new GUIContent("On Animation Start"));
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+
+        private void DrawOnShowComplete_EVENT()
+        {
+            EditorGUILayout.PropertyField(_onShowCompleteEvent, new GUIContent("On Animation Complete"));
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+
+        private void DrawOnHide_EVENT()
+        {
+            EditorGUILayout.PropertyField(_onHideEvent, new GUIContent("On Animation Start"));
+        }
+
+
+        private void DrawOnHideComplete_EVENT()
+        {
+            EditorGUILayout.PropertyField(_onHideCompleteEvent, new GUIContent("On Animation Complete"));
+        }
+
+
+        private void DrawChildrenShowDelays_BUTTONS()
+        {
+            GUILayout.Space(20);
+
+            EditorGUILayout.BeginHorizontal();
+
+            float addedTime = animatedElement.animationShowDuration;
+            addedTime += (animatedElement.delayEnabled) ? animatedElement.showDelay : 0;
+
+            if (GUILayout.Button("<Auto Set>\nShow Delays In Children"))
+            {
+                AnimatedElement[] elementsInChildren = Selection.activeGameObject.GetComponentsInChildren<AnimatedElement>();
+
+                float step = (animatedElement.animationShowDuration / elementsInChildren.Length);
+                float currentValue = 0;
+
+                for (int i = 1; i < elementsInChildren.Length; i++)
+                {
+                    if (elementsInChildren[i].delayEnabled)
+                        elementsInChildren[i].showDelay = addedTime + currentValue;
+
+                    currentValue += step;
+                }
+                Debug.Log("<color=orange><b>[Airy UI]</color></b>" +
+                "<color=green><b>✓</color></b>" +
+                " anchors set for "
+                + Selection.gameObjects.Length +
+                " game object/s");
+                Debug.Log("<color=orange><b>[Airy UI]</color></b> <color=green><b>✓</color></b> children hide delays set for " + elementsInChildren.Length + " game objects");
+            }
+
+            //==============================================
+
+            if (GUILayout.Button("<Randomize>\nShow Delays In Children"))
+            {
+                AnimatedElement[] elementsInChildren = Selection.activeGameObject.GetComponentsInChildren<AnimatedElement>();
+
+                for (int i = 1; i < elementsInChildren.Length; i++)
+                {
+                    if (elementsInChildren[i].delayEnabled)
+                    {
+                        elementsInChildren[i].showDelay = addedTime + UnityEngine.Random.Range(animatedElement.animationShowDuration / elementsInChildren.Length, animatedElement.animationShowDuration);
+                    }
+                }
+
+                Debug.Log("<color=orange><b>[Airy UI]</color></b> <color=green><b>✓</color></b> children hide delays randomized for " + elementsInChildren.Length + " game objects");
+            }
+
+            EditorGUILayout.EndHorizontal();
+            GUILayout.Space(20);
+        }
+
+
+        private void DrawChildrenHideDelays_BUTTONS()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            float addedTime = animatedElement.animationHideDuration;
+            addedTime += (animatedElement.delayEnabled) ? animatedElement.hideDelay : 0;
+
+            if (GUILayout.Button("<Auto Set>\nHide Delays In Children"))
+            {
+                AnimatedElement[] elementsInChildren = Selection.activeGameObject.GetComponentsInChildren<AnimatedElement>();
+
+                float step = (animatedElement.animationHideDuration / elementsInChildren.Length);
+                float currentValue = 0;
+
+                elementsInChildren[elementsInChildren.Length - 1].hideDelay = 0;
+                for (int i = elementsInChildren.Length - 2; i >= 1; i--)
+                {
+                    if (elementsInChildren[i].delayEnabled)
+                        elementsInChildren[i].hideDelay = step + currentValue;
+
+                    currentValue += step;
+                }
+
+                Debug.Log("<color=orange><b>[Airy UI]</color></b> <color=green><b>✓</color></b> children hide delays set for" + elementsInChildren.Length + " game objects");
+            }
+
+            //==============================================
+
+            if (GUILayout.Button("<Randomize>\nHide Delays In Children"))
+            {
+                AnimatedElement[] elementsInChildren = Selection.activeGameObject.GetComponentsInChildren<AnimatedElement>();
+
+                addedTime = animatedElement.hideDelay;
+
+                for (int i = 1; i < elementsInChildren.Length; i++)
+                {
+                    if (elementsInChildren[i].delayEnabled)
+                    {
+                        elementsInChildren[i].hideDelay = addedTime - UnityEngine.Random.Range(animatedElement.animationHideDuration / elementsInChildren.Length, animatedElement.animationHideDuration);
+                    }
+                }
+
+                Debug.Log("<color=orange><b>[Airy UI]</color></b> <color=green><b>✓</color></b> children hide delays randomized for " + elementsInChildren.Length + " game objects");
+            }
+
+            EditorGUILayout.EndHorizontal();
+            GUILayout.Space(20);
+        }
+
+
+        //===========================================================================================================
+
+
+        private void SaveInspectorValues()
+        {
+            foreach (var id in Selection.instanceIDs)
+            {
+                EditorPrefs.SetInt("airyui/" + nameof(currentTabIndex), currentTabIndex);
+
+                EditorPrefs.SetBool("airyui/" + nameof(basicFoldout_SHOW), basicFoldout_SHOW);
+                EditorPrefs.SetBool("airyui/" + nameof(animationFoldout_SHOW), animationFoldout_SHOW);
+                EditorPrefs.SetBool("airyui/" + nameof(delayFoldout_SHOW), delayFoldout_SHOW);
+                EditorPrefs.SetBool("airyui/" + nameof(bouncinessFoldout_SHOW), bouncinessFoldout_SHOW);
+                EditorPrefs.SetBool("airyui/" + nameof(eventsFoldout_SHOW), eventsFoldout_SHOW);
+
+                EditorPrefs.SetBool("airyui/" + nameof(basicFoldout_HIDE), basicFoldout_HIDE);
+                EditorPrefs.SetBool("airyui/" + nameof(animationFoldout_HIDE), animationFoldout_HIDE);
+                EditorPrefs.SetBool("airyui/" + nameof(delayFoldout_HIDE), delayFoldout_HIDE);
+                EditorPrefs.SetBool("airyui/" + nameof(eventsFoldout_HIDE), eventsFoldout_HIDE);
+            }
+        }
+
+
+        private void GetSavedInspectorValues()
+        {
+            currentTabIndex = EditorPrefs.GetInt("airyui/" + nameof(currentTabIndex), 0);
+
+            basicFoldout_SHOW = EditorPrefs.GetBool("airyui/" + nameof(basicFoldout_SHOW));
+            animationFoldout_SHOW = EditorPrefs.GetBool("airyui/" + nameof(animationFoldout_SHOW));
+            delayFoldout_SHOW = EditorPrefs.GetBool("airyui/" + nameof(delayFoldout_SHOW));
+            bouncinessFoldout_SHOW = EditorPrefs.GetBool("airyui/" + nameof(bouncinessFoldout_SHOW));
+            eventsFoldout_SHOW = EditorPrefs.GetBool("airyui/" + nameof(eventsFoldout_SHOW));
+
+            basicFoldout_HIDE = EditorPrefs.GetBool("airyui/" + nameof(basicFoldout_HIDE));
+            animationFoldout_HIDE = EditorPrefs.GetBool("airyui/" + nameof(animationFoldout_HIDE));
+            delayFoldout_HIDE = EditorPrefs.GetBool("airyui/" + nameof(delayFoldout_HIDE));
+            eventsFoldout_HIDE = EditorPrefs.GetBool("airyui/" + nameof(eventsFoldout_HIDE));
+        }
+    }
+}

Assets/Airy UI/Editor/AnimatedElement_Inspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 872041dd0a8729c4193982932cb5d8bd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 4350cb3056a566c48ac0f3588c16a85d, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/AnimatedElement_Inspector.cs
+  uploadId: 760159

Assets/Airy UI/Editor/AnimatedElementsGroup_Inspector.cs

@@ -0,0 +1,73 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace AiryUI
+{
+    [CustomEditor ( typeof ( AnimatedElementsGroup ) )]
+    [CanEditMultipleObjects]
+    public class AnimatedElementsGroup_Inspector : Editor
+    {
+        private AnimatedElementsGroup animatedGroup;
+
+
+        private SerializedProperty _showAnimaitonOnEnable;
+        private SerializedProperty animatedElements;
+
+
+        private SerializedProperty _onShowEvent;
+        private SerializedProperty _onHideEvent;
+
+
+        private void OnEnable ()
+        {
+            animatedGroup = ( AnimatedElementsGroup ) target;
+
+            _showAnimaitonOnEnable = serializedObject.FindProperty ( "showAnimaitonOnEnable" );
+            animatedElements = serializedObject.FindProperty ( "animatedElements" );
+
+            _onShowEvent = serializedObject.FindProperty ( "OnShow" );
+            _onHideEvent = serializedObject.FindProperty ( "OnHide" );
+        }
+
+
+        public override void OnInspectorGUI ()
+        {
+            Undo.RecordObject ( animatedGroup , "animated group" );
+
+            GUILayout.Space ( 20 );
+
+            EditorGUILayout.PropertyField ( _showAnimaitonOnEnable , new GUIContent ( "Animate On Enable" ) );
+
+            if ( animatedGroup.showAnimaitonOnEnable )
+            {
+                EditorGUILayout.HelpBox ( "TRUE: All Animated Elements in this Group will animate automatically when this GameObject is enabled.\n\nFALSE: You control the animation by calling ShowGroup() in this script." , MessageType.None );
+            }
+
+            GUILayout.Space ( 10 );
+
+            EditorGUILayout.PropertyField ( animatedElements , new GUIContent ( "Animated Elements" ) );
+
+            GUILayout.Space ( 20 );
+
+            DrawOnShow_EVENT ();
+            DrawOnHide_EVENT ();
+
+            GUILayout.Space ( 20 );
+
+            serializedObject.ApplyModifiedProperties ();
+        }
+
+
+        private void DrawOnShow_EVENT ()
+        {
+            EditorGUILayout.PropertyField ( _onShowEvent , new GUIContent ( "On Show" ) );
+            EditorGUILayout.Space (); EditorGUILayout.Space ();
+        }
+
+
+        private void DrawOnHide_EVENT ()
+        {
+            EditorGUILayout.PropertyField ( _onHideEvent , new GUIContent ( "On Hide" ) );
+        }
+    }
+}

Assets/Airy UI/Editor/AnimatedElementsGroup_Inspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2057bd040dbb83a45b41376ca5336bd5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: c6d7f5a7c4a1c364c81769ff255bc0d9, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/AnimatedElementsGroup_Inspector.cs
+  uploadId: 760159

Assets/Airy UI/Editor/CloseButtonController_Inspector.cs

@@ -0,0 +1,45 @@
+using UnityEditor;
+using UnityEngine;
+
+
+namespace AiryUI
+{
+
+
+    [CustomEditor ( typeof ( EscButtonController ) )]
+    [CanEditMultipleObjects]
+    public class CloseButtonController_Inspector : Editor
+    {
+
+        private EscButtonController esc_manager;
+
+
+        private SerializedProperty _esc_buttons;
+
+
+        private void OnEnable ()
+        {
+            esc_manager = ( EscButtonController ) target;
+
+            _esc_buttons = serializedObject.FindProperty ( "esc_buttons" );
+        }
+
+
+        public override void OnInspectorGUI ()
+        {
+            EditorGUILayout.Space ( 10 );
+
+            EditorGUILayout.HelpBox ( "This game object is automatically added When you add EscBackButton please don't remove it" , MessageType.Info );
+
+            EditorGUILayout.Space ( 10 );
+
+            EditorGUILayout.PropertyField ( _esc_buttons );
+
+            serializedObject.ApplyModifiedProperties ();
+        }
+
+
+    }
+
+
+}

Assets/Airy UI/Editor/CloseButtonController_Inspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7a732036fa711b849967a979ac4753b2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7f02f0462f80e0340b3014e7a07c5ac2, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/CloseButtonController_Inspector.cs
+  uploadId: 760159

Assets/Airy UI/Editor/CloseButton_Inspector.cs

@@ -0,0 +1,83 @@
+using UnityEditor;
+using UnityEngine;
+
+
+namespace AiryUI
+{
+
+
+    [CustomEditor ( typeof ( CloseButton ) , true )]
+    [CanEditMultipleObjects]
+    public class CloseButton_Inspector : Editor
+    {
+
+
+        private CloseButton close_button;
+
+
+        private SerializedProperty _backButtonAffects;
+        private SerializedProperty _animatedElement;
+        private SerializedProperty _animatedElementsGroup;
+
+        private SerializedProperty _buttonComponent;
+
+
+        private void OnEnable ()
+        {
+            close_button = ( CloseButton ) target;
+
+            _backButtonAffects = serializedObject.FindProperty ( "backButtonAffects" );
+            _animatedElement = serializedObject.FindProperty ( "affectedAnimatedElement" );
+            _animatedElementsGroup = serializedObject.FindProperty ( "affectedAnimatedElementsGroup" );
+
+            if ( close_button is UICloseButton )
+            {
+                _buttonComponent = serializedObject.FindProperty ( "buttonComponent" );
+            }
+        }
+
+
+        public override void OnInspectorGUI ()
+        {
+            EditorGUILayout.Space ( 10 );
+
+            EditorGUILayout.PropertyField ( _backButtonAffects );
+
+            EditorGUILayout.Space ( 10 );
+
+            if ( close_button.backButtonAffects == BackButtonAffects.AnimatedElement )
+            {
+                EditorGUILayout.PropertyField ( _animatedElement );
+            }
+            else if ( close_button.backButtonAffects == BackButtonAffects.AnimatedElementsGroup )
+            {
+                EditorGUILayout.PropertyField ( _animatedElementsGroup );
+            }
+
+            EditorGUILayout.Space ( 10 );
+
+            if ( close_button is UICloseButton )
+            {
+                EditorGUILayout.PropertyField ( _buttonComponent );
+            }
+
+            serializedObject.ApplyModifiedProperties ();
+        }
+
+
+        private void InspectorTitle_LABEL ( string text , bool spaceBefore , bool spaceAfter )
+        {
+            if ( spaceBefore )
+                GUILayout.Space ( 20 );
+
+            var titleLabelStyle = new GUIStyle ( GUI.skin.label ) { alignment = TextAnchor.UpperCenter , fontSize = 20 , fontStyle = FontStyle.Bold , fixedHeight = 50 };
+
+            EditorGUILayout.LabelField ( text , titleLabelStyle );
+
+            if ( spaceAfter )
+                GUILayout.Space ( 20 );
+        }
+    }
+
+
+}

Assets/Airy UI/Editor/CloseButton_Inspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 19d50b70d8e402447a73338bd8aecf26
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7f02f0462f80e0340b3014e7a07c5ac2, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/CloseButton_Inspector.cs
+  uploadId: 760159

Assets/Airy UI/Editor/CustomAnimatedElement_Inspector.cs

@@ -0,0 +1,630 @@
+using UnityEngine;
+using UnityEditor;
+
+
+namespace AiryUI
+{
+    [CustomEditor(typeof(CustomAnimatedElement))]
+    [CanEditMultipleObjects]
+    public class CustomAnimatedElement_Inspector : Editor
+    {
+        private CustomAnimatedElement animatedElement;
+
+        private SerializedProperty _isControlledByGroup;
+
+        private SerializedProperty _animateOnEnable;
+
+        //===================
+
+
+        private SerializedProperty _showTimeMode;
+        private SerializedProperty _hideTimeMode;
+
+
+        //===================
+
+
+        private SerializedProperty _group;
+
+
+        //===================
+
+
+        private SerializedProperty _containerCanvas;
+
+
+        //===================
+
+
+        private SerializedProperty _componentsToAnimate_SHOW;
+        private SerializedProperty _transformAnimationRecords_SHOW;
+        private SerializedProperty _graphicAnimationRecords_SHOW;
+        private SerializedProperty _transformAndGraphicAnimationRecords_SHOW;
+
+
+        //===================
+
+
+        private SerializedProperty _componentsToAnimate_HIDE;
+        private SerializedProperty _transformAnimationRecords_HIDE;
+        private SerializedProperty _graphicAnimationRecords_HIDE;
+        private SerializedProperty _transformAndGraphicAnimationRecords_HIDE;
+
+
+        //===================
+
+
+        private SerializedProperty _currentRecordDuration;
+        private SerializedProperty _currentRecordDelay;
+
+
+        //===================
+
+
+        private SerializedProperty _showDelay;
+        private SerializedProperty _hideDelay;
+
+
+        //===================
+
+
+        private SerializedProperty _onShowEvent;
+        private SerializedProperty _onHideEvent;
+        private SerializedProperty _onShowCompleteEvent;
+        private SerializedProperty _onHideCompleteEvent;
+
+
+        //===================
+
+
+        private string[] tabsTexts = { "Show", "Hide" };
+        private int currentTabIndex = 0;
+
+        public float currentRecordDuration = 0.5f;
+        public float currentRecordStartsAt = 0;
+
+        private bool recordModeActive;
+
+
+        //===================
+
+
+        private Color showPropsColor = new Color(0.52f, 1, 0.8f, 1);
+        private Color hidePropsColor = new Color(1, 0.66f, 0.66f, 1);
+
+
+        //===================
+
+
+        private void OnEnable()
+        {
+            GetSavedInspectorValues();
+
+            animatedElement = (CustomAnimatedElement)target;
+
+            _isControlledByGroup = serializedObject.FindProperty("isControlledByGroup");
+            _group = serializedObject.FindProperty("group");
+
+            _animateOnEnable = serializedObject.FindProperty("animateOnEnable");
+
+            _containerCanvas = serializedObject.FindProperty("containerCanvas");
+
+            _showTimeMode = serializedObject.FindProperty("showTimeMode");
+            _hideTimeMode = serializedObject.FindProperty("hideTimeMode");
+
+            _componentsToAnimate_SHOW = serializedObject.FindProperty("componentsToAnimate_SHOW");
+            _transformAnimationRecords_SHOW = serializedObject.FindProperty("TransformAnimationRecords_SHOW");
+            _graphicAnimationRecords_SHOW = serializedObject.FindProperty("GraphicAnimationRecords_SHOW");
+            _transformAndGraphicAnimationRecords_SHOW = serializedObject.FindProperty("TransformAndGraphicAnimationRecords_SHOW");
+
+            _componentsToAnimate_HIDE = serializedObject.FindProperty("componentsToAnimate_HIDE");
+            _transformAnimationRecords_HIDE = serializedObject.FindProperty("TransformAnimationRecords_HIDE");
+            _graphicAnimationRecords_HIDE = serializedObject.FindProperty("GraphicAnimationRecords_HIDE");
+            _transformAndGraphicAnimationRecords_HIDE = serializedObject.FindProperty("TransformAndGraphicAnimationRecords_HIDE");
+
+            _currentRecordDuration = serializedObject.FindProperty("currentRecordDuration");
+            _currentRecordDelay = serializedObject.FindProperty("currentRecordDelay");
+
+            _showDelay = serializedObject.FindProperty("showDelay");
+            _hideDelay = serializedObject.FindProperty("hideDelay");
+
+            _onShowEvent = serializedObject.FindProperty("OnShow");
+            _onHideEvent = serializedObject.FindProperty("OnHide");
+            _onShowCompleteEvent = serializedObject.FindProperty("OnShowComplete");
+            _onHideCompleteEvent = serializedObject.FindProperty("OnHideComplete");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (animatedElement.GetComponent<AnimatedElementsGroup>())
+            {
+                EditorGUILayout.HelpBox("You can't add 'Custom Animated Element' on a game object that has 'Animated Elements Group' !", MessageType.Error);
+
+                animatedElement.enabled = false;
+                animatedElement.disableShowAnimation = true;
+                animatedElement.disableHideAnimation = true;
+
+
+                // Don't draw anything.
+                return;
+            }
+
+            Undo.RecordObject(animatedElement, "custom animated element");
+
+            GeneralSettings();
+
+            DrawLinkedGroup();
+
+            DrawAnimateOnEnable_TOGGLE();
+
+            Tabs();
+
+            if (currentTabIndex == 0)
+            {
+                EditorGUILayout.BeginVertical(SetContainerBoxStyle(new Color(0.52f, 1, 0.8f, 0.1f)));
+
+                if (!animatedElement.disableShowAnimation)
+                {
+
+                    Loop_TOGGLE();
+                    ComponentsToAnimateShow_DROPDOWN();
+                    AnimationShowTimeMode_DROPDOWN();
+                    RecordMode_BUTTONS();
+                    ShowAnimationDelay_PROPS();
+                    Duration_PROPS();
+                    TransformAnimationRecordsShow_LIST();
+                    GraphicAnimationRecordsShow_LIST();
+                    TransformAndGraphicAnimationRecordsShow_LIST();
+                    OnShow_EVENT();
+                    OnShowComplete_EVENT();
+                }
+                else
+                {
+                    OnShowComplete_EVENT();
+                }
+
+                GUILayout.EndVertical();
+            }
+            else if (currentTabIndex == 1)
+            {
+                EditorGUILayout.BeginVertical(SetContainerBoxStyle(new Color(1, 0.66f, 0.66f, 0.1f)));
+
+
+                if (!animatedElement.disableHideAnimation)
+                {
+                    ComponentsToAnimateHide_DROPDOWN();
+                    AnimationHideTimeMode_DROPDOWN();
+                    RecordMode_BUTTONS();
+                    HideAnimationDelay_PROPS();
+                    Duration_PROPS();
+                    TransformAnimationRecordsHide_LIST();
+                    GraphicAnimationRecordsHide_LIST();
+                    TransformAndGraphicAnimationRecordsHide_LIST();
+                    OnHide_EVENT();
+                    OnHideComplete_EVENT();
+                }
+                else
+                {
+                    OnHideComplete_EVENT();
+                }
+
+
+                GUILayout.EndVertical();
+            }
+
+
+            serializedObject.ApplyModifiedProperties();
+            SaveInspectorValues();
+        }
+
+        private void GeneralSettings()
+        {
+            //Title_LABEL ();
+
+            GUILayout.Space(10);
+
+            GUI.color = showPropsColor;
+            animatedElement.disableShowAnimation = EditorGUILayout.ToggleLeft("Disable Show Animation", animatedElement.disableShowAnimation);
+
+            GUI.color = hidePropsColor;
+            animatedElement.disableHideAnimation = EditorGUILayout.ToggleLeft("Disable Hide Animation", animatedElement.disableHideAnimation);
+
+            GUILayout.Space(10);
+
+            GUI.color = Color.white;
+            ContainerCanvas();
+
+            GUILayout.Space(10);
+        }
+
+
+        private void DrawLinkedGroup()
+        {
+            animatedElement.isControlledByGroup = EditorGUILayout.ToggleLeft("Is Controlled By Group?", animatedElement.isControlledByGroup);
+            if (animatedElement.isControlledByGroup)
+            {
+                EditorGUILayout.PropertyField(_group);
+            }
+
+            EditorGUILayout.Space(10);
+        }
+
+
+        private void DrawAnimateOnEnable_TOGGLE()
+        {
+            EditorGUILayoutExtensions.ToggleLeft(_animateOnEnable, new GUIContent("Animate On Enable"));
+
+            if (animatedElement.isControlledByGroup && animatedElement.group != null)
+            {
+                animatedElement.animateOnEnable = false;
+                EditorGUILayout.HelpBox("You can't enable 'Animate On Enable' because this Animated Element is controlled by an 'Animated Elements Group'", MessageType.None);
+            }
+
+            GUILayout.Space(10);
+        }
+
+
+        private void Tabs()
+        {
+            GUILayout.Space(20);
+
+            currentTabIndex = GUILayout.Toolbar(currentTabIndex, new string[] { "Show Animation", "Hide Animation" });
+
+            GUILayout.Space(10);
+        }
+
+
+        private void ContainerCanvas()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            EditorGUILayout.PropertyField(_containerCanvas, new GUIContent("Container Canvas"));
+
+            if (GUILayout.Button("Auto Find"))
+            {
+                foreach (var go in Selection.gameObjects)
+                {
+                    go.GetComponent<AnimatedElement>().containerCanvas = go.GetComponentInParent<Canvas>();
+                }
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space(10);
+        }
+
+
+        private GUIStyle SetContainerBoxStyle(Color color)
+        {
+            GUIStyle boxStyle = new GUIStyle("box");
+            boxStyle.padding = new RectOffset(20, 20, 20, 20);
+            boxStyle.margin = new RectOffset(5, 5, 5, 5);
+
+            var texture = new Texture2D(1, 1);
+            texture.SetPixel(0, 0, color);
+            texture.Apply();
+
+            boxStyle.normal.background = texture;
+
+
+            return boxStyle;
+        }
+
+
+        private void AnimationShowTimeMode_DROPDOWN()
+        {
+            EditorGUILayout.PropertyField(_showTimeMode, new GUIContent("Time Mode"));
+
+            GUILayout.Space(10);
+        }
+
+        private void AnimationHideTimeMode_DROPDOWN()
+        {
+            EditorGUILayout.PropertyField(_hideTimeMode, new GUIContent("Time Mode"));
+
+            GUILayout.Space(10);
+        }
+
+
+        private void Loop_TOGGLE()
+        {
+            animatedElement.loop = EditorGUILayout.ToggleLeft("Loop", animatedElement.loop);
+
+            GUILayout.Space(10);
+        }
+
+        private void Title_LABEL()
+        {
+            GUILayout.Space(20);
+            var titleLabelStyle = new GUIStyle(GUI.skin.label) { alignment = TextAnchor.UpperCenter, fontSize = 20, fontStyle = FontStyle.Bold, fixedHeight = 50 };
+
+            EditorGUILayout.LabelField("Custom Animated Element", titleLabelStyle);
+
+            GUILayout.Space(30);
+        }
+
+        private void ComponentsToAnimateShow_DROPDOWN()
+        {
+            EditorGUILayout.PropertyField(_componentsToAnimate_SHOW, new GUIContent("What to animate"), true);
+
+            GUI.color = Color.white;
+
+            GUILayout.Space(20);
+        }
+
+        private void ComponentsToAnimateHide_DROPDOWN()
+        {
+            //GUI.color = Color.cyan;
+            EditorGUILayout.PropertyField(_componentsToAnimate_HIDE, new GUIContent("What to animate"), true);
+            GUI.color = Color.white;
+            GUILayout.Space(20);
+        }
+
+        private void Duration_PROPS()
+        {
+            EditorGUILayout.BeginVertical();
+
+            GUI.color = Color.yellow;
+
+            EditorGUILayout.PropertyField(_currentRecordDuration);
+
+            GUI.color = Color.green;
+
+            EditorGUILayout.PropertyField(_currentRecordDelay);
+
+            GUI.color = Color.white;
+            GUILayout.Space(20);
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void TransformAnimationRecordsShow_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_SHOW == CustomAnimatedElement.ComponentsToAnimate.Transform)
+            {
+                EditorGUILayout.PropertyField(_transformAnimationRecords_SHOW, new GUIContent("Animation Records"));
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void TransformAnimationRecordsHide_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_HIDE == CustomAnimatedElement.ComponentsToAnimate.Transform)
+            {
+                EditorGUILayout.PropertyField(_transformAnimationRecords_HIDE, new GUIContent("Animation Records"), true);
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void GraphicAnimationRecordsShow_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_SHOW == CustomAnimatedElement.ComponentsToAnimate.Graphic)
+            {
+                EditorGUILayout.PropertyField(_graphicAnimationRecords_SHOW, new GUIContent("Animation Records"), true);
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void GraphicAnimationRecordsHide_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_HIDE == CustomAnimatedElement.ComponentsToAnimate.Graphic)
+            {
+                EditorGUILayout.PropertyField(_graphicAnimationRecords_HIDE, new GUIContent("Animation Records"), true);
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void TransformAndGraphicAnimationRecordsShow_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_SHOW == CustomAnimatedElement.ComponentsToAnimate.Both)
+            {
+                EditorGUILayout.PropertyField(_transformAndGraphicAnimationRecords_SHOW, new GUIContent("Animation Records"), true);
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void TransformAndGraphicAnimationRecordsHide_LIST()
+        {
+            EditorGUILayout.BeginVertical();
+
+            if (animatedElement.componentsToAnimate_HIDE == CustomAnimatedElement.ComponentsToAnimate.Both)
+            {
+                EditorGUILayout.PropertyField(_transformAndGraphicAnimationRecords_HIDE, new GUIContent("Animation Records"), true);
+                GUILayout.Space(20);
+            }
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void RecordMode_BUTTONS()
+        {
+            EditorGUILayout.BeginHorizontal();
+
+            EditorGUI.BeginDisabledGroup(recordModeActive);
+
+            GUI.color = new Color(1, 0.45f, 0, 1);
+            if (GUILayout.Button("●\n<color=white>RECORD</color>", new GUIStyle(GUI.skin.button) { fontSize = 12, fontStyle = FontStyle.Bold, fixedWidth = 100, richText = true }))
+            {
+                foreach (var g in Selection.gameObjects)
+                {
+                    CustomAnimatedElement aniamtedElement = g.GetComponent<CustomAnimatedElement>();
+                    if (aniamtedElement)
+                    {
+                        aniamtedElement.EnterRecordMode(g, (CustomAnimatedElement.AnimationShowOrHide)currentTabIndex);
+                    }
+                }
+
+                recordModeActive = true;
+            }
+
+            EditorGUI.EndDisabledGroup();
+
+            EditorGUILayout.Space(5);
+
+            EditorGUI.BeginDisabledGroup(!recordModeActive);
+
+            GUI.color = Color.yellow;
+            if (GUILayout.Button("■\n<color=white>STOP</color> ", new GUIStyle(GUI.skin.button) { fontSize = 12, fontStyle = FontStyle.Bold, fixedWidth = 100, richText = true }))
+            {
+                foreach (var g in Selection.gameObjects)
+                {
+                    CustomAnimatedElement aniamtedElement = g.GetComponent<CustomAnimatedElement>();
+                    if (aniamtedElement)
+                    {
+                        aniamtedElement.ExitRecordMode(g, (CustomAnimatedElement.AnimationShowOrHide)currentTabIndex);
+                    }
+                }
+
+                recordModeActive = false;
+                GUI.color = Color.white;
+            }
+
+
+            EditorGUI.EndDisabledGroup();
+
+            EditorGUILayout.EndHorizontal();
+
+            EditorGUILayout.Space(5);
+
+            EditorGUILayout.BeginHorizontal();
+
+            EditorGUI.BeginDisabledGroup(!recordModeActive);
+
+
+            GUI.color = new Color(0.66f, 0, 1, 1);
+
+            if (GUILayout.Button("⌦\n<color=white>KEYFRAME</color>", new GUIStyle(GUI.skin.button) { fontSize = 12, fontStyle = FontStyle.Bold, richText = true }))
+            {
+                if (currentTabIndex == 0)
+                {
+                    foreach (var g in Selection.gameObjects)
+                    {
+                        CustomAnimatedElement aniamtedElement = g.GetComponent<CustomAnimatedElement>();
+                        if (aniamtedElement)
+                        {
+                            aniamtedElement.Record(g, CustomAnimatedElement.AnimationShowOrHide.Show);
+                        }
+                    }
+                }
+                else if (currentTabIndex == 1)
+                {
+                    foreach (var g in Selection.gameObjects)
+                    {
+                        CustomAnimatedElement aniamtedElement = g.GetComponent<CustomAnimatedElement>();
+                        if (aniamtedElement)
+                        {
+                            aniamtedElement.Record(g, CustomAnimatedElement.AnimationShowOrHide.Hide);
+                        }
+                    }
+                }
+            }
+
+
+            EditorGUI.EndDisabledGroup();
+
+            //GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+
+            GUILayout.Space(20);
+        }
+
+        private void ShowAnimationDelay_PROPS()
+        {
+            GUI.color = Color.white;
+            animatedElement.delayEnabled = EditorGUILayout.ToggleLeft("Enable Delay", animatedElement.delayEnabled);
+
+            if (animatedElement.delayEnabled)
+            {
+                EditorGUILayout.PropertyField(_showDelay, new GUIContent("Show Delay"));
+            }
+
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+        private void HideAnimationDelay_PROPS()
+        {
+            GUI.color = Color.white;
+            animatedElement.delayEnabled = EditorGUILayout.ToggleLeft("Enable Delay", animatedElement.delayEnabled);
+
+            if (animatedElement.delayEnabled)
+            {
+                EditorGUILayout.PropertyField(_hideDelay, new GUIContent("Hide Delay"));
+            }
+
+            EditorGUILayout.Space(); EditorGUILayout.Space();
+        }
+
+        private void OnShow_EVENT()
+        {
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(_onShowEvent, new GUIContent("On Animation Start"));
+            GUILayout.Space(10);
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void OnShowComplete_EVENT()
+        {
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(_onShowCompleteEvent, new GUIContent("On Animation Complete"));
+            GUILayout.Space(10);
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void OnHide_EVENT()
+        {
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(_onHideEvent, new GUIContent("On Animation Start"));
+
+            EditorGUILayout.EndVertical();
+        }
+
+        private void OnHideComplete_EVENT()
+        {
+            EditorGUILayout.BeginVertical();
+
+            EditorGUILayout.PropertyField(_onHideCompleteEvent, new GUIContent("On Animation Complete"));
+
+            EditorGUILayout.EndVertical();
+        }
+
+        //===========================================================================================================
+
+        private void SaveInspectorValues()
+        {
+            foreach (var id in Selection.instanceIDs)
+            {
+                EditorPrefs.SetInt("airyui/custom/" + nameof(currentTabIndex), currentTabIndex);
+            }
+        }
+
+        private void GetSavedInspectorValues()
+        {
+            currentTabIndex = EditorPrefs.GetInt("airyui/custom/" + nameof(currentTabIndex), 0);
+        }
+    }
+}

Assets/Airy UI/Editor/CustomAnimatedElement_Inspector.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: ca397c1c5f6fa984abd9caafd619f284
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 5012f5c66ad8aef43950aabb25f0b7e0, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/CustomAnimatedElement_Inspector.cs
+  uploadId: 760159

Assets/Airy UI/Editor/EditorGUILayoutExtensions.cs

@@ -0,0 +1,56 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+
+
+namespace AiryUI
+{
+
+
+    public static class EditorGUILayoutExtensions
+    {
+        public static void ToggleLeft(this SerializedProperty prop, GUIContent label, params GUILayoutOption[] options)
+        {
+            EditorGUI.BeginChangeCheck();
+            EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+            var newValue = EditorGUILayout.ToggleLeft(label, prop.boolValue, options);
+            EditorGUI.showMixedValue = false;
+            if (EditorGUI.EndChangeCheck())
+                prop.boolValue = newValue;
+        }
+
+
+        /// <summary>
+        /// Create a EditorGUILayout.Slider which properly handles multi-object editing
+        /// We apply the 'convIn' conversion to the SerializedProperty value before exposing it as a Slider.
+        /// We apply the 'convOut' conversion to the Slider value to store it back to the SerializedProperty.
+        /// </summary>
+        /// <param name="prop">The value the slider shows. This determines the position of the draggable thumb.</param>
+        /// <param name="label">Label in front of the slider.</param>
+        /// <param name="leftValue">The value at the left end of the slider.</param>
+        /// <param name="rightValue">The value at the right end of the slider.</param>
+        /// <param name="convIn">Conversion function applied on the SerializedProperty to get the Slider value</param>
+        /// <param name="convOut">Conversion function applied on the Slider value to get the SerializedProperty</param>
+        public static void FloatSlider(
+            this SerializedProperty prop,
+            GUIContent label,
+            float leftValue, float rightValue,
+            Func<float, float> convIn,
+            Func<float, float> convOut,
+            params GUILayoutOption[] options)
+        {
+            var floatValue = convIn(prop.floatValue);
+            EditorGUI.BeginChangeCheck();
+            {
+                EditorGUI.showMixedValue = prop.hasMultipleDifferentValues;
+                {
+                    floatValue = EditorGUILayout.Slider(label, floatValue, leftValue, rightValue, options);
+                }
+                EditorGUI.showMixedValue = false;
+            }
+            if (EditorGUI.EndChangeCheck())
+                prop.floatValue = convOut(floatValue);
+        }
+    }
+
+}

Assets/Airy UI/Editor/EditorGUILayoutExtensions.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c0ec872a0a1c26340835775ab18f99ed
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/EditorGUILayoutExtensions.cs
+  uploadId: 760159

Assets/Airy UI/Editor/MainWindow.cs

@@ -0,0 +1,275 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace AiryUI
+{
+    public class MainWindow : EditorWindow
+    {
+
+
+        private static EditorWindow window;
+        private GUIStyle buttonContentStyle;
+        private Vector2 windowScroll;
+
+
+        [MenuItem ( "Airy UI/Main Window" , priority = 0 )]
+        private static void ShowWindow ()
+        {
+            window = GetWindow<MainWindow> ( "Airy UI" );
+            window.Show ();
+
+            window.maxSize = new Vector2 ( 370 , 650 );
+            window.minSize = new Vector2 ( 370 , 620 );
+        }
+
+
+        private void OnGUI ()
+        {
+            windowScroll = EditorGUILayout.BeginScrollView ( windowScroll , false , false );
+
+            GUILayout.Space ( 20 );
+
+            DrawAnimationManager_BUTTONS ();
+
+            DrawAnimatedElement_BUTTONS ();
+
+            DrawBackBtn_BUTTONS ();
+
+            DrawRateBox ();
+
+            DrawYoutube ();
+
+            EditorGUILayout.EndScrollView ();
+        }
+
+
+        private void WindowTitle_LABEL ()
+        {
+            GUI.color = Color.white;
+
+
+            GUILayout.Space ( 10 );
+
+            var titleLabelStyle = new GUIStyle ( GUI.skin.label ) { alignment = TextAnchor.MiddleLeft , fontSize = 25 , fontStyle = FontStyle.Bold , fixedHeight = 50 };
+
+            EditorGUILayout.LabelField ( "Airy UI Main Window" , titleLabelStyle );
+            GUILayout.Space ( 50 );
+        }
+
+
+        private void DrawAnimationManager_BUTTONS ()
+        {
+            SetButtonStyle ( new Color ( 0.48f , 0.56f , 1 ) );
+
+            GUIContent buttonContent = new GUIContent ( " Add Animated Elements Group" , SetIcon ( "manager_add.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    Undo.AddComponent<AnimatedElementsGroup> ( g );
+                }
+            }
+
+
+            buttonContent = new GUIContent ( " Remove Animated Elements Group" , SetIcon ( "manager_remove.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<AnimatedElementsGroup> () != null )
+                    {
+                        Undo.DestroyObjectImmediate ( g.GetComponent<AnimatedElementsGroup> () );
+                    }
+                }
+            }
+
+            GUILayout.Space ( 20 );
+
+        }
+
+
+        private void DrawAnimatedElement_BUTTONS ()
+        {
+            SetButtonStyle ( new Color ( 1 , 0.29f , 0.74f ) );
+
+            GUIContent buttonContent = new GUIContent ( " Add Animated Element" , SetIcon ( "animation_add.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    Undo.AddComponent<AnimatedElement> ( g );
+                }
+            }
+
+
+            buttonContent = new GUIContent ( " Add Custom Animated Element" , SetIcon ( "c_animation_add.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<CustomAnimatedElement> () == null )
+                    {
+                        Undo.AddComponent<CustomAnimatedElement> ( g );
+                    }
+                }
+            }
+
+
+            buttonContent = new GUIContent ( " Remove Animated Element" , SetIcon ( "animation_remove.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    Undo.RecordObject ( g , "Remove Animated Element" );
+                    if ( g.GetComponent<AnimatedElement> () != null )
+                        Undo.DestroyObjectImmediate ( g.GetComponent<AnimatedElement> () );
+
+                    if ( g.GetComponent<CustomAnimatedElement> () != null )
+                        Undo.DestroyObjectImmediate ( g.GetComponent<CustomAnimatedElement> () );
+                }
+            }
+
+            GUILayout.Space ( 20 );
+        }
+
+
+
+        private void DrawBackBtn_BUTTONS ()
+        {
+            SetButtonStyle ( new Color ( 1 , 0.52f , 0.28f ) );
+
+
+            GUIContent buttonContent = new GUIContent ( " Add Esc Button" , SetIcon ( "esc_add.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<EscCloseButton> () == null )
+                    {
+                        Undo.AddComponent<EscCloseButton> ( g );
+                    }
+                }
+            }
+
+
+            buttonContent = new GUIContent ( " Remove Esc Button" , SetIcon ( "esc_remove.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<EscCloseButton> () != null )
+                    {
+                        Undo.DestroyObjectImmediate ( g.GetComponent<EscCloseButton> () );
+                    }
+                }
+            }
+
+            GUILayout.Space ( 20 );
+
+            SetButtonStyle ( new Color ( 1 , 0.38f , 0.28f ) );
+
+
+            buttonContent = new GUIContent ( " Add UI Close Button" , SetIcon ( "back_add.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<UICloseButton> () == null )
+                    {
+                        Undo.AddComponent<UICloseButton> ( g );
+                    }
+                }
+            }
+
+
+            buttonContent = new GUIContent ( " Remove UI Close Button" , SetIcon ( "back_remove.png" ) );
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+            {
+                foreach ( GameObject g in Selection.gameObjects )
+                {
+                    if ( g.GetComponent<UICloseButton> () != null )
+                    {
+                        Undo.DestroyObjectImmediate ( g.GetComponent<UICloseButton> () );
+                    }
+                }
+            }
+
+
+            GUILayout.Space ( 20 );
+        }
+
+
+
+        [MenuItem ( "Airy UI/Rate On Asset Store" , priority = 15 )]
+        public static void RateOnAssetStore ()
+        {
+            Application.OpenURL ( "https://assetstore.unity.com/packages/tools/gui/airy-ui-2-easy-ui-animation-135898#reviews" );
+        }
+
+
+        [MenuItem ( "Airy UI/Suggest | Report Bug" , priority = 16 )]
+        public static void ReportBug ()
+        {
+            Application.OpenURL ( "https://forms.gle/4a9BU3C9ScP4XBoS8" );
+        }
+
+
+        [MenuItem ( "Airy UI/My Youtube Channel" , priority = 36 )]
+        public static void YoutubeChannel ()
+        {
+            Application.OpenURL ( "https://youtube.com/ahmedsabrygamedev" );
+        }
+
+
+        private void DrawRateBox ()
+        {
+            GUILayout.Label ( "If you like Airy UI, Please Rate it On Asset Store ♡" );
+
+            SetButtonStyle ( new Color ( 0.317f , 1 , 0.43f ) , 30 );
+
+            GUIContent buttonContent = new GUIContent ( " Rate ♡" , SetIcon ( "asset_store.png" ) );
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+                Application.OpenURL ( "https://assetstore.unity.com/packages/tools/gui/airy-ui-2-easy-ui-animation-135898#reviews" );
+
+            GUILayout.Space ( 10 );
+        }
+
+
+        private void DrawYoutube ()
+        {
+            GUILayout.Label ( "And also, take a visit to my GameDev Youtube channel" );
+
+            SetButtonStyle ( new Color ( 0.31f , 0.51f , 1 ) , 30 );
+
+            GUIContent buttonContent = new GUIContent ( " Visit ♡" , SetIcon ( "youtube.png" ) );
+
+            if ( GUILayout.Button ( buttonContent , buttonContentStyle ) )
+                Application.OpenURL ( "https://youtube.com/ahmedsabrygamedev" );
+        }
+
+
+        private void SetButtonStyle ( Color backgroundColor , float height = 40 )
+        {
+            GUI.backgroundColor = backgroundColor;
+
+            buttonContentStyle = new GUIStyle ( GUI.skin.button );
+
+            buttonContentStyle.alignment = TextAnchor.MiddleLeft;
+            buttonContentStyle.normal.textColor = Color.white;
+            buttonContentStyle.hover.textColor = Color.yellow;
+            buttonContentStyle.fixedHeight = height;
+            buttonContentStyle.fixedWidth = 361;
+            buttonContentStyle.fontSize = 17;
+            buttonContentStyle.fontStyle = FontStyle.Bold;
+        }
+
+
+        private Texture2D SetIcon ( string icon )
+        {
+            Texture2D buttonIcon = AssetDatabase.LoadAssetAtPath<Texture2D> ( "Assets/Airy UI/Sprites/Icons/" + icon );
+
+            return buttonIcon;
+        }
+    }
+}

Assets/Airy UI/Editor/MainWindow.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 1605469f191200d40b9930ba490515f1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 0c86d94cc61dd1f4d9e208a11aed6c15, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Editor/MainWindow.cs
+  uploadId: 760159

Assets/Airy UI/Fonts.meta

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

Assets/Airy UI/Fonts/Font 1.ttf.meta

@@ -0,0 +1,29 @@
+fileFormatVersion: 2
+guid: 7e762b4b6b3331d4ea0cc148ee304a6f
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Beautiful People Personal Use
+  fontNames:
+  - Beautiful People Personal Use
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Fonts/Font 1.ttf
+  uploadId: 760159

Assets/Airy UI/Fonts/Font 2.ttf.meta

@@ -0,0 +1,28 @@
+fileFormatVersion: 2
+guid: 4506bf6ca285b494ab0993e12703d5e6
+timeCreated: 1506421581
+licenseType: Store
+TrueTypeFontImporter:
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Fredoka One
+  fontNames:
+  - Fredoka One
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Fonts/Font 2.ttf
+  uploadId: 760159

Assets/Airy UI/Fonts/Font 3.ttf.meta

@@ -0,0 +1,29 @@
+fileFormatVersion: 2
+guid: 540af095b0b487a4f81d2d30c250df69
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Merry Christmas Color
+  fontNames:
+  - Merry Christmas Color
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Fonts/Font 3.ttf
+  uploadId: 760159

Assets/Airy UI/Fonts/Font 4.ttf.meta

@@ -0,0 +1,28 @@
+fileFormatVersion: 2
+guid: 14f4ee6bda529af43a941a41922b6132
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontNames:
+  - Magensburg
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Fonts/Font 4.ttf
+  uploadId: 760159

Assets/Airy UI/Scripts.meta

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

Assets/Airy UI/Scripts/Anchors.cs

@@ -0,0 +1,271 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AiryUI
+{
+
+
+    [ExecuteInEditMode]
+    public class Anchors
+    {
+
+
+        private static float parentRectWidth, parentRectHeight;
+
+        private static RectTransform rectTransform;
+
+        private static float thisRectWidth, thisRectHeight;
+
+        private static Vector3 rectInitialPosition;
+        private static Vector2 minAnchors;
+        private static Vector2 maxAnchors;
+        private static Vector2 rectPositionRelativeToParent;
+        private static Vector2 initialPivot;
+
+        private static float rectWidthRatio;
+        private static float rectHeightRatio;
+
+        private static void SetInitialValues ()
+        {
+            // Initial Position, because we will reset the position later.
+            rectInitialPosition = rectTransform.localPosition;
+            initialPivot = rectTransform.pivot;
+
+            rectTransform.pivot = new Vector2 ( 0.5f , 0.5f );
+
+            // Screen dimensions.
+            // 15-12-2018 We do not use Screen.width and Screen.height here, because these variables are only set correctly in play mode, in edit mode, they return the size of the game window, it's a litte bit tricky -_- .
+            // 16-12-2018 We do not use screen dimensions anymore. Instead we use the parent rect's dimensions.
+
+            //string[] resolution = UnityEditor.UnityStats.screenRes.Split('x');
+            //screenWidth = int.Parse(resolution[0]);
+            //screenHeight = int.Parse(resolution[1]);
+
+            parentRectWidth = rectTransform.parent.GetComponent<RectTransform> ().rect.width;
+            parentRectHeight = rectTransform.parent.GetComponent<RectTransform> ().rect.height;
+
+            // Rect dimensions.
+            thisRectWidth = rectTransform.rect.width;
+            thisRectHeight = rectTransform.rect.height;
+
+            // Relative position, width, and height. We add 0.5 to X and Y coordinates becuase the center in local space is (0, 0) while the center in world space (0.5, 0.5).
+            rectPositionRelativeToParent = new Vector2 ( ( rectTransform.localPosition.x / parentRectWidth ) + 0.5f , ( rectTransform.localPosition.y / parentRectHeight ) + 0.5f );
+
+            // rectWidthRatio and rectHeightRatio return the ratio of the current rect's dimensions relative to screen. e.g if parent rect's width = 400 and current rect's width = 100, then rectWidthRatio will be 0.25 
+            rectWidthRatio = thisRectWidth / parentRectWidth;
+            rectHeightRatio = thisRectHeight / parentRectHeight;
+
+            float minX = rectPositionRelativeToParent.x - ( rectWidthRatio / 2 );
+            float minY = rectPositionRelativeToParent.y - ( rectHeightRatio / 2 );
+
+            float maxX = rectPositionRelativeToParent.x + ( rectWidthRatio / 2 );
+            float maxY = rectPositionRelativeToParent.y + ( rectHeightRatio / 2 );
+
+            minAnchors = new Vector2 ( minX , minY );
+            maxAnchors = new Vector2 ( maxX , maxY );
+        }
+
+        public static void SetAnchorsToRect ( RectTransform rect )
+        {
+            // Done in 17-12-2018  ----------- It took too much time.
+            // First, We will get the current position, width, and height of the rect transform, because we will reset these values after setting the anchor.
+            // That's because when the anchors positions change, they autmatically change the coordinates of the rect transform.
+            // Second, we will get the width and height of the parent rect transform.
+            // Second, we will get the width and height of this rect transform.
+            // Third, we have to find the rect transform's position in relativity with parent width, and height. (rectTransform.position.x / parent.width)
+
+            rectTransform = rect;
+
+            // Here we calculate the min and max anchors.
+            SetInitialValues ();
+
+            // And finally setting the anchors.
+
+            rectTransform.anchorMin = minAnchors;
+            rectTransform.anchorMax = maxAnchors;
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsCenter ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 0.5f , 0.5f );
+            rectTransform.anchorMax = new Vector2 ( 0.5f , 0.5f );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsTop ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 0.5f , 1 );
+            rectTransform.anchorMax = new Vector2 ( 0.5f , 1 );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsBottom ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 0.5f , 0 );
+            rectTransform.anchorMax = new Vector2 ( 0.5f , 0 );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsRight ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 1 , 0.5f );
+            rectTransform.anchorMax = new Vector2 ( 1 , 0.5f );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsLeft ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 0 , 0.5f );
+            rectTransform.anchorMax = new Vector2 ( 0 , 0.5f );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsTopRight ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = Vector2.one;
+            rectTransform.anchorMax = Vector2.one;
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsTopLeft ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 0 , 1 );
+            rectTransform.anchorMax = new Vector2 ( 0 , 1 );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsBottomRight ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = new Vector2 ( 1 , 0 );
+            rectTransform.anchorMax = new Vector2 ( 1 , 0 );
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetAnchorsBottomLeft ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            SetInitialValues ();
+
+            rectTransform.anchorMin = Vector2.zero;
+            rectTransform.anchorMax = Vector2.zero;
+
+            // Resetting the rect to its initial position, width, and height.
+            rectTransform.pivot = initialPivot;
+            rectTransform.localPosition = rectInitialPosition;
+
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Vertical , thisRectHeight );
+            rectTransform.SetSizeWithCurrentAnchors ( RectTransform.Axis.Horizontal , thisRectWidth );
+        }
+
+        public static void SetRectToAnchor ( RectTransform rect )
+        {
+            rectTransform = rect;
+            initialPivot = rectTransform.pivot;
+
+            rectTransform.pivot = initialPivot;
+
+            rectTransform.offsetMin = Vector2.zero;
+            rectTransform.offsetMax = Vector2.zero;
+        }
+
+
+    }
+}

Assets/Airy UI/Scripts/Anchors.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 1908b58820c26f94489349886e3424cf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 0f44a0ceee9527f4a99c043c83e5d37d, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/Anchors.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/AnimatedElement.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 9a8dff8c7bdaea24098c5c167c761c64
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 300
+  icon: {fileID: 2800000, guid: 3a66e1d307308d041a8b9c7a714f2639, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/AnimatedElement.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/AnimatedElementsGroup.cs

@@ -0,0 +1,108 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine.Events;
+using UnityEditor;
+
+namespace AiryUI
+{
+
+
+    [DisallowMultipleComponent]
+    [AddComponentMenu ( "Airy UI/Animated Elements Group" )]
+    public class AnimatedElementsGroup : MonoBehaviour
+    {
+
+
+        [Tooltip ( "Aniamted elements managed by this Animation Manager" )]
+        public List<AnimatedElement> animatedElements = new List<AnimatedElement> ();
+
+
+        [Tooltip ( "TRUE: the Animated Elements linked to this group will be animated when this game object is enabled.\nFALSE: every animated element linked to this group is on it own." )]
+        public bool showAnimaitonOnEnable;
+
+
+        public UnityEvent OnShow;
+        public UnityEvent OnHide;
+
+
+
+        //====================================
+
+
+
+        private void OnEnable ()
+        {
+            animatedElements.RemoveAll ( a => a == null );
+
+            foreach ( var item in animatedElements )
+            {
+                if ( item.group == null )
+                    item.group = this;
+            }
+
+            if ( showAnimaitonOnEnable )
+            {
+                ShowGroup ();
+            }
+        }
+
+
+        public void ShowGroup ()
+        {
+            gameObject.SetActive ( true );
+
+            foreach ( var element in animatedElements )
+            {
+                element.ShowElement ();
+            }
+
+            OnShow?.Invoke ();
+        }
+
+
+        public void HideGroup ()
+        {
+            foreach ( var element in animatedElements )
+            {
+                element.HideElement ();
+            }
+
+            OnHide?.Invoke ();
+        }
+
+
+        public void UpdateElementsInChildren ()
+        {
+            animatedElements = GetComponentsInChildren<AnimatedElement> ( true ).Where ( a => a.isControlledByGroup ).ToList ();
+
+            foreach ( var c in animatedElements )
+            {
+                c.group = this;
+            }
+        }
+
+
+#if UNITY_EDITOR
+
+
+        [MenuItem ( "GameObject/Airy UI/Animated Elements Group" , false , 0 )]
+        private static void HierarchyCreateMenu ( MenuCommand menuCommand )
+        {
+            GameObject newGameObject = new GameObject ( "Animated Elements Group" );
+
+            newGameObject.AddComponent<AnimatedElementsGroup> ();
+
+            GameObjectUtility.SetParentAndAlign ( newGameObject , menuCommand.context as GameObject );
+
+            Undo.RegisterCreatedObjectUndo ( newGameObject , "Create " + newGameObject.name );
+
+            Selection.activeObject = newGameObject;
+        }
+
+
+#endif
+
+
+    }
+}

Assets/Airy UI/Scripts/AnimatedElementsGroup.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 048ea60d7d5ddcb4f9571521619af551
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 400
+  icon: {fileID: 2800000, guid: 20e204a63dd92db4789aa5672485efb3, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/AnimatedElementsGroup.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/AnimationPositions.cs

@@ -0,0 +1,187 @@
+using UnityEngine;
+
+namespace AiryUI
+{
+    public class AnimationPositions : MonoBehaviour
+    {
+
+
+        /// <summary>
+        /// Used for initializing the position from a certian corner.
+        /// </summary>
+        /// <param name="initialPosition">the start position of the transform</param>
+        /// <param name="rectTransform">the rect transform</param>
+        /// <param name="animationStartPosition">BottomRight, UpRight, BottomLeft, UpLeft, Up, Bottom, Left, Or Right</param>
+        /// <param name="animationFromCornerStartFromType">Screen or Rect</param>
+        /// <returns></returns>
+        public static Vector3 GetStartPositionFromCorner
+            ( Vector3 initialPosition , RectTransform rectTransform , AnimationStartPosition animationStartPosition )
+        {
+            float startPositionX = 0;
+            float startPositionY = 0;
+
+            var containerCanvas = rectTransform.GetComponent<AnimatedElement> ().containerCanvas;
+            var canvasRect = containerCanvas.GetComponent<RectTransform> ();
+
+            switch ( animationStartPosition )
+            {
+                case ( AnimationStartPosition.Up ):
+
+                    startPositionX = initialPosition.x;
+                    startPositionY = ( canvasRect.sizeDelta.y / 2 ) + ( rectTransform.rect.height / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.Bottom ):
+
+                    startPositionX = initialPosition.x;
+                    startPositionY = -( canvasRect.sizeDelta.y / 2 ) - ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.Left ):
+
+                    startPositionX = -( canvasRect.sizeDelta.x / 2 ) - ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = initialPosition.y;
+
+                    break;
+
+                case ( AnimationStartPosition.Right ):
+
+                    startPositionX = ( canvasRect.sizeDelta.x / 2 ) + ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = initialPosition.y;
+
+                    break;
+
+                case ( AnimationStartPosition.BottomRight ):
+
+                    startPositionX = ( canvasRect.sizeDelta.x / 2 ) + ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = -( canvasRect.sizeDelta.y / 2 ) - ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.BottomLeft ):
+
+                    startPositionX = -( canvasRect.sizeDelta.x / 2 ) - ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = -( canvasRect.sizeDelta.y / 2 ) - ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.UpRight ):
+
+                    startPositionX = ( canvasRect.sizeDelta.x / 2 ) + ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = ( canvasRect.sizeDelta.y / 2 ) + ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+
+                    break;
+
+                case ( AnimationStartPosition.UpLeft ):
+
+                    startPositionX = -( canvasRect.sizeDelta.x / 2 ) - ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = ( canvasRect.sizeDelta.y / 2 ) + ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.Center ):
+
+                    startPositionX = 0;
+                    startPositionY = 0;
+
+                    break;
+
+                case ( AnimationStartPosition.UpCenter ):
+
+                    startPositionX = 0;
+                    startPositionY = ( canvasRect.sizeDelta.y / 2 ) + ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.BottomCenter ):
+
+                    startPositionX = 0;
+                    startPositionY = -( canvasRect.sizeDelta.y / 2 ) - ( rectTransform.rect.height * rectTransform.localScale.y / 2 );
+
+                    break;
+
+                case ( AnimationStartPosition.RightCenter ):
+
+                    startPositionX = ( canvasRect.sizeDelta.x / 2 ) + ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = 0;
+
+                    break;
+
+                case ( AnimationStartPosition.LeftCenter ):
+
+                    startPositionX = -( canvasRect.sizeDelta.x / 2 ) - ( rectTransform.rect.width * rectTransform.localScale.x / 2 );
+                    startPositionY = 0;
+
+                    break;
+            }
+
+            Vector3 startPos = new Vector3 ( startPositionX , startPositionY , 0 );
+
+
+            //==============================================================================================
+
+
+            Vector3 addedVector = Vector3.zero;
+            var parent = rectTransform.parent;
+            var parentLocalPosition = parent.gameObject.Equals ( containerCanvas.gameObject ) ? Vector3.zero : parent.localPosition;
+
+
+            switch ( animationStartPosition )
+            {
+                case ( AnimationStartPosition.Center ):
+
+                    addedVector = new Vector3 ( -parentLocalPosition.x , -parentLocalPosition.y , 0 );
+                    startPos = new Vector3 ( startPos.x + addedVector.x , startPos.y + addedVector.y , 0 );
+
+                    break;
+
+                case ( AnimationStartPosition.Up ):
+                case ( AnimationStartPosition.Bottom ):
+
+                    addedVector = new Vector3 ( 0 , -parentLocalPosition.y , 0 );
+                    startPos = startPos + addedVector;
+
+                    break;
+
+                case ( AnimationStartPosition.Right ):
+                case ( AnimationStartPosition.Left ):
+
+                    addedVector = new Vector3 ( -parentLocalPosition.x , 0 , 0 );
+                    startPos = startPos + addedVector;
+
+                    break;
+
+                case ( AnimationStartPosition.UpCenter ):
+                case ( AnimationStartPosition.BottomCenter ):
+
+                    addedVector = new Vector3 ( 0 , -parentLocalPosition.y , 0 );
+                    startPos = new Vector3 ( -parentLocalPosition.x , startPos.y + addedVector.y , 0 );
+
+                    break;
+
+                case ( AnimationStartPosition.RightCenter ):
+                case ( AnimationStartPosition.LeftCenter ):
+
+                    addedVector = new Vector3 ( -parentLocalPosition.x , 0 , 0 );
+                    startPos = new Vector3 ( startPos.x + addedVector.x , -parentLocalPosition.y , 0 );
+
+                    break;
+
+                case ( AnimationStartPosition.UpLeft ):
+                case ( AnimationStartPosition.UpRight ):
+                case ( AnimationStartPosition.BottomLeft ):
+                case ( AnimationStartPosition.BottomRight ):
+
+                    addedVector = new Vector3 ( -parentLocalPosition.x , -parentLocalPosition.y , 0 );
+                    startPos = startPos + addedVector;
+
+                    break;
+            }
+
+            return ( startPos );
+        }
+    }
+}

Assets/Airy UI/Scripts/AnimationPositions.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 28ab1c11203c7df43bb2e04b9dbae4dd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 0727ad002e9a86b499cb1f23b7bf175b, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/AnimationPositions.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/CloseButton.cs

@@ -0,0 +1,51 @@
+using UnityEngine;
+
+
+
+namespace AiryUI
+{
+
+
+    [DisallowMultipleComponent]
+    public abstract class CloseButton : MonoBehaviour
+    {
+
+
+        public BackButtonAffects backButtonAffects;
+        public AnimatedElement affectedAnimatedElement;
+        public AnimatedElementsGroup affectedAnimatedElementsGroup;
+
+
+
+        public virtual void DoBack ()
+        {
+            if ( backButtonAffects == BackButtonAffects.AnimatedElement )
+            {
+                if ( affectedAnimatedElementsGroup == null )
+                {
+                    Debug.LogError ( "<color=orange><b>[Airy UI]</color></b> <color=red><b>X</color></b> Affected Animated Element is null, please set it" , gameObject );
+                    return;
+                }
+
+                affectedAnimatedElement.HideElement ();
+            }
+            else if ( backButtonAffects == BackButtonAffects.AnimatedElementsGroup )
+            {
+                if ( affectedAnimatedElementsGroup == null )
+                {
+                    Debug.LogError ( "<color=orange><b>[Airy UI]</color></b> <color=red><b>X</color></b> Affected Animated Elements Group is null, please set it" , gameObject );
+                    return;
+                }
+
+                affectedAnimatedElementsGroup.HideGroup ();
+            }
+        }
+
+
+    }
+
+
+    public enum BackButtonAffects { AnimatedElement, AnimatedElementsGroup }
+
+
+}

Assets/Airy UI/Scripts/CloseButton.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2858f6c67272dd14383549fcdd22c15a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 16954819a70521f49a68dbfc436a4076, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/CloseButton.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/CustomAnimatedElement.cs

@@ -0,0 +1,993 @@
+using System.Collections;
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+
+namespace AiryUI
+{
+    [AddComponentMenu("Airy UI/CustomAnimated Element")]
+    public class CustomAnimatedElement : AnimatedElement
+    {
+        public ComponentsToAnimate componentsToAnimate_SHOW;
+        public ComponentsToAnimate componentsToAnimate_HIDE;
+
+        public List<TransformAnimationRecord> TransformAnimationRecords_SHOW = new List<TransformAnimationRecord>();
+        public List<GraphicAnimationRecord> GraphicAnimationRecords_SHOW = new List<GraphicAnimationRecord>();
+        public List<TransformAndGraphicAnimationRecord> TransformAndGraphicAnimationRecords_SHOW = new List<TransformAndGraphicAnimationRecord>();
+
+        public List<TransformAnimationRecord> TransformAnimationRecords_HIDE = new List<TransformAnimationRecord>();
+        public List<GraphicAnimationRecord> GraphicAnimationRecords_HIDE = new List<GraphicAnimationRecord>();
+        public List<TransformAndGraphicAnimationRecord> TransformAndGraphicAnimationRecords_HIDE = new List<TransformAndGraphicAnimationRecord>();
+
+        [Min(0.01f)] public float currentRecordDuration = 0.5f;
+        public float currentRecordDelay = 0;
+
+        public bool loop = false;
+
+        private GraphicType graphicType;
+
+        private Graphic graphic;
+        private Image img;
+        //private Text txt;
+        private TextMeshPro txt_m;
+
+        private TransformAnimationRecord initialRectValues;
+        private GraphicAnimationRecord initialGraphicValues;
+
+        private TransformAnimationRecord transformRecord_beforeRecrod;
+        private GraphicAnimationRecord graphicRecord_beforeRecrod;
+        private TransformAndGraphicAnimationRecord transformAndGraphicRecord_beforeRecrod;
+
+        private void Awake()
+        {
+            currentRunningCoroutine = EmptyCoroutine();
+
+            rectTransformComponent = GetComponent<RectTransform>();
+            graphic = GetComponent<Graphic>();
+
+            InitializeValues();
+        }
+
+        private void Start()
+        {
+            if (!initializeComplete)
+                InitializeValues();
+        }
+
+        private void OnEnable()
+        {
+            if (animateOnEnable)
+            {
+                ShowElement();
+            }
+        }
+
+        private void InitializeValues()
+        {
+            initialRectValues = new TransformAnimationRecord()
+            {
+                Position = rectTransformComponent.localPosition,
+                Scale = rectTransformComponent.localScale,
+                Rotation = rectTransformComponent.eulerAngles,
+            };
+
+            if (graphic)
+            {
+                if (graphic is Image)
+                {
+                    graphicType = GraphicType.Image;
+                    img = GetComponent<Image>();
+                }
+                // else if (graphic is Text)
+                // {
+                //     graphicType = GraphicType.Text;
+                //     txt = GetComponent<Text>();
+                // }
+                else if (graphic is TextMeshProUGUI)
+                {
+                    graphicType = GraphicType.Text;
+                    txt_m = GetComponent<TextMeshPro>();
+                }
+
+                initialGraphicValues = new GraphicAnimationRecord()
+                {
+                    Color = graphic.color,
+                    Sprite = (graphicType == GraphicType.Image) ? img?.sprite : null,
+                    Text = (graphicType == GraphicType.Text) ? txt_m?.text : "",
+                };
+            }
+        }
+
+        public override void ShowElement()
+        {
+            gameObject.SetActive(true);
+            StopAllCoroutines();
+
+            if (disableShowAnimation)
+            {
+                OnShowComplete.Invoke();
+
+                return;
+            }
+
+            if (!initializeComplete)
+                InitializeValues();
+
+            switch (componentsToAnimate_SHOW)
+            {
+                case (ComponentsToAnimate.Transform):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateTransform_SHOW();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+
+                case (ComponentsToAnimate.Graphic):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateGraphic_SHOW();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+
+                case (ComponentsToAnimate.Both):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateTransformAndGraphic_SHOW();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+            }
+        }
+
+
+        public override void HideElement()
+        {
+            OnHideComplete.AddListener(ResetAll);
+
+            if (disableHideAnimation)
+            {
+                OnHideComplete.Invoke();
+
+                return;
+            }
+
+            switch (componentsToAnimate_HIDE)
+            {
+                case (ComponentsToAnimate.Transform):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateTransform_HIDE();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+
+                case (ComponentsToAnimate.Graphic):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateGraphic_HIDE();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+
+                case (ComponentsToAnimate.Both):
+
+                    if (currentRunningCoroutine != null)
+                        StopCoroutine(currentRunningCoroutine);
+
+                    currentRunningCoroutine = AnimateTransformAndGraphic_HIDE();
+                    StartCoroutine(currentRunningCoroutine);
+
+                    break;
+            }
+        }
+
+        #region Show Coroutines
+
+
+        private IEnumerator AnimateTransform_SHOW()
+        {
+            if (delayEnabled)
+                yield return WaitForSeconds_SHOW(showDelay);
+
+            if (TransformAnimationRecords_SHOW.Count > 1)
+            {
+                if (loop)
+                {
+                    while (true)
+                    {
+                        if (OnShow != null)
+                            OnShow.Invoke();
+
+                        for (int i = 1; i < TransformAnimationRecords_SHOW.Count; i++)
+                        {
+                            yield return WaitForSeconds_SHOW(TransformAnimationRecords_SHOW[i - 1].Delay);
+
+                            float elapsedTime = 0;
+                            while (elapsedTime <= TransformAnimationRecords_SHOW[i - 1].Duration)
+                            {
+                                float t = elapsedTime / TransformAnimationRecords_SHOW[i - 1].Duration;
+
+                                rectTransformComponent.localPosition = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Position, TransformAnimationRecords_SHOW[i].Position, t);
+                                rectTransformComponent.localScale = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Scale, TransformAnimationRecords_SHOW[i].Scale, t);
+
+                                rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Rotation, TransformAnimationRecords_SHOW[i].Rotation, t);
+
+                                elapsedTime += DeltaTimeFor_SHOW;
+                                yield return (null);
+                            }
+
+                            #region Set Final Values
+
+                            rectTransformComponent.localPosition = TransformAnimationRecords_SHOW[i].Position;
+                            rectTransformComponent.localScale = TransformAnimationRecords_SHOW[i].Scale;
+                            rectTransformComponent.eulerAngles = TransformAnimationRecords_SHOW[i].Rotation;
+
+                            #endregion
+                        }
+
+                        if (OnShowComplete != null)
+                            OnShowComplete.Invoke();
+                    }
+                }
+                else
+                {
+                    if (OnShow != null)
+                        OnShow.Invoke();
+
+                    for (int i = 1; i < TransformAnimationRecords_SHOW.Count; i++)
+                    {
+                        yield return WaitForSeconds_SHOW(TransformAnimationRecords_SHOW[i - 1].Delay);
+
+                        float elapsedTime = 0;
+                        while (elapsedTime <= TransformAnimationRecords_SHOW[i - 1].Duration)
+                        {
+                            float t = elapsedTime / TransformAnimationRecords_SHOW[i - 1].Duration;
+
+                            rectTransformComponent.localPosition = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Position, TransformAnimationRecords_SHOW[i].Position, t);
+                            rectTransformComponent.localScale = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Scale, TransformAnimationRecords_SHOW[i].Scale, t);
+
+                            rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAnimationRecords_SHOW[i - 1].Rotation, TransformAnimationRecords_SHOW[i].Rotation, t);
+
+                            elapsedTime += DeltaTimeFor_SHOW;
+                            yield return (null);
+                        }
+
+                        #region Set Final Values
+
+                        rectTransformComponent.localPosition = TransformAnimationRecords_SHOW[i].Position;
+                        rectTransformComponent.localScale = TransformAnimationRecords_SHOW[i].Scale;
+                        rectTransformComponent.eulerAngles = TransformAnimationRecords_SHOW[i].Rotation;
+
+                        #endregion
+                    }
+
+                    if (OnShowComplete != null)
+                        OnShowComplete.Invoke();
+                }
+            }
+        }
+
+        private IEnumerator AnimateGraphic_SHOW()
+        {
+            if (delayEnabled)
+                yield return WaitForSeconds_SHOW(showDelay);
+
+            if (GraphicAnimationRecords_SHOW.Count > 1)
+            {
+                if (loop)
+                {
+                    while (true)
+                    {
+                        if (OnShow != null)
+                            OnShow.Invoke();
+
+                        for (int i = 1; i < GraphicAnimationRecords_SHOW.Count; i++)
+                        {
+                            yield return WaitForSeconds_SHOW(GraphicAnimationRecords_SHOW[i - 1].Delay);
+
+                            float elapsedTime = 0;
+                            while (elapsedTime <= GraphicAnimationRecords_SHOW[i - 1].Duration)
+                            {
+                                float t = elapsedTime / GraphicAnimationRecords_SHOW[i - 1].Duration;
+
+                                if (graphicType == GraphicType.Image)
+                                {
+                                    Image img = graphic as Image;
+                                    if (GraphicAnimationRecords_SHOW[i - 1].Sprite)
+                                    {
+                                        img.sprite = GraphicAnimationRecords_SHOW[i - 1].Sprite;
+                                    }
+                                    img.color = Color.Lerp(GraphicAnimationRecords_SHOW[i - 1].Color, GraphicAnimationRecords_SHOW[i].Color, t);
+                                }
+
+                                else if (graphicType == GraphicType.Text)
+                                {
+                                    TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                    if (!string.IsNullOrEmpty(GraphicAnimationRecords_SHOW[i - 1].Text))
+                                    {
+                                        txt.text = GraphicAnimationRecords_SHOW[i - 1].Text;
+                                        txt.color = Color.Lerp(GraphicAnimationRecords_SHOW[i - 1].Color, GraphicAnimationRecords_SHOW[i].Color, t);
+                                    }
+                                }
+
+                                elapsedTime += DeltaTimeFor_SHOW;
+                                yield return (null);
+                            }
+
+                            #region Set Final Values
+
+                            if (graphicType == GraphicType.Image)
+                            {
+                                Image img = graphic as Image;
+                                img.sprite = GraphicAnimationRecords_SHOW[i].Sprite;
+                                img.color = GraphicAnimationRecords_SHOW[i].Color;
+                            }
+                            else if (graphicType == GraphicType.Text)
+                            {
+                                TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                txt.text = GraphicAnimationRecords_SHOW[i].Text;
+                                txt.color = GraphicAnimationRecords_SHOW[i].Color;
+                            }
+
+                            #endregion
+                        }
+
+                        if (OnShowComplete != null)
+                            OnShowComplete.Invoke();
+                    }
+                }
+                else
+                {
+                    if (OnShow != null)
+                        OnShow.Invoke();
+
+                    for (int i = 1; i < GraphicAnimationRecords_SHOW.Count; i++)
+                    {
+                        yield return WaitForSeconds_SHOW(GraphicAnimationRecords_SHOW[i - 1].Delay);
+
+                        float elapsedTime = 0;
+                        while (elapsedTime <= GraphicAnimationRecords_SHOW[i - 1].Duration)
+                        {
+                            float t = elapsedTime / GraphicAnimationRecords_SHOW[i - 1].Duration;
+
+                            if (graphicType == GraphicType.Image)
+                            {
+                                Image img = graphic as Image;
+                                if (GraphicAnimationRecords_SHOW[i - 1].Sprite)
+                                    img.sprite = GraphicAnimationRecords_SHOW[i - 1].Sprite;
+                                img.color = Color.Lerp(GraphicAnimationRecords_SHOW[i - 1].Color, GraphicAnimationRecords_SHOW[i].Color, t);
+                            }
+
+                            else if (graphicType == GraphicType.Text)
+                            {
+                                TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                if (!string.IsNullOrEmpty(GraphicAnimationRecords_SHOW[i - 1].Text))
+                                    txt.text = GraphicAnimationRecords_SHOW[i - 1].Text;
+                                txt.color = Color.Lerp(GraphicAnimationRecords_SHOW[i - 1].Color, GraphicAnimationRecords_SHOW[i].Color, t);
+                            }
+
+                            elapsedTime += DeltaTimeFor_SHOW;
+                            yield return (null);
+                        }
+
+                        #region Set Final Values
+
+                        if (graphicType == GraphicType.Image)
+                        {
+                            Image img = graphic as Image;
+                            if (GraphicAnimationRecords_SHOW[i].Sprite)
+                                img.sprite = GraphicAnimationRecords_SHOW[i].Sprite;
+                            img.color = GraphicAnimationRecords_SHOW[i].Color;
+                        }
+                        else if (graphicType == GraphicType.Text)
+                        {
+                            TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                            if (!string.IsNullOrEmpty(GraphicAnimationRecords_SHOW[i].Text))
+                                txt.text = GraphicAnimationRecords_SHOW[i].Text;
+                            txt.color = GraphicAnimationRecords_SHOW[i].Color;
+                        }
+
+                        #endregion
+                    }
+
+                    if (OnShowComplete != null)
+                        OnShowComplete.Invoke();
+                }
+            }
+        }
+
+        private IEnumerator AnimateTransformAndGraphic_SHOW()
+        {
+            if (TransformAndGraphicAnimationRecords_SHOW.Count > 1)
+            {
+                if (delayEnabled)
+                    yield return WaitForSeconds_SHOW(showDelay);
+
+                if (loop)
+                {
+                    while (true)
+                    {
+                        if (OnShow != null)
+                            OnShow.Invoke();
+
+                        for (int i = 1; i < TransformAndGraphicAnimationRecords_SHOW.Count; i++)
+                        {
+                            yield return WaitForSeconds_SHOW(TransformAndGraphicAnimationRecords_SHOW[i - 1].Delay);
+
+                            float elapsedTime = 0;
+                            while (elapsedTime <= TransformAndGraphicAnimationRecords_SHOW[i - 1].Duration)
+                            {
+                                float t = elapsedTime / TransformAndGraphicAnimationRecords_SHOW[i - 1].Duration;
+
+                                rectTransformComponent.localPosition = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Position, TransformAndGraphicAnimationRecords_SHOW[i].Position, t);
+                                rectTransformComponent.localScale = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Scale, TransformAndGraphicAnimationRecords_SHOW[i].Scale, t);
+                                rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Rotation, TransformAndGraphicAnimationRecords_SHOW[i].Rotation, t);
+
+                                if (graphicType == GraphicType.Image)
+                                {
+                                    Image img = graphic as Image;
+                                    if (TransformAndGraphicAnimationRecords_SHOW[i - 1].Sprite)
+                                    {
+                                        img.sprite = TransformAndGraphicAnimationRecords_SHOW[i - 1].Sprite;
+                                    }
+                                    img.color = Color.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Color, TransformAndGraphicAnimationRecords_SHOW[i].Color, t);
+                                }
+
+                                else if (graphicType == GraphicType.Text)
+                                {
+                                    TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                    if (!string.IsNullOrEmpty(TransformAndGraphicAnimationRecords_SHOW[i - 1].Text))
+                                    {
+                                        txt.text = TransformAndGraphicAnimationRecords_SHOW[i - 1].Text;
+                                    }
+                                    txt.color = Color.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Color, TransformAndGraphicAnimationRecords_SHOW[i].Color, t);
+                                }
+
+                                elapsedTime += DeltaTimeFor_SHOW;
+                                yield return (null);
+                            }
+
+                            #region Set Final Values
+
+                            rectTransformComponent.localPosition = TransformAndGraphicAnimationRecords_SHOW[i].Position;
+                            rectTransformComponent.localScale = TransformAndGraphicAnimationRecords_SHOW[i].Scale;
+                            rectTransformComponent.eulerAngles = TransformAndGraphicAnimationRecords_SHOW[i].Rotation;
+
+                            if (graphicType == GraphicType.Image)
+                            {
+                                Image img = graphic as Image;
+                                if (TransformAndGraphicAnimationRecords_SHOW[i].Sprite)
+                                    img.color = TransformAndGraphicAnimationRecords_SHOW[i].Color;
+                            }
+                            else if (graphicType == GraphicType.Text)
+                            {
+                                TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                if (!string.IsNullOrEmpty(TransformAndGraphicAnimationRecords_SHOW[i].Text))
+                                    txt.color = TransformAndGraphicAnimationRecords_SHOW[i].Color;
+                            }
+
+                            #endregion
+                        }
+
+                        if (OnShowComplete != null)
+                            OnShowComplete.Invoke();
+                    }
+                }
+                else
+                {
+
+                    if (OnShow != null)
+                        OnShow.Invoke();
+
+                    for (int i = 1; i < TransformAndGraphicAnimationRecords_SHOW.Count; i++)
+                    {
+                        yield return WaitForSeconds_SHOW(TransformAndGraphicAnimationRecords_SHOW[i - 1].Delay);
+
+                        float elapsedTime = 0;
+                        while (elapsedTime <= TransformAndGraphicAnimationRecords_SHOW[i - 1].Duration)
+                        {
+                            float t = elapsedTime / TransformAndGraphicAnimationRecords_SHOW[i - 1].Duration;
+
+                            rectTransformComponent.localPosition = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Position, TransformAndGraphicAnimationRecords_SHOW[i].Position, t);
+                            rectTransformComponent.localScale = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Scale, TransformAndGraphicAnimationRecords_SHOW[i].Scale, t);
+                            rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Rotation, TransformAndGraphicAnimationRecords_SHOW[i].Rotation, t);
+
+                            if (graphicType == GraphicType.Image)
+                            {
+                                Image img = graphic as Image;
+                                if (TransformAndGraphicAnimationRecords_SHOW[i - 1].Sprite)
+                                    img.sprite = TransformAndGraphicAnimationRecords_SHOW[i - 1].Sprite;
+
+                                img.color = Color.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Color, TransformAndGraphicAnimationRecords_SHOW[i].Color, t);
+                            }
+
+                            else if (graphicType == GraphicType.Text)
+                            {
+                                TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                                if (!string.IsNullOrEmpty(TransformAndGraphicAnimationRecords_SHOW[i - 1].Text))
+                                    txt.text = TransformAndGraphicAnimationRecords_SHOW[i - 1].Text;
+
+                                txt.color = Color.Lerp(TransformAndGraphicAnimationRecords_SHOW[i - 1].Color, TransformAndGraphicAnimationRecords_SHOW[i].Color, t);
+                            }
+
+                            elapsedTime += DeltaTimeFor_SHOW;
+                            yield return (null);
+                        }
+
+                        #region Set Final Values
+
+                        rectTransformComponent.localPosition = TransformAndGraphicAnimationRecords_SHOW[i].Position;
+                        rectTransformComponent.localScale = TransformAndGraphicAnimationRecords_SHOW[i].Scale;
+                        rectTransformComponent.eulerAngles = TransformAndGraphicAnimationRecords_SHOW[i].Rotation;
+
+                        if (graphicType == GraphicType.Image)
+                        {
+                            Image img = graphic as Image;
+                            img.color = TransformAndGraphicAnimationRecords_SHOW[i].Color;
+                        }
+                        else if (graphicType == GraphicType.Text)
+                        {
+                            TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                            txt.color = TransformAndGraphicAnimationRecords_SHOW[i].Color;
+                        }
+
+                        #endregion
+                    }
+
+                    if (OnShowComplete != null)
+                        OnShowComplete.Invoke();
+                }
+            }
+        }
+
+
+        #endregion
+
+        //==========================================================================================
+        //==========================================================================================
+
+        #region Hide Coroutines
+
+        private IEnumerator AnimateTransform_HIDE()
+        {
+            if (delayEnabled)
+                yield return WaitForSeconds_HIDE(hideDelay);
+
+            if (OnShow != null)
+                OnShow.Invoke();
+
+            for (int i = 1; i < TransformAnimationRecords_HIDE.Count; i++)
+            {
+                yield return WaitForSeconds_HIDE(TransformAnimationRecords_HIDE[i - 1].Delay);
+
+                float elapsedTime = 0;
+                while (elapsedTime <= TransformAnimationRecords_HIDE[i - 1].Duration)
+                {
+                    float t = elapsedTime / TransformAnimationRecords_HIDE[i - 1].Duration;
+
+                    rectTransformComponent.localPosition = Vector3.Lerp(TransformAnimationRecords_HIDE[i - 1].Position, TransformAnimationRecords_HIDE[i].Position, t);
+                    rectTransformComponent.localScale = Vector3.Lerp(TransformAnimationRecords_HIDE[i - 1].Scale, TransformAnimationRecords_HIDE[i].Scale, t);
+                    rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAnimationRecords_HIDE[i - 1].Rotation, TransformAnimationRecords_HIDE[i].Rotation, t);
+
+                    elapsedTime += DeltaTimeFor_HIDE;
+                    yield return (null);
+                }
+
+                #region Set Final Values
+
+                rectTransformComponent.localPosition = TransformAnimationRecords_HIDE[i].Position;
+                rectTransformComponent.localScale = TransformAnimationRecords_HIDE[i].Scale;
+                rectTransformComponent.eulerAngles = TransformAnimationRecords_HIDE[i].Rotation;
+
+                #endregion
+            }
+
+            gameObject.SetActive(false);
+
+            if (OnHideComplete != null)
+                OnHideComplete.Invoke();
+        }
+
+        private IEnumerator AnimateGraphic_HIDE()
+        {
+            if (delayEnabled)
+                yield return WaitForSeconds_HIDE(hideDelay);
+
+            if (OnShow != null)
+                OnShow.Invoke();
+
+            for (int i = 1; i < GraphicAnimationRecords_HIDE.Count; i++)
+            {
+                yield return WaitForSeconds_HIDE(GraphicAnimationRecords_HIDE[i - 1].Delay);
+
+                float elapsedTime = 0;
+                while (elapsedTime <= GraphicAnimationRecords_HIDE[i - 1].Duration)
+                {
+                    float t = elapsedTime / GraphicAnimationRecords_HIDE[i - 1].Duration;
+
+                    if (graphicType == GraphicType.Image)
+                    {
+                        Image img = graphic as Image;
+                        if (GraphicAnimationRecords_HIDE[i - 1].Sprite)
+                            img.sprite = GraphicAnimationRecords_HIDE[i - 1].Sprite;
+                        img.color = Color.Lerp(GraphicAnimationRecords_HIDE[i - 1].Color, GraphicAnimationRecords_HIDE[i].Color, t);
+                    }
+
+                    else if (graphicType == GraphicType.Text)
+                    {
+                        TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                        if (!string.IsNullOrEmpty(GraphicAnimationRecords_HIDE[i - 1].Text))
+                            txt.text = GraphicAnimationRecords_HIDE[i - 1].Text;
+                        txt.color = Color.Lerp(GraphicAnimationRecords_HIDE[i - 1].Color, GraphicAnimationRecords_HIDE[i].Color, t);
+                    }
+
+                    elapsedTime += DeltaTimeFor_HIDE;
+                    yield return (null);
+                }
+
+                #region Set Final Values
+
+                if (graphicType == GraphicType.Image)
+                {
+                    Image img = graphic as Image;
+                    img.color = GraphicAnimationRecords_HIDE[i].Color;
+                }
+                else if (graphicType == GraphicType.Text)
+                {
+                    TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                    txt.color = GraphicAnimationRecords_HIDE[i].Color;
+                }
+
+                #endregion
+            }
+
+            gameObject.SetActive(false);
+
+            if (OnHideComplete != null)
+                OnHideComplete.Invoke();
+        }
+
+        private IEnumerator AnimateTransformAndGraphic_HIDE()
+        {
+            if (delayEnabled)
+                yield return WaitForSeconds_HIDE(hideDelay);
+
+            if (OnShow != null)
+                OnShow.Invoke();
+
+            for (int i = 1; i < TransformAndGraphicAnimationRecords_HIDE.Count; i++)
+            {
+                yield return WaitForSeconds_HIDE(TransformAndGraphicAnimationRecords_HIDE[i - 1].Delay);
+
+                float elapsedTime = 0;
+                while (elapsedTime <= TransformAndGraphicAnimationRecords_HIDE[i - 1].Duration)
+                {
+                    float t = elapsedTime / TransformAndGraphicAnimationRecords_HIDE[i - 1].Duration;
+
+                    rectTransformComponent.localPosition = Vector3.Lerp(TransformAndGraphicAnimationRecords_HIDE[i - 1].Position, TransformAndGraphicAnimationRecords_HIDE[i].Position, t);
+                    rectTransformComponent.localScale = Vector3.Lerp(TransformAndGraphicAnimationRecords_HIDE[i - 1].Scale, TransformAndGraphicAnimationRecords_HIDE[i].Scale, t);
+                    rectTransformComponent.eulerAngles = Vector3.Lerp(TransformAndGraphicAnimationRecords_HIDE[i - 1].Rotation, TransformAndGraphicAnimationRecords_HIDE[i].Rotation, t);
+
+                    if (graphicType == GraphicType.Image)
+                    {
+                        Image img = graphic as Image;
+                        if (TransformAndGraphicAnimationRecords_HIDE[i].Sprite)
+                            img.sprite = TransformAndGraphicAnimationRecords_HIDE[i].Sprite;
+                        img.color = Color.Lerp(TransformAndGraphicAnimationRecords_HIDE[i - 1].Color, TransformAndGraphicAnimationRecords_HIDE[i].Color, t);
+                    }
+
+                    else if (graphicType == GraphicType.Text)
+                    {
+                        TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                        if (!string.IsNullOrEmpty(TransformAndGraphicAnimationRecords_HIDE[i].Text))
+                            txt.text = TransformAndGraphicAnimationRecords_HIDE[i].Text;
+                        txt.color = Color.Lerp(TransformAndGraphicAnimationRecords_HIDE[i - 1].Color, TransformAndGraphicAnimationRecords_HIDE[i].Color, t);
+                    }
+
+                    elapsedTime += DeltaTimeFor_HIDE;
+                    yield return (null);
+                }
+
+                #region Set Final Values
+
+                rectTransformComponent.localPosition = TransformAndGraphicAnimationRecords_HIDE[i].Position;
+                rectTransformComponent.localScale = TransformAndGraphicAnimationRecords_HIDE[i].Scale;
+                rectTransformComponent.eulerAngles = TransformAndGraphicAnimationRecords_HIDE[i].Rotation;
+
+                if (graphicType == GraphicType.Image)
+                {
+                    Image img = graphic as Image;
+                    if (TransformAndGraphicAnimationRecords_HIDE[i].Sprite)
+                        img.sprite = TransformAndGraphicAnimationRecords_HIDE[i].Sprite;
+                    img.color = TransformAndGraphicAnimationRecords_HIDE[i].Color;
+                }
+                else if (graphicType == GraphicType.Text)
+                {
+                    TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                    if (!string.IsNullOrEmpty(TransformAndGraphicAnimationRecords_HIDE[i].Text))
+                        txt.text = TransformAndGraphicAnimationRecords_HIDE[i].Text;
+                    txt.color = TransformAndGraphicAnimationRecords_HIDE[i].Color;
+                }
+
+                #endregion
+            }
+
+            gameObject.SetActive(false);
+
+            if (OnHideComplete != null)
+                OnHideComplete.Invoke();
+        }
+
+        #endregion
+
+        private void ResetAll()
+        {
+            rectTransformComponent.localPosition = initialRectValues.Position;
+            rectTransformComponent.localScale = initialRectValues.Scale;
+            rectTransformComponent.eulerAngles = initialRectValues.Rotation;
+
+            if (graphicType == GraphicType.Image)
+            {
+                Image img = graphic as Image;
+                img.sprite = initialGraphicValues.Sprite;
+                img.color = initialGraphicValues.Color;
+            }
+
+            else if (graphicType == GraphicType.Text)
+            {
+                TextMeshProUGUI txt = graphic as TextMeshProUGUI;
+                txt.text = initialGraphicValues.Text;
+                txt.color = initialGraphicValues.Color;
+            }
+        }
+
+        public void Record(GameObject gObject, AnimationShowOrHide showOrHide)
+        {
+            rectTransformComponent = gObject.GetComponent<RectTransform>();
+            graphic = gObject.GetComponent<Graphic>();
+
+            RecordValues(showOrHide, false);
+        }
+
+        public void EnterRecordMode(GameObject gObject, AnimationShowOrHide showOrHide)
+        {
+            rectTransformComponent = gObject.GetComponent<RectTransform>();
+            graphic = gObject.GetComponent<Graphic>();
+
+            transformRecord_beforeRecrod = null;
+            graphicRecord_beforeRecrod = null;
+            transformAndGraphicRecord_beforeRecrod = null;
+
+            RecordValues(showOrHide, true);
+        }
+
+        public void ExitRecordMode(GameObject gObject, AnimationShowOrHide showOrHide)
+        {
+            rectTransformComponent = gObject.GetComponent<RectTransform>();
+            graphic = gObject.GetComponent<Graphic>();
+
+            ReturnValuesAfterRecord(gObject, showOrHide);
+        }
+
+        private void RecordValues(AnimationShowOrHide showOrHide, bool recordModeActive)
+        {
+            ComponentsToAnimate componentsToAnimate = (showOrHide == AnimationShowOrHide.Show) ? componentsToAnimate_SHOW : componentsToAnimate_HIDE;
+
+            switch (componentsToAnimate)
+            {
+                case (ComponentsToAnimate.Transform):
+                    TransformAnimationRecord transformRecord = new TransformAnimationRecord()
+                    {
+                        Duration = currentRecordDuration,
+                        Delay = currentRecordDelay,
+
+                        Position = rectTransformComponent.localPosition,
+                        Scale = rectTransformComponent.localScale,
+                        Rotation = new Vector3
+                        (
+                            rectTransformComponent.eulerAngles.x > 180 ? rectTransformComponent.eulerAngles.x - 360 : rectTransformComponent.eulerAngles.x,
+                            rectTransformComponent.eulerAngles.y > 180 ? rectTransformComponent.eulerAngles.y - 360 : rectTransformComponent.eulerAngles.y,
+                            rectTransformComponent.eulerAngles.z > 180 ? rectTransformComponent.eulerAngles.z - 360 : rectTransformComponent.eulerAngles.z
+                        )
+                    };
+
+                    if (recordModeActive)
+                    {
+                        transformRecord_beforeRecrod = transformRecord;
+                        return;
+                    }
+
+                    if (showOrHide == AnimationShowOrHide.Show)
+                        TransformAnimationRecords_SHOW.Add(transformRecord);
+                    else
+                        TransformAnimationRecords_HIDE.Add(transformRecord);
+
+                    break;
+
+                case (ComponentsToAnimate.Graphic):
+                    if (graphic is Image)
+                    {
+                        img = graphic as Image;
+                        graphicType = GraphicType.Image;
+                    }
+                    else if (graphic is TextMeshPro)
+                    {
+                        txt_m = graphic as TextMeshPro;
+                        graphicType = GraphicType.Text;
+                    }
+
+                    GraphicAnimationRecord graphicRecord = new GraphicAnimationRecord()
+                    {
+                        Duration = currentRecordDuration,
+                        Delay = currentRecordDelay,
+
+                        Color = graphic.color,
+                        Sprite = (graphicType == GraphicType.Image) ? img.sprite : null,
+                        Text = (graphicType == GraphicType.Text) ? txt_m.text : ""
+                    };
+
+                    if (recordModeActive)
+                    {
+                        graphicRecord_beforeRecrod = graphicRecord;
+                        return;
+                    }
+
+                    if (showOrHide == AnimationShowOrHide.Show)
+                        GraphicAnimationRecords_SHOW.Add(graphicRecord);
+                    else
+                        GraphicAnimationRecords_HIDE.Add(graphicRecord);
+                    break;
+
+                case (ComponentsToAnimate.Both):
+                    if (graphic is Image)
+                    {
+                        img = graphic as Image;
+                        graphicType = GraphicType.Image;
+                    }
+                    else if (graphic is TextMeshProUGUI)
+                    {
+                        txt_m = graphic as TextMeshPro;
+                        graphicType = GraphicType.Text;
+                    }
+
+                    TransformAndGraphicAnimationRecord transformAndGrapihcRecord = new TransformAndGraphicAnimationRecord()
+                    {
+                        Duration = currentRecordDuration,
+                        Delay = currentRecordDelay,
+
+                        Position = rectTransformComponent.localPosition,
+                        Scale = rectTransformComponent.localScale,
+                        Rotation = new Vector3
+                        (
+                            rectTransformComponent.eulerAngles.x > 180 ? rectTransformComponent.eulerAngles.x - 360 : rectTransformComponent.eulerAngles.x,
+                            rectTransformComponent.eulerAngles.y > 180 ? rectTransformComponent.eulerAngles.y - 360 : rectTransformComponent.eulerAngles.y,
+                            rectTransformComponent.eulerAngles.z > 180 ? rectTransformComponent.eulerAngles.z - 360 : rectTransformComponent.eulerAngles.z
+                        ),
+
+                        Color = graphic.color,
+                        Sprite = (graphicType == GraphicType.Image) ? img.sprite : null,
+                        Text = (graphicType == GraphicType.Text) ? txt_m.text : ""
+                    };
+
+                    if (recordModeActive)
+                    {
+                        transformAndGraphicRecord_beforeRecrod = transformAndGrapihcRecord;
+                        return;
+                    }
+
+                    if (showOrHide == AnimationShowOrHide.Show)
+                        TransformAndGraphicAnimationRecords_SHOW.Add(transformAndGrapihcRecord);
+                    else
+                        TransformAndGraphicAnimationRecords_HIDE.Add(transformAndGrapihcRecord);
+
+                    break;
+            }
+        }
+
+        private void ReturnValuesAfterRecord(GameObject gObject, AnimationShowOrHide showOrHide)
+        {
+            ComponentsToAnimate componentsToAnimate = (showOrHide == AnimationShowOrHide.Show) ? componentsToAnimate_SHOW : componentsToAnimate_HIDE;
+
+            switch (componentsToAnimate)
+            {
+                case (ComponentsToAnimate.Transform):
+                    rectTransformComponent.localPosition = transformRecord_beforeRecrod.Position;
+                    rectTransformComponent.localScale = transformRecord_beforeRecrod.Scale;
+                    rectTransformComponent.eulerAngles = transformRecord_beforeRecrod.Rotation;
+
+                    break;
+                case (ComponentsToAnimate.Graphic):
+                    graphic.color = graphicRecord_beforeRecrod.Color;
+
+                    if (graphic is Image)
+                        gObject.GetComponent<Image>().sprite = graphicRecord_beforeRecrod.Sprite;
+                    else if (graphic is TextMeshProUGUI)
+                        gObject.GetComponent<TextMeshProUGUI>().text = graphicRecord_beforeRecrod.Text;
+
+                    break;
+                case (ComponentsToAnimate.Both):
+                    rectTransformComponent.localPosition = transformAndGraphicRecord_beforeRecrod.Position;
+                    rectTransformComponent.localScale = transformAndGraphicRecord_beforeRecrod.Scale;
+                    rectTransformComponent.eulerAngles = transformAndGraphicRecord_beforeRecrod.Rotation;
+
+                    graphic.color = transformAndGraphicRecord_beforeRecrod.Color;
+                    if (graphic is Image)
+                        gObject.GetComponent<Image>().sprite = transformAndGraphicRecord_beforeRecrod.Sprite;
+                    else if (graphic is TextMeshProUGUI)
+                        gObject.GetComponent<TextMeshProUGUI>().text = transformAndGraphicRecord_beforeRecrod.Text;
+
+                    break;
+            }
+
+            transformRecord_beforeRecrod = null;
+            graphicRecord_beforeRecrod = null;
+            transformAndGraphicRecord_beforeRecrod = null;
+        }
+
+        public enum ComponentsToAnimate
+        {
+            Transform = 0, Graphic = 1, Both = 2
+        }
+
+        public enum AnimationShowOrHide
+        {
+            Show = 0, Hide = 1
+        }
+
+        private enum GraphicType
+        {
+            Image = 0, Text = 1
+        }
+    }
+
+    [System.Serializable]
+    public class TransformAnimationRecord
+    {
+        public float Delay;
+        [Min(0.01f)] public float Duration = 0.5f;
+
+        public Vector3 Position;         // The anchored position.
+        public Vector3 Scale;
+        public Vector3 Rotation;
+    }
+
+    [System.Serializable]
+    public class GraphicAnimationRecord
+    {
+        public float Delay;
+        [Min(0.01f)] public float Duration = 0.5f;
+
+        [Tooltip("Only works if the game object has Image component")] public Sprite Sprite;
+        [Tooltip("Only works if the game object has Text component")] public string Text;
+        public Color Color;
+    }
+
+    [System.Serializable]
+    public class TransformAndGraphicAnimationRecord
+    {
+        public float Delay;
+        [Min(0.01f)] public float Duration = 0.5f;
+
+        public Vector3 Position;
+        public Vector3 Scale;
+        public Vector3 Rotation;
+
+        [Tooltip("Only works if the game object has Image component")] public Sprite Sprite;
+        [Tooltip("Only works if the game object has Text component")] public string Text;
+        public Color Color;
+    }
+}

Assets/Airy UI/Scripts/CustomAnimatedElement.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: c69e9fcc3b192734a80b5e34d3132db6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 7302f66924eef9247b9bc469e954b55c, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/CustomAnimatedElement.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/EscButtonController.cs

@@ -0,0 +1,77 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace AiryUI
+{
+
+
+    public class EscButtonController : MonoBehaviour
+    {
+
+
+        public List<EscCloseButton> esc_buttons = new List<EscCloseButton> ();
+
+
+        public static EscButtonController Instance;
+
+
+        private void Awake ()
+        {
+            if ( Instance == null )
+                Instance = this;
+            else
+                Destroy ( gameObject );
+        }
+
+
+        private void Update ()
+        {
+            if ( Input.GetKeyDown ( KeyCode.Escape ) )
+            {
+                DoBack ();
+            }
+        }
+
+
+        private void DoBack ()
+        {
+            if ( esc_buttons.Count > 0 )
+            {
+                var last_button = esc_buttons [ esc_buttons.Count - 1 ];
+
+                if ( last_button != null )
+                {
+                    last_button.DoBack ();
+                }
+                else
+                {
+                    Debug.LogError ( "<color=orange><b>[Airy UI]</color></b> <color=red><b>X</color></b> there's a missing item in <b>'ESC Button Controller'</b>, please check your list again!" , gameObject );
+                }
+            }
+        }
+
+
+        public void AddButtonToList ( EscCloseButton backButton )
+        {
+            if ( !esc_buttons.Contains ( backButton ) )
+            {
+                esc_buttons.Add ( backButton );
+            }
+        }
+
+
+        public void RemoveButtonFromList ( EscCloseButton backButton )
+        {
+            if ( esc_buttons.Contains ( backButton ) )
+            {
+                esc_buttons.Remove ( backButton );
+            }
+        }
+
+
+    }
+
+
+}

Assets/Airy UI/Scripts/EscButtonController.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 20d6b40c8f6527141812c945d9ab89a4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 385aabfb1d7577e4eab41a95a7aa5c6e, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/EscButtonController.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/EscCloseButton.cs

@@ -0,0 +1,118 @@
+using UnityEditor;
+using UnityEngine;
+
+
+namespace AiryUI
+{
+
+
+    [AddComponentMenu ( "Airy UI/Esc Close Button" )]
+    public class EscCloseButton : CloseButton
+    {
+
+
+        private EscButtonController manager;
+
+
+        private void Awake ()
+        {
+            InstantiateController ();
+
+            if ( backButtonAffects == BackButtonAffects.AnimatedElement )
+            {
+                if ( affectedAnimatedElement == null )
+                {
+                    Debug.LogError ( "<color=orange><b>[Airy UI]</color></b> <color=red><b>X</color></b> Affected Animated Element is null, please set it" , gameObject );
+                    return;
+                }
+
+                affectedAnimatedElement.OnShow.AddListener ( () => EscButtonController.Instance.AddButtonToList ( this ) );
+                affectedAnimatedElement.OnHide.AddListener ( () => EscButtonController.Instance.RemoveButtonFromList ( this ) );
+            }
+            else if ( backButtonAffects == BackButtonAffects.AnimatedElementsGroup )
+            {
+                if ( affectedAnimatedElementsGroup == null )
+                {
+                    Debug.LogError ( "<color=orange><b>[Airy UI]</color></b> <color=red><b>X</color></b> Affected Animated Elements Group is null, please set it" , gameObject );
+                    return;
+                }
+                affectedAnimatedElementsGroup.OnShow.AddListener ( () => EscButtonController.Instance.AddButtonToList ( this ) );
+                affectedAnimatedElementsGroup.OnHide.AddListener ( () => EscButtonController.Instance.RemoveButtonFromList ( this ) );
+            }
+
+        }
+
+
+        private void Start ()
+        {
+            InstantiateController ();
+        }
+
+
+        private void OnEnable ()
+        {
+            InstantiateController ();
+        }
+
+
+        private void OnValidate ()
+        {
+            InstantiateController ();
+
+            manager = FindObjectOfType<EscButtonController> ();
+
+            if ( manager != null )
+            {
+                if ( !manager.esc_buttons.Contains ( this ) )
+                {
+                    //manager.esc_buttons.Add ( this );
+                }
+            }
+        }
+
+
+        private void Reset ()
+        {
+            InstantiateController ();
+        }
+
+
+        public override void DoBack ()
+        {
+            base.DoBack ();
+        }
+
+
+        private void InstantiateController ()
+        {
+            if ( !FindObjectOfType<EscButtonController> () )
+            {
+                GameObject controller = new GameObject ( "[Airy UI] Esc Button Controller" );
+                controller.AddComponent<EscButtonController> ();
+            }
+        }
+
+
+#if UNITY_EDITOR
+
+
+        [MenuItem ( "GameObject/Airy UI/Esc Close Button" , false , 2 )]
+        private static void HierarchyCreateMenu ( MenuCommand menuCommand )
+        {
+            GameObject newGameObject = new GameObject ( "Esc Close Button" );
+
+            newGameObject.AddComponent<EscCloseButton> ();
+
+            GameObjectUtility.SetParentAndAlign ( newGameObject , menuCommand.context as GameObject );
+
+            Undo.RegisterCreatedObjectUndo ( newGameObject , "Create " + newGameObject.name );
+
+            Selection.activeObject = newGameObject;
+        }
+
+
+#endif
+
+
+    }
+}

Assets/Airy UI/Scripts/EscCloseButton.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 7f91f9ffb1c2c1041bff92bcaecf4752
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 135e03f43ae12554e87964b6cc57b425, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/EscCloseButton.cs
+  uploadId: 760159

Assets/Airy UI/Scripts/UICloseButton.cs

@@ -0,0 +1,93 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+
+
+namespace AiryUI
+{
+
+
+    [RequireComponent ( typeof ( Image ) )]
+    [RequireComponent ( typeof ( Button ) )]
+    [RequireComponent ( typeof ( AnimatedElement ) )]
+    [AddComponentMenu ( "Airy UI/UI Close Button" )]
+    public class UICloseButton : CloseButton
+    {
+
+
+        public Button buttonComponent;
+
+
+        private AnimatedElement myAnimatedElement;
+
+
+        private void Awake ()
+        {
+            buttonComponent = buttonComponent ? GetComponent<Button> () : buttonComponent;
+            myAnimatedElement = GetComponent<AnimatedElement> ();
+
+
+            buttonComponent.onClick.AddListener ( DoBack );
+
+
+            if ( backButtonAffects == BackButtonAffects.AnimatedElement && affectedAnimatedElement != null )
+            {
+                affectedAnimatedElement.OnShow.AddListener ( myAnimatedElement.ShowElement );
+            }
+            else if ( backButtonAffects == BackButtonAffects.AnimatedElementsGroup && affectedAnimatedElementsGroup != null && !affectedAnimatedElementsGroup.animatedElements.Contains ( myAnimatedElement ) )
+            {
+                affectedAnimatedElementsGroup.animatedElements.Add ( myAnimatedElement );
+            }
+        }
+
+
+        private void Reset ()
+        {
+            buttonComponent = GetComponent<Button> ();
+        }
+
+
+        private void OnValidate ()
+        {
+            buttonComponent = GetComponent<Button> ();
+
+            if ( backButtonAffects == BackButtonAffects.AnimatedElementsGroup && affectedAnimatedElementsGroup != null && !affectedAnimatedElementsGroup.animatedElements.Contains ( GetComponent<AnimatedElement> () ) )
+            {
+                affectedAnimatedElementsGroup.animatedElements.Add ( GetComponent<AnimatedElement> () );
+            }
+        }
+
+
+        public override void DoBack ()
+        {
+            base.DoBack ();
+
+            myAnimatedElement.HideElement ();
+        }
+
+
+#if UNITY_EDITOR
+
+
+        [MenuItem ( "GameObject/Airy UI/UI Close Button" , false , 1 )]
+        private static void HierarchyCreateMenu ( MenuCommand menuCommand )
+        {
+            GameObject newGameObject = new GameObject ( "UI Close Button" );
+
+            newGameObject.AddComponent<UICloseButton> ();
+
+            GameObjectUtility.SetParentAndAlign ( newGameObject , menuCommand.context as GameObject );
+
+            Undo.RegisterCreatedObjectUndo ( newGameObject , "Create " + newGameObject.name );
+
+            Selection.activeObject = newGameObject;
+        }
+
+
+#endif
+
+
+    }
+
+
+}

Assets/Airy UI/Scripts/UICloseButton.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 17cdd31cbca20554baf3a78326c9e6b7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: dac0515b2a64d0449b98bccca9da0dc0, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Scripts/UICloseButton.cs
+  uploadId: 760159

Assets/Airy UI/Sprites.meta

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

Assets/Airy UI/Sprites/Icons.meta

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

Assets/Airy UI/Sprites/Icons/anchor.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 0f44a0ceee9527f4a99c043c83e5d37d
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/anchor.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/anchor_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 76009eabd85feab4db90da457c751412
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/anchor_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/animation.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 3a66e1d307308d041a8b9c7a714f2639
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/animation.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/animation_add.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 8da0723d3fe044c4583138aa39297779
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 5469266597174324981
+    second: animation_add_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: animation_add_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1903
+        height: 1905
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 5fe2c722efcb6eb40800000000000000
+      internalID: 5469266597174324981
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      animation_add_0: 5469266597174324981
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/animation_add.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/animation_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 4350cb3056a566c48ac0f3588c16a85d
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/animation_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/animation_remove.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: d851f3d19c0f46f4abfc094c7d3f9a02
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -5026189170565072930
+    second: animation_remove_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: animation_remove_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1845
+        height: 1847
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: ed7bd8a44936f3ab0800000000000000
+      internalID: -5026189170565072930
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      animation_remove_0: -5026189170565072930
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/animation_remove.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/asset_store.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: f7f35e20f600c204fa502fefa58541bc
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 6270446564354777991
+    second: asset_store_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: asset_store_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1774
+        height: 1774
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 7836f639de9150750800000000000000
+      internalID: 6270446564354777991
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      asset_store_0: 6270446564354777991
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/asset_store.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/back.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 16954819a70521f49a68dbfc436a4076
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/back.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/back_add.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: cc962f90c8119a540a96dd8a8945d2c5
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -3233504054029274593
+    second: back_add_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: back_add_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1903
+        height: 1905
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: f12bcc7d1394023d0800000000000000
+      internalID: -3233504054029274593
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      back_add_0: -3233504054029274593
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/back_add.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/back_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 7f02f0462f80e0340b3014e7a07c5ac2
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/back_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/back_remove.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 19a561b410f6f4440913d84eda8cb081
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 4676048546561905576
+    second: back_remove_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: back_remove_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1845
+        height: 1847
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 8a3dd4ad069a4e040800000000000000
+      internalID: 4676048546561905576
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      back_remove_0: 4676048546561905576
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/back_remove.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/c_animation.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 7302f66924eef9247b9bc469e954b55c
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/c_animation.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/c_animation_add.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: aaee8ab538177a04199d21e7f42eb7ba
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 1796007722138793564
+    second: c_animation_add_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: c_animation_add_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1903
+        height: 1905
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: c56f0f3f183bce810800000000000000
+      internalID: 1796007722138793564
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      c_animation_add_0: 1796007722138793564
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/c_animation_add.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/c_animation_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 5012f5c66ad8aef43950aabb25f0b7e0
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/c_animation_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/c_animation_remove.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 5c66553e69036764db879332a354391f
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -9179552049715512275
+    second: c_animation_remove_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: c_animation_remove_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1845
+        height: 1847
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: d2c7f7fcb0eab9080800000000000000
+      internalID: -9179552049715512275
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      c_animation_remove_0: -9179552049715512275
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/c_animation_remove.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/esc.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 135e03f43ae12554e87964b6cc57b425
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/esc.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/esc_add.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 385aabfb1d7577e4eab41a95a7aa5c6e
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 7268539904133779391
+    second: esc_add_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: esc_add_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1903
+        height: 1905
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: fbf45ad488a0fd460800000000000000
+      internalID: 7268539904133779391
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      esc_add_0: 7268539904133779391
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/esc_add.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/esc_remove.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 0a82f8951079d00429ff59d959600496
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: 4913950681523570307
+    second: esc_remove_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: esc_remove_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1845
+        height: 1847
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 38640001c1cd13440800000000000000
+      internalID: 4913950681523570307
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      esc_remove_0: 4913950681523570307
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/esc_remove.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/main_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 0c86d94cc61dd1f4d9e208a11aed6c15
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/main_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/manager.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 20e204a63dd92db4789aa5672485efb3
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/manager.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/manager_add.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: fe5b369e6426b1144a584fb7f372bea9
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -8144659250357955641
+    second: manager_add_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: manager_add_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1903
+        height: 1905
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: 7c390d5609b58fe80800000000000000
+      internalID: -8144659250357955641
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      manager_add_0: -8144659250357955641
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/manager_add.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/manager_e.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: c6d7f5a7c4a1c364c81769ff255bc0d9
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/manager_e.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/manager_remove.png.meta

@@ -0,0 +1,202 @@
+fileFormatVersion: 2
+guid: 00144a9c2e1996044b68e9798654839d
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -3019987494099606115
+    second: manager_remove_0
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 0
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites:
+    - serializedVersion: 2
+      name: manager_remove_0
+      rect:
+        serializedVersion: 2
+        x: 137
+        y: 137
+        width: 1845
+        height: 1847
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      customData: 
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: d95221cef59d616d0800000000000000
+      internalID: -3019987494099606115
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable:
+      manager_remove_0: -3019987494099606115
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/manager_remove.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/position.png.meta

@@ -0,0 +1,176 @@
+fileFormatVersion: 2
+guid: 0727ad002e9a86b499cb1f23b7bf175b
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 13
+  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
+    flipGreenChannel: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  vTOnly: 0
+  ignoreMipmapLimit: 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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 0
+  applyGammaDecoding: 0
+  swizzle: 50462976
+  cookieLightType: 1
+  platformSettings:
+  - serializedVersion: 4
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: iOS
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WebGL
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: Android
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 4
+    buildTarget: WindowsStoreApps
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    ignorePlatformSupport: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    customData: 
+    physicsShape: []
+    bones: []
+    spriteID: 5e97eb03825dee720800000000000000
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    spriteCustomMetadata:
+      entries: []
+    nameFileIdTable: {}
+  mipmapLimitGroupName: 
+  pSDRemoveMatte: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/position.png
+  uploadId: 760159

Assets/Airy UI/Sprites/Icons/ui_close.png.meta

@@ -0,0 +1,190 @@
+fileFormatVersion: 2
+guid: dac0515b2a64d0449b98bccca9da0dc0
+TextureImporter:
+  internalIDToNameTable:
+  - first:
+      213: -6894759885519639715
+    second: ui_close_0
+  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
+  vTOnly: 0
+  ignoreMasterTextureLimit: 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: 1
+  nPOTScale: 0
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 2
+  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: 8
+  textureShape: 1
+  singleChannelComponent: 0
+  flipbookRows: 1
+  flipbookColumns: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  ignorePngGamma: 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: iOS
+    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: Android
+    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
+  - 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
+  - serializedVersion: 3
+    buildTarget: WindowsStoreApps
+    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:
+    - serializedVersion: 2
+      name: ui_close_0
+      rect:
+        serializedVersion: 2
+        x: 6
+        y: 0
+        width: 244
+        height: 256
+      alignment: 0
+      pivot: {x: 0, y: 0}
+      border: {x: 0, y: 0, z: 0, w: 0}
+      outline: []
+      physicsShape: []
+      tessellationDetail: -1
+      bones: []
+      spriteID: d5b2df30a64e050a0800000000000000
+      internalID: -6894759885519639715
+      vertices: []
+      indices: 
+      edges: []
+      weights: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+    nameFileIdTable:
+      ui_close_0: -6894759885519639715
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 135898
+  packageName: Airy UI 2 - Easy UI Animation
+  packageVersion: 2.0.2
+  assetPath: Assets/Airy UI/Sprites/Icons/ui_close.png
+  uploadId: 760159