Merge branch 'v0.13.0'

# Conflicts:
#	README.md

Author: KonH

Docs/_ReleaseNotes.txt

@@ -1,3 +1,13 @@
+v.0.13.0
+New controller:
+- Analytics;
+Features:
+- String functor to avoid allocations when it isn’t required;
+Enchantment: 
+- OneLine usage for more useful configuration;
+Fixes:
+- Raise scene load event only once, when loading scene already passed;
+
 v.0.12.0
 Breaking changes:
 - Removed: CompositeEnum, UDBaseConfig, JsonUtils, AssetUtils, CoroutineHelper, ICustomUpdate, EnumUtility, ApplicationQuitTracker, UnityCallbackTracker, UnityHelper, UpdateHelper;

Extensions/OneLine/Editor.meta

@@ -0,0 +1,35 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.Text.RegularExpressions;
+
+namespace OneLine {
+    internal class CustomDrawer : SimpleFieldDrawer {
+
+        private CustomPropertyDrawers drawers = new CustomPropertyDrawers();
+
+        public bool HasCustomDrawer(SerializedProperty property){
+            return drawers.GetCustomPropertyDrawerFor(property) != null;
+        }
+
+        public override void Draw(Rect rect, SerializedProperty property) {
+            DrawProperty(rect, property);
+        }
+
+        private void DrawProperty(Rect rect, SerializedProperty property){
+            var drawer = drawers.GetCustomPropertyDrawerFor(property);
+            if (drawer != null) {
+                drawer.OnGUI(rect, property, GUIContent.none);
+            }
+            else {
+                var message = "[OneLine] Can not draw CustomPropertyDrawer for `{0}` at property path `{1}";
+                throw new Exception(string.Format(message, property.type, property.propertyPath));
+            }
+        }
+
+    }
+}

Extensions/OneLine/OneLine/Editor/Drawers/CustomDrawer.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.Text.RegularExpressions;
+
+namespace OneLine {
+    internal class CustomPropertyDrawers {
+
+        /*
+         * Optimization
+         * To avoid creating separate drawers for each array element
+         */
+        private static readonly Regex REGEXP_ARRAY_INDEX = new Regex(".data\\[\\d+\\]");
+
+        private static CustomDrawerTypesCache types = new CustomDrawerTypesCache();
+        private readonly Dictionary<string, PropertyDrawer> drawers = new Dictionary<string, PropertyDrawer>();
+
+        public PropertyDrawer GetCustomPropertyDrawerFor(SerializedProperty property){
+            var key = REGEXP_ARRAY_INDEX.Replace(property.propertyPath, "");
+            PropertyDrawer result = null;
+
+            if (! drawers.TryGetValue(key, out result)){
+                result = CreatePropertyDrawerFor(property);
+                drawers[key] = result;
+            }
+
+            return result;
+        }
+
+        private PropertyDrawer CreatePropertyDrawerFor(SerializedProperty property){
+            var propertyType = property.GetRealType();
+            if (propertyType == null) return null;
+            
+            var result = FindAttributeDrawer(property);
+
+            if (result == null) {
+                result = FindDirectDrawer(propertyType);
+            }
+
+            return result;
+        }
+
+        private PropertyDrawer FindAttributeDrawer(SerializedProperty property){
+            TypeForDrawing typeDrawer = null;
+            Attribute drawerAttribute = null;
+
+            var attributes = property.GetCustomAttributes<PropertyAttribute>();
+
+            foreach (var type in types){
+                foreach (var attribute in attributes){
+                    if (type.IsMatch(attribute.GetType())) {
+                        typeDrawer = type;
+                        drawerAttribute = attribute;
+                        break;
+                    }
+                }
+            }
+
+            if (typeDrawer == null) return null;
+
+            var drawer = Activator.CreateInstance(typeDrawer.DrawerType) as PropertyDrawer;
+            drawer.SetAttribute(drawerAttribute);
+            return drawer;
+        }
+
+        private PropertyDrawer FindDirectDrawer(Type propertyType){
+            var typeDrawer = types.FirstOrDefault(x => x.IsMatch(propertyType));
+
+            if (typeDrawer == null) return null;
+
+            return Activator.CreateInstance(typeDrawer.DrawerType) as PropertyDrawer;
+        }
+    }
+}

Extensions/OneLine/OneLine/Editor/Drawers/CustomDrawer.cs.meta

@@ -0,0 +1,38 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.Text.RegularExpressions;
+
+namespace OneLine {
+    internal class CustomDrawerTypesCache : IEnumerable<TypeForDrawing> {
+        private static IEnumerable<TypeForDrawing> customDrawers;
+
+        private void Init(){
+            if (customDrawers == null) {
+                customDrawers = findAllCustomDrawers();
+            }
+        }
+
+        private static IEnumerable<TypeForDrawing> findAllCustomDrawers(){
+            return from assembly in AppDomain.CurrentDomain.GetAssemblies()
+                        from type in assembly.GetTypes()
+                        where type.IsSubclassOf(typeof(PropertyDrawer))
+                        where type != typeof(OneLinePropertyDrawer) && ! type.IsSubclassOf(typeof(OneLinePropertyDrawer))
+                        from attribute in type.GetCustomAttributes(typeof(CustomPropertyDrawer), true)
+                        select new TypeForDrawing(attribute as CustomPropertyDrawer, type);
+        }
+
+        public IEnumerator<TypeForDrawing> GetEnumerator() {
+            Init();
+            return customDrawers.GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() {
+            return GetEnumerator();
+        }
+    }
+}

Extensions/OneLine/OneLine/Editor/Drawers/CustomDrawer.meta

@@ -0,0 +1,35 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using System.Text.RegularExpressions;
+
+namespace OneLine {
+    internal class TypeForDrawing {
+        private Type Type {get; set;}
+        private bool UseForChildren {get; set;}
+        public Type DrawerType {get; private set;}
+
+        public TypeForDrawing(CustomPropertyDrawer attribute, Type drawerType) {
+            Type = attribute.GetTargetType();
+            UseForChildren = attribute.IsForChildren();
+
+            DrawerType = drawerType;
+        }
+
+        public bool IsMatch(Type target){
+            if (target == null) return false;
+
+            if (UseForChildren){
+                return Type == target || target.IsSubclassOf(Type);
+            }
+            else {
+                return Type == target;
+            }
+        }
+    }
+
+}