Insanely huge initial commit

Assets/ProCamera2D/Editor.meta

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

Assets/ProCamera2D/Editor/Core.meta

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

Assets/ProCamera2D/Editor/Core/ProCamera2DEditor.cs

@@ -0,0 +1,530 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    public class PC2DEditorExtension
+    {
+        public string ExtName;
+        public System.Type ExtType;
+        public BasePC2D Component;
+    }
+
+    public class PC2DEditorTrigger
+    {
+        public string TriggerName;
+        public System.Type TriggerType;
+        public List<Object> AllTriggers;
+        public int TriggerCurrentIndex;
+    }
+
+    [CustomEditor(typeof(ProCamera2D))]
+    public class ProCamera2DEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        ReorderableList _targetsList;
+
+        List<PC2DEditorExtension> _extensions;
+        List<PC2DEditorTrigger> _triggers;
+        
+        string hAxis = "";
+        string vAxis = "";
+
+        bool _showReviewMessage;
+
+        void OnEnable()
+        {
+            var proCamera2D = (ProCamera2D)target;
+
+            if (proCamera2D.GameCamera == null)
+                proCamera2D.GameCamera = proCamera2D.GetComponent<Camera>();
+            
+            // Show correct axis name
+            switch (proCamera2D.Axis)
+            {
+                case MovementAxis.XY:
+                    hAxis = "X";
+                    vAxis = "Y";
+                    break;
+
+                case MovementAxis.XZ:
+                    hAxis = "X";
+                    vAxis = "Z";
+                    break;
+
+                case MovementAxis.YZ:
+                    hAxis = "Y";
+                    vAxis = "Z";
+                    break;
+            }
+
+            // Targets List
+            _targetsList = new ReorderableList(serializedObject, serializedObject.FindProperty("CameraTargets"), false, false, true, true);
+
+            _targetsList.onSelectCallback = (list) =>
+            {
+                EditorGUIUtility.PingObject(_targetsList.serializedProperty.GetArrayElementAtIndex(_targetsList.index).FindPropertyRelative("TargetTransform").objectReferenceValue);
+            };
+
+            _targetsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 2;
+                var element = _targetsList.serializedProperty.GetArrayElementAtIndex(index);
+
+				EditorGUI.PrefixLabel(new Rect(rect.x, rect.y, 65, 10), new GUIContent("Transform", "The target transform"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 65,
+                        rect.y,
+                        80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetTransform"), GUIContent.none);
+
+				EditorGUI.PrefixLabel(new Rect(rect.x + 160, rect.y, 65, 10), new GUIContent("Offset", "Offset the camera position relative to this target"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 200,
+                        rect.y,
+                        rect.width - 200,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetOffset"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 25, 65, 10), new GUIContent("Influence" + hAxis, "How much does this target horizontal position influences the camera position?"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 80,
+                        rect.y + 25,
+                        rect.width - 80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetInfluenceH"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 40, 65, 10), new GUIContent("Influence" + vAxis, "How much does this target vertical position influences the camera position?"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 80,
+                        rect.y + 40,
+                        rect.width - 80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetInfluenceV"), GUIContent.none);
+            };
+
+            _targetsList.elementHeight = 80;
+            _targetsList.headerHeight = 0;
+            _targetsList.draggable = true;
+
+
+            // Review message
+            if (EditorPrefs.GetInt("ProCamera2DReview", 0) >= 0)
+                EditorPrefs.SetInt("ProCamera2DReview", EditorPrefs.GetInt("ProCamera2DReview", 0) + 1);
+
+            if (EditorPrefs.GetInt("ProCamera2DReview", 0) >= 100)
+                _showReviewMessage = true;
+
+
+
+            // Get extensions and triggers to show on the list
+            _extensions = new List<PC2DEditorExtension>();
+            _triggers = new List<PC2DEditorTrigger>();
+            MonoScript[] scripts = (MonoScript[])Resources.FindObjectsOfTypeAll(typeof(MonoScript));
+            foreach (MonoScript m in scripts)
+            {
+                var scriptClass = m.GetClass();
+                if (scriptClass != null && scriptClass.IsSubclassOf(typeof(BasePC2D)))
+                {
+                    var extensionName = scriptClass.GetField("ExtensionName");
+                    if (extensionName != null)
+                    {
+                        var ext = new PC2DEditorExtension()
+                        {
+                            ExtName = extensionName.GetValue(null) as string,
+                            ExtType = scriptClass,
+                            Component = proCamera2D.GetComponent(scriptClass) as BasePC2D
+                        };
+                        
+                        _extensions.Add(ext);
+                    }
+
+                    var triggerName = scriptClass.GetField("TriggerName");
+                    if (triggerName != null)
+                    {
+                        var trig = new PC2DEditorTrigger()
+                            {
+                                TriggerName = triggerName.GetValue(null) as string,
+                                TriggerType = scriptClass,
+                                AllTriggers = FindObjectsOfType(scriptClass).ToList(),
+                                TriggerCurrentIndex = 0
+                            };
+
+                        _triggers.Add(trig);
+                    }
+                }
+            }
+            _extensions = _extensions.OrderBy(s => s.ExtName).ToList();
+            _triggers = _triggers.OrderBy(s => s.TriggerName).ToList();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+            
+            var proCamera2D = (ProCamera2D)target;
+
+            serializedObject.Update();
+
+
+            EditorGUILayout.Space();
+
+            // Draw User Guide link
+            if (ProCamera2DEditorResources.UserGuideIcon != null)
+            {
+                var rect = GUILayoutUtility.GetRect(0f, 0f);
+                rect.width = ProCamera2DEditorResources.UserGuideIcon.width;
+                rect.height = ProCamera2DEditorResources.UserGuideIcon.height;
+                if (GUI.Button(new Rect(15, rect.y, 32, 32), new GUIContent(ProCamera2DEditorResources.UserGuideIcon, "User Guide")))
+                {
+                    Application.OpenURL("http://www.procamera2d.com/user-guide/");
+                }
+            }
+
+            // Draw header
+            if (ProCamera2DEditorResources.InspectorHeader != null)
+            {
+                var rect = GUILayoutUtility.GetRect(0f, 0f);
+                rect.x += 37;
+                rect.width = ProCamera2DEditorResources.InspectorHeader.width;
+                rect.height = ProCamera2DEditorResources.InspectorHeader.height;
+                GUILayout.Space(rect.height);
+                GUI.DrawTexture(rect, ProCamera2DEditorResources.InspectorHeader);
+            }
+
+            EditorGUILayout.Space();
+
+
+            // Review prompt
+            if (_showReviewMessage)
+            {
+                EditorGUILayout.HelpBox("Sorry for the intrusion, but I need you for a second. Reviews on the Asset Store are very important for me to keep improving this product. Please take a minute to write a review and support ProCamera2D.", MessageType.Warning, true);
+                EditorGUILayout.BeginHorizontal();
+                if (GUILayout.Button("Sure, I'll write a review!"))
+                {
+                    _showReviewMessage = false;
+                    EditorPrefs.SetInt("ProCamera2DReview", -1);
+                    Application.OpenURL("http://u3d.as/i7L");
+                }
+                if (GUILayout.Button("No, thanks."))
+                {
+                    _showReviewMessage = false;
+                    EditorPrefs.SetInt("ProCamera2DReview", -1);
+                }
+                EditorGUILayout.EndHorizontal();
+                AddSpace();
+            }
+
+
+            // Assign game camera
+            if (proCamera2D.GameCamera == null)
+                proCamera2D.GameCamera = proCamera2D.GetComponent<Camera>();
+
+
+            // Targets Drop Area
+            Event evt = Event.current;
+            Rect drop_area = GUILayoutUtility.GetRect(0.0f, 50.0f, GUILayout.ExpandWidth(true));
+            var style = new GUIStyle("box");
+            if (EditorGUIUtility.isProSkin)
+                style.normal.textColor = Color.white;
+            GUI.Box(drop_area, "\nDROP CAMERA TARGETS HERE", style);
+            
+            Undo.RecordObject(proCamera2D, "Added camera targets");
+            switch (evt.type)
+            {
+                case EventType.DragUpdated:
+                case EventType.DragPerform:
+                    if (!drop_area.Contains(evt.mousePosition))
+                        return;
+
+                    DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
+
+                    if (evt.type == EventType.DragPerform)
+                    {
+                        DragAndDrop.AcceptDrag();
+
+                        foreach (Object dragged_object in DragAndDrop.objectReferences)
+                        {
+                            var newCameraTarget = new CameraTarget
+                            {
+                                TargetTransform = ((GameObject)dragged_object).transform,
+                                TargetInfluence = 1f
+                            };
+							
+                            proCamera2D.CameraTargets.Add(newCameraTarget);
+                            EditorUtility.SetDirty(proCamera2D);
+                        }
+                    }
+                    break;
+            }
+
+            EditorGUILayout.Space();
+
+
+
+
+            // Remove empty targets
+            for (int i = 0; i < proCamera2D.CameraTargets.Count; i++)
+            {
+                if (proCamera2D.CameraTargets[i].TargetTransform == null)
+                {
+                    proCamera2D.CameraTargets.RemoveAt(i);
+                }
+            }
+
+
+
+
+            // Targets List
+            _targetsList.DoLayoutList();
+            AddSpace();
+
+
+
+
+
+            // Center target on start
+            _tooltip = new GUIContent("Center target on start", "Should the camera move instantly to the target on game start?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("CenterTargetOnStart"), _tooltip);
+
+            AddSpace();
+            
+
+
+
+
+            // Axis
+            _tooltip = new GUIContent("Axis", "Choose the axis in which the camera should move.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Axis"), _tooltip);
+
+            AddSpace();
+
+
+
+
+            // UpdateType
+            _tooltip = new GUIContent("Update Type", "LateUpdate: Non physics based game\nFixedUpdate: Physics based game");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateType"), _tooltip);
+
+            AddSpace();
+
+
+
+
+            // Show correct axis name
+            switch (proCamera2D.Axis)
+            {
+                case MovementAxis.XY:
+                    hAxis = "X";
+                    vAxis = "Y";
+                    break;
+
+                case MovementAxis.XZ:
+                    hAxis = "X";
+                    vAxis = "Z";
+                    break;
+
+                case MovementAxis.YZ:
+                    hAxis = "Y";
+                    vAxis = "Z";
+                    break;
+            }
+
+
+
+
+            // Follow horizontal
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Follow " + hAxis, "Should the camera move on the horizontal axis?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("FollowHorizontal"), _tooltip);
+            if (proCamera2D.FollowHorizontal)
+            {
+                // Follow smoothness
+                _tooltip = new GUIContent("Smoothness", "How long it takes the camera to reach the target horizontal position.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("HorizontalFollowSmoothness"), _tooltip);
+
+                if (proCamera2D.HorizontalFollowSmoothness < 0f)
+                    proCamera2D.HorizontalFollowSmoothness = 0f;
+
+            }
+            EditorGUILayout.EndHorizontal();
+
+
+            // Follow vertical
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Follow " + vAxis, "Should the camera move on the vertical axis?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("FollowVertical"), _tooltip);
+
+            if (proCamera2D.FollowVertical)
+            {
+                // Follow smoothness
+                _tooltip = new GUIContent("Smoothness", "How long it takes the camera to reach the target vertical position.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("VerticalFollowSmoothness"), _tooltip);
+
+                if (proCamera2D.VerticalFollowSmoothness < 0f)
+                    proCamera2D.VerticalFollowSmoothness = 0f;
+            }
+            EditorGUILayout.EndHorizontal();
+
+            if (!proCamera2D.FollowHorizontal && !proCamera2D.FollowVertical)
+                EditorGUILayout.HelpBox("Camera won't move if it's not following the targets on any axis.", MessageType.Error, true);
+
+            AddSpace();
+
+
+
+
+
+            // Overall offset
+            EditorGUILayout.LabelField("Offset");
+            EditorGUI.indentLevel = 1;
+
+            if (proCamera2D.IsRelativeOffset)
+            {
+                _tooltip = new GUIContent(hAxis, "Horizontal offset");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("OffsetX"), _tooltip);
+
+                _tooltip = new GUIContent(vAxis, "Vertical offset");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("OffsetY"), _tooltip);
+            }
+            else
+            {
+                _tooltip = new GUIContent(hAxis, "Horizontal offset");
+                serializedObject.FindProperty("OffsetX").floatValue = EditorGUILayout.FloatField(hAxis, serializedObject.FindProperty("OffsetX").floatValue);
+
+                _tooltip = new GUIContent(vAxis, "Vertical offset");
+                serializedObject.FindProperty("OffsetY").floatValue = EditorGUILayout.FloatField(vAxis, serializedObject.FindProperty("OffsetY").floatValue);
+            }
+
+            _tooltip = new GUIContent("Relative Offset", "If enabled, the offset is relative to the current screen size. Otherwise it's in world units.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("IsRelativeOffset"), _tooltip);
+
+            EditorGUI.indentLevel = 0;
+
+            AddSpace();
+
+
+
+            // Zoom with FOV
+            if (!proCamera2D.GameCamera.orthographic)
+            {
+                GUI.enabled = !Application.isPlaying;
+                _tooltip = new GUIContent("Zoom With FOV", "If enabled, when using a perspective camera, the camera will zoom by changing the FOV instead of moving the camera closer/further from the objects.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("ZoomWithFOV"), _tooltip);
+                GUI.enabled = true;
+                AddSpace();
+            }
+            
+            
+            
+            // Ignore TimeScale
+            _tooltip = new GUIContent("Ignore TimeScale", "If enabled, the camera will not be affected by the Time.timeScale. It will use Time.unscaledDeltaTime instead.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("IgnoreTimeScale"), _tooltip);
+            AddSpace();
+
+
+
+            // Divider
+            GUILayout.Box("", new GUILayoutOption[]{ GUILayout.ExpandWidth(true), GUILayout.Height(1) });
+            GUILayout.Label("EXTENSIONS", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+
+            // Extensions
+            GUI.color = Color.white;
+            for (int i = 0; i < _extensions.Count; i++)
+            {
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUILayout.LabelField(_extensions[i].ExtName);
+                if (_extensions[i].Component == null)
+                {
+                    GUI.color = new Color(133f / 255f, 235f / 255f, 154f / 255f, 1f);
+                    if (GUILayout.Button("Enable"))
+                    {
+                        _extensions[i].Component = proCamera2D.gameObject.AddComponent(_extensions[i].ExtType) as BasePC2D;
+                    }
+                }
+                else
+                {
+                    GUI.color = new Color(236f / 255f, 72f / 255f, 105f / 255f, 1f);
+                    if (GUILayout.Button("Disable"))
+                    {
+                        if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to remove this extension?", "Yes", "No"))
+                        {
+                            DestroyImmediate(_extensions[i].Component);
+                            EditorGUIUtility.ExitGUI();
+                        }
+                    }
+                }
+                GUI.color = Color.white;
+                EditorGUILayout.EndHorizontal();
+            }
+
+
+
+            // Divider
+            EditorGUILayout.Space();
+            GUI.color = Color.white;
+            GUILayout.Box("", new GUILayoutOption[]{ GUILayout.ExpandWidth(true), GUILayout.Height(1) });
+            GUILayout.Label("TRIGGERS", EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+
+
+            // Triggers
+            for (int i = 0; i < _triggers.Count; i++)
+            {
+                EditorGUILayout.BeginHorizontal();
+
+                EditorGUILayout.LabelField(_triggers[i].TriggerName + " (" + _triggers[i].AllTriggers.Count() + ")");
+
+                if (GUILayout.Button("Add"))
+                {
+                    var newGo = new GameObject(_triggers[i].TriggerType.Name);
+                    newGo.transform.localScale = new Vector3(5, 5, 5);
+                    var trigger = newGo.AddComponent(_triggers[i].TriggerType) as BasePC2D;
+                    _triggers[i].AllTriggers.Add(trigger);
+                }
+
+                GUI.enabled = _triggers[i].AllTriggers.Count() > 0;
+
+                if (GUILayout.Button(">"))
+                {
+                    Selection.activeGameObject = ((BasePC2D)_triggers[i].AllTriggers[_triggers[i].TriggerCurrentIndex]).gameObject;
+                    SceneView.FrameLastActiveSceneView();
+                    EditorGUIUtility.PingObject(((BasePC2D)_triggers[i].AllTriggers[_triggers[i].TriggerCurrentIndex]).gameObject);
+
+                    Selection.activeGameObject = proCamera2D.gameObject;
+
+                    _triggers[i].TriggerCurrentIndex = _triggers[i].TriggerCurrentIndex >= _triggers[i].AllTriggers.Count - 1 ? 0 : _triggers[i].TriggerCurrentIndex + 1;
+                }
+
+                GUI.enabled = true;
+
+                EditorGUILayout.EndHorizontal();
+            }
+
+            AddSpace();
+
+
+            serializedObject.ApplyModifiedProperties();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty(proCamera2D);
+            }
+        }
+
+        void AddSpace()
+        {
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Core/ProCamera2DEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0ec0a4b8d78d046bf847659ecee5ce39
+timeCreated: 1426795762
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Core/ProCamera2DEditorResources.cs

@@ -0,0 +1,36 @@
+using UnityEngine;
+using UnityEditor;
+
+public static class ProCamera2DEditorResources 
+{
+	public const string FolderPath = "ProCamera2D";
+
+    public static Texture InspectorHeader
+    {
+        get
+        {
+            if (_inspectorHeader == null)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(AssetDatabase.FindAssets("ProCamera2DEditor")[0]).Replace("ProCamera2DEditor.cs", "") + "Images/inspector_header.png";
+                _inspectorHeader = (Texture)AssetDatabase.LoadAssetAtPath(path, typeof(Texture));
+            }
+            return _inspectorHeader;
+        }
+    }
+    static Texture _inspectorHeader;
+
+
+    public static Texture UserGuideIcon
+    {
+        get
+        {
+            if (_userGuideIcon == null)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(AssetDatabase.FindAssets("ProCamera2DEditor")[0]).Replace("ProCamera2DEditor.cs", "") + "Images/user-guide-link.png";
+                _userGuideIcon = (Texture)AssetDatabase.LoadAssetAtPath(path, typeof(Texture));
+            }
+            return _userGuideIcon;
+        }
+    }
+    static Texture _userGuideIcon;
+}

Assets/ProCamera2D/Editor/Core/ProCamera2DEditorResources.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c1c9af31e004f4354b965d841a0e3c0e
+timeCreated: 1430510771
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Core/ProCamera2DHierarchyIcon.cs

@@ -0,0 +1,53 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [InitializeOnLoad]
+    public class ProCamera2DHierarchyIcon : MonoBehaviour
+    {
+        static readonly Texture2D _icon;
+        static readonly Texture2D _icon_plugin;
+
+        static ProCamera2DHierarchyIcon()
+        {
+            _icon = AssetDatabase.LoadAssetAtPath("Assets/Gizmos/ProCamera2D/pro_camera_2d_icon.png", typeof(Texture2D)) as Texture2D;
+            _icon_plugin = AssetDatabase.LoadAssetAtPath("Assets/Gizmos/ProCamera2D/pro_camera_2d_plugin_icon.png", typeof(Texture2D)) as Texture2D;
+
+            if (_icon == null || _icon_plugin == null)
+            {
+                return;
+            } 
+
+            EditorApplication.hierarchyWindowItemOnGUI += HierarchyItemCB;
+            EditorApplication.RepaintHierarchyWindow();
+        }
+
+        static void HierarchyItemCB(int instanceID, Rect selectionRect)
+        {
+            GameObject go = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
+
+            if (go == null)
+            {
+                return;
+            }   
+
+            if (_icon != null && go.GetComponent<ProCamera2D>() != null)
+            {
+                Rect r = new Rect(selectionRect);
+                r.x = r.width - 5;
+
+                GUI.Label(r, _icon);
+                return;
+            }
+
+            if (_icon_plugin != null && go.GetComponent<BasePC2D>() != null)
+            {
+                Rect r = new Rect(selectionRect);
+                r.x = r.width - 5;
+
+                GUI.Label(r, _icon_plugin);
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Core/ProCamera2DHierarchyIcon.cs.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: abb08b691ffc4432797b3ffb5351650b
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 

Assets/ProCamera2D/Editor/Core/ProCamera2DPrefs.cs

@@ -0,0 +1,156 @@
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+#if !UNITY_2018_3_OR_NEWER
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    public static class ProCamera2DPrefs
+    {	
+	    
+    	static bool _prefsLoaded;
+
+        static Color[] _procamera2DGizmosColors;
+        readonly static string[] _procamera2DGizmosKeys = new string[]
+        {
+            PrefsData.RoomsColorKey,
+        	PrefsData.NumericBoundariesColorKey, 
+        	PrefsData.TargetsMidPointColorKey,
+        	PrefsData.InfluencesColorKey,
+        	PrefsData.ShakeInfluenceColorKey,
+        	PrefsData.OverallOffsetColorKey,
+        	PrefsData.CamDistanceColorKey,
+        	PrefsData.CamTargetPositionColorKey,
+        	PrefsData.CamTargetPositionSmoothedColorKey,
+        	PrefsData.CurrentCameraPositionColorKey,
+        	PrefsData.CameraWindowColorKey,
+
+        	PrefsData.ForwardFocusColorKey,
+
+			PrefsData.ZoomToFitColorKey,
+
+            PrefsData.RailsColorKey,
+
+            PrefsData.PanEdgesColorKey,
+	        
+	        PrefsData.FitterFillColorKey,
+	        PrefsData.FitterLineColorKey,
+
+            PrefsData.BoundariesTriggerColorKey,
+
+            PrefsData.InfluenceTriggerColorKey,
+
+            PrefsData.ZoomTriggerColorKey,
+
+            PrefsData.TriggerShapeColorKey
+        };
+        readonly static Color[] _procamera2DGizmosValues = new Color[]
+        {
+            PrefsData.RoomsColorValue,
+        	PrefsData.NumericBoundariesColorValue, 
+        	PrefsData.TargetsMidPointColorValue,
+        	PrefsData.InfluencesColorValue,
+        	PrefsData.ShakeInfluenceColorValue,
+        	PrefsData.OverallOffsetColorValue,
+        	PrefsData.CamDistanceColorValue,
+        	PrefsData.CamTargetPositionColorValue,
+        	PrefsData.CamTargetPositionSmoothedColorValue,
+        	PrefsData.CurrentCameraPositionColorValue,
+        	PrefsData.CameraWindowColorValue,
+
+        	PrefsData.ForwardFocusColorValue,
+
+			PrefsData.ZoomToFitColorValue,   
+
+            PrefsData.RailsColorValue,
+
+            PrefsData.PanEdgesColorValue,
+	        
+	        PrefsData.FitterFillColorValue,
+	        PrefsData.FitterLineColorValue,
+
+            PrefsData.BoundariesTriggerColorValue,
+
+            PrefsData.InfluenceTriggerColorValue,
+
+            PrefsData.ZoomTriggerColorValue,
+
+            PrefsData.TriggerShapeColorValue
+        };
+
+        static Vector2 _scrollPos;
+
+        [PreferenceItem("ProCamera2D")]
+        static void PreferencesGUI()
+        {
+            // Load the preferences
+            if (!_prefsLoaded)
+            {
+                _procamera2DGizmosColors = new Color[_procamera2DGizmosKeys.Length];
+                for (int i = 0; i < _procamera2DGizmosColors.Length; i++) 
+                {
+                	_procamera2DGizmosColors[i] = EditorPrefsX.GetColor(_procamera2DGizmosKeys[i], _procamera2DGizmosValues[i]);
+                }
+
+                _prefsLoaded = true;
+            }
+		
+            // Preferences GUI
+            _scrollPos = EditorGUILayout.BeginScrollView(_scrollPos);
+
+            GUILayout.Label("ProCamera2D", EditorStyles.boldLabel);
+            for (int i = 0; i < _procamera2DGizmosColors.Length; i++) 
+            {
+            	_procamera2DGizmosColors[i] = EditorGUILayout.ColorField(_procamera2DGizmosKeys[i], _procamera2DGizmosColors[i]);
+
+            	if(i == 9)
+            	{
+            		EditorGUILayout.Space();
+            		GUILayout.Label("Extensions", EditorStyles.boldLabel);
+            	}
+
+                if(i == 16)
+                {
+                    EditorGUILayout.Space();
+                    GUILayout.Label("Triggers", EditorStyles.boldLabel);
+                }
+            }
+
+            // Rails snapping
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            GUILayout.Label("Rails Snapping", EditorStyles.boldLabel);
+            EditorPrefs.SetFloat("RailsSnapping", EditorGUILayout.Slider(EditorPrefs.GetFloat("RailsSnapping"), .1f, 10f));
+
+            // Rooms snapping
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            GUILayout.Label("Rooms Snapping", EditorStyles.boldLabel);
+            EditorPrefs.SetFloat("RoomsSnapping", EditorGUILayout.Slider(EditorPrefs.GetFloat("RoomsSnapping"), .01f, 10f));
+
+            // Reset defaults
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            if (GUILayout.Button("Use defaults", GUILayout.Width(120)))
+            {
+                for (int i = 0; i < _procamera2DGizmosColors.Length; i++) 
+	            {
+	            	EditorPrefsX.SetColor(_procamera2DGizmosKeys[i], _procamera2DGizmosValues[i]);
+	            }
+            }
+
+            EditorGUILayout.EndScrollView();
+		
+            // Save the preferences
+            if (GUI.changed)
+            {
+                for (int i = 0; i < _procamera2DGizmosColors.Length; i++) 
+		        {
+		        	EditorPrefsX.SetColor(_procamera2DGizmosKeys[i], _procamera2DGizmosColors[i]);
+		        }
+            }
+        }
+    }
+}
+#endif

Assets/ProCamera2D/Editor/Core/ProCamera2DPrefs.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4e68d0fb62ae848cb910c25da87a659a
+timeCreated: 1432892307
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions.meta

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

Assets/ProCamera2D/Editor/Extensions/ProCamera2DCameraWindowEditor.cs

@@ -0,0 +1,100 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DCameraWindow))]
+    public class ProCamera2DCameraWindowEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DCameraWindow)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DCameraWindow = (ProCamera2DCameraWindow)target;
+            if (proCamera2DCameraWindow.ProCamera2D == null)
+            {
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                return;
+            }
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+
+            string hAxis = "";
+            string vAxis = "";
+            switch (proCamera2DCameraWindow.ProCamera2D.Axis)
+            {
+                case MovementAxis.XY:
+                    hAxis = "X";
+                    vAxis = "Y";
+                    break;
+
+                case MovementAxis.XZ:
+                    hAxis = "X";
+                    vAxis = "Z";
+                    break;
+
+                case MovementAxis.YZ:
+                    hAxis = "Y";
+                    vAxis = "Z";
+                    break;
+            }
+
+            if (proCamera2DCameraWindow.IsRelativeSizeAndPosition)
+            {
+                _tooltip = new GUIContent("Width", "Window width");
+                EditorGUILayout.Slider(serializedObject.FindProperty("CameraWindowRect.width"), 0f, 1f, _tooltip);
+
+                _tooltip = new GUIContent("Height", "Window height");
+                EditorGUILayout.Slider(serializedObject.FindProperty("CameraWindowRect.height"), 0f, 1f, _tooltip);
+
+                _tooltip = new GUIContent(hAxis, "Window horizontal offset");
+                EditorGUILayout.Slider(serializedObject.FindProperty("CameraWindowRect.x"), -.5f, .5f, _tooltip);
+
+                _tooltip = new GUIContent(vAxis, "Window vertical offset");
+                EditorGUILayout.Slider(serializedObject.FindProperty("CameraWindowRect.y"), -.5f, .5f, _tooltip);
+            }
+            else
+            {
+                _tooltip = new GUIContent("Width", "Window width");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("CameraWindowRect.width"), _tooltip);
+
+                _tooltip = new GUIContent("Height", "Window height");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("CameraWindowRect.height"), _tooltip);
+
+                _tooltip = new GUIContent(hAxis, "Window horizontal offset");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("CameraWindowRect.x"), _tooltip);
+
+                _tooltip = new GUIContent(vAxis, "Window vertical offset");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("CameraWindowRect.y"), _tooltip);
+            }
+
+            _tooltip = new GUIContent("Relative Size and Position", "If enabled, the camera window is relative to the current screen size. Otherwise it's in world units.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("IsRelativeSizeAndPosition"), _tooltip);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DCameraWindowEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8e60d5f5492994506bd228ba9c488515
+timeCreated: 1444930113
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DCinematicsEditor.cs

@@ -0,0 +1,275 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEditorInternal;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DCinematics))]
+    [CanEditMultipleObjects]
+    public class ProCamera2DCinematicsEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        ReorderableList _cinematicTargetsList;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DCinematics)target);
+
+            // Cinematic targets list
+            _cinematicTargetsList = new ReorderableList(serializedObject, serializedObject.FindProperty("CinematicTargets"), false, true, false, true);
+
+            _cinematicTargetsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+                {
+                    rect.y += 2;
+                    var element = _cinematicTargetsList.serializedProperty.GetArrayElementAtIndex(index);
+
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("Target", "The target transform"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 90,
+                        rect.y,
+                        90,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("TargetTransform"), GUIContent.none);
+
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x + 200, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("EaseType", "The type of the movement the camera will do to reach this target"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 260,
+                        rect.y,
+                        rect.width - 260,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("EaseType"), GUIContent.none);
+
+                    rect.y += 25;
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("EaseInDuration", "The time it takes to reach this target"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 90,
+                        rect.y,
+                        30,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("EaseInDuration"), GUIContent.none);
+                    
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x + 135, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("HoldDuration", "The time the camera follows this target. If below 0, you'll have to manually move to the next target by using the GoToNextTarget method."));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 215,
+                        rect.y,
+                        30,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("HoldDuration"), GUIContent.none);
+
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x + 260, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("Zoom", "The zoom the camera will reach when focusing on this target"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 300,
+                        rect.y,
+                        rect.width - 300,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("Zoom"), GUIContent.none);
+
+                    rect.y += 25;
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("SendMessage Name", "The name of the SendMessage to be sent to the target once it arrives its position"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 115,
+                        rect.y,
+                        70,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("SendMessageName"), GUIContent.none);
+
+                    EditorGUI.PrefixLabel(new Rect(
+                        rect.x + 195, 
+                        rect.y, 
+                        90, 
+                        10), 
+                        new GUIContent("SendMessage Param", "The (optional) string parameter to send"));
+                    EditorGUI.PropertyField(new Rect(
+                        rect.x + 310,
+                        rect.y,
+                        rect.width - 310,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                        element.FindPropertyRelative("SendMessageParam"), GUIContent.none);
+                };
+
+            _cinematicTargetsList.drawHeaderCallback = (Rect rect) =>
+                {  
+                    EditorGUI.LabelField(rect, "Cinematic Targets");
+                };
+
+            _cinematicTargetsList.elementHeight = 90;
+            _cinematicTargetsList.draggable = true;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DCinematics = (ProCamera2DCinematics)target;
+            if (proCamera2DCinematics.ProCamera2D == null)
+            {
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                return;
+            }
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            // Targets Drop Area
+            EditorGUILayout.Space();
+            Event evt = Event.current;
+            Rect drop_area = GUILayoutUtility.GetRect(0.0f, 50.0f, GUILayout.ExpandWidth(true));
+            var style = new GUIStyle("box");
+            if (EditorGUIUtility.isProSkin)
+                style.normal.textColor = Color.white;
+            GUI.Box(drop_area, "\nDROP CINEMATC TARGETS HERE", style);
+
+            switch (evt.type)
+            {
+                case EventType.DragUpdated:
+                case EventType.DragPerform:
+                    if (drop_area.Contains(evt.mousePosition))
+                    {
+                        DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
+
+                        if (evt.type == EventType.DragPerform)
+                        {
+                            DragAndDrop.AcceptDrag();
+
+                            foreach (Object dragged_object in DragAndDrop.objectReferences)
+                            {
+                                var newCinematicTarget = new CinematicTarget
+                                {
+                                    TargetTransform = ((GameObject)dragged_object).transform,
+                                    EaseInDuration = 1f,
+                                    HoldDuration = 1f,
+                                    EaseType = EaseType.EaseOut
+                                };
+
+                                proCamera2DCinematics.CinematicTargets.Add(newCinematicTarget);
+                                EditorUtility.SetDirty(proCamera2DCinematics);
+                            }
+                        }
+                    }
+                    break;
+            }
+
+            EditorGUILayout.Space();
+
+            // Remove empty targets
+            for (int i = 0; i < proCamera2DCinematics.CinematicTargets.Count; i++)
+            {
+                if (proCamera2DCinematics.CinematicTargets[i].TargetTransform == null)
+                {
+                    proCamera2DCinematics.CinematicTargets.RemoveAt(i);
+                }
+            }
+
+            // Camera targets list
+            _cinematicTargetsList.DoLayoutList();
+            EditorGUILayout.Space();
+
+            // End duration
+            _tooltip = new GUIContent("End Duration", "How long it takes for the camera to get back to its regular targets");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("EndDuration"), _tooltip);
+
+            // End ease type
+            _tooltip = new GUIContent("End Ease Type", "The ease type of the end animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("EndEaseType"), _tooltip);
+            
+            // Use numeric boundaries
+            _tooltip = new GUIContent("Use Numeric Boundaries", "If existent, the camera movement will be limited by the numeric boundaries");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseNumericBoundaries"), _tooltip);
+
+            // Letterbox
+            _tooltip = new GUIContent("Use Letterbox", "If checked, the camera will show black bars on top and bottom during the cinematic sequence");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseLetterbox"), _tooltip);
+
+            if (proCamera2DCinematics.UseLetterbox)
+            {
+                // Letterbox amount
+                _tooltip = new GUIContent("Letterbox Amount", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("LetterboxAmount"), _tooltip);
+
+                // Letterbox animation duration
+                _tooltip = new GUIContent("Letterbox Anim Duration", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("LetterboxAnimDuration"), _tooltip);
+
+                // Letterbox color
+                _tooltip = new GUIContent("Letterbox Color", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("LetterboxColor"), _tooltip);
+            }
+
+            EditorGUILayout.Space();
+
+            // Events
+            // Cinematic started event
+            _tooltip = new GUIContent("OnCinematicStarted", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("OnCinematicStarted"), _tooltip);
+
+            // Cinematic target reached event
+            _tooltip = new GUIContent("OnCinematicTargetReached", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("OnCinematicTargetReached"), _tooltip);
+
+            // Cinematic finished event
+            _tooltip = new GUIContent("OnCinematicFinished", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("OnCinematicFinished"), _tooltip);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Test buttons
+            GUI.enabled = Application.isPlaying && proCamera2DCinematics.CinematicTargets.Count > 0;
+            if (GUILayout.Button((proCamera2DCinematics.IsPlaying ? "Stop" : "Start") + " Cinematic"))
+            {
+                if (proCamera2DCinematics.IsPlaying)
+                    proCamera2DCinematics.Stop();
+                else
+                    proCamera2DCinematics.Play();
+            }
+            GUI.enabled = true;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DCinematicsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9a2e65b71725e4c5bbf002444e31c9aa
+timeCreated: 1445100310
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DContentFitterEditor.cs

@@ -0,0 +1,135 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DContentFitter))]
+    public class ProCamera2DAspectRatioEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DContentFitter)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DAspectRatio = (ProCamera2DContentFitter)target;
+            if (proCamera2DAspectRatio.ProCamera2D == null)
+            {
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                return;
+            }
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+    
+            // Mode
+            var changedMode = false;
+            EditorGUI.BeginChangeCheck ();
+            _tooltip = new GUIContent("Content Fitter Mode", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_contentFitterMode"), _tooltip);
+            if (EditorGUI.EndChangeCheck())
+            {
+                changedMode = true;
+                proCamera2DAspectRatio.ProCamera2D.GameCamera.ResetProjectionMatrix();
+            }
+            
+            switch (proCamera2DAspectRatio.ContentFitterMode)
+            {
+                case ContentFitterMode.FixedHeight:
+                    _tooltip = new GUIContent("Target Height", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_targetHeight"), _tooltip);
+                    break;
+                    
+                case ContentFitterMode.FixedWidth:
+                    _tooltip = new GUIContent("Target Width", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_targetWidth"), _tooltip);
+                    break;
+                    
+                case ContentFitterMode.AspectRatio:
+                    var changedWidth = false;
+                    var changedHeight = false;
+                    
+                    // Target Width
+                    EditorGUI.BeginChangeCheck ();
+                    _tooltip = new GUIContent("Target Width", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_targetWidth"), _tooltip);
+                    if (EditorGUI.EndChangeCheck ())
+                        changedWidth = true;
+                    
+                    // Target Height
+                    EditorGUI.BeginChangeCheck ();
+                    _tooltip = new GUIContent("Target Height", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_targetHeight"), _tooltip);
+                    if (EditorGUI.EndChangeCheck ())
+                        changedHeight = true;
+                    
+                    // Target Aspect Ratio
+                    EditorGUI.BeginChangeCheck ();
+                    _tooltip = new GUIContent("Target Aspect Ratio", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_targetAspectRatio"), _tooltip);
+                    if (EditorGUI.EndChangeCheck ())
+                    {
+                        changedWidth = true;
+                        proCamera2DAspectRatio.TargetWidth =
+                            proCamera2DAspectRatio.TargetHeight * proCamera2DAspectRatio.TargetAspectRatio;
+                    }
+                    
+                    // Horizontal Alignment
+                    _tooltip = new GUIContent("Horizontal Alignment", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("HorizontalAlignment"), _tooltip);
+                    
+                    // Vertical Alignment
+                    _tooltip = new GUIContent("Vertical Alignment", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("VerticalAlignment"), _tooltip);
+                    
+                    // Use letterbox
+                    _tooltip = new GUIContent("Use Letter/Pillarboxing", "");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("_useLetterOrPillarboxing"), _tooltip);
+                    
+                    serializedObject.ApplyModifiedProperties();
+
+                    if (changedWidth)
+                    {
+                        proCamera2DAspectRatio.TargetHeight =
+                            proCamera2DAspectRatio.TargetWidth / proCamera2DAspectRatio.TargetAspectRatio;
+                    }
+                    else if (changedHeight)
+                    {
+                        proCamera2DAspectRatio.TargetWidth =
+                            proCamera2DAspectRatio.TargetHeight * proCamera2DAspectRatio.TargetAspectRatio;
+                    }
+                    break;
+            }
+            
+            serializedObject.ApplyModifiedProperties();
+            
+            if(changedMode && proCamera2DAspectRatio.ContentFitterMode == ContentFitterMode.AspectRatio)
+                proCamera2DAspectRatio.TargetWidth = proCamera2DAspectRatio.TargetHeight * proCamera2DAspectRatio.TargetAspectRatio;
+
+            if (proCamera2DAspectRatio.TargetWidth < .1f)
+                proCamera2DAspectRatio.TargetWidth = .1f;
+            if (proCamera2DAspectRatio.TargetHeight < .1f)
+                proCamera2DAspectRatio.TargetHeight = .1f;
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DContentFitterEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: fef095ad04a364516b1d801635b8d45e
+timeCreated: 1444930113
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DForwardFocusEditor.cs

@@ -0,0 +1,100 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DForwardFocus))]
+    public class ProCamera2DForwardFocusEditor : Editor
+    {
+    	GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DForwardFocus)target);
+        }
+
+    	public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+        	var proCamera2DForwardFocus = (ProCamera2DForwardFocus)target;
+
+			serializedObject.Update();
+
+			// Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            if(proCamera2DForwardFocus.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+			// Progressive
+			_tooltip = new GUIContent("Progressive", "Should the forward focus move progressively based on the camera speed or should it transition to the focus based on the direction.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Progressive"), _tooltip);
+
+
+            // Speed multiplier
+            if(proCamera2DForwardFocus.Progressive)
+            {
+				_tooltip = new GUIContent("Speed Multiplier", "Multiply the camera speed by this number. You probably only want to change this value if the camera speed is not sufficient to reach the target focus.");
+	            EditorGUILayout.PropertyField(serializedObject.FindProperty("SpeedMultiplier"), _tooltip);
+            }
+
+
+            // Transition smoothness
+            _tooltip = new GUIContent("Transition Smoothness", "How smoothly should the forward focus influence move?");
+
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionSmoothness"), _tooltip);
+
+            if(proCamera2DForwardFocus.TransitionSmoothness < 0f) proCamera2DForwardFocus.TransitionSmoothness = 0f;
+
+
+            // Movement threshold
+            _tooltip = new GUIContent ("Movement Threshold", "If the camera movement is smaller than this, it will be ignored. Use it to prevent unexpected forward focus direction changes");
+
+            EditorGUILayout.PropertyField (serializedObject.FindProperty ("MovementThreshold"), _tooltip);
+
+            if (proCamera2DForwardFocus.MovementThreshold.x < 0f) proCamera2DForwardFocus.MovementThreshold.x = 0f;
+            if (proCamera2DForwardFocus.MovementThreshold.y < 0f) proCamera2DForwardFocus.MovementThreshold.y = 0f;
+
+
+            // Maintain Influence On Stop
+			_tooltip = new GUIContent("Maintain Influence On Stop", "Should the influence maintain after the camera stops?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("MaintainInfluenceOnStop"), _tooltip);
+
+
+            // Left focus
+            _tooltip = new GUIContent("Left Focus", "How much should the camera compensate when moving left?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("LeftFocus"), _tooltip);
+
+
+            // Right focus
+            _tooltip = new GUIContent("Right Focus", "How much should the camera compensate when moving right?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("RightFocus"), _tooltip);
+
+
+            // Up focus
+            _tooltip = new GUIContent("Up Focus", "How much should the camera compensate when moving up?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TopFocus"), _tooltip);
+
+
+            // Down focus
+            _tooltip = new GUIContent("Down Focus", "How much should the camera compensate when moving down?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("BottomFocus"), _tooltip);
+
+
+			serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DForwardFocusEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3618ca0cfb2be4d3c875332d2e7b9831
+timeCreated: 1432167686
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DGeometryBoundariesEditor.cs

@@ -0,0 +1,29 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DGeometryBoundaries))]
+    public class ProCamera2DGeometryBoundariesEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DGeometryBoundaries = (ProCamera2DGeometryBoundaries)target;
+
+            if (proCamera2DGeometryBoundaries.ProCamera2D == null)
+            {
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                return;
+            }
+
+            DrawDefaultInspector();
+
+            if (proCamera2DGeometryBoundaries.ProCamera2D.CenterTargetOnStart)
+                EditorGUILayout.HelpBox("Centering on target at start while using geometry boundaries might cause the camera to get stuck.", MessageType.Warning, true);
+            
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DGeometryBoundariesEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f684a511b29e0489bbac1ffbfaa8fdce
+timeCreated: 1445297384
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DLimitDistanceEditor.cs

@@ -0,0 +1,96 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DLimitDistance))]
+	public class ProCamera2DLimitDistanceEditor : Editor
+	{
+		GUIContent _tooltip;
+
+		MonoScript _script;
+
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			_script = MonoScript.FromMonoBehaviour((ProCamera2DLimitDistance)target);
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DLimitDistance = (ProCamera2DLimitDistance)target;
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+			if (proCamera2DLimitDistance.ProCamera2D == null)
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+			
+			// Use Targets Position
+			EditorGUILayout.Space();
+			_tooltip = new GUIContent("Use Targets Position", "If enabled, the extension will use the targets midpoint instead of the camera center for calculations.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsPosition"), _tooltip);
+			EditorGUILayout.Space();
+
+			// Limits
+			DrawGUI(
+				"Limit Top Distance",
+				"Prevent the camera target from getting out of the screen. Use this if you have a high follow smoothness and your targets are getting out of the screen.",
+				"LimitTopCameraDistance",
+				proCamera2DLimitDistance.LimitTopCameraDistance,
+				"MaxTopTargetDistance");
+
+			DrawGUI(
+				"Limit Bottom Distance",
+				"Prevent the camera target from getting out of the screen. Use this if you have a high follow smoothness and your targets are getting out of the screen.",
+				"LimitBottomCameraDistance",
+				proCamera2DLimitDistance.LimitBottomCameraDistance,
+				"MaxBottomTargetDistance");
+
+			DrawGUI(
+				"Limit Left Distance",
+				"Prevent the camera target from getting out of the screen. Use this if you have a high follow smoothness and your targets are getting out of the screen.",
+				"LimitLeftCameraDistance",
+				proCamera2DLimitDistance.LimitLeftCameraDistance,
+				"MaxLeftTargetDistance");
+
+			DrawGUI(
+				"Limit Right Distance",
+				"Prevent the camera target from getting out of the screen. Use this if you have a high follow smoothness and your targets are getting out of the screen.",
+				"LimitRightCameraDistance",
+				proCamera2DLimitDistance.LimitRightCameraDistance,
+				"MaxRightTargetDistance");
+
+			serializedObject.ApplyModifiedProperties();
+		}
+
+		void DrawGUI(string label, string description, string prop1, bool prop2, string prop3)
+		{
+			EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent(label, description);
+			EditorGUILayout.PropertyField(serializedObject.FindProperty(prop1), _tooltip);
+
+			if (prop2)
+			{
+				_tooltip = new GUIContent(" ", "");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty(prop3), _tooltip);
+			}
+
+			EditorGUILayout.EndHorizontal();
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DLimitDistanceEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a02f82477f4d04eac8783a722a5016c9
+timeCreated: 1455279332
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DLimitSpeedEditor.cs

@@ -0,0 +1,89 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DLimitSpeed))]
+    public class ProCamera2DLimitSpeedEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DLimitSpeed)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DLimitSpeed = (ProCamera2DLimitSpeed)target;
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            if(proCamera2DLimitSpeed.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            // Max speed horizontal
+            EditorGUILayout.BeginHorizontal();
+
+            _tooltip = new GUIContent("Limit Horizontal Speed", "Limit how fast the camera moves per second on the horizontal axis");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("LimitHorizontalSpeed"), _tooltip);
+
+            if (proCamera2DLimitSpeed.LimitHorizontalSpeed)
+            {
+                _tooltip = new GUIContent(" ", "Limit how fast the camera moves per second on the horizontal axis");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("MaxHorizontalSpeed"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Max speed vertical
+            EditorGUILayout.BeginHorizontal();
+
+            _tooltip = new GUIContent("Limit Vertical Speed", "Limit how fast the camera moves per second on the vertical axis");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("LimitVerticalSpeed"), _tooltip);
+
+            if (proCamera2DLimitSpeed.LimitVerticalSpeed)
+            {
+                _tooltip = new GUIContent(" ", "Limit how fast the camera moves per second on the vertical axis");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("MaxVerticalSpeed"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Limit values
+            if (proCamera2DLimitSpeed.MaxHorizontalSpeed <= 0f)
+                proCamera2DLimitSpeed.MaxHorizontalSpeed = .01f;
+
+            if (proCamera2DLimitSpeed.MaxVerticalSpeed <= 0f)
+                proCamera2DLimitSpeed.MaxVerticalSpeed = .01f;
+
+            // Show current speed
+            EditorGUILayout.Space();
+            GUI.enabled = false;
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Label("Current Speed");
+            GUILayout.Label("H: " + Mathf.Abs(proCamera2DLimitSpeed.CurrentSpeedHorizontal).ToString("F") + "    V: " + Mathf.Abs(proCamera2DLimitSpeed.CurrentSpeedVertical).ToString("F"));
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DLimitSpeedEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0c78eb40490804974bdabc9e747d1684
+timeCreated: 1455205028
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DNumericBoundariesEditor.cs

@@ -0,0 +1,151 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DNumericBoundaries))]
+	public class ProCamera2DNumericBoundariesEditor : Editor
+	{
+		GUIContent _tooltip;
+
+		MonoScript _script;
+
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			_script = MonoScript.FromMonoBehaviour((ProCamera2DNumericBoundaries)target);
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DNumericBoundaries = (ProCamera2DNumericBoundaries)target;
+			if (proCamera2DNumericBoundaries.ProCamera2D == null)
+			{
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+				return;
+			}
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+			_tooltip = new GUIContent("Use Numeric Boundaries", "Should the camera position be constrained by position?");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseNumericBoundaries"), _tooltip);
+
+			// Boundaries
+			GUI.enabled = proCamera2DNumericBoundaries.UseNumericBoundaries;
+			EditorGUI.indentLevel = 1;
+
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Use Top", "Prevent camera movement beyond this point");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTopBoundary"), _tooltip);
+
+			if (proCamera2DNumericBoundaries.UseTopBoundary)
+			{
+				_tooltip = new GUIContent(" ", "Prevent camera movement beyond this point");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("TopBoundary"), _tooltip);
+			}
+
+			if (proCamera2DNumericBoundaries.UseBottomBoundary && proCamera2DNumericBoundaries.TopBoundary < proCamera2DNumericBoundaries.BottomBoundary)
+				proCamera2DNumericBoundaries.TopBoundary = proCamera2DNumericBoundaries.BottomBoundary;
+
+			EditorGUILayout.EndHorizontal();
+
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Use Bottom", "Prevent camera movement beyond this point");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseBottomBoundary"), _tooltip);
+
+			if (proCamera2DNumericBoundaries.UseBottomBoundary)
+			{
+				_tooltip = new GUIContent(" ", "Prevent camera movement beyond this point");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("BottomBoundary"), _tooltip);
+			}
+
+			if (proCamera2DNumericBoundaries.UseTopBoundary && proCamera2DNumericBoundaries.BottomBoundary > proCamera2DNumericBoundaries.TopBoundary)
+				proCamera2DNumericBoundaries.BottomBoundary = proCamera2DNumericBoundaries.TopBoundary;
+
+			EditorGUILayout.EndHorizontal();
+
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Use Left", "Prevent camera movement beyond this point");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseLeftBoundary"), _tooltip);
+
+			if (proCamera2DNumericBoundaries.UseLeftBoundary)
+			{
+				_tooltip = new GUIContent(" ", "Prevent camera movement beyond this point");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("LeftBoundary"), _tooltip);
+			}
+
+			if (proCamera2DNumericBoundaries.UseRightBoundary && proCamera2DNumericBoundaries.LeftBoundary > proCamera2DNumericBoundaries.RightBoundary)
+				proCamera2DNumericBoundaries.LeftBoundary = proCamera2DNumericBoundaries.RightBoundary;
+
+			EditorGUILayout.EndHorizontal();
+
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Use Right", "Prevent camera movement beyond this point");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseRightBoundary"), _tooltip);
+
+			if (proCamera2DNumericBoundaries.UseRightBoundary)
+			{
+				_tooltip = new GUIContent(" ", "Prevent camera movement beyond this point");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("RightBoundary"), _tooltip);
+			}
+
+			if (proCamera2DNumericBoundaries.UseLeftBoundary && proCamera2DNumericBoundaries.RightBoundary < proCamera2DNumericBoundaries.LeftBoundary)
+				proCamera2DNumericBoundaries.RightBoundary = proCamera2DNumericBoundaries.LeftBoundary;
+
+			EditorGUILayout.EndHorizontal();
+
+			if ((proCamera2DNumericBoundaries.UseTopBoundary && proCamera2DNumericBoundaries.UseBottomBoundary && proCamera2DNumericBoundaries.BottomBoundary == proCamera2DNumericBoundaries.TopBoundary) ||
+				(proCamera2DNumericBoundaries.UseLeftBoundary && proCamera2DNumericBoundaries.UseRightBoundary && proCamera2DNumericBoundaries.LeftBoundary == proCamera2DNumericBoundaries.RightBoundary))
+				EditorGUILayout.HelpBox("Same axis boundaries can't have the same value!", MessageType.Error, true);
+
+			EditorGUI.indentLevel = 0;
+			EditorGUILayout.Space();
+			GUI.enabled = true;
+
+			// Soft boundaries
+			_tooltip = new GUIContent("Soft Boundaries", "If enabled, the camera movement will ease out at the boundaries instead of instantly stopping.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseSoftBoundaries"), _tooltip);
+
+			GUI.enabled = proCamera2DNumericBoundaries.UseSoftBoundaries;
+			EditorGUI.indentLevel = 1;
+			
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Frame Delay On Enter", "If enabled, the soft boundaries will be delayed for a number of frames (use if a jerking motion is noticed when entering a scene).");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseBoundaryDelayOnEnterScene"), _tooltip);
+
+			GUI.enabled = proCamera2DNumericBoundaries.UseBoundaryDelayOnEnterScene;
+			_tooltip = new GUIContent(" ", "The number of frames to delay the activation of the soft boundaries when entering scene.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("BoundaryDelayFrames"), _tooltip);
+			EditorGUILayout.EndHorizontal();
+
+
+			_tooltip = new GUIContent("Softness", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("Softness"), _tooltip);
+
+			_tooltip = new GUIContent("Soft Area", "The distance from the boundary from which the camera will start easing out the movement");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("SoftAreaSize"), _tooltip);
+			
+			if (proCamera2DNumericBoundaries.SoftAreaSize <= 0)
+				proCamera2DNumericBoundaries.SoftAreaSize = .001f;
+
+			EditorGUI.indentLevel = 0;
+			GUI.enabled = true;
+
+			serializedObject.ApplyModifiedProperties();
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DNumericBoundariesEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 05dea446992c0436c842613c03fd93f0
+timeCreated: 1444933705
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPanAndZoomEditor.cs

@@ -0,0 +1,216 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DPanAndZoom))]
+	public class ProCamera2DPanAndZoomEditor : Editor
+	{
+		GUIContent _tooltip;
+
+		MonoScript _script;
+
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			_script = MonoScript.FromMonoBehaviour((ProCamera2DPanAndZoom)target);
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DPanAndZoom = (ProCamera2DPanAndZoom)target;
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+			if (proCamera2DPanAndZoom.ProCamera2D == null)
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+			EditorGUILayout.Space();
+			
+			// Input method
+			_tooltip = new GUIContent("Automatic Input Detection", "If enabled, the input method will be automatically detected. Mouse on desktop and touch on mobile. Disable to enable both (beta).");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("AutomaticInputDetection"), _tooltip);
+
+			if (!proCamera2DPanAndZoom.AutomaticInputDetection)
+			{
+				EditorGUI.indentLevel = 1;
+				
+				_tooltip = new GUIContent("Use Mouse Input", "");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UseMouseInput"), _tooltip);
+				
+				_tooltip = new GUIContent("Use Touch Input", "");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTouchInput"), _tooltip);
+				
+				EditorGUI.indentLevel = 0;
+
+				EditorGUILayout.Space();
+			}
+
+			// Disable over uGUI
+			_tooltip = new GUIContent("Disable Over uGUI", "If enabled, the camera won't pan or zoom if the user has a pointer (or touch) over a UI element");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("DisableOverUGUI"), _tooltip);
+
+			// Allow Zoom
+			_tooltip = new GUIContent("Allow Zoom", "If enabled, the user will be able to manually zoom the camera");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("AllowZoom"), _tooltip);
+
+			if (proCamera2DPanAndZoom.AllowZoom)
+			{
+				EditorGUI.indentLevel = 1;
+
+				// Mouse zoom speed
+				_tooltip = new GUIContent("Mouse Zoom Speed", "The speed at which to zoom when using the mouse wheel (Desktop Only)");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("MouseZoomSpeed"), _tooltip);
+
+				// Pinch zoom speed
+				_tooltip = new GUIContent("Pinch Zoom Speed", "The speed at which to zoom when using the pinch gesture (Mobile Only)");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("PinchZoomSpeed"), _tooltip);
+
+				// Zoom smoothness
+				_tooltip = new GUIContent("Zoom Smoothness", "The smoothness of the zoom");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("ZoomSmoothness"), _tooltip);
+
+				// Max zoom in amount
+				_tooltip = new GUIContent("Max Zoom In Amount", "Represents the maximum amount the camera should zoom in");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("MaxZoomInAmount"), _tooltip);
+
+				// Max zoom in amount
+				_tooltip = new GUIContent("Max Zoom Out Amount", "Represents the maximum amount the camera should zoom out");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("MaxZoomOutAmount"), _tooltip);
+
+				// Zoom to input center
+				_tooltip = new GUIContent("Zoom To Input Center", "If enabled, the camera will zoom to the current input position (mouse or touch). If disabled, the camera will zoom to its center");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("ZoomToInputCenter"), _tooltip);
+
+				EditorGUI.indentLevel = 0;
+
+				EditorGUILayout.Space();
+			}
+
+			// Allow Pan
+			_tooltip = new GUIContent("Allow Pan", "If enabled, the user will be able to manually pan the camera");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("AllowPan"), _tooltip);
+
+			if (proCamera2DPanAndZoom.AllowPan)
+			{
+				EditorGUI.indentLevel = 1;
+
+				// Use pan by drag
+				_tooltip = new GUIContent("Use Drag Pan", "Pan the camera by dragging the 'world'");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UsePanByDrag"), _tooltip);
+
+				if (proCamera2DPanAndZoom.UsePanByDrag)
+				{
+					EditorGUI.indentLevel = 2;
+					
+					// Min Pan Amount
+					_tooltip = new GUIContent("Min Pan Amount", "What's the minimum pan amount (in screen size percentage) that can trigger the pan movement? Consider it like a dead zone.");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("MinPanAmount"), _tooltip);
+					
+					// Pan mouse button
+					_tooltip = new GUIContent("Drag Mouse Button", "Which mouse button do you want to use for panning? Only applicable if mouse is used");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("PanMouseButton"), _tooltip);
+					
+					_tooltip = new GUIContent("Drag Speed Multiplier", "The speed at which to pan the camera");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("DragPanSpeedMultiplier"), _tooltip);
+
+					_tooltip = new GUIContent("Draggable Area", "A normalized screen space area where the drag is active. Leave to default to use the whole screen");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("DraggableAreaRect"), _tooltip);
+
+					_tooltip = new GUIContent("Stop Speed On Drag Start", "How fast the camera inertia stops once the user starts dragging");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("StopSpeedOnDragStart"), _tooltip);
+					EditorGUI.indentLevel = 1;
+				}
+
+				// Use pan by move to edges
+				_tooltip = new GUIContent("Use Edges Pan", "Pan the camera by moving the mouse to the edges of the screen (Desktop only)");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UsePanByMoveToEdges"), _tooltip);
+
+				if (proCamera2DPanAndZoom.UsePanByMoveToEdges)
+				{
+					EditorGUI.indentLevel = 2;
+					_tooltip = new GUIContent("Edges Pan Speed", "The speed at which the camera will move when the mouse reaches the edges of the screen");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("EdgesPanSpeed"), _tooltip);
+
+					_tooltip = new GUIContent("Top Pan Edge", "If the mouse pointer goes beyond this edge the camera will start moving vertically");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("TopPanEdge"), _tooltip);
+
+					_tooltip = new GUIContent("Bottom Pan Edge", "If the mouse pointer goes beyond this edge the camera will start moving vertically");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("BottomPanEdge"), _tooltip);
+
+					_tooltip = new GUIContent("Left Pan Edge", "If the mouse pointer goes beyond this edge the camera will start moving horizontally");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("LeftPanEdge"), _tooltip);
+
+					_tooltip = new GUIContent("Right Pan Edge", "If the mouse pointer goes beyond this edge the camera will start moving horizontally");
+					EditorGUILayout.PropertyField(serializedObject.FindProperty("RightPanEdge"), _tooltip);
+					EditorGUI.indentLevel = 1;
+				}
+
+				EditorGUI.indentLevel = 0;
+			}
+
+			// Apply properties
+			serializedObject.ApplyModifiedProperties();
+
+			// Limit
+			if (proCamera2DPanAndZoom.MaxZoomInAmount < 1f)
+				proCamera2DPanAndZoom.MaxZoomInAmount = 1f;
+
+			if (proCamera2DPanAndZoom.MaxZoomOutAmount < 1f)
+				proCamera2DPanAndZoom.MaxZoomOutAmount = 1f;
+
+			if (proCamera2DPanAndZoom.ZoomSmoothness < 0f)
+				proCamera2DPanAndZoom.ZoomSmoothness = 0f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.width < 0f)
+				proCamera2DPanAndZoom.DraggableAreaRect.width = 0f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.width > 1f)
+				proCamera2DPanAndZoom.DraggableAreaRect.width = 1f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.height < 0f)
+				proCamera2DPanAndZoom.DraggableAreaRect.height = 0f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.height > 1f)
+				proCamera2DPanAndZoom.DraggableAreaRect.height = 1f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.x < -.5f)
+				proCamera2DPanAndZoom.DraggableAreaRect.x = -.5f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.x > .5f)
+				proCamera2DPanAndZoom.DraggableAreaRect.x = .5f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.y < -.5f)
+				proCamera2DPanAndZoom.DraggableAreaRect.y = -.5f;
+
+			if (proCamera2DPanAndZoom.DraggableAreaRect.y > .5f)
+				proCamera2DPanAndZoom.DraggableAreaRect.y = .5f;
+			
+			if (proCamera2DPanAndZoom.MinPanAmount < 0f)
+				proCamera2DPanAndZoom.MinPanAmount = 0f;
+			
+			if (proCamera2DPanAndZoom.MinPanAmount > 1f)
+				proCamera2DPanAndZoom.MinPanAmount = 1f;
+
+			// Warning
+			if (!proCamera2DPanAndZoom.AllowPan && !proCamera2DPanAndZoom.AllowZoom)
+			{
+				EditorGUILayout.HelpBox("This won't be the most useful extension now, will it?", MessageType.Warning, true);
+			}
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPanAndZoomEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4bb42435cc3584998b8842101e1b3873
+timeCreated: 1452878040
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DParallaxEditor.cs

@@ -0,0 +1,409 @@
+using System.Linq;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+#if USING_URP
+using UnityEngine.Rendering.Universal;
+#endif
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DParallax))]
+	public class ProCamera2DParallaxEditor : Editor
+	{
+		GUIContent _tooltip;
+
+		ReorderableList _parallaxLayersList;
+
+		ProCamera2D _proCamera2D;
+		ProCamera2DParallax _proCamera2DParallax;
+
+		MonoScript _script;
+		
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			_proCamera2DParallax = (ProCamera2DParallax)target;
+
+			_proCamera2D = _proCamera2DParallax.ProCamera2D;
+
+			_script = MonoScript.FromMonoBehaviour(_proCamera2DParallax);
+			
+			// Parallax layers List
+			_parallaxLayersList = new ReorderableList(serializedObject, serializedObject.FindProperty("ParallaxLayers"), false, true, true, true);
+
+			// Draw element callback
+			_parallaxLayersList.drawElementCallback = (rect, index, isActive, isFocused) =>
+			{
+				rect.y += 2;
+				var element = _parallaxLayersList.serializedProperty.GetArrayElementAtIndex(index);
+				
+				EditorGUI.PrefixLabel(new Rect(rect.x, rect.y, 65, 10), new GUIContent("Camera", "The parallax camera"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 65,
+						rect.y,
+						80,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("ParallaxCamera"), GUIContent.none);
+
+
+				// Speed slider
+				EditorGUI.LabelField(new Rect(rect.x + 170, rect.y, 65, 20), new GUIContent(_proCamera2DParallax.UseIndependentAxisSpeeds ? "SpeedX" : "Speed", "The relative speed at which the camera should move in comparison to the main camera."));
+				
+				if(_proCamera2DParallax.UseIndependentAxisSpeeds )
+					EditorGUI.LabelField(new Rect(rect.x + 170, rect.y + 15, 65, 20), new GUIContent("SpeedY", "The relative speed at which the camera should move in comparison to the main camera."));
+				
+				if (_proCamera2DParallax.UseIndependentAxisSpeeds)
+				{
+					EditorGUI.PropertyField(new Rect(
+							rect.x + 215,
+							rect.y,
+							rect.width - 215,
+							EditorGUIUtility.singleLineHeight),
+						element.FindPropertyRelative("SpeedX"), GUIContent.none);
+					EditorGUI.PropertyField(new Rect(
+							rect.x + 215,
+							rect.y + 15,
+							rect.width - 215,
+							EditorGUIUtility.singleLineHeight),
+						element.FindPropertyRelative("SpeedY"), GUIContent.none);
+				}
+				else
+				{
+					EditorGUI.PropertyField(new Rect(
+							rect.x + 210,
+							rect.y,
+							rect.width - 210,
+							EditorGUIUtility.singleLineHeight),
+						element.FindPropertyRelative("Speed"), GUIContent.none);
+				}
+
+				if (_proCamera2DParallax.UseIndependentAxisSpeeds)
+					rect.y += 10;
+
+				// Layer mask
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 25, 65, 10), new GUIContent("Culling Mask", "Which layers should this camera render?"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 85,
+						rect.y + 25,
+						rect.width - 85,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("LayerMask"), GUIContent.none);
+			};
+
+			// Draw header callback
+			_parallaxLayersList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "Parallax layers");
+
+			// Add element callback
+			_parallaxLayersList.onAddCallback = list => AddParallaxLayer();
+
+			// Remove element callback
+			_parallaxLayersList.onRemoveCallback = list =>
+			{
+				if (EditorUtility.DisplayDialog("Warning!", "Are you sure you want to delete this layer?", "Yes", "No"))
+				{
+					var cam = list.serializedProperty.GetArrayElementAtIndex(list.index).FindPropertyRelative("ParallaxCamera").objectReferenceValue as Camera;
+					if (cam != null)
+						DestroyImmediate(cam.gameObject);
+
+					ReorderableList.defaultBehaviours.DoRemoveButton(list);
+				}
+			};
+
+			// Select element callback
+			_parallaxLayersList.onSelectCallback = list =>
+			{
+				EditorGUIUtility.PingObject(list.serializedProperty.GetArrayElementAtIndex(list.index).FindPropertyRelative("ParallaxCamera").objectReferenceValue as Camera);
+			};
+
+			_parallaxLayersList.onReorderCallback = list =>
+			{
+				if (_proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags != CameraClearFlags.SolidColor &&
+					_proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags != CameraClearFlags.Skybox)
+					_proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags = CameraClearFlags.SolidColor;
+			};
+
+			_parallaxLayersList.elementHeight = 70;
+			_parallaxLayersList.headerHeight = 18;
+			_parallaxLayersList.draggable = true;
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+			if (_proCamera2DParallax.ProCamera2D == null)
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+			_proCamera2D = _proCamera2DParallax.ProCamera2D;
+			if (_proCamera2D == null)
+			{
+				serializedObject.ApplyModifiedProperties();
+				return;
+			}
+
+			// Perspective camera
+			if (!_proCamera2D.GameCamera.orthographic)
+				EditorGUILayout.HelpBox("ProCamera2D Parallax needs an orthographic projection camera to work.", MessageType.Error, true);
+
+			// Parallax layers List
+			_parallaxLayersList.DoLayoutList();
+
+			var areSpeedsNotOrdered = false;
+			var isLayerMaskEmpty = false;
+			var isLayerMaskOverlapping = false;
+			for (var i = 0; i < _proCamera2DParallax.ParallaxLayers.Count; i++)
+			{
+				// Detect unordered speeds
+				if (i < _proCamera2DParallax.ParallaxLayers.Count - 1)
+				{
+					if (_proCamera2DParallax.ParallaxLayers[i].Speed > _proCamera2DParallax.ParallaxLayers[i + 1].Speed)
+						areSpeedsNotOrdered = true;
+				}
+
+				// Detect empty layer masks
+				if (_proCamera2DParallax.ParallaxLayers[i].LayerMask.value == 0)
+					isLayerMaskEmpty = true;
+
+				// Detect equal layer masks
+				for (var j = 0; j < _proCamera2DParallax.ParallaxLayers.Count; j++)
+				{
+					if (i != j && _proCamera2DParallax.ParallaxLayers[i].LayerMask.value == _proCamera2DParallax.ParallaxLayers[j].LayerMask.value)
+						isLayerMaskOverlapping = true;
+				}
+
+				// Remove layers with no camera assigned
+				if (_proCamera2DParallax.ParallaxLayers[i].ParallaxCamera == null)
+				{
+					_proCamera2DParallax.ParallaxLayers.RemoveAt(i);
+					GUIUtility.ExitGUI();
+					continue;
+				}
+
+				// Apply layer masks as camera culling mask
+				_proCamera2DParallax.ParallaxLayers[i].ParallaxCamera.cullingMask = _proCamera2DParallax.ParallaxLayers[i].LayerMask;
+
+				// Setup clear flags
+				if (_proCamera2DParallax.ParallaxLayers[0].Speed > 1)
+				{
+					_proCamera2D.GameCamera.clearFlags = CameraClearFlags.SolidColor;
+					_proCamera2DParallax.ParallaxLayers[i].ParallaxCamera.clearFlags = CameraClearFlags.Depth;
+				}
+				else
+				{
+					_proCamera2D.GameCamera.clearFlags = CameraClearFlags.Depth;
+
+					if (i > 0)
+					{
+						_proCamera2DParallax.ParallaxLayers[i].ParallaxCamera.clearFlags = CameraClearFlags.Depth;
+					}
+					else if (_proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags != CameraClearFlags.SolidColor &&
+					         _proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags != CameraClearFlags.Skybox &&
+					         _proCamera2DParallax.AutomaticallyConfigureCameraClearFlags)
+					{
+						_proCamera2DParallax.ParallaxLayers[0].ParallaxCamera.clearFlags = CameraClearFlags.SolidColor;
+					}
+				}
+			}
+
+			// Show warnings
+			if (areSpeedsNotOrdered)
+				EditorGUILayout.HelpBox("Parallax layer speeds are not ordered.", MessageType.Warning, true);
+
+			if (isLayerMaskEmpty)
+				EditorGUILayout.HelpBox("One or more layer mask is empty.", MessageType.Warning, true);
+
+			if (isLayerMaskOverlapping)
+				EditorGUILayout.HelpBox("Two or more cameras are rendering the same layers. Check your Layer Masks.", MessageType.Warning, true);
+
+
+			// Setup depths
+			var sortedNegativeParallaxLayers = _proCamera2DParallax.ParallaxLayers
+				.OrderByDescending(x => x.Speed)
+				.Where(p => p.Speed < 1)
+				.ToList();
+
+			for (var i = 0; i < sortedNegativeParallaxLayers.Count; i++)
+			{
+				var parallaxLayer = sortedNegativeParallaxLayers[i];
+				parallaxLayer.ParallaxCamera.depth = _proCamera2DParallax.BackDepthStart - i - 1;
+			}
+
+			var sortedPositiveParallaxLayers = _proCamera2DParallax.ParallaxLayers
+				.OrderBy(x => x.Speed)
+				.Where(p => p.Speed > 1)
+				.ToList();
+
+			for (var i = 0; i < sortedPositiveParallaxLayers.Count; i++)
+			{
+				var parallaxLayer = sortedPositiveParallaxLayers[i];
+				parallaxLayer.ParallaxCamera.depth = _proCamera2DParallax.FrontDepthStart + i + 1;
+			}
+			
+			// Setup hierarchy order
+			var sortedParallaxLayers = _proCamera2DParallax.ParallaxLayers
+				.OrderBy(x => x.Speed)
+				.ToList();
+
+			for (var i = 0; i < sortedParallaxLayers.Count; i++)
+			{
+				var parallaxLayer = sortedParallaxLayers[i];
+				parallaxLayer.ParallaxCamera.transform.SetSiblingIndex(i);
+			}
+			
+#if USING_URP
+			sortedParallaxLayers.Add(new ProCamera2DParallaxLayer
+			{
+				ParallaxCamera = _proCamera2DParallax.ProCamera2D.GameCamera,
+				CameraTransform = _proCamera2DParallax.ProCamera2D.transform,
+				Speed = 1
+			});
+			
+			sortedParallaxLayers = sortedParallaxLayers
+				.OrderBy(x => x.Speed)
+				.ToList();
+			
+			for (var i = 0; i < sortedParallaxLayers.Count; i++)
+			{
+				var parallaxLayer = sortedParallaxLayers[i];
+				
+				var cameraData = parallaxLayer.ParallaxCamera.GetUniversalAdditionalCameraData();
+				if (cameraData == null) continue;
+				
+				cameraData.renderType = i == 0 ? CameraRenderType.Base : CameraRenderType.Overlay;
+
+				if (i != 0 || sortedParallaxLayers.Count <= 1) continue;
+				
+				cameraData.cameraStack?.Clear();
+				for (var j = 1; j < sortedParallaxLayers.Count; j++)
+				{
+					cameraData.cameraStack?.Add(sortedParallaxLayers[j].ParallaxCamera);
+				}
+			}
+#endif
+
+			// Show correct axis name
+			var hAxis = "";
+			var vAxis = "";
+			switch (_proCamera2D.Axis)
+			{
+				case MovementAxis.XY:
+					hAxis = "X";
+					vAxis = "Y";
+					break;
+
+				case MovementAxis.XZ:
+					hAxis = "X";
+					vAxis = "Z";
+					break;
+
+				case MovementAxis.YZ:
+					hAxis = "Y";
+					vAxis = "Z";
+					break;
+			}
+
+			// Follow X
+			_tooltip = new GUIContent("Parallax " + hAxis, "Should the parallax occur on the horizontal axis? On by default.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("ParallaxHorizontal"), _tooltip);
+
+			// Follow Y
+			_tooltip = new GUIContent("Parallax " + vAxis, "Should the parallax occur on the vertical axis? On by default.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("ParallaxVertical"), _tooltip);
+
+			// Parallax Zoom
+			_tooltip = new GUIContent("Parallax Zoom", "Should the parallax layers size be affected? On by default.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("ParallaxZoom"), _tooltip);
+			
+			// Use independent axis speeds
+			_tooltip = new GUIContent("Use Independent Axis Speeds", "Enable if you want your parallax layers to move at different horizontal and vertical speeds. May cause inconsistent parallax results. Use only if you know what you're doing.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseIndependentAxisSpeeds"), _tooltip);
+			
+			// Automatically configure camera clear flags
+			_tooltip = new GUIContent("Automatically Configure Clear Flags", "Disable only if you want to manually configure your camera clear flags.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("AutomaticallyConfigureCameraClearFlags"), _tooltip);
+
+			// Back Depth Start
+			_tooltip = new GUIContent("Back Depth Start", "The depth at which the back cameras start");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("BackDepthStart"), _tooltip);
+
+			// Front Depth Start
+			_tooltip = new GUIContent("Front Depth Start", "The depth at which the front cameras start");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("FrontDepthStart"), _tooltip);
+
+			// Root Position
+			_tooltip = new GUIContent("Root Position", "The position at which your camera is going to start.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("RootPosition"), _tooltip);
+
+			// Reset offset button
+			if (GUILayout.Button("Set Root Position"))
+			{
+				switch (_proCamera2D.Axis)
+				{
+					case MovementAxis.XY:
+						_proCamera2DParallax.RootPosition = new Vector3(_proCamera2D.transform.localPosition.x, _proCamera2D.transform.localPosition.y, 0);
+						break;
+
+					case MovementAxis.XZ:
+						_proCamera2DParallax.RootPosition = new Vector3(_proCamera2D.transform.localPosition.x, 0, _proCamera2D.transform.localPosition.z);
+						break;
+
+					case MovementAxis.YZ:
+						_proCamera2DParallax.RootPosition = new Vector3(0, _proCamera2D.transform.localPosition.y, _proCamera2D.transform.localPosition.z);
+						break;
+				}
+			}
+
+			// Limit back and front depth start
+			if (_proCamera2DParallax.FrontDepthStart < _proCamera2D.GameCamera.depth)
+				_proCamera2DParallax.FrontDepthStart = (int)_proCamera2D.GameCamera.depth;
+
+			if (_proCamera2DParallax.BackDepthStart > _proCamera2D.GameCamera.depth)
+				_proCamera2DParallax.BackDepthStart = (int)_proCamera2D.GameCamera.depth;
+
+			// Rename layers
+			if (serializedObject.ApplyModifiedProperties())
+			{
+				foreach (var parallaxLayer in _proCamera2DParallax.ParallaxLayers)
+				{
+					parallaxLayer.ParallaxCamera.gameObject.name = "ParallaxCamera (" + parallaxLayer.Speed + ")";
+				}
+			}
+		}
+
+		private void AddParallaxLayer()
+		{
+			var go = new GameObject("ParallaxCamera");
+			var cam = go.AddComponent<Camera>();
+			EditorUtility.CopySerialized(_proCamera2D.GameCamera, cam);
+			go.transform.SetParent(_proCamera2D.transform);
+			go.transform.localPosition = Vector3.zero;
+
+			cam.cullingMask = 0;
+			cam.clearFlags = CameraClearFlags.Depth;
+
+			var parallaxLayer = new ProCamera2DParallaxLayer
+			{
+				ParallaxCamera = cam, 
+				Speed = 1
+			};
+
+			_proCamera2DParallax.ParallaxLayers.Add(parallaxLayer);
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DParallaxEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 5a43d15fb3d5b4ac788c748677487bbc
+timeCreated: 1432319396
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPixelPerfectEditor.cs

@@ -0,0 +1,131 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DPixelPerfect))]
+	public class ProCamera2DPixelPerfectEditor : Editor
+	{
+		MonoScript _script;
+		GUIContent _tooltip;
+
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			_script = MonoScript.FromMonoBehaviour((ProCamera2DPixelPerfect)target);
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DPixelPerfect = (ProCamera2DPixelPerfect)target;
+
+			if (proCamera2DPixelPerfect.ProCamera2D == null)
+			{
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+				return;
+			}
+
+			var isOrthographic = proCamera2DPixelPerfect.ProCamera2D.GameCamera.orthographic;
+			if (!isOrthographic)
+				EditorGUILayout.HelpBox("Pixel perfect only works with orthographic cameras!", MessageType.Error, true);
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+			EditorGUI.BeginChangeCheck();
+
+			// Pixels per unit
+			_tooltip = new GUIContent("Pixels per Unit", "How many pixels in a sprite correspond to one unit in the world");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("PixelsPerUnit"), _tooltip);
+
+			// Viewport auto-scale
+			EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Viewport AutoScale", "If not None, the camera will automatically calculate the best scale across all resolutions based on the art viewport.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("ViewportAutoScale"), _tooltip);
+
+			// Viewport Scale
+			if (proCamera2DPixelPerfect.ViewportAutoScale != AutoScaleMode.None)
+			{
+				GUI.enabled = false;
+				EditorGUILayout.LabelField(proCamera2DPixelPerfect.CalculateViewportScale() + "x", GUILayout.MaxWidth(60));
+				GUI.enabled = true;
+			}
+
+			EditorGUILayout.EndHorizontal();
+
+			// Viewport size in pixels
+			if (proCamera2DPixelPerfect.ViewportAutoScale != AutoScaleMode.None)
+			{
+				_tooltip = new GUIContent("Game Viewport (pixels)", "Set it that if the screen was of this size, each pixel on the screen would correspond to a pixel on your art. On a pixel-art game this probably has low values.");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("TargetViewportSizeInPixels"), _tooltip);
+			}
+
+			// Zoom
+			_tooltip = new GUIContent("Zoom", "The zoom level of the camera");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_zoom"), _tooltip);
+
+			// Snap movement to grid
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Snap Movement to Grid", "If checked, the the sprites will snap to the grid. Might create some stuttering on your camera targets, especially if you're using a large grid and a follow smoothness greater than zero.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("SnapMovementToGrid"), _tooltip);
+
+			if (proCamera2DPixelPerfect.SnapMovementToGrid)
+			{
+				_tooltip = new GUIContent("Snap Camera", "If checked, the camera will also snap to the grid. If you notice some stuttering in your game elements try to leave this on.");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("SnapCameraToGrid"), _tooltip);
+			}
+			EditorGUILayout.EndHorizontal();
+
+			// Draw grid
+			EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Draw Grid", "If checked, the camera will draw a pixel grid. 'Gizmos' button must be enabled on the Game window.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("DrawGrid"), _tooltip);
+
+			if (proCamera2DPixelPerfect.DrawGrid)
+			{
+				_tooltip = new GUIContent("Grid Color", "");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("GridColor"), _tooltip);
+			}
+
+			EditorGUILayout.EndHorizontal();
+
+			// Grid density warning
+			if (proCamera2DPixelPerfect.DrawGrid && proCamera2DPixelPerfect.GridDensity < 4)
+				EditorGUILayout.HelpBox("Grid density is too high to draw, so we're skipping it to avoid performance issues with the editor.", MessageType.None, true);
+
+			// Save properties
+			serializedObject.ApplyModifiedProperties();
+
+			// Limit values
+			if (proCamera2DPixelPerfect.PixelsPerUnit < 1f)
+				proCamera2DPixelPerfect.PixelsPerUnit = 1f;
+
+			if (proCamera2DPixelPerfect.TargetViewportSizeInPixels.x < 1)
+				proCamera2DPixelPerfect.TargetViewportSizeInPixels.x = 1;
+
+			if (proCamera2DPixelPerfect.TargetViewportSizeInPixels.y < 1)
+				proCamera2DPixelPerfect.TargetViewportSizeInPixels.y = 1;
+
+			// Resize camera
+			if (EditorGUI.EndChangeCheck() || !Application.isPlaying)
+			{
+				proCamera2DPixelPerfect.ResizeCameraToPixelPerfect();
+			}
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPixelPerfectEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 17ae8481c7b584e1cae66c666bdf480f
+timeCreated: 1440808166
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPixelPerfectSpriteEditor.cs

@@ -0,0 +1,99 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CanEditMultipleObjects]
+    [CustomEditor(typeof(ProCamera2DPixelPerfectSprite))]
+    public class ProCamera2DPixelPerfectSpriteEditor : Editor
+    {
+        MonoScript _script;
+        GUIContent _tooltip;
+
+        void OnEnable()
+        {
+            var proCamera2DPixelPerfectSprite = (ProCamera2DPixelPerfectSprite)target;
+            
+            _script = MonoScript.FromMonoBehaviour(proCamera2DPixelPerfectSprite);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var proCamera2DPixelPerfectSprite = (ProCamera2DPixelPerfectSprite)target;
+
+            if (proCamera2DPixelPerfectSprite.ProCamera2D == null)
+            {
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                return;
+            }
+
+            // No sprite found
+            var hasSprite = proCamera2DPixelPerfectSprite.GetComponent<SpriteRenderer>() != null;
+            if (!hasSprite)
+                EditorGUILayout.HelpBox("This component needs a Sprite renderer on the same GameObject!", MessageType.Error, true);
+
+
+            // Rigidbody, collider, character controller warning
+            if (proCamera2DPixelPerfectSprite.IsAMovingObject &&
+                (proCamera2DPixelPerfectSprite.GetComponent<Rigidbody>() != null ||
+                 proCamera2DPixelPerfectSprite.GetComponent<Rigidbody2D>() != null ||
+                 proCamera2DPixelPerfectSprite.GetComponent<Collider>() != null ||
+                 proCamera2DPixelPerfectSprite.GetComponent<Collider2D>() != null ||
+                 proCamera2DPixelPerfectSprite.GetComponent<CharacterController>() != null))
+            {
+                EditorGUILayout.HelpBox("You should not add this component to GameObjects that have physics components, because rounding the sprite to a pixel-perfect position might interfere with the physics calculations. Please add the sprite as a child of this GameObject and add this component to it instead.", MessageType.Warning, true);
+            }
+
+            serializedObject.Update();
+
+            // Show script link
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            // Moving object
+            _tooltip = new GUIContent("Is A Moving Object", "If checked, the object position will be aligned to pixel perfect every frame. To improve performance, enable only if the object (or its parent) move.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("IsAMovingObject"), _tooltip);
+
+            // Child sprite
+            if (proCamera2DPixelPerfectSprite.IsAMovingObject && proCamera2DPixelPerfectSprite.transform.parent != null)
+            {
+                _tooltip = new GUIContent("Use Parent Movement", "Enable if you're moving the parent of this sprite instead of the sprite itself.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("IsAChildSprite"), _tooltip);
+            }
+            else
+            {
+                proCamera2DPixelPerfectSprite.IsAChildSprite = false;
+            }
+
+            // Local Position
+            if (proCamera2DPixelPerfectSprite.IsAChildSprite)
+            {
+                EditorGUILayout.BeginHorizontal();
+
+                _tooltip = new GUIContent("Local Position", "If you're using the parent movement, you have to set this sprite local position using this value.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("LocalPosition"), _tooltip);
+
+                if (GUILayout.Button("R", GUILayout.Width(20)))
+                    serializedObject.FindProperty("LocalPosition").vector2Value = Vector2.zero;
+
+                EditorGUILayout.EndHorizontal();
+            }
+
+            // Pixel Scale
+            _tooltip = new GUIContent("Sprite Scale", "The scale of this sprite");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("SpriteScale"), _tooltip);
+
+            // Scale 0 warning
+            if (proCamera2DPixelPerfectSprite.SpriteScale == 0)
+            {
+                EditorGUILayout.HelpBox("A scale of 0 allows you to manually scale the sprite, however, it doesn't guarantee that it will be pixel-perfect. Use a scale different than 0 to guarantee your sprite size is pixel-perfect.", MessageType.Warning, true);
+            }
+
+            // Save properties
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPixelPerfectSpriteEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 88325b3ce424845d081502ac0c530aae
+timeCreated: 1440957737
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPointerInfluenceEditor.cs

@@ -0,0 +1,22 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DPointerInfluence))]
+    public class ProCamera2DPointerInfluenceEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DPointerInfluence = (ProCamera2DPointerInfluence)target;
+            
+            if(proCamera2DPointerInfluence.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                
+            DrawDefaultInspector();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DPointerInfluenceEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3bfe4e8d4677843e6ad26d9a6eb06950
+timeCreated: 1436383912
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRailsEditor.cs

@@ -0,0 +1,348 @@
+using UnityEditor;
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+using UnityEditorInternal;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DRails))]
+    public class ProCamera2DRailsEditor : Editor
+    {
+        Func<Vector3, float> Vector3H;
+        Func<Vector3, float> Vector3V;
+        Func<float, float, Vector3> VectorHV;
+
+        static List<Vector3> _playModeNodes = new List<Vector3>();
+        static string _currentScene;
+        
+        MonoScript _script;
+        GUIContent _tooltip;
+        
+        ReorderableList _targetsList;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+
+            var proCamera2DRails = (ProCamera2DRails)target;
+
+            // Get nodes from play mode
+            serializedObject.Update();
+
+            if (_currentScene != UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().name)
+                _playModeNodes.Clear();
+
+            _currentScene = UnityEditor.SceneManagement.EditorSceneManager.GetActiveScene().name;
+
+            if (!Application.isPlaying && _playModeNodes.Count > 0)
+            {
+                var list = serializedObject.FindProperty("RailNodes");
+                list.ClearArray();
+                for (int i = 0; i < _playModeNodes.Count; i++)
+                {
+                    list.InsertArrayElementAtIndex(i);
+                    var preset = list.GetArrayElementAtIndex(i);
+                    preset.vector3Value = _playModeNodes[i];
+                }
+                _playModeNodes.Clear();
+            }
+            serializedObject.ApplyModifiedProperties();
+            
+            // Script
+            _script = MonoScript.FromMonoBehaviour(proCamera2DRails);
+
+            // Create Vector conversion methods
+            switch (proCamera2DRails.ProCamera2D.Axis)
+            {
+                case MovementAxis.XY:
+                    Vector3H = vector => vector.x;
+                    Vector3V = vector => vector.y;
+                    VectorHV = (h, v) => new Vector3(h, v, 0);
+                    break;
+                case MovementAxis.XZ:
+                    Vector3H = vector => vector.x;
+                    Vector3V = vector => vector.z;
+                    VectorHV = (h, v) => new Vector3(h, 0, v);
+                    break;
+                case MovementAxis.YZ:
+                    Vector3H = vector => vector.z;
+                    Vector3V = vector => vector.y;
+                    VectorHV = (h, v) => new Vector3(0, v, h);
+                    break;
+            }
+            
+            // Create nodes if non-existant
+            if (proCamera2DRails.RailNodes.Count < 2)
+            {
+                proCamera2DRails.RailNodes.Add(VectorHV(1, 1));
+                proCamera2DRails.RailNodes.Add(VectorHV(2, 2));
+            }
+            
+            // Show correct axis name
+            var hAxis = "";
+            var vAxis = "";
+            switch (proCamera2DRails.ProCamera2D.Axis)
+            {
+                case MovementAxis.XY:
+                    hAxis = "X";
+                    vAxis = "Y";
+                    break;
+
+                case MovementAxis.XZ:
+                    hAxis = "X";
+                    vAxis = "Z";
+                    break;
+
+                case MovementAxis.YZ:
+                    hAxis = "Y";
+                    vAxis = "Z";
+                    break;
+            }
+            
+            // Targets List
+            _targetsList = new ReorderableList(serializedObject, serializedObject.FindProperty("CameraTargets"), false, false, true, true);
+
+            _targetsList.onSelectCallback = (list) =>
+            {
+                EditorGUIUtility.PingObject(_targetsList.serializedProperty.GetArrayElementAtIndex(_targetsList.index).FindPropertyRelative("TargetTransform").objectReferenceValue);
+            };
+
+            _targetsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 2;
+                var element = _targetsList.serializedProperty.GetArrayElementAtIndex(index);
+
+				EditorGUI.PrefixLabel(new Rect(rect.x, rect.y, 65, 10), new GUIContent("Transform", "The target transform"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 65,
+                        rect.y,
+                        80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetTransform"), GUIContent.none);
+
+				EditorGUI.PrefixLabel(new Rect(rect.x + 160, rect.y, 65, 10), new GUIContent("Offset", "Offset the camera position relative to this target"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 200,
+                        rect.y,
+                        rect.width - 200,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetOffset"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 25, 65, 10), new GUIContent("Influence" + hAxis, "How much does this target horizontal position influences the camera position?"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 80,
+                        rect.y + 25,
+                        rect.width - 80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetInfluenceH"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 40, 65, 10), new GUIContent("Influence" + vAxis, "How much does this target vertical position influences the camera position?"));
+                EditorGUI.PropertyField(new Rect(
+                        rect.x + 80,
+                        rect.y + 40,
+                        rect.width - 80,
+                        EditorGUIUtility.singleLineHeight),
+                    element.FindPropertyRelative("TargetInfluenceV"), GUIContent.none);
+            };
+
+            _targetsList.elementHeight = 80;
+            _targetsList.headerHeight = 0;
+            _targetsList.draggable = true;
+        }
+
+        void OnDisable()
+        {
+            var proCamera2DRails = (ProCamera2DRails)target;
+
+            _playModeNodes = proCamera2DRails.RailNodes;
+        }
+        
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DRails = (ProCamera2DRails)target;
+            
+            if(proCamera2DRails.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+                
+            serializedObject.Update();
+            
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+            EditorGUILayout.Space();
+            
+            // Targets Drop Area
+            Event evt = Event.current;
+            Rect drop_area = GUILayoutUtility.GetRect(0.0f, 50.0f, GUILayout.ExpandWidth(true));
+            var style = new GUIStyle("box");
+            if (EditorGUIUtility.isProSkin)
+                style.normal.textColor = Color.white;
+            GUI.Box(drop_area, "\nDROP CAMERA TARGETS HERE", style);
+
+            switch (evt.type)
+            {
+                case EventType.DragUpdated:
+                case EventType.DragPerform:
+                    if (!drop_area.Contains(evt.mousePosition))
+                        return;
+
+                    DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
+
+                    if (evt.type == EventType.DragPerform)
+                    {
+                        DragAndDrop.AcceptDrag();
+
+                        foreach (UnityEngine.Object dragged_object in DragAndDrop.objectReferences)
+                        {
+                            var newCameraTarget = new CameraTarget
+                            {
+                                TargetTransform = ((GameObject)dragged_object).transform,
+                                TargetInfluence = 1f
+                            };
+							
+                            proCamera2DRails.CameraTargets.Add(newCameraTarget);
+                            EditorUtility.SetDirty(proCamera2DRails);
+                        }
+                    }
+                    break;
+            }
+            EditorGUILayout.Space();
+            
+            // Targets List
+            _targetsList.DoLayoutList();
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            
+            // Follow mode
+            _tooltip = new GUIContent("FollowMode", "This defines which axis to use to calculate the targets position on the rails");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("FollowMode"), _tooltip);
+            EditorGUILayout.Space();
+            
+            // Apply modified properties
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        void OnSceneGUI()
+        {
+            var proCamera2DRails = (ProCamera2DRails)target;
+
+            // Return if less than 2 nodes
+            var nodesCount = proCamera2DRails.RailNodes.Count;
+            if (nodesCount < 2)
+                return;
+
+            // Detect delete mode
+            bool deleteMode = false;
+            Event e = Event.current;
+            if (e.alt || e.shift)
+            {
+                deleteMode = true;
+            }
+
+            // Handles color
+            Handles.color = EditorPrefsX.GetColor(PrefsData.RailsColorKey, PrefsData.RailsColorValue);
+
+            // Draw line between nodes
+            Handles.DrawPolyLine(proCamera2DRails.RailNodes.ToArray());
+
+            // Handle size
+            float handleSize = HandleUtility.GetHandleSize(Vector3.zero) * .1f;
+
+            // Draw left and right handles
+            var rightHandlePos = (proCamera2DRails.RailNodes[nodesCount - 1] - proCamera2DRails.RailNodes[nodesCount - 2]).normalized * .5f + proCamera2DRails.RailNodes[nodesCount - 1];
+            if (Handles.Button(
+                rightHandlePos, 
+                Quaternion.identity, 
+                handleSize * .5f, 
+                handleSize, 
+                Handles.RectangleHandleCap))
+            {
+                Undo.RecordObject(proCamera2DRails, "Add");
+                proCamera2DRails.RailNodes.Insert(nodesCount, rightHandlePos);
+            }
+
+            var leftHandlesPos = (proCamera2DRails.RailNodes[0] - proCamera2DRails.RailNodes[1]).normalized * .5f + proCamera2DRails.RailNodes[0];
+            if (Handles.Button(
+                leftHandlesPos, 
+                Quaternion.identity, 
+                handleSize * .5f, 
+                handleSize, 
+                Handles.RectangleHandleCap))
+            {
+                Undo.RecordObject(proCamera2DRails, "Add");
+                proCamera2DRails.RailNodes.Insert(0, leftHandlesPos);
+            }
+
+            // Snap value
+            var pointSnap = Vector3.one * EditorPrefs.GetFloat("RailsSnapping", PrefsData.RailsSnapping);
+
+            // Draw a handle for each node
+            for (int i = 0; i < nodesCount; i++)
+            {
+                var oldPos = proCamera2DRails.RailNodes[i];
+#if UNITY_2022_1_OR_NEWER
+                var newPos = Handles.FreeMoveHandle(oldPos, handleSize, pointSnap, Handles.DotHandleCap);
+#else
+                var newPos = Handles.FreeMoveHandle(oldPos, Quaternion.identity, handleSize, pointSnap, Handles.DotHandleCap);
+#endif
+                
+                // Move
+                if (newPos != oldPos)
+                {
+                    newPos.x = Handles.SnapValue(newPos.x, pointSnap.x);
+                    newPos.y = Handles.SnapValue(newPos.y, pointSnap.y);
+                    newPos.z = Handles.SnapValue(newPos.z, pointSnap.z);
+
+                    Undo.RecordObject(proCamera2DRails, "Move");
+                    proCamera2DRails.RailNodes[i] = VectorHV(Vector3H(newPos), Vector3V(newPos));
+                }
+
+                // Draw the midpoint button
+                if (i > 0)
+                {
+                    var midPoint = Vector3.Lerp(proCamera2DRails.RailNodes[i - 1], proCamera2DRails.RailNodes[i], 0.5f);
+
+                    if (Handles.Button(
+                        midPoint, 
+                        Quaternion.identity, 
+                        handleSize * .5f, 
+                        handleSize, 
+                        Handles.RectangleHandleCap))
+                    {
+                        Undo.RecordObject(proCamera2DRails, "Add");
+                        proCamera2DRails.RailNodes.Insert(i, midPoint);
+                    }
+                }
+
+                // Draw the delete button
+                if (deleteMode && nodesCount > 2)
+                {
+                    Handles.color = Color.red;
+                    var deleteButtonPos = proCamera2DRails.RailNodes[i];
+                    if (Handles.Button(
+                        deleteButtonPos, 
+                        Quaternion.identity, 
+                        handleSize, 
+                        handleSize, 
+                        Handles.DotHandleCap))
+                    {
+                        Undo.RecordObject(proCamera2DRails, "Remove");
+                        proCamera2DRails.RailNodes.RemoveAt(i);
+                        return;
+                    }
+                    Handles.color = EditorPrefsX.GetColor(PrefsData.RailsColorKey, PrefsData.RailsColorValue);
+                }
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRailsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 88d97cb0ec705473c9e7fc2690ee962d
+timeCreated: 1447886565
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRepeaterEditor.cs

@@ -0,0 +1,111 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DRepeater))]
+    public class ProCamera2DRepeaterEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DRepeater)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DRepeater = (ProCamera2DRepeater)target;
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            if (proCamera2DRepeater.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            // Object To Repeat
+            EditorGUI.BeginChangeCheck();
+
+            _tooltip = new GUIContent("Object To Repeat", "This is the object that you want to repeat. It may be a prefab or not.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ObjectToRepeat"), _tooltip);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                var objectToRepeat = serializedObject.FindProperty("ObjectToRepeat").objectReferenceValue as Transform;
+                if (objectToRepeat != null && objectToRepeat.GetComponent<SpriteRenderer>())
+                {
+                    var sprite = objectToRepeat.GetComponent<SpriteRenderer>();
+                    var size = new Vector2(sprite.bounds.max.x - sprite.bounds.min.x, sprite.bounds.max.y - sprite.bounds.min.y);
+
+                    serializedObject.FindProperty("ObjectSize").vector2Value = size;
+                    serializedObject.FindProperty("ObjectBottomLeft").vector2Value = -size / 2f;
+                }
+            }
+
+            if (proCamera2DRepeater.ObjectToRepeat == null)
+                EditorGUILayout.HelpBox("No object to repeat set. Please drag one to the field above.", MessageType.Error, true);
+
+            // Object Size
+            _tooltip = new GUIContent("Object Size", "The size of the object to repeat (in world units).");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ObjectSize"), _tooltip);
+
+            if (proCamera2DRepeater.ObjectSize.x <= 0)
+                proCamera2DRepeater.ObjectSize.x = .01f;
+
+            if (proCamera2DRepeater.ObjectSize.y <= 0)
+                proCamera2DRepeater.ObjectSize.y = .01f;
+
+            // Object Bottom Left
+            _tooltip = new GUIContent("Object Bottom Left", "The bottom left position of your object in relation to it's pivot (in world units).");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ObjectBottomLeft"), _tooltip);
+
+            // Object On Stage
+            _tooltip = new GUIContent("Object On Stage", "Mark as selected if your original object to repeat is already placed on the scene.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ObjectOnStage"), _tooltip);
+
+            // Repeat horizontal
+            _tooltip = new GUIContent("Repeat Horizontal", "If enabled, the object will be repeated horizontally.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_repeatHorizontal"), _tooltip);
+
+            // Repeat vertical
+            _tooltip = new GUIContent("Repeat Vertical", "If enabled, the object will be repeated vertically.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_repeatVertical"), _tooltip);
+
+            // Camera to use
+            if (proCamera2DRepeater.CameraToUse == null)
+                proCamera2DRepeater.CameraToUse = proCamera2DRepeater.ProCamera2D.GameCamera;
+
+            var parallax = FindObjectOfType<ProCamera2DParallax>();
+            if (parallax != null)
+            {
+                _tooltip = new GUIContent("Camera To Use", "Choose what camera is rendering the object to repeat.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("CameraToUse"), _tooltip);
+            }
+
+            if (serializedObject.ApplyModifiedProperties())
+            {
+                if (Application.isPlaying)
+                {
+                    proCamera2DRepeater.RepeatHorizontal = serializedObject.FindProperty("_repeatHorizontal").boolValue;
+                    proCamera2DRepeater.RepeatVertical = serializedObject.FindProperty("_repeatVertical").boolValue;
+                }
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRepeaterEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 393d9ed651d964b8ebd96b556d461df9
+timeCreated: 1451574789
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRoomsEditor.cs

@@ -0,0 +1,455 @@
+using UnityEditor;
+using UnityEngine;
+using System;
+using System.Collections.Generic;
+using UnityEditorInternal;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DRooms))]
+	public class ProCamera2DRoomsEditor : Editor
+	{
+		Func<Vector3, float> Vector3H;
+		Func<Vector3, float> Vector3V;
+		Func<float, float, Vector3> VectorHV;
+		Func<float, float, float, Vector3> VectorHVD;
+
+		MonoScript _script;
+		GUIContent _tooltip;
+
+		ReorderableList _roomsList;
+
+		int _currentlyEditingRoom = -1;
+
+		void OnEnable()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DRooms = (ProCamera2DRooms)target;
+			
+			if (proCamera2DRooms.ProCamera2D == null)
+				return;
+
+			// Add Numeric Boundaries component if needed
+			var numericBoundaries = proCamera2DRooms.ProCamera2D.GetComponent<ProCamera2DNumericBoundaries>();
+			if (numericBoundaries == null)
+				proCamera2DRooms.ProCamera2D.gameObject.AddComponent<ProCamera2DNumericBoundaries>();
+
+			// Create Vector conversion methods
+			switch (proCamera2DRooms.ProCamera2D.Axis)
+			{
+				case MovementAxis.XY:
+					Vector3H = vector => vector.x;
+					Vector3V = vector => vector.y;
+					VectorHV = (h, v) => new Vector3(h, v, 0);
+					VectorHVD = (h, v, d) => new Vector3(h, v, d);
+					break;
+				case MovementAxis.XZ:
+					Vector3H = vector => vector.x;
+					Vector3V = vector => vector.z;
+					VectorHV = (h, v) => new Vector3(h, 0, v);
+					VectorHVD = (h, v, d) => new Vector3(h, d, v);
+					break;
+				case MovementAxis.YZ:
+					Vector3H = vector => vector.z;
+					Vector3V = vector => vector.y;
+					VectorHV = (h, v) => new Vector3(0, v, h);
+					VectorHVD = (h, v, d) => new Vector3(d, v, h);
+					break;
+			}
+
+			// Script
+			_script = MonoScript.FromMonoBehaviour(proCamera2DRooms);
+
+			// Rooms List
+			_roomsList = new ReorderableList(serializedObject, serializedObject.FindProperty("Rooms"), false, true, true, true);
+
+			_roomsList.drawHeaderCallback = (Rect rect) =>
+			{
+				EditorGUI.LabelField(rect, "Rooms");
+			};
+
+			_roomsList.onSelectCallback = (list) =>
+			{
+				_currentlyEditingRoom = _roomsList.index;
+				SceneView.RepaintAll();
+			};
+
+			_roomsList.onAddCallback = (list) =>
+			{
+				var index = list.serializedProperty.arraySize;
+				list.serializedProperty.arraySize++;
+				list.index = index;
+
+				var newEntry = list.serializedProperty.GetArrayElementAtIndex(list.count - 1);
+				if (list.count > 1)
+				{
+					var prevRect = list.serializedProperty.GetArrayElementAtIndex(list.count - 2).FindPropertyRelative("Dimensions").rectValue;
+					prevRect.x += prevRect.width;
+					newEntry.FindPropertyRelative("Dimensions").rectValue = prevRect;
+
+				}
+				else if (list.count == 1)
+				{
+					newEntry.FindPropertyRelative("Dimensions").rectValue = new Rect(0, 0, 10, 10);
+					newEntry.FindPropertyRelative("TransitionDuration").floatValue = 1f;
+					newEntry.FindPropertyRelative("ZoomScale").floatValue = 1.5f;
+				}
+
+				_currentlyEditingRoom = index;
+			};
+
+			_roomsList.onRemoveCallback = (list) =>
+			{
+				_currentlyEditingRoom = -1;
+				SceneView.RepaintAll();
+				ReorderableList.defaultBehaviours.DoRemoveButton(list);
+			};
+
+			_roomsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+			{
+				rect.y += 2;
+				var element = _roomsList.serializedProperty.GetArrayElementAtIndex(index);
+
+				EditorGUI.DropShadowLabel(new Rect(rect.x, rect.y + 3, 60, 10), "Room " + index);
+				rect.y += 20;
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y, 65, 10), new GUIContent("ID", "The room id"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 80,
+						rect.y,
+						100,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("ID"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x + 200, rect.y, 65, 10), new GUIContent("Rect", "The room size and position"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 260,
+						rect.y,
+						rect.width - 260,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("Dimensions"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 45, 65, 10), new GUIContent("Ease Type", ""));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 80,
+						rect.y + 45,
+						100,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("TransitionEaseType"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x + 200, rect.y + 45, 65, 10), new GUIContent("Duration", "How long it takes for the camera to reach this room"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 260,
+						rect.y + 45,
+						rect.width - 260,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("TransitionDuration"), GUIContent.none);
+
+                EditorGUI.PrefixLabel(new Rect(rect.x, rect.y + 70, 65, 10), new GUIContent("Scale To Fit", "If checked, the camera will resize to fit the room"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 80,
+						rect.y + 70,
+						20,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("ScaleCameraToFit"), GUIContent.none);
+
+				GUI.enabled = !element.FindPropertyRelative("ScaleCameraToFit").boolValue;
+				
+                EditorGUI.PrefixLabel(new Rect(rect.x + 120, rect.y + 70, 65, 10), new GUIContent("Zoom", "If checked, the camera will zoom when entering the room"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 160,
+						rect.y + 70,
+						20,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("Zoom"), GUIContent.none);
+				GUI.enabled = true;
+
+				GUI.enabled = !element.FindPropertyRelative("ScaleCameraToFit").boolValue && element.FindPropertyRelative("Zoom").boolValue;
+				
+                EditorGUI.PrefixLabel(new Rect(rect.x + 200, rect.y + 70, 65, 10), new GUIContent("Scale", "The zoom scale"));
+				EditorGUI.PropertyField(new Rect(
+						rect.x + 260,
+						rect.y + 70,
+						rect.width - 260,
+						EditorGUIUtility.singleLineHeight),
+					element.FindPropertyRelative("ZoomScale"), GUIContent.none);
+				GUI.enabled = true;
+			};
+
+			_roomsList.elementHeight = 130;
+			_roomsList.draggable = true;
+		}
+
+		public override void OnInspectorGUI()
+		{
+			if (target == null)
+				return;
+
+			var proCamera2DRooms = (ProCamera2DRooms)target;
+
+			if (proCamera2DRooms.ProCamera2D == null)
+			{
+				EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+				return;
+			}
+
+			serializedObject.Update();
+
+			// Show script link
+			GUI.enabled = false;
+			_script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+			GUI.enabled = true;
+
+			// ProCamera2D
+			_tooltip = new GUIContent("Pro Camera 2D", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+			EditorGUILayout.Space();
+
+			// Rooms List
+			_roomsList.DoLayoutList();
+			EditorGUILayout.Space();
+			EditorGUILayout.Space();
+
+			// Update interval
+			_tooltip = new GUIContent("Update Interval", "Every X seconds detect collision. Smaller frequencies are more precise but also require more processing.");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateInterval"), _tooltip);
+
+			if (proCamera2DRooms.UpdateInterval <= 0.01f)
+				proCamera2DRooms.UpdateInterval = 0.01f;
+
+			// Trigger targets
+			EditorGUILayout.BeginHorizontal();
+			_tooltip = new GUIContent("Use Targets Mid Point", "If checked, the trigger will use the mid point of all your camera targets");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsMidPoint"), _tooltip);
+
+			if (!proCamera2DRooms.UseTargetsMidPoint)
+			{
+				_tooltip = new GUIContent("Trigger Target", "The target to use instead of the mid point of all camera targets");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerTarget"), _tooltip);
+			}
+			EditorGUILayout.EndHorizontal();
+
+			// Transition instanly on start
+			_tooltip = new GUIContent("Transition Instanly On Start", "If checked, the camera will instantly transition to the current room on start");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionInstanlyOnStart"), _tooltip);
+
+			// Restore on room exit
+			_tooltip = new GUIContent("Restore On Room Exit", "If checked, the camera will restore its initial settings when not in any room");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("RestoreOnRoomExit"), _tooltip);
+
+			if (proCamera2DRooms.RestoreOnRoomExit)
+			{
+				EditorGUI.indentLevel = 1;
+
+				// Restore duration
+				_tooltip = new GUIContent("Restore Duration", "How long it takes to restore the original settings");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("RestoreDuration"), _tooltip);
+
+				// Restore ease type
+				_tooltip = new GUIContent("Restore Ease Type", "The ease type of the restore animation");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("RestoreEaseType"), _tooltip);
+
+				EditorGUI.indentLevel = 0;
+			}
+
+			// Automatic room detection
+			_tooltip = new GUIContent("Automatic Room Activation", "If checked, ProCamera2D will automatically transition to the rooms based on the target(s) position. If disabled, you have to manually call the method EnterRoom(roomID)");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("AutomaticRoomActivation"), _tooltip);
+			
+			// Use relative position - Option only visible if the gameobject is not the ProCamera2D container
+			if (proCamera2DRooms.GetComponent<ProCamera2D>() == null)
+			{
+				_tooltip = new GUIContent("Use Relative Positioning", "If checked, the rooms positions are relative to the containing GameObject");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UseRelativePosition"), _tooltip);
+			}
+			else
+			{
+				GUI.enabled = false;
+				_tooltip = new GUIContent("Use Relative Positioning", "If checked, the rooms positions are relative to the containing GameObject. Only supported if the Rooms extension is on a GameObject different than the ProCamera2D core component");
+				EditorGUILayout.PropertyField(serializedObject.FindProperty("UseRelativePosition"), _tooltip);
+				GUI.enabled = true;
+			}
+
+			EditorGUILayout.Space();
+
+			// Transition started event
+			_tooltip = new GUIContent("OnStartedTransition", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("OnStartedTransition"), _tooltip);
+
+			// Transition started event
+			_tooltip = new GUIContent("OnFinishedTransition", "");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("OnFinishedTransition"), _tooltip);
+
+			// Exited all rooms event
+			_tooltip = new GUIContent("OnExitedAllRooms", "This event fires when the camera target is not currently on any room");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("OnExitedAllRooms"), _tooltip);
+
+			// Apply modified properties
+			serializedObject.ApplyModifiedProperties();
+		}
+
+		void OnSceneGUI()
+		{
+			var proCamera2DRooms = (ProCamera2DRooms)target;
+			
+			if (proCamera2DRooms.ProCamera2D == null)
+				return;
+
+			// Text style for room numbers
+			var guiStyle = new GUIStyle();
+			guiStyle.fontStyle = FontStyle.Bold;
+			guiStyle.fontSize = 30;
+			guiStyle.normal.textColor = EditorPrefsX.GetColor(PrefsData.RoomsColorKey, PrefsData.RoomsColorValue);
+			guiStyle.alignment = TextAnchor.MiddleCenter;
+			guiStyle.fixedWidth = 1f;
+			guiStyle.fixedHeight = 1f;
+
+			Handles.color = EditorPrefsX.GetColor(PrefsData.RoomsColorKey, PrefsData.RoomsColorValue);
+			for (int i = 0; i < proCamera2DRooms.Rooms.Count; i++)
+			{
+				Handles.color = new Color(Handles.color.r, Handles.color.g, Handles.color.b, 0f);
+
+				// Button to toggle room editing
+				var buttonSize = Mathf.Min(proCamera2DRooms.Rooms[i].Dimensions.width / 2f, proCamera2DRooms.Rooms[i].Dimensions.height / 2f);
+				buttonSize = Mathf.Min(1, buttonSize);
+
+				var buttonPosition = proCamera2DRooms.Rooms[i].Dimensions.position;
+				if (proCamera2DRooms.UseRelativePosition)
+				{
+					buttonPosition.x += Vector3H(proCamera2DRooms.transform.position);
+					buttonPosition.y += Vector3V(proCamera2DRooms.transform.position);
+				}
+				
+				if (Handles.Button(
+					buttonPosition,
+					Quaternion.LookRotation(VectorHVD(0, 0, 1)),
+					buttonSize,
+					buttonSize,
+					Handles.RectangleHandleCap))
+				{
+					if (i == _currentlyEditingRoom)
+						_currentlyEditingRoom = -1;
+					else
+						_currentlyEditingRoom = i;
+				}
+
+				// Room number
+				Handles.Label(VectorHV(buttonPosition.x, buttonPosition.y), i.ToString(), guiStyle);
+			}
+
+			// Room rect editor
+			if (_currentlyEditingRoom != -1)
+			{
+				var currentDimensions = proCamera2DRooms.Rooms[_currentlyEditingRoom].Dimensions;
+
+				// Snap value
+				var snap = EditorPrefs.GetFloat("RoomsSnapping", PrefsData.RoomsSnapping);
+
+				// Move
+				var oldPos = VectorHV(currentDimensions.position.x, currentDimensions.position.y);
+				if (proCamera2DRooms.UseRelativePosition)
+				{
+					oldPos.x += Vector3H(proCamera2DRooms.transform.position);
+					oldPos.y += Vector3V(proCamera2DRooms.transform.position);
+				}
+				
+				var newPos = Handles.PositionHandle(oldPos, Quaternion.identity);
+				if (newPos != oldPos)
+				{
+					Undo.RecordObject(proCamera2DRooms, "MoveRoom");
+					currentDimensions.position = new Vector2(Vector3H(newPos), Vector3V(newPos));
+					
+					if (proCamera2DRooms.UseRelativePosition)
+					{
+						currentDimensions.x -= Vector3H(proCamera2DRooms.transform.position);
+						currentDimensions.y -= Vector3V(proCamera2DRooms.transform.position);
+					}
+				}
+
+				// Draw rect editor
+				var currentDimensionsRelative = currentDimensions;
+				if (proCamera2DRooms.UseRelativePosition)
+				{
+					currentDimensionsRelative.x += Vector3H(proCamera2DRooms.transform.position);
+					currentDimensionsRelative.y += Vector3V(proCamera2DRooms.transform.position);
+				}
+				
+				var newDimensions = ResizeRect(
+										currentDimensionsRelative,
+										Handles.CubeHandleCap,
+										Color.green,
+										Color.yellow,
+										HandleUtility.GetHandleSize(Vector3.zero) * .1f,
+										snap);
+
+
+				// Undo
+				if (newDimensions.x != currentDimensionsRelative.x ||
+					newDimensions.y != currentDimensionsRelative.y ||
+					newDimensions.width != currentDimensionsRelative.width ||
+					newDimensions.height != currentDimensionsRelative.height)
+					Undo.RecordObject(proCamera2DRooms, "ResizeRect");
+
+				// Save new dimensions
+				var newDimensionsRelative = newDimensions;
+				if (proCamera2DRooms.UseRelativePosition)
+				{
+					newDimensionsRelative.x -= Vector3H(proCamera2DRooms.transform.position);
+					newDimensionsRelative.y -= Vector3V(proCamera2DRooms.transform.position);
+				}
+				
+				proCamera2DRooms.Rooms[_currentlyEditingRoom].Dimensions = newDimensionsRelative;
+
+				// Redraw views
+				if (Event.current.rawType == EventType.Used)
+					UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+			}
+		}
+
+		Rect ResizeRect(Rect rect, UnityEditor.Handles.CapFunction capFunc, Color capCol, Color fillCol, float capSize, float snap)
+		{
+			Vector2 halfSize = new Vector2(rect.size.x * 0.5f, rect.size.y * 0.5f);
+
+			Vector3[] rectangleCorners =
+				{
+					VectorHVD(rect.position.x - halfSize.x, rect.position.y - halfSize.y, 0),   // Bottom Left
+                    VectorHVD(rect.position.x + halfSize.x, rect.position.y - halfSize.y, 0),   // Bottom Right
+                    VectorHVD(rect.position.x + halfSize.x, rect.position.y + halfSize.y, 0),   // Top Right
+                    VectorHVD(rect.position.x - halfSize.x, rect.position.y + halfSize.y, 0)    // Top Left
+                };
+
+			Handles.color = fillCol;
+			Handles.DrawSolidRectangleWithOutline(rectangleCorners, new Color(fillCol.r, fillCol.g, fillCol.b, 0.25f), capCol);
+
+			Vector3[] handlePoints =
+				{
+					VectorHVD(rect.position.x - halfSize.x, rect.position.y, 0),   // Left
+                    VectorHVD(rect.position.x + halfSize.x, rect.position.y, 0),   // Right
+                    VectorHVD(rect.position.x, rect.position.y + halfSize.y, 0),   // Top
+                    VectorHVD(rect.position.x, rect.position.y - halfSize.y, 0)    // Bottom 
+                };
+
+			Handles.color = capCol;
+
+			var newSize = rect.size;
+			var newPosition = rect.position;
+
+			var leftHandle = Utils.AlignToGrid(Vector3H(Handles.Slider(handlePoints[0], -VectorHVD(1, 0, 0), capSize, capFunc, snap)) - Vector3H(handlePoints[0]), snap);
+			var rightHandle = Utils.AlignToGrid(Vector3H(Handles.Slider(handlePoints[1], VectorHVD(1, 0, 0), capSize, capFunc, snap)) - Vector3H(handlePoints[1]), snap);
+			var topHandle = Utils.AlignToGrid(Vector3V(Handles.Slider(handlePoints[2], VectorHVD(0, 1, 0), capSize, capFunc, snap)) - Vector3V(handlePoints[2]), snap);
+			var bottomHandle = Utils.AlignToGrid(Vector3V(Handles.Slider(handlePoints[3], -VectorHVD(0, 1, 0), capSize, capFunc, snap)) - Vector3V(handlePoints[3]), snap);
+
+			newSize = new Vector2(
+				Mathf.Max(0f, newSize.x - leftHandle + rightHandle),
+				Mathf.Max(0f, newSize.y + topHandle - bottomHandle));
+
+			newPosition = new Vector2(
+				newPosition.x + leftHandle * .5f + rightHandle * .5f,
+				newPosition.y + topHandle * .5f + bottomHandle * .5f);
+
+			return new Rect(newPosition.x, newPosition.y, newSize.x, newSize.y);
+		}
+	}
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DRoomsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: a42ce3ffdbc1649c7a69d7b003ed9587
+timeCreated: 1473418872
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DShakeEditor.cs

@@ -0,0 +1,310 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEditorInternal;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DShake))]
+    public class ProCamera2DShakeEditor : Editor
+    {
+        MonoScript _script;
+        GUIContent _tooltip;
+
+        ReorderableList _shakePresetsList;
+        ReorderableList _constantShakePresetsList;
+
+        int _currentPickerWindow;
+
+        double _toggleButtonClick = 0.0;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+
+            var proCamera2DShake = (ProCamera2DShake)target;
+
+            _script = MonoScript.FromMonoBehaviour(proCamera2DShake);
+
+            //
+            // ShakePresets list
+            //
+            _shakePresetsList = new ReorderableList(serializedObject, serializedObject.FindProperty("ShakePresets"), true, true, true, true);
+
+            _shakePresetsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 2;
+                var element = _shakePresetsList.serializedProperty.GetArrayElementAtIndex(index);
+
+                if (element == null || element.objectReferenceValue == null)
+                {
+                    proCamera2DShake.ShakePresets.RemoveAt(index);
+                    return;
+                }
+
+                // Name field
+                EditorGUI.LabelField(
+                    new Rect(
+                        rect.x,
+                        rect.y,
+                        rect.width / 2f,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                    ((ShakePreset)element.objectReferenceValue).name);
+
+                // Edit button
+                if (GUI.Button(new Rect(
+                            rect.x + 2 * rect.width / 4f + 5,
+                            rect.y - 2,
+                            rect.width / 4f - 5,
+                            EditorGUIUtility.singleLineHeight * 1.1f), "Edit"))
+                {
+                    Selection.activeObject = (ShakePreset)element.objectReferenceValue;
+                }
+
+                // Shake button
+                GUI.enabled = Application.isPlaying;
+                if (GUI.Button(new Rect(
+                            rect.x + 3 * rect.width / 4f + 5,
+                            rect.y - 2,
+                            rect.width / 4f - 5,
+                            EditorGUIUtility.singleLineHeight * 1.1f), "Shake!"))
+                {
+                    proCamera2DShake.Shake((ShakePreset)element.objectReferenceValue);
+                }
+                GUI.enabled = true;
+
+            };
+
+            _shakePresetsList.onAddCallback = (list) =>
+            {
+                _currentPickerWindow = GUIUtility.GetControlID(FocusType.Passive) + 100;
+                EditorGUIUtility.ShowObjectPicker<ShakePreset>(null, false, "", _currentPickerWindow);
+            };
+
+            _shakePresetsList.onSelectCallback = (list) =>
+            {
+                var element = _shakePresetsList.serializedProperty.GetArrayElementAtIndex(list.index);
+
+                if (element != null)
+                    EditorGUIUtility.PingObject(element.objectReferenceValue);
+            };
+
+            _shakePresetsList.onRemoveCallback = (list) =>
+            {
+                Undo.RecordObject(proCamera2DShake, "Removed shake preset");
+                var element = _shakePresetsList.serializedProperty.GetArrayElementAtIndex(list.index);
+
+                proCamera2DShake.ShakePresets.Remove((ShakePreset)element.objectReferenceValue);
+            };
+
+            _shakePresetsList.drawHeaderCallback = (Rect rect) =>
+            {
+                EditorGUI.LabelField(rect, "Shake Presets");
+            };
+
+
+            //
+            // ConstantShakePresets list
+            //
+
+            _constantShakePresetsList = new ReorderableList(serializedObject, serializedObject.FindProperty("ConstantShakePresets"), true, true, true, true);
+
+            _constantShakePresetsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 2;
+                var element = _constantShakePresetsList.serializedProperty.GetArrayElementAtIndex(index);
+
+                if (element == null || element.objectReferenceValue == null)
+                {
+                    proCamera2DShake.ConstantShakePresets.RemoveAt(index);
+                    return;
+                }
+
+                var preset = (ConstantShakePreset)element.objectReferenceValue;
+
+                // Name field
+                EditorGUI.LabelField(
+                    new Rect(
+                        rect.x,
+                        rect.y,
+                        rect.width / 2f,
+                        EditorGUIUtility.singleLineHeight * 1.1f),
+                    (preset).name);
+
+                // Toggle to enable on start
+                if (!Application.isPlaying)
+                {
+                    if(GUI.Toggle(new Rect(
+                            rect.x + 1 * rect.width / 4f + 5,
+                            rect.y - 2,
+                            rect.width / 4f - 5,
+                            EditorGUIUtility.singleLineHeight * 1.1f),
+                                  proCamera2DShake.StartConstantShakePreset == preset,
+                                  "Enable on Start"))
+                    {
+                        if (Event.current.type == EventType.Used && EditorApplication.timeSinceStartup - _toggleButtonClick > .5)
+                        {
+                            if (proCamera2DShake.StartConstantShakePreset == preset)
+                                proCamera2DShake.StartConstantShakePreset = null;
+                            else
+                                proCamera2DShake.StartConstantShakePreset = preset;
+
+                            _toggleButtonClick = EditorApplication.timeSinceStartup;
+                        }
+
+                    }
+                }
+
+                // Edit button
+                if (GUI.Button(new Rect(
+                            rect.x + 2 * rect.width / 4f + 5,
+                            rect.y - 2,
+                            rect.width / 4f - 5,
+                            EditorGUIUtility.singleLineHeight * 1.1f), "Edit"))
+                {
+                    Selection.activeObject = preset;
+                }
+
+                // Shake button
+                GUI.enabled = Application.isPlaying;
+                if (GUI.Button(new Rect(
+                            rect.x + 3 * rect.width / 4f + 5,
+                            rect.y - 2,
+                            rect.width / 4f - 5,
+                    EditorGUIUtility.singleLineHeight * 1.1f), (proCamera2DShake.CurrentConstantShakePreset != null && proCamera2DShake.CurrentConstantShakePreset.GetInstanceID() == preset.GetInstanceID()) ? "Disable" : "Enable"))
+                {
+                    if (proCamera2DShake.CurrentConstantShakePreset == null || proCamera2DShake.CurrentConstantShakePreset.GetInstanceID() != preset.GetInstanceID())
+                    {
+                        proCamera2DShake.ConstantShake(preset);
+                    }
+                    else
+                    {
+                        proCamera2DShake.StopConstantShaking();
+                    }
+                }
+                GUI.enabled = true;
+            };
+
+            _constantShakePresetsList.onAddCallback = (list) =>
+            {
+                _currentPickerWindow = GUIUtility.GetControlID(FocusType.Passive) + 100;
+                EditorGUIUtility.ShowObjectPicker<ConstantShakePreset>(null, false, "", _currentPickerWindow);
+            };
+
+            _constantShakePresetsList.onSelectCallback = (list) =>
+            {
+                var element = _constantShakePresetsList.serializedProperty.GetArrayElementAtIndex(list.index);
+
+                if (element != null)
+                    EditorGUIUtility.PingObject(element.objectReferenceValue);
+            };
+
+            _constantShakePresetsList.onRemoveCallback = (list) =>
+            {
+                Undo.RecordObject(proCamera2DShake, "Removed shake preset");
+                var element = _constantShakePresetsList.serializedProperty.GetArrayElementAtIndex(list.index);
+
+                proCamera2DShake.ConstantShakePresets.Remove((ConstantShakePreset)element.objectReferenceValue);
+            };
+
+            _constantShakePresetsList.drawHeaderCallback = (Rect rect) =>
+            {
+                EditorGUI.LabelField(rect, "Constant Shake Presets");
+            };
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            EditorGUI.BeginChangeCheck();
+            
+            var proCamera2DShake = (ProCamera2DShake)target;
+
+            if (proCamera2DShake.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Create ShakePreset button
+            if (GUILayout.Button("Create ShakePreset"))
+            {
+                Undo.RecordObject(proCamera2DShake, "Added shake preset");
+
+                proCamera2DShake.ShakePresets.Add(ScriptableObjectUtility.CreateAsset<ShakePreset>("ShakePreset"));
+            }
+
+            // Shake Presets list
+            EditorGUILayout.Space();
+            _shakePresetsList.DoLayoutList();
+
+            // ShakePreset selected from picker window
+            if (Event.current.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == _currentPickerWindow)
+            {
+                var preset = EditorGUIUtility.GetObjectPickerObject() as ShakePreset;
+
+                if (preset != null)
+                {
+                    if (!proCamera2DShake.ShakePresets.Contains(preset))
+                    {
+                        Undo.RecordObject(proCamera2DShake, "Added shake preset");
+
+                        proCamera2DShake.ShakePresets.Add(preset);
+                    }
+                }
+            }
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Create ConstantShakePreset button
+            if (GUILayout.Button("Create ConstantShakePreset"))
+            {
+                Undo.RecordObject(proCamera2DShake, "Added shake preset");
+
+                ScriptableObjectUtility.CreateAsset<ConstantShakePreset>("ConstantShakePreset");
+            }
+
+            // ConstantShake Presets list
+            EditorGUILayout.Space();
+            _constantShakePresetsList.DoLayoutList();
+
+            // ConstantShakePreset selected from picker window
+            if (Event.current.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == _currentPickerWindow)
+            {
+                var preset = EditorGUIUtility.GetObjectPickerObject() as ConstantShakePreset;
+
+                if (preset != null)
+                {
+                    if (!proCamera2DShake.ConstantShakePresets.Contains(preset))
+                    {
+                        Undo.RecordObject(proCamera2DShake, "Added shake preset");
+
+                        proCamera2DShake.ConstantShakePresets.Add(preset);
+                    }
+                }
+            }
+
+            // Save changes
+            serializedObject.ApplyModifiedProperties();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                EditorUtility.SetDirty(proCamera2DShake);
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DShakeEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 17b4ecbd0af5d4d6ab565d28f4301e8d
+timeCreated: 1432597708
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DSpeedBasedZoomEditor.cs

@@ -0,0 +1,45 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DSpeedBasedZoom))]
+    public class ProCamera2DSpeedBasedZoomEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DSpeedBasedZoom = (ProCamera2DSpeedBasedZoom)target;
+
+            if(proCamera2DSpeedBasedZoom.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            DrawDefaultInspector();
+
+            if (proCamera2DSpeedBasedZoom.MaxZoomInAmount < 1f)
+                proCamera2DSpeedBasedZoom.MaxZoomInAmount = 1f;
+
+            if (proCamera2DSpeedBasedZoom.MaxZoomOutAmount < 1f)
+                proCamera2DSpeedBasedZoom.MaxZoomOutAmount = 1f;
+
+            if (proCamera2DSpeedBasedZoom.CamVelocityForZoomOut <= proCamera2DSpeedBasedZoom.CamVelocityForZoomIn)
+                proCamera2DSpeedBasedZoom.CamVelocityForZoomOut = proCamera2DSpeedBasedZoom.CamVelocityForZoomIn + .1f;
+
+            if (proCamera2DSpeedBasedZoom.CamVelocityForZoomIn >= proCamera2DSpeedBasedZoom.CamVelocityForZoomOut)
+                proCamera2DSpeedBasedZoom.CamVelocityForZoomIn = proCamera2DSpeedBasedZoom.CamVelocityForZoomOut - .1f;
+
+            if (proCamera2DSpeedBasedZoom.CamVelocityForZoomIn < .5f)
+                proCamera2DSpeedBasedZoom.CamVelocityForZoomIn = .5f;
+
+            EditorGUILayout.Space();
+            GUI.enabled = false;
+            EditorGUILayout.BeginHorizontal();
+            GUILayout.Label("Current Velocity (approx.)");
+            GUILayout.Label(proCamera2DSpeedBasedZoom.CurrentVelocity.ToString());
+            EditorGUILayout.EndHorizontal();
+            GUI.enabled = true;
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DSpeedBasedZoomEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e012d54185d0c4a7897bbf0d72bd3578
+timeCreated: 1442534204
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DTransitionsFXEditor.cs

@@ -0,0 +1,183 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DTransitionsFX))]
+    public class ProCamera2DTransitionsFXEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        MonoScript _script;
+
+        void OnEnable()
+        {
+            if (target == null)
+                return;
+            
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DTransitionsFX)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DTransitionsFX = (ProCamera2DTransitionsFX)target;
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);
+
+            if (proCamera2DTransitionsFX.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            EditorGUILayout.Space();
+
+            // Enter
+            _tooltip = new GUIContent("TransitionFX Enter", "The FX for the enter animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionShaderEnter"), _tooltip);
+
+            EditorGUI.indentLevel = 1;
+
+            _tooltip = new GUIContent("Duration", "The duration of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("DurationEnter"), _tooltip);
+
+            _tooltip = new GUIContent("Delay", "A delay for the start of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("DelayEnter"), _tooltip);
+
+            _tooltip = new GUIContent("Ease Type", "The ease type of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("EaseTypeEnter"), _tooltip);
+
+            _tooltip = new GUIContent("Background Color", "The background color of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("BackgroundColorEnter"), _tooltip);
+
+            if (proCamera2DTransitionsFX.TransitionShaderEnter == TransitionsFXShaders.Wipe ||
+                proCamera2DTransitionsFX.TransitionShaderEnter == TransitionsFXShaders.Blinds)
+            {
+                _tooltip = new GUIContent("Side", "The side of the animation");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("SideEnter"), _tooltip);
+
+                if (proCamera2DTransitionsFX.TransitionShaderEnter == TransitionsFXShaders.Blinds)
+                {
+                    _tooltip = new GUIContent("Blinds", "The number of blinds");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("BlindsEnter"), _tooltip);
+                }
+            }
+            else if (proCamera2DTransitionsFX.TransitionShaderEnter == TransitionsFXShaders.Shutters)
+            {
+                _tooltip = new GUIContent("Direction", "The direction of the animation");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("DirectionEnter"), _tooltip);
+            }
+            else if (proCamera2DTransitionsFX.TransitionShaderEnter == TransitionsFXShaders.Texture)
+            {
+                _tooltip = new GUIContent("Texture", "The texture to use as a mask. Should be a black and white texture.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureEnter"), _tooltip);
+
+                _tooltip = new GUIContent("Texture Smoothing", "The amount of fade smoothing to apply on the texture.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureSmoothingEnter"), _tooltip);
+            }
+            EditorGUI.indentLevel = 0;
+
+            EditorGUILayout.Space();
+
+            // Exit
+            _tooltip = new GUIContent("TransitionFX Exit", "The FX for the exit animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionShaderExit"), _tooltip);
+
+            EditorGUI.indentLevel = 1;
+
+            _tooltip = new GUIContent("Duration", "The duration of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("DurationExit"), _tooltip);
+
+            _tooltip = new GUIContent("Delay", "A delay for the start of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("DelayExit"), _tooltip);
+
+            _tooltip = new GUIContent("Ease Type", "The ease type of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("EaseTypeExit"), _tooltip);
+
+            _tooltip = new GUIContent("Background Color", "The background color of the animation");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("BackgroundColorExit"), _tooltip);
+
+            if (proCamera2DTransitionsFX.TransitionShaderExit == TransitionsFXShaders.Wipe ||
+                proCamera2DTransitionsFX.TransitionShaderExit == TransitionsFXShaders.Blinds)
+            {
+                _tooltip = new GUIContent("Side", "The side of the animation");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("SideExit"), _tooltip);
+
+                if (proCamera2DTransitionsFX.TransitionShaderExit == TransitionsFXShaders.Blinds)
+                {
+                    _tooltip = new GUIContent("Blinds", "The number of blinds");
+                    EditorGUILayout.PropertyField(serializedObject.FindProperty("BlindsExit"), _tooltip);
+                }
+            }
+            else if (proCamera2DTransitionsFX.TransitionShaderExit == TransitionsFXShaders.Shutters)
+            {
+                _tooltip = new GUIContent("Direction", "The direction of the animation");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("DirectionExit"), _tooltip);
+            }
+            else if (proCamera2DTransitionsFX.TransitionShaderExit == TransitionsFXShaders.Texture)
+            {
+                _tooltip = new GUIContent("Texture", "The texture to use as a mask. Should be a black and white texture.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureExit"), _tooltip);
+
+                _tooltip = new GUIContent("Texture Smoothing", "The amount of fade smoothing to apply on the texture.");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TextureSmoothingExit"), _tooltip);
+            }
+            EditorGUI.indentLevel = 0;
+
+            // Start scene on enter state
+            EditorGUILayout.Space();
+            _tooltip = new GUIContent("Start Scene On Enter State", "If selected, on scene start the Enter FX will be loaded.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("StartSceneOnEnterState"), _tooltip);
+
+
+            // Limit values
+            if (proCamera2DTransitionsFX.DurationEnter < 0)
+                proCamera2DTransitionsFX.DurationEnter = 0;
+            if (proCamera2DTransitionsFX.DurationExit < 0)
+                proCamera2DTransitionsFX.DurationExit = 0;
+
+            if (proCamera2DTransitionsFX.DelayEnter < 0)
+                proCamera2DTransitionsFX.DelayEnter = 0;
+            if (proCamera2DTransitionsFX.DelayExit < 0)
+                proCamera2DTransitionsFX.DelayExit = 0;
+
+            // Apply properties
+            serializedObject.ApplyModifiedProperties();
+
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Detect changes
+            if (GUI.changed && Application.isPlaying)
+            {
+                proCamera2DTransitionsFX.UpdateTransitionsShaders();
+                proCamera2DTransitionsFX.UpdateTransitionsProperties();
+                proCamera2DTransitionsFX.UpdateTransitionsColor();
+            }
+
+
+            // Test buttons
+            GUI.enabled = Application.isPlaying;
+            if (GUILayout.Button("Transition Enter"))
+            {
+                proCamera2DTransitionsFX.TransitionEnter();
+            }
+
+            if (GUILayout.Button("Transition Exit"))
+            {
+                proCamera2DTransitionsFX.TransitionExit();
+            }
+            GUI.enabled = true;
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DTransitionsFXEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0f289b62546754160b0811408dbbdcee
+timeCreated: 1456390555
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ProCamera2DZoomToFitTargetsEditor.cs

@@ -0,0 +1,52 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DZoomToFitTargets))]
+    public class ProCamera2DZoomToFitTargetsEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            if (target == null)
+                return;
+            
+            var proCamera2DZoomToFitTargets = (ProCamera2DZoomToFitTargets)target;
+
+            if(proCamera2DZoomToFitTargets.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            DrawDefaultInspector();
+
+            if (proCamera2DZoomToFitTargets.ZoomInBorder > proCamera2DZoomToFitTargets.ZoomOutBorder)
+                proCamera2DZoomToFitTargets.ZoomOutBorder = proCamera2DZoomToFitTargets.ZoomInBorder;
+
+            if (proCamera2DZoomToFitTargets.ZoomOutBorder < proCamera2DZoomToFitTargets.ZoomInBorder)
+                proCamera2DZoomToFitTargets.ZoomInBorder = proCamera2DZoomToFitTargets.ZoomOutBorder;
+
+            if (proCamera2DZoomToFitTargets.ZoomInBorder <= 0f)
+                proCamera2DZoomToFitTargets.ZoomInBorder = 0f;
+
+            if (proCamera2DZoomToFitTargets.ZoomInBorder >= 1f)
+                proCamera2DZoomToFitTargets.ZoomInBorder = 1f;
+
+            if (proCamera2DZoomToFitTargets.ZoomOutBorder <= 0f)
+                proCamera2DZoomToFitTargets.ZoomOutBorder = 0f;
+
+            if (proCamera2DZoomToFitTargets.ZoomOutBorder >= 1f)
+                proCamera2DZoomToFitTargets.ZoomOutBorder = 1f;
+    
+            if (proCamera2DZoomToFitTargets.ZoomInSmoothness < 0f)
+                proCamera2DZoomToFitTargets.ZoomInSmoothness = 0f;
+
+            if (proCamera2DZoomToFitTargets.ZoomOutSmoothness < 0f)
+                proCamera2DZoomToFitTargets.ZoomOutSmoothness = 0f;
+
+            if (proCamera2DZoomToFitTargets.MaxZoomInAmount < 1f)
+                proCamera2DZoomToFitTargets.MaxZoomInAmount = 1f;
+
+            if (proCamera2DZoomToFitTargets.MaxZoomOutAmount < 1f)
+                proCamera2DZoomToFitTargets.MaxZoomOutAmount = 1f;
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ProCamera2DZoomToFitTargetsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 40c11ebcbf4f742db98560cf2b003bc4
+timeCreated: 1428076294
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Extensions/ShakePresetEditor.cs

@@ -0,0 +1,89 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ShakePreset))]
+    public class ShakePresetEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        ShakePreset _preset;
+
+        void OnEnable()
+        {
+            _preset = (ShakePreset)target;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            // Strength
+            _tooltip = new GUIContent("Strength", "The shake strength on each axis");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Strength"), _tooltip);
+
+            // Duration
+            _tooltip = new GUIContent("Duration", "The duration of the shake");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Duration"), _tooltip);
+
+            // Vibrato
+            _tooltip = new GUIContent("Vibrato", "Indicates how much will the shake vibrate");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Vibrato"), _tooltip);
+
+            // Smoothness
+            _tooltip = new GUIContent("Smoothness", "Indicates how smooth the shake will be");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Smoothness"), _tooltip);
+
+            // Randomness
+            _tooltip = new GUIContent("Randomness", "Indicates how random the shake will be");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Randomness"), _tooltip);
+
+            // Random initial direction
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Use Random Initial Angle", "If enabled, the initial shaking angle will be random");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseRandomInitialAngle"), _tooltip);
+
+            if (!_preset.UseRandomInitialAngle)
+            {
+                _tooltip = new GUIContent("Initial Angle", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("InitialAngle"), _tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            // Rotation
+            _tooltip = new GUIContent("Rotation", "The maximum rotation the camera will reach");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Rotation"), _tooltip);
+
+            // Ignore time scale
+            _tooltip = new GUIContent("Ignore TimeScale", "If enabled, the shake will occur even if the timeScale is 0");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("IgnoreTimeScale"), _tooltip);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Shake test buttons
+            GUI.enabled = Application.isPlaying;
+            if (GUILayout.Button("Shake!"))
+            {
+                if (ProCamera2DShake.Exists)
+                    ProCamera2DShake.Instance.Shake(_preset);
+            }
+
+            if (GUILayout.Button("Stop!"))
+            {
+                if (ProCamera2DShake.Exists)
+                    ProCamera2DShake.Instance.StopShaking();
+            }
+            GUI.enabled = true;
+
+            if (GUILayout.Button("Go to ProCamera2D"))
+            {
+                Selection.activeGameObject = ProCamera2D.Instance.gameObject;
+            }
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Extensions/ShakePresetEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: cfffbde034de349769157a64cd484ae9
+timeCreated: 1487344181
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Helpers.meta

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

Assets/ProCamera2D/Editor/Helpers/CleanupMissingScripts.cs

@@ -0,0 +1,46 @@
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    using UnityEngine;
+    using UnityEditor;
+
+    public static class Cleanup
+    {
+        [MenuItem("Edit/Cleanup Missing Scripts")]
+        static void CleanupMissingScripts()
+        {
+            for (int i = 0; i < Selection.gameObjects.Length; i++)
+            {
+                var gameObject = Selection.gameObjects[i];
+
+                // We must use the GetComponents array to actually detect missing components
+                var components = gameObject.GetComponents<Component>();
+
+                // Create a serialized object so that we can edit the component list
+                var serializedObject = new SerializedObject(gameObject);
+                // Find the component list property
+                var prop = serializedObject.FindProperty("m_Component");
+
+                // Track how many components we've removed
+                int r = 0;
+
+                // Iterate over all components
+                for (int j = 0; j < components.Length; j++)
+                {
+                    // Check if the ref is null
+                    if (components[j] == null)
+                    {
+                        // If so, remove from the serialized component array
+                        prop.DeleteArrayElementAtIndex(j - r);
+                        // Increment removed count
+                        r++;
+
+                        Debug.Log("Removed missing script");
+                    }
+                }
+
+                // Apply our changes to the game object
+                serializedObject.ApplyModifiedProperties();
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Helpers/CleanupMissingScripts.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9598d346dbf444e8fb812b1274e34da2
+timeCreated: 1455621342
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Helpers/ConstantShakePresetEditor.cs

@@ -0,0 +1,61 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ConstantShakePreset))]
+    public class ConstantShakePresetEditor : Editor
+    {
+        GUIContent _tooltip;
+
+        ConstantShakePreset _preset;
+
+        void OnEnable()
+        {
+            _preset = (ConstantShakePreset)target;
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            // Intensity
+            _tooltip = new GUIContent("Intensity", "How fast the camera moves towards the amplitude");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Intensity"), _tooltip);
+
+            // Layers
+            _tooltip = new GUIContent("Layers", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Layers"), _tooltip, true);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+            EditorGUILayout.Space();
+
+            // Shake test buttons
+            GUI.enabled = Application.isPlaying && ProCamera2DShake.Exists;
+            if (GUILayout.Button("Constant Shake!"))
+            {
+                ProCamera2DShake.Instance.ConstantShake(_preset);
+            }
+
+            if (GUILayout.Button("Stop!"))
+            {
+                ProCamera2DShake.Instance.StopConstantShaking();
+            }
+            GUI.enabled = true;
+
+            if (GUILayout.Button("Go to ProCamera2D"))
+            {
+                if (ProCamera2D.Instance != null)
+                {
+                    Selection.activeGameObject = ProCamera2D.Instance.gameObject;
+                }
+            }
+
+            if (_preset.Intensity < .01f)
+                _preset.Intensity = .01f;
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Helpers/ConstantShakePresetEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 85cdbf63cb8f64a508a733af6bd0f58e
+timeCreated: 1487344181
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Helpers/MinMaxSliderDrawer.cs

@@ -0,0 +1,37 @@
+// https://gist.github.com/frarees/9791517
+
+using UnityEngine;
+using UnityEditor;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomPropertyDrawer(typeof(MinMaxSliderAttribute))]
+    class MinMaxSliderDrawer : PropertyDrawer
+    {
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            if (property.propertyType == SerializedPropertyType.Vector2)
+            {
+                Vector2 range = property.vector2Value;
+                float min = range.x;
+                float max = range.y;
+                var attr = attribute as MinMaxSliderAttribute;
+                EditorGUI.BeginChangeCheck();
+
+                EditorGUI.LabelField(position, label.text + " (" + min.ToString("F3") + " - " + max.ToString("F3") + ")");
+
+                EditorGUI.MinMaxSlider(position, label, ref min, ref max, attr.min, attr.max);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    range.x = min;
+                    range.y = max;
+                    property.vector2Value = range;
+                }
+            }
+            else {
+                EditorGUI.LabelField(position, label, "Use only with Vector2");
+            }
+        }
+    }
+}

Assets/ProCamera2D/Editor/Helpers/MinMaxSliderDrawer.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: e624fc6d0e51945a1b48d32407f6f06b
+timeCreated: 1487610199
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Helpers/RenderPipelineDefines.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+
+#if UNITY_2019_3_OR_NEWER
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    public static class RenderPipelineDefines
+    {
+        private const string HDRP_PACKAGE = "com.unity.render-pipelines.high-definition";
+        private const string URP_PACKAGE = "com.unity.render-pipelines.universal";
+ 
+        private const string TAG_HDRP = "USING_HDRP";
+        private const string TAG_URP = "USING_URP";
+ 
+        [UnityEditor.Callbacks.DidReloadScripts]
+        private static void OnScriptsReloaded()
+        {
+            var packagesRequest = Client.List(true);
+            LoadPackages(packagesRequest);
+        }
+        
+        private static void LoadPackages (ListRequest request)
+        {
+            if (request == null)
+                return;
+ 
+            // Wait for request to complete
+            while (!request.IsCompleted)
+            {
+                Task.Delay(1_000).Wait();
+            }
+            
+            if (request.Result == null)
+                return;
+ 
+            // Find out what packages are installed
+            var packagesList = request.Result.ToList();
+ 
+            var hasHDRP = packagesList.Find(x => x.name.Contains(HDRP_PACKAGE)) != null;
+            var hasURP = packagesList.Find(x => x.name.Contains(URP_PACKAGE)) != null;
+ 
+            DefinePreProcessors(hasHDRP, hasURP);
+        }
+ 
+        private static void DefinePreProcessors(bool defineHDRP, bool defineURP)
+        {
+            string originalDefineSymbols;
+            string newDefineSymbols;
+ 
+            List<string> defined;
+            var platform = EditorUserBuildSettings.selectedBuildTargetGroup;
+ 
+            originalDefineSymbols = PlayerSettings.GetScriptingDefineSymbolsForGroup(platform);
+            defined = originalDefineSymbols.Split(';').Where(x => !String.IsNullOrWhiteSpace(x)).ToList();
+
+            void AppendRemoveTag(bool stat, string tag)
+            {
+                if (stat && !defined.Contains(tag))
+                    defined.Add(tag);
+                else if (!stat && defined.Contains(tag)) 
+                    defined.Remove(tag);
+            }
+
+            AppendRemoveTag(defineHDRP, TAG_HDRP);
+            AppendRemoveTag(defineURP, TAG_URP);
+ 
+            newDefineSymbols = string.Join(";", defined);
+            if(originalDefineSymbols != newDefineSymbols)
+            {
+                PlayerSettings.SetScriptingDefineSymbolsForGroup(platform, newDefineSymbols);
+            }
+        }
+    }
+}
+#endif

Assets/ProCamera2D/Editor/Helpers/RenderPipelineDefines.cs.meta

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

Assets/ProCamera2D/Editor/Helpers/ScriptableObjectUtility.cs

@@ -0,0 +1,42 @@
+// http://wiki.unity3d.com/index.php?title=CreateScriptableObjectAsset
+
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    public static class ScriptableObjectUtility
+    {
+        /// <summary>
+        ///  This makes it easy to create, name and place unique new ScriptableObject asset files.
+        /// </summary>
+        public static T CreateAsset<T>(string name = null) where T : ScriptableObject
+        {
+            T asset = ScriptableObject.CreateInstance<T>();
+
+            string path = AssetDatabase.GetAssetPath(Selection.activeObject);
+            if (path == "")
+            {
+                path = "Assets";
+            }
+            else if (Path.GetExtension(path) != "")
+            {
+                path = path.Replace(Path.GetFileName(AssetDatabase.GetAssetPath(Selection.activeObject)), "");
+            }
+
+            var assetPathAndName = "";
+            if(string.IsNullOrEmpty(name))
+                assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(path + "/New " + typeof(T) + ".asset");
+            else
+                assetPathAndName = AssetDatabase.GenerateUniqueAssetPath(path + "/New " + name + ".asset");
+
+            AssetDatabase.CreateAsset(asset, assetPathAndName);
+
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            return asset;
+        }
+    }
+}

Assets/ProCamera2D/Editor/Helpers/ScriptableObjectUtility.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8350fbe69d9444d73a37d4be985af32f
+timeCreated: 1487180818
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Images.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 9dfd1dd3e50bb469b8bb1d6e1a92afaa
+folderAsset: yes
+timeCreated: 1441321671
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Images/inspector_header.png.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: 9d9bbd7169db4417e9f267c19416e9ed
+timeCreated: 1430510482
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 8
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 1024
+  textureSettings:
+    filterMode: -1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 5
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Images/user-guide-link.png.meta

@@ -0,0 +1,55 @@
+fileFormatVersion: 2
+guid: d3fac318a474644ca9989da2d8125c11
+timeCreated: 1441668058
+licenseType: Store
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    linearTexture: 1
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 8
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -3
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: 1
+    aniso: 1
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 0
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 1
+  textureType: 2
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Triggers.meta

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

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerBoundariesEditor.cs

@@ -0,0 +1,185 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DTriggerBoundaries))]
+	[CanEditMultipleObjects]
+    public class ProCamera2DTriggerBoundariesEditor : Editor
+    {
+        MonoScript _script;
+    	GUIContent _tooltip;
+
+        void OnEnable()
+        {
+			var proCamera2DTriggerBoundaries = (ProCamera2DTriggerBoundaries)target;
+
+            if (proCamera2DTriggerBoundaries.NumericBoundaries == null && proCamera2DTriggerBoundaries.ProCamera2D != null)
+            {
+                var numericBoundaries = proCamera2DTriggerBoundaries.ProCamera2D.GetComponent<ProCamera2DNumericBoundaries>();
+                proCamera2DTriggerBoundaries.NumericBoundaries = numericBoundaries == null ? proCamera2DTriggerBoundaries.ProCamera2D.gameObject.AddComponent<ProCamera2DNumericBoundaries>() : numericBoundaries;
+            }
+
+            _script = MonoScript.FromMonoBehaviour(proCamera2DTriggerBoundaries);
+        }
+
+        public override void OnInspectorGUI()
+        {
+			var proCamera2DTriggerBoundaries = (ProCamera2DTriggerBoundaries)target;
+
+            if (proCamera2DTriggerBoundaries.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+			serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);            
+
+            // Update interval
+            _tooltip = new GUIContent("Update Interval", "Every X seconds detect collision. Smaller frequencies are more precise but also require more processing.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateInterval"), _tooltip);            
+
+            if (proCamera2DTriggerBoundaries.UpdateInterval <= 0.01f)
+                proCamera2DTriggerBoundaries.UpdateInterval = 0.01f;
+
+            // Trigger shape
+            _tooltip = new GUIContent("Trigger Shape", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerShape"), _tooltip);
+
+			// Boundaries relative
+			_tooltip = new GUIContent("Are boundaries relative", "Are the boundaries relative to this or are they world positions?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("AreBoundariesRelative"), _tooltip);			
+
+			// Top boundary
+			EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Use Top Boundary", "Should the camera top position be limited?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTopBoundary"), _tooltip);
+
+            if(proCamera2DTriggerBoundaries.UseTopBoundary)
+            {
+	            _tooltip = new GUIContent(" ", "Camera top boundary");
+	            EditorGUILayout.PropertyField(serializedObject.FindProperty("TopBoundary"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Bottom boundary
+            EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Use Bottom Boundary", "Should the camera bottom position be limited?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseBottomBoundary"), _tooltip);
+
+            if(proCamera2DTriggerBoundaries.UseBottomBoundary)
+            {
+	            _tooltip = new GUIContent(" ", "Camera bottom boundary");
+	            EditorGUILayout.PropertyField(serializedObject.FindProperty("BottomBoundary"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Left boundary
+            EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Use Left Boundary", "Should the camera left position be limited?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseLeftBoundary"), _tooltip);
+
+            if(proCamera2DTriggerBoundaries.UseLeftBoundary)
+            {
+	            _tooltip = new GUIContent(" ", "Camera left boundary");
+	            EditorGUILayout.PropertyField(serializedObject.FindProperty("LeftBoundary"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Right boundary
+            EditorGUILayout.BeginHorizontal();
+
+			_tooltip = new GUIContent("Use Right Boundary", "Should the camera right position be limited?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseRightBoundary"), _tooltip);
+
+            if(proCamera2DTriggerBoundaries.UseRightBoundary)
+            {
+	            _tooltip = new GUIContent(" ", "Camera right boundary");
+	            EditorGUILayout.PropertyField(serializedObject.FindProperty("RightBoundary"), _tooltip);
+            }
+
+            EditorGUILayout.EndHorizontal();
+
+            // Transition duration
+            _tooltip = new GUIContent("Transition duration", "How many X seconds should the transition take?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionDuration"), _tooltip);
+
+            if (proCamera2DTriggerBoundaries.TransitionDuration <= 0)
+                proCamera2DTriggerBoundaries.TransitionDuration = 0;
+
+            // Transition ease type
+            _tooltip = new GUIContent("Transition ease type", "The transition animation ease type");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionEaseType"), _tooltip);
+
+            // Trigger targets
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Use Targets Mid Point", "If checked, the trigger will use the mid point of all your camera targets");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsMidPoint"), _tooltip);
+
+            if (!proCamera2DTriggerBoundaries.UseTargetsMidPoint)
+            {
+                _tooltip = new GUIContent("Trigger Target", "The target to use instead of the mid point of all camera targets");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerTarget"), _tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            // Change zoom
+            _tooltip = new GUIContent("Change Zoom", "Change the camera zoom in/out?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ChangeZoom"), _tooltip);
+
+            if (proCamera2DTriggerBoundaries.ChangeZoom)
+            {
+                // Target zoom
+                _tooltip = new GUIContent("Zoom Amount", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TargetZoom"), _tooltip);
+
+                // Zoom smoothness
+                _tooltip = new GUIContent("Zoom Smoothness", "");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("ZoomSmoothness"), _tooltip);
+            }
+
+            // Set as starting boundaries
+            _tooltip = new GUIContent("Set as starting boundaries", "Use this boundaries as the starting ones");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_setAsStartingBoundaries"), _tooltip);
+
+            if(proCamera2DTriggerBoundaries._setAsStartingBoundaries)
+            {
+                var allBoundariesTriggers = FindObjectsOfType(typeof(ProCamera2DTriggerBoundaries));
+                foreach (ProCamera2DTriggerBoundaries trigger in allBoundariesTriggers) 
+                {
+                    trigger._setAsStartingBoundaries = false;
+                }
+
+                proCamera2DTriggerBoundaries._setAsStartingBoundaries = true;
+            }
+
+            // Limit boundaries
+			if (proCamera2DTriggerBoundaries.LeftBoundary > proCamera2DTriggerBoundaries.RightBoundary)
+				proCamera2DTriggerBoundaries.LeftBoundary = proCamera2DTriggerBoundaries.RightBoundary;
+
+			if (proCamera2DTriggerBoundaries.RightBoundary < proCamera2DTriggerBoundaries.LeftBoundary)
+				proCamera2DTriggerBoundaries.RightBoundary = proCamera2DTriggerBoundaries.LeftBoundary;
+
+			if (proCamera2DTriggerBoundaries.BottomBoundary > proCamera2DTriggerBoundaries.TopBoundary)
+				proCamera2DTriggerBoundaries.BottomBoundary = proCamera2DTriggerBoundaries.TopBoundary;
+
+			if (proCamera2DTriggerBoundaries.TopBoundary < proCamera2DTriggerBoundaries.BottomBoundary)
+				proCamera2DTriggerBoundaries.TopBoundary = proCamera2DTriggerBoundaries.BottomBoundary;
+
+
+			serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerBoundariesEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6788b08df8aa14da38a16f5c742c1fda
+timeCreated: 1429473345
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerInfluenceEditor.cs

@@ -0,0 +1,81 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DTriggerInfluence))]
+	[CanEditMultipleObjects]
+    public class ProCamera2DTriggerInfluenceEditor : Editor
+    {
+        MonoScript _script;
+        GUIContent _tooltip;
+
+        void OnEnable()
+        {
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DTriggerInfluence)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var proCamera2DTriggerInfluence = (ProCamera2DTriggerInfluence)target;
+
+            if(proCamera2DTriggerInfluence.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+            
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);            
+
+            // Update interval
+            _tooltip = new GUIContent("Update Interval", "Every X seconds detect collision. Smaller frequencies are more precise but also require more processing.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateInterval"), _tooltip);            
+
+            if (proCamera2DTriggerInfluence.UpdateInterval <= 0.01f)
+                proCamera2DTriggerInfluence.UpdateInterval = 0.01f;
+
+            // Trigger shape
+            _tooltip = new GUIContent("Trigger Shape", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerShape"), _tooltip);
+
+            // Focus point
+            _tooltip = new GUIContent("Focus Point", "If set, the focus point will be this instead of the center of the trigger");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("FocusPoint"), _tooltip);
+
+            // Influence smoothness
+            _tooltip = new GUIContent("Influence Smoothness", "How smoothly should the camera move towards the focus point?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("InfluenceSmoothness"), _tooltip);
+
+            if (proCamera2DTriggerInfluence.InfluenceSmoothness < 0f)
+                proCamera2DTriggerInfluence.InfluenceSmoothness = 0f;
+
+            // Exclusive influence percentage
+            _tooltip = new GUIContent("Exclusive Influence Percentage", "After entering this area the camera will reach it's max zoom value");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ExclusiveInfluencePercentage"), _tooltip);
+
+            // Trigger targets
+            EditorGUILayout.BeginHorizontal();
+            var tooltip = new GUIContent("Use Targets Mid Point", "If checked, the trigger will use the mid point of all your camera targets");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsMidPoint"), tooltip);
+
+            if (!proCamera2DTriggerInfluence.UseTargetsMidPoint)
+            {
+                tooltip = new GUIContent("Trigger Target", "The target to use instead of the mid point of all camera targets");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerTarget"), tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+			// Mode
+			_tooltip = new GUIContent("Influence Mode", "Choose what axis the influence affects");
+			EditorGUILayout.PropertyField(serializedObject.FindProperty("Mode"), _tooltip);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerInfluenceEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2a7f82f941621444d868baab8d8ce85e
+timeCreated: 1436623618
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerRailsEditor.cs

@@ -0,0 +1,76 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [CustomEditor(typeof(ProCamera2DTriggerRails))]
+    [CanEditMultipleObjects]
+    public class ProCamera2DTriggerRailsEditor : Editor
+    {
+        MonoScript _script;
+        GUIContent _tooltip;
+
+        void OnEnable()
+        {
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DTriggerRails)target);
+
+            var proCamera2DTriggerRails = (ProCamera2DTriggerRails)target;
+
+            if(proCamera2DTriggerRails.ProCamera2D != null && proCamera2DTriggerRails.ProCamera2DRails == null)
+                proCamera2DTriggerRails.ProCamera2DRails = proCamera2DTriggerRails.ProCamera2D.GetComponentInChildren<ProCamera2DRails>();
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var proCamera2DTriggerRails = (ProCamera2DTriggerRails)target;
+
+            if(proCamera2DTriggerRails.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);            
+
+            // Update interval
+            _tooltip = new GUIContent("Update Interval", "Every X seconds detect collision. Smaller frequencies are more precise but also require more processing.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateInterval"), _tooltip);            
+
+            if (proCamera2DTriggerRails.UpdateInterval <= 0.01f)
+                proCamera2DTriggerRails.UpdateInterval = 0.01f;
+
+            // Trigger shape
+            _tooltip = new GUIContent("Trigger Shape", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerShape"), _tooltip);
+
+            // Trigger targets
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Use Targets Mid Point", "If checked, the trigger will use the mid point of all your camera targets");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsMidPoint"), _tooltip);
+
+            if (!proCamera2DTriggerRails.UseTargetsMidPoint)
+            {
+                _tooltip = new GUIContent("Trigger Target", "The target to use instead of the mid point of all camera targets");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerTarget"), _tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            // Mode
+            _tooltip = new GUIContent("Mode", "Choose if you want this trigger to enable or disable the rails.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("Mode"), _tooltip);
+
+            // Transition Duration
+            _tooltip = new GUIContent("Transition Duration", "The time it should take to transition from/to rails.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TransitionDuration"), _tooltip);
+
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerRailsEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 64990ab6dd6114e4eb011e7db84fa6e7
+timeCreated: 1448989170
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerZoomEditor.cs

@@ -0,0 +1,103 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+	[CustomEditor(typeof(ProCamera2DTriggerZoom))]
+	[CanEditMultipleObjects]
+    public class ProCamera2DTriggerZoomEditor : Editor
+    {
+        MonoScript _script;
+        GUIContent _tooltip;
+
+        void OnEnable()
+        {
+            _script = MonoScript.FromMonoBehaviour((ProCamera2DTriggerZoom)target);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var proCamera2DTriggerZoom = (ProCamera2DTriggerZoom)target;
+
+            if(proCamera2DTriggerZoom.ProCamera2D == null)
+                EditorGUILayout.HelpBox("ProCamera2D is not set.", MessageType.Error, true);
+            
+            serializedObject.Update();
+
+            // Show script link
+            GUI.enabled = false;
+            _script = EditorGUILayout.ObjectField("Script", _script, typeof(MonoScript), false) as MonoScript;
+            GUI.enabled = true;
+
+            // ProCamera2D
+            _tooltip = new GUIContent("Pro Camera 2D", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("_pc2D"), _tooltip);            
+
+            // Update interval
+            _tooltip = new GUIContent("Update Interval", "Every X seconds detect collision. Smaller frequencies are more precise but also require more processing.");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UpdateInterval"), _tooltip);            
+
+            if (proCamera2DTriggerZoom.UpdateInterval <= 0.01f)
+                proCamera2DTriggerZoom.UpdateInterval = 0.01f;
+
+            // Trigger shape
+            _tooltip = new GUIContent("Trigger Shape", "");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerShape"), _tooltip);
+
+            // Set size as multiplier
+            _tooltip = new GUIContent("Set Size As Multiplier", "If checked, you set target size of the camera as a zoom multiplier of the initial camera size");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("SetSizeAsMultiplier"), _tooltip);
+
+            // Target zoom
+            if(proCamera2DTriggerZoom.SetSizeAsMultiplier)
+                _tooltip = new GUIContent("Zoom Multiplier", "The amount of zoom the camera should do when entering this trigger");
+            else if(proCamera2DTriggerZoom.ProCamera2D.GameCamera.orthographic)
+                _tooltip = new GUIContent("Target Ortho Size", "The target size of the camera when entering this trigger");
+            else 
+                _tooltip = new GUIContent("Target FOV Size", "The target size of the camera when entering this trigger");
+
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("TargetZoom"), _tooltip);
+
+            if (proCamera2DTriggerZoom.TargetZoom <= 0.01f)
+                proCamera2DTriggerZoom.TargetZoom = 0.01f;
+
+            // Zoom smoothness
+            _tooltip = new GUIContent("Zoom Smoothness", "How smooth should the zoom be?");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ZoomSmoothness"), _tooltip);
+            
+            if (proCamera2DTriggerZoom.ZoomSmoothness < 0f)
+                proCamera2DTriggerZoom.ZoomSmoothness = 0f;
+
+            // Exclusive influence percentage
+            _tooltip = new GUIContent("Exclusive Influence Percentage", "After entering this area the camera will reach it's max zoom value");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ExclusiveInfluencePercentage"), _tooltip);
+
+            // Reset size on exit
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Reset Size On Leave", "As the target leaves the trigger area the camera will reset its size to the start value");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("ResetSizeOnExit"), _tooltip);
+
+            if (proCamera2DTriggerZoom.ResetSizeOnExit)
+            {
+                // Reset size smoothness
+                _tooltip = new GUIContent("Smoothness", "How smoothly should the camera resit its size?");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("ResetSizeSmoothness"), _tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            // Trigger targets
+            EditorGUILayout.BeginHorizontal();
+            _tooltip = new GUIContent("Use Targets Mid Point", "If checked, the trigger will use the mid point of all your camera targets");
+            EditorGUILayout.PropertyField(serializedObject.FindProperty("UseTargetsMidPoint"), _tooltip);
+
+            if (!proCamera2DTriggerZoom.UseTargetsMidPoint)
+            {
+                _tooltip = new GUIContent("Trigger Target", "The target to use instead of the mid point of all camera targets");
+                EditorGUILayout.PropertyField(serializedObject.FindProperty("TriggerTarget"), _tooltip);
+            }
+            EditorGUILayout.EndHorizontal();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Assets/ProCamera2D/Editor/Triggers/ProCamera2DTriggerZoomEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: c8db0f2a5b4c4434686eb71f1ee594a1
+timeCreated: 1436610957
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Editor/_ProCamera2D.Editor.asmdef

@@ -0,0 +1,19 @@
+{
+    "name": "ProCamera2D.Editor",
+    "rootNamespace": "Com.LuisPedroFonseca.ProCamera2D",
+    "references": [
+        "GUID:da0319847955a4a36b91883508290fe8",
+        "GUID:15fc0a57446b3144c949da3e2b9737a9"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

Assets/ProCamera2D/Editor/_ProCamera2D.Editor.asmdef.meta

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

Assets/ProCamera2D/Examples.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: ff778cd57e2e2429ea4e80002c918115
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/ProCamera2D/Examples/Platformer.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5b27830d4ae564882bf1f5eacfd9b4d4
+folderAsset: yes
+timeCreated: 1442488650
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Materials.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: fa1cbe695a84a419ebb6cc0dbceb7bdd
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/ProCamera2D/Examples/Platformer/Materials/MountainDark.mat

@@ -0,0 +1,157 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: MountainDark
+  m_Shader: {fileID: 6, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _BumpMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailNormalMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _Illum
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _ParallaxMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _OcclusionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _EmissionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailMask
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailAlbedoMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _MetallicGlossMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _SrcBlend
+        second: 1
+      data:
+        first:
+          name: _DstBlend
+        second: 0
+      data:
+        first:
+          name: _Cutoff
+        second: 0.5
+      data:
+        first:
+          name: _Shininess
+        second: 0.01
+      data:
+        first:
+          name: _Parallax
+        second: 0.02
+      data:
+        first:
+          name: _ZWrite
+        second: 1
+      data:
+        first:
+          name: _Glossiness
+        second: 0.5
+      data:
+        first:
+          name: _BumpScale
+        second: 1
+      data:
+        first:
+          name: _OcclusionStrength
+        second: 1
+      data:
+        first:
+          name: _DetailNormalMapScale
+        second: 1
+      data:
+        first:
+          name: _UVSec
+        second: 0
+      data:
+        first:
+          name: _Mode
+        second: 0
+      data:
+        first:
+          name: _Metallic
+        second: 0
+    m_Colors:
+      data:
+        first:
+          name: _EmissionColor
+        second: {r: 0, g: 0, b: 0, a: 1}
+      data:
+        first:
+          name: _Color
+        second: {r: 0.49411768, g: 0.21176472, b: 0.1137255, a: 1}
+      data:
+        first:
+          name: _SpecColor
+        second: {r: 0.49411768, g: 0.21176472, b: 0.1137255, a: 1}
+      data:
+        first:
+          name: _Emission
+        second: {r: 0, g: 0, b: 0, a: 0}

Assets/ProCamera2D/Examples/Platformer/Materials/MountainDark.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 594ce61ded4ec41909c36faf018dfd3f
+timeCreated: 1438442417
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Materials/MountainLight.mat

@@ -0,0 +1,157 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: MountainLight
+  m_Shader: {fileID: 6, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _BumpMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailNormalMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _Illum
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _ParallaxMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _OcclusionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _EmissionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailMask
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailAlbedoMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _MetallicGlossMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _SrcBlend
+        second: 1
+      data:
+        first:
+          name: _DstBlend
+        second: 0
+      data:
+        first:
+          name: _Cutoff
+        second: 0.5
+      data:
+        first:
+          name: _Shininess
+        second: 0.01
+      data:
+        first:
+          name: _Parallax
+        second: 0.02
+      data:
+        first:
+          name: _ZWrite
+        second: 1
+      data:
+        first:
+          name: _Glossiness
+        second: 0.4
+      data:
+        first:
+          name: _BumpScale
+        second: 1
+      data:
+        first:
+          name: _OcclusionStrength
+        second: 1
+      data:
+        first:
+          name: _DetailNormalMapScale
+        second: 1
+      data:
+        first:
+          name: _UVSec
+        second: 0
+      data:
+        first:
+          name: _Mode
+        second: 0
+      data:
+        first:
+          name: _Metallic
+        second: 0
+    m_Colors:
+      data:
+        first:
+          name: _EmissionColor
+        second: {r: 0, g: 0, b: 0, a: 1}
+      data:
+        first:
+          name: _Color
+        second: {r: 0.93725497, g: 0.72156864, b: 0.6039216, a: 1}
+      data:
+        first:
+          name: _SpecColor
+        second: {r: 0.93725497, g: 0.72156864, b: 0.6039216, a: 1}
+      data:
+        first:
+          name: _Emission
+        second: {r: 0, g: 0, b: 0, a: 0}

Assets/ProCamera2D/Examples/Platformer/Materials/MountainLight.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 324e14e3cf7d04e48957864aa672e90c
+timeCreated: 1438559084
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Materials/MountainMedium.mat

@@ -0,0 +1,150 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: MountainMedium
+  m_Shader: {fileID: 6, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_CustomRenderQueue: 2000
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _BumpMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailNormalMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _ParallaxMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _OcclusionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _EmissionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailMask
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailAlbedoMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _MetallicGlossMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _SrcBlend
+        second: 1
+      data:
+        first:
+          name: _DstBlend
+        second: 0
+      data:
+        first:
+          name: _Cutoff
+        second: 0.5
+      data:
+        first:
+          name: _Shininess
+        second: 0.01
+      data:
+        first:
+          name: _Parallax
+        second: 0.02
+      data:
+        first:
+          name: _ZWrite
+        second: 1
+      data:
+        first:
+          name: _Glossiness
+        second: 0.5
+      data:
+        first:
+          name: _BumpScale
+        second: 1
+      data:
+        first:
+          name: _OcclusionStrength
+        second: 1
+      data:
+        first:
+          name: _DetailNormalMapScale
+        second: 1
+      data:
+        first:
+          name: _UVSec
+        second: 0
+      data:
+        first:
+          name: _Mode
+        second: 0
+      data:
+        first:
+          name: _Metallic
+        second: 0
+    m_Colors:
+      data:
+        first:
+          name: _EmissionColor
+        second: {r: 0, g: 0, b: 0, a: 1}
+      data:
+        first:
+          name: _Color
+        second: {r: 0.6666667, g: 0.40784317, b: 0.28235295, a: 1}
+      data:
+        first:
+          name: _SpecColor
+        second: {r: 0.6666667, g: 0.40784317, b: 0.28235295, a: 1}
+      data:
+        first:
+          name: _Emission
+        second: {r: 0, g: 0, b: 0, a: 0}

Assets/ProCamera2D/Examples/Platformer/Materials/MountainMedium.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 02e2b15427cd643359e5865c915a314e
+timeCreated: 1438443798
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Materials/Walls.mat

@@ -0,0 +1,40 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 5
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Walls
+  m_Shader: {fileID: 10, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 1
+  m_CustomRenderQueue: -1
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _Illum
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _EmissionLM
+        second: 0
+    m_Colors:
+      data:
+        first:
+          name: _Color
+        second: {r: .16911763, g: 0, b: 0, a: 1}

Assets/ProCamera2D/Examples/Platformer/Materials/Walls.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f55c4d26159b348748a4ce6e97625c9e
+timeCreated: 1429657444
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Models.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: f026f66309de8407093be8b8c882b818
+folderAsset: yes
+timeCreated: 1438442417
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Models/Materials.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 732e45acf034243e7ac969e6e563e7f7
+folderAsset: yes
+timeCreated: 1470311582
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Models/Materials/mapping_grid_color_512.mat

@@ -0,0 +1,138 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: mapping_grid_color_512
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 5
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  m_SavedProperties:
+    serializedVersion: 2
+    m_TexEnvs:
+      data:
+        first:
+          name: _MainTex
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _BumpMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailNormalMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _ParallaxMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _OcclusionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _EmissionMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailMask
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _DetailAlbedoMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+      data:
+        first:
+          name: _MetallicGlossMap
+        second:
+          m_Texture: {fileID: 0}
+          m_Scale: {x: 1, y: 1}
+          m_Offset: {x: 0, y: 0}
+    m_Floats:
+      data:
+        first:
+          name: _SrcBlend
+        second: 1
+      data:
+        first:
+          name: _DstBlend
+        second: 0
+      data:
+        first:
+          name: _Cutoff
+        second: 0.5
+      data:
+        first:
+          name: _Parallax
+        second: 0.02
+      data:
+        first:
+          name: _ZWrite
+        second: 1
+      data:
+        first:
+          name: _Glossiness
+        second: 0.5
+      data:
+        first:
+          name: _BumpScale
+        second: 1
+      data:
+        first:
+          name: _OcclusionStrength
+        second: 1
+      data:
+        first:
+          name: _DetailNormalMapScale
+        second: 1
+      data:
+        first:
+          name: _UVSec
+        second: 0
+      data:
+        first:
+          name: _Mode
+        second: 0
+      data:
+        first:
+          name: _Metallic
+        second: 0
+    m_Colors:
+      data:
+        first:
+          name: _EmissionColor
+        second: {r: 0, g: 0, b: 0, a: 1}
+      data:
+        first:
+          name: _Color
+        second: {r: 1, g: 1, b: 1, a: 1}

Assets/ProCamera2D/Examples/Platformer/Models/Materials/mapping_grid_color_512.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 14bef3c54b5a14c38a73312e6c6b4461
+timeCreated: 1470311582
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Models/Pyramid.fbx.meta

@@ -0,0 +1,75 @@
+fileFormatVersion: 2
+guid: 860b5946caa9143b098b605936d9c739
+timeCreated: 1438558839
+licenseType: Store
+ModelImporter:
+  serializedVersion: 18
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: pyramid4
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    optimizeGameObjects: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    animationCompression: 1
+    animationRotationError: .5
+    animationPositionError: .5
+    animationScaleError: .5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    splitTangentsAcrossUV: 1
+    normalImportMode: 0
+    tangentImportMode: 1
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    human: []
+    skeleton: []
+    armTwist: .5
+    foreArmTwist: .5
+    upperLegTwist: .5
+    legTwist: .5
+    armStretch: .0500000007
+    legStretch: .0500000007
+    feetSpacing: 0
+    rootMotionBoneName: 
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/ProCamera2D/Examples/Platformer/Prefabs.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 5b30791715d444c19bec4efd86acc7bc
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/ProCamera2D/Examples/Platformer/Prefabs/Level.prefab.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f041036210ca24c12ad93ebdb067910f
+timeCreated: 1435002650
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: