public static bool CanBeLerped(AvailableMemberTypes type)
        {
            switch (type)
            {
            case AvailableMemberTypes.Boolean:
                return(false);

            default:
                return(true);
            }
        }
        public static object GetObject(Type _type, string str)
        {
            try
            {
                Type type = _type;
                if (!GetInstance().typesDictionary.ContainsKey(type))
                {
                    return(new object());
                }

                AvailableMemberTypes memberType = GetInstance().typesDictionary[type];
                switch (memberType)
                {
                case AvailableMemberTypes.Vector2:
                    return(ConvertStringToVector2(str));

                case AvailableMemberTypes.Vector3:
                    return(ConvertStringToVector3(str));

                case AvailableMemberTypes.Vector4:
                    return(ConvertStringToVector4(str));

                case AvailableMemberTypes.String:
                    return(str);

                case AvailableMemberTypes.Integer:
                    return(int.Parse(str));

                case AvailableMemberTypes.Float:
                    return(float.Parse(str));

                case AvailableMemberTypes.Boolean:
                {
                    bool tryparse = false;
                    bool.TryParse(str, out tryparse);
                    return(tryparse);
                }

                case AvailableMemberTypes.Color:
                    return(ConvertStringToColor(str));

                default:
                    return(new object());
                }
            }
            catch
            {
                return(new object());
            }
        }
        public static T GetObject <T>(string str)
        {
            Type type = typeof(T);

            if (!GetInstance().typesDictionary.ContainsKey(type))
            {
                return((T) new object());
            }

            AvailableMemberTypes memberType = GetInstance().typesDictionary[type];

            switch (memberType)
            {
            case AvailableMemberTypes.Vector2:
                return((T)Convert.ChangeType(ConvertStringToVector2(str), type));

            case AvailableMemberTypes.Vector3:
                return((T)Convert.ChangeType(ConvertStringToVector3(str), type));

            case AvailableMemberTypes.Vector4:
                return((T)Convert.ChangeType(ConvertStringToVector4(str), type));

            case AvailableMemberTypes.String:
                return((T)Convert.ChangeType(str, type));

            case AvailableMemberTypes.Integer:
                return((T)Convert.ChangeType(int.Parse(str), type));

            case AvailableMemberTypes.Float:
                return((T)Convert.ChangeType(float.Parse(str), type));

            case AvailableMemberTypes.Boolean:
            {
                bool tryparse = false;
                bool.TryParse(str, out tryparse);
                return((T)Convert.ChangeType(tryparse, type));
            }

            case AvailableMemberTypes.Color:
                return((T)Convert.ChangeType(ConvertStringToColor(str), type));

            default:
                return((T)Convert.ChangeType(new object(), type));
            }
        }
        public static object GetObject_Runtime(AvailableMemberTypes _type, string str)
        {
            try
            {
                AvailableMemberTypes memberType = _type;
                switch (memberType)
                {
                case AvailableMemberTypes.Vector2:
                    return(ConvertStringToVector2(str));

                case AvailableMemberTypes.Vector3:
                    return(ConvertStringToVector3(str));

                case AvailableMemberTypes.Vector4:
                    return(ConvertStringToVector4(str));

                case AvailableMemberTypes.String:
                    return(str);

                case AvailableMemberTypes.Integer:
                    return(int.Parse(str));

                case AvailableMemberTypes.Float:
                    return(float.Parse(str));

                case AvailableMemberTypes.Boolean:
                {
                    bool tryparse = false;
                    bool.TryParse(str, out tryparse);
                    return(tryparse);
                }

                case AvailableMemberTypes.Color:
                    return(ConvertStringToColor(str));

                default:
                    return(new object());
                }
            }
            catch
            {
                return(new object());
            }
        }
        public static object GetLerpedValue(string currentValueString, string finalValueString, AvailableMemberTypes memberType, float lerpedTime)
        {
            switch (memberType)
            {
            case AvailableMemberTypes.Color:
            {
                Color final             = new Color();
                Color currentValueColor = GetObject <Color>(currentValueString);
                Color finalValueColor   = GetObject <Color>(finalValueString);
                final = Color.Lerp(currentValueColor, finalValueColor, lerpedTime);
                return(final);
            }

            case AvailableMemberTypes.Float:
            {
                float final             = 0;
                float currentValueFloat = float.Parse(currentValueString);
                float finalValueFloat   = float.Parse(finalValueString);
                final = Mathf.Lerp(currentValueFloat, finalValueFloat, lerpedTime);
                return(final);
            }

            case AvailableMemberTypes.Vector2:
            {
                Vector2 final = new Vector2();
                Vector2 currentValueVector2 = GetObject <Vector2>(currentValueString);
                Vector2 finalValueVector2   = GetObject <Vector2>(finalValueString);
                final = Vector2.Lerp(currentValueVector2, finalValueVector2, lerpedTime);
                return(final);
            }

            case AvailableMemberTypes.Vector3:
            {
                Vector3 final = new Vector3();
                Vector3 currentValueVector3 = GetObject <Vector3>(currentValueString);
                Vector3 finalValueVector3   = GetObject <Vector3>(finalValueString);
                final = Vector3.Lerp(currentValueVector3, finalValueVector3, lerpedTime);
                return(final);
            }

            case AvailableMemberTypes.Vector4:
            {
                Vector4 final = new Vector4();
                Vector4 currentValueVector4 = GetObject <Vector4>(currentValueString);
                Vector4 finalValueVector4   = GetObject <Vector4>(finalValueString);
                final = Vector4.Lerp(currentValueVector4, finalValueVector4, lerpedTime);
                return(final);
            }

            case AvailableMemberTypes.Integer:
            {
                int   final      = 0;
                float currentInt = GetObject <int>(currentValueString);
                float finalInt   = GetObject <int>(finalValueString);
                final = Mathf.RoundToInt(Mathf.Lerp(currentInt, finalInt, lerpedTime));
                return(final);
            }

            case AvailableMemberTypes.String:
            {
                int maxIndexFromLerp = Mathf.RoundToInt(finalValueString.Length * lerpedTime);
                return(finalValueString.Substring(0, maxIndexFromLerp));
            }

            default:
                return(new object());
            }
        }
        public static object GetLerpedValue_Runtime(object currentValue, object finalValue, AvailableMemberTypes memberType, float lerpedTime)
        {
            try
            {
                switch (memberType)
                {
                case AvailableMemberTypes.Color:
                {
                    Color final             = new Color();
                    Color currentValueColor = (Color)currentValue;
                    Color finalValueColor   = (Color)finalValue;
                    final = Color.Lerp(currentValueColor, finalValueColor, lerpedTime);
                    return(final);
                }

                case AvailableMemberTypes.Float:
                {
                    float final             = 0;
                    float currentValueFloat = (float)currentValue;
                    float finalValueFloat   = (float)finalValue;
                    final = Mathf.Lerp(currentValueFloat, finalValueFloat, lerpedTime);
                    return(final);
                }

                case AvailableMemberTypes.Vector2:
                {
                    Vector2 final = new Vector2();
                    Vector2 currentValueVector2 = (Vector2)currentValue;
                    Vector2 finalValueVector2   = (Vector2)finalValue;
                    final = Vector2.Lerp(currentValueVector2, finalValueVector2, lerpedTime);
                    return(final);
                }

                case AvailableMemberTypes.Vector3:
                {
                    Vector3 final = new Vector3();
                    Vector3 currentValueVector3 = (Vector3)currentValue;
                    Vector3 finalValueVector3   = (Vector3)finalValue;
                    final = Vector3.Lerp(currentValueVector3, finalValueVector3, lerpedTime);
                    return(final);
                }

                case AvailableMemberTypes.Vector4:
                {
                    Vector4 final = new Vector4();
                    Vector4 currentValueVector4 = (Vector4)currentValue;
                    Vector4 finalValueVector4   = (Vector4)finalValue;
                    final = Vector4.Lerp(currentValueVector4, finalValueVector4, lerpedTime);
                    return(final);
                }

                case AvailableMemberTypes.Integer:
                {
                    int   final      = 0;
                    float currentInt = (int)currentValue;
                    float finalInt   = (int)finalValue;
                    final = Mathf.RoundToInt(Mathf.Lerp(currentInt, finalInt, lerpedTime));
                    return(final);
                }

                case AvailableMemberTypes.String:
                {
                    string finalValueString = (string)finalValue;
                    int    maxIndexFromLerp = Mathf.RoundToInt(finalValueString.Length * lerpedTime);
                    return(finalValueString.Substring(0, maxIndexFromLerp));
                }

                default:
                    return(new object());
                }
            }
            catch
            {
                return(new object());
            }
        }