Insanely huge initial commit

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerBoundaries.cs

@@ -0,0 +1,380 @@
+using UnityEngine;
+using System.Collections;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [HelpURLAttribute("http://www.procamera2d.com/user-guide/trigger-boundaries/")]
+    public class ProCamera2DTriggerBoundaries : BaseTrigger, IPositionOverrider
+    {
+        public static string TriggerName = "Boundaries Trigger";
+
+        public ProCamera2DNumericBoundaries NumericBoundaries;
+
+        public bool AreBoundariesRelative = true;
+        
+        public bool UseTopBoundary = true;
+        public float TopBoundary = 10;
+        public bool UseBottomBoundary = true;
+        public float BottomBoundary = -10;
+        public bool UseLeftBoundary = true;
+        public float LeftBoundary = -10;
+        public bool UseRightBoundary = true;
+        public float RightBoundary = 10;
+
+        public float TransitionDuration = 1f;
+        public EaseType TransitionEaseType;
+
+        public bool ChangeZoom;
+        public float TargetZoom = 1.5f;
+        public float ZoomSmoothness = 1f;
+
+        public bool IsCurrentTrigger { get { return NumericBoundaries.CurrentBoundariesTrigger._instanceID == _instanceID; } }
+
+        public bool SetAsStartingBoundaries
+        {
+            set
+            {
+                if (value && !_setAsStartingBoundaries)
+                {
+                    var allBoundariesTriggers = FindObjectsOfType(typeof(ProCamera2DTriggerBoundaries));
+                    foreach (ProCamera2DTriggerBoundaries trigger in allBoundariesTriggers)
+                    {
+                        trigger.SetAsStartingBoundaries = false;
+                    }
+                }
+
+                _setAsStartingBoundaries = value;
+            }
+
+            get
+            {
+                return _setAsStartingBoundaries;
+            }
+        }
+
+        /// <summary>Internal use only. Use the property SetAsStartingBoundaries</summary>
+        public bool _setAsStartingBoundaries;
+
+        float _initialCamSize;
+
+        BoundariesAnimator _boundsAnim;
+
+        float _targetTopBoundary;
+        float _targetBottomBoundary;
+        float _targetLeftBoundary;
+        float _targetRightBoundary;
+
+        bool _transitioning;
+        Vector3 _newPos;
+
+        protected override void Awake()
+        {
+            base.Awake();
+
+            ProCamera2D.AddPositionOverrider(this);
+        }
+
+        protected override void OnDestroy()
+        {
+            base.OnDestroy();
+
+            if(ProCamera2D)
+                ProCamera2D.RemovePositionOverrider(this);
+        }
+
+        void Start()
+        {
+            if (ProCamera2D == null)
+                return;
+            
+            if (NumericBoundaries == null)
+            {
+                var numericBoundaries = FindObjectOfType<ProCamera2DNumericBoundaries>();
+                NumericBoundaries = numericBoundaries == null ? ProCamera2D.gameObject.AddComponent<ProCamera2DNumericBoundaries>() : numericBoundaries;
+            }
+
+            _boundsAnim = new BoundariesAnimator(ProCamera2D, NumericBoundaries);
+            _boundsAnim.OnTransitionStarted += () =>
+            {
+                if (NumericBoundaries.OnBoundariesTransitionStarted != null)
+                    NumericBoundaries.OnBoundariesTransitionStarted();
+            };
+
+            _boundsAnim.OnTransitionFinished += () =>
+            {
+                if (NumericBoundaries.OnBoundariesTransitionFinished != null)
+                    NumericBoundaries.OnBoundariesTransitionFinished();
+            };
+
+            GetTargetBoundaries();
+
+            if (SetAsStartingBoundaries)
+                SetBoundaries();
+
+            _initialCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+        }
+
+        #region IPositionOverrider implementation
+
+        public Vector3 OverridePosition(float deltaTime, Vector3 originalPosition)
+        {
+            if (!enabled)
+                return originalPosition;
+
+            if (_transitioning)
+                return _newPos;
+            else
+                return originalPosition;
+        }
+
+        public int POOrder { get { return _poOrder; } set { _poOrder = value; } }
+        int _poOrder = 1000;
+
+        #endregion
+
+        protected override void EnteredTrigger()
+        {
+            base.EnteredTrigger();
+
+            if (NumericBoundaries.CurrentBoundariesTrigger != null)
+                StartCoroutine(TurnOffPreviousTrigger(NumericBoundaries.CurrentBoundariesTrigger));
+
+            if ((NumericBoundaries.CurrentBoundariesTrigger != null &&
+                 NumericBoundaries.CurrentBoundariesTrigger._instanceID != _instanceID) || 
+                NumericBoundaries.CurrentBoundariesTrigger == null) 
+            {
+                NumericBoundaries.CurrentBoundariesTrigger = this;
+
+                StartCoroutine (Transition ());
+            }
+        }
+
+        IEnumerator TurnOffPreviousTrigger(ProCamera2DTriggerBoundaries trigger)
+        {
+            yield return new WaitForEndOfFrame();
+
+            trigger._transitioning = false;
+        }
+
+        /// <summary>
+        /// Sets the Numeric Boundaries extension to the values of this trigger
+        /// </summary>
+        public void SetBoundaries()
+        {
+            if (NumericBoundaries != null)
+            {
+                NumericBoundaries.CurrentBoundariesTrigger = this;
+
+                NumericBoundaries.UseLeftBoundary = UseLeftBoundary;
+                if (UseLeftBoundary)
+                    NumericBoundaries.LeftBoundary = NumericBoundaries.TargetLeftBoundary = _targetLeftBoundary;
+
+                NumericBoundaries.UseRightBoundary = UseRightBoundary;
+                if (UseRightBoundary)
+                    NumericBoundaries.RightBoundary = NumericBoundaries.TargetRightBoundary = _targetRightBoundary;
+
+                NumericBoundaries.UseTopBoundary = UseTopBoundary;
+                if (UseTopBoundary)
+                    NumericBoundaries.TopBoundary = NumericBoundaries.TargetTopBoundary = _targetTopBoundary;
+
+                NumericBoundaries.UseBottomBoundary = UseBottomBoundary;
+                if (UseBottomBoundary)
+                    NumericBoundaries.BottomBoundary = NumericBoundaries.TargetBottomBoundary = _targetBottomBoundary;
+            }
+        }
+
+        void GetTargetBoundaries()
+        {
+            if (AreBoundariesRelative)
+            {
+                _targetTopBoundary = Vector3V(transform.position) + TopBoundary;
+                _targetBottomBoundary = Vector3V(transform.position) + BottomBoundary;
+                _targetLeftBoundary = Vector3H(transform.position) + LeftBoundary;
+                _targetRightBoundary = Vector3H(transform.position) + RightBoundary;
+            }
+            else
+            {
+                _targetTopBoundary = TopBoundary;
+                _targetBottomBoundary = BottomBoundary;
+                _targetLeftBoundary = LeftBoundary;
+                _targetRightBoundary = RightBoundary;
+            }
+        }
+
+        IEnumerator Transition()
+        {
+            if (!UseTopBoundary && !UseBottomBoundary && !UseLeftBoundary && !UseRightBoundary)
+            {
+                NumericBoundaries.UseTopBoundary = false;
+                NumericBoundaries.UseBottomBoundary = false;
+                NumericBoundaries.UseLeftBoundary = false;
+                NumericBoundaries.UseRightBoundary = false;
+                yield break;
+            }
+            
+            var position = transform.position;
+            var topBoundary = AreBoundariesRelative ? position.y + TopBoundary : TopBoundary;
+            var bottomBoundary = AreBoundariesRelative ? position.y + BottomBoundary : BottomBoundary;
+            var leftBoundary = AreBoundariesRelative ? position.x + LeftBoundary : LeftBoundary;
+            var rightBoundary = AreBoundariesRelative ? position.x + RightBoundary : RightBoundary;
+            const float epsilon = 0.01f;
+
+            // Avoid unnecessary transitions
+            var skip = true;
+            if (UseTopBoundary && (Mathf.Abs(NumericBoundaries.TopBoundary - topBoundary) > epsilon || !NumericBoundaries.UseTopBoundary))
+                skip = false;
+            if (skip && UseBottomBoundary && (Mathf.Abs(NumericBoundaries.BottomBoundary - bottomBoundary) > epsilon || !NumericBoundaries.UseBottomBoundary))
+                skip = false;
+            if (skip && UseLeftBoundary && (Mathf.Abs(NumericBoundaries.LeftBoundary - leftBoundary) > epsilon || !NumericBoundaries.UseLeftBoundary))
+                skip = false;
+            if (skip && UseRightBoundary && (Mathf.Abs(NumericBoundaries.RightBoundary - rightBoundary) > epsilon || !NumericBoundaries.UseRightBoundary))
+                skip = false;
+            if (skip)
+                yield break;
+
+            GetTargetBoundaries();
+
+            _boundsAnim.UseTopBoundary = UseTopBoundary;
+            _boundsAnim.TopBoundary = _targetTopBoundary;
+            _boundsAnim.UseBottomBoundary = UseBottomBoundary;
+            _boundsAnim.BottomBoundary = _targetBottomBoundary;
+            _boundsAnim.UseLeftBoundary = UseLeftBoundary;
+            _boundsAnim.LeftBoundary = _targetLeftBoundary;
+            _boundsAnim.UseRightBoundary = UseRightBoundary;
+            _boundsAnim.RightBoundary = _targetRightBoundary;
+
+            _boundsAnim.TransitionDuration = TransitionDuration;
+            _boundsAnim.TransitionEaseType = TransitionEaseType;
+
+            // Zoom
+            if (ChangeZoom && _initialCamSize / TargetZoom != ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f)
+                ProCamera2D.UpdateScreenSize(_initialCamSize / TargetZoom, ZoomSmoothness, TransitionEaseType);
+            
+
+            // Move camera "manually"
+            if (_boundsAnim.GetAnimsCount() > 1)
+            {
+                if (NumericBoundaries.MoveCameraToTargetRoutine != null)
+                    NumericBoundaries.StopCoroutine(NumericBoundaries.MoveCameraToTargetRoutine);
+
+                NumericBoundaries.MoveCameraToTargetRoutine = NumericBoundaries.StartCoroutine(MoveCameraToTarget());
+            }
+
+            // Start bounds animation
+            yield return new WaitForEndOfFrame();
+            _boundsAnim.Transition();
+        }
+
+        IEnumerator MoveCameraToTarget()
+        {
+            var initialCamPosH = Vector3H(ProCamera2D.LocalPosition);
+            var initialCamPosV = Vector3V(ProCamera2D.LocalPosition);
+
+            _newPos = VectorHVD(initialCamPosH, initialCamPosV, 0);
+            _transitioning = true;
+
+            var t = 0f;
+            while (t <= 1.0f)
+            {
+                t += ProCamera2D.DeltaTime / TransitionDuration;
+
+                var newPosH = Utils.EaseFromTo(initialCamPosH, ProCamera2D.CameraTargetPositionSmoothed.x, t, TransitionEaseType);
+                var newPosV = Utils.EaseFromTo(initialCamPosV, ProCamera2D.CameraTargetPositionSmoothed.y, t, TransitionEaseType);
+
+                LimitToNumericBoundaries(ref newPosH, ref newPosV);
+
+                _newPos = VectorHVD(newPosH, newPosV, 0);
+
+                yield return ProCamera2D.GetYield();
+            }
+
+            NumericBoundaries.MoveCameraToTargetRoutine = null;
+
+            _transitioning = false;
+        }
+
+        void LimitToNumericBoundaries(ref float horizontalPos, ref float verticalPos)
+        {
+            if (NumericBoundaries.UseLeftBoundary && horizontalPos - ProCamera2D.ScreenSizeInWorldCoordinates.x / 2 < NumericBoundaries.LeftBoundary)
+                horizontalPos = NumericBoundaries.LeftBoundary + ProCamera2D.ScreenSizeInWorldCoordinates.x / 2;
+            else if (NumericBoundaries.UseRightBoundary && horizontalPos + ProCamera2D.ScreenSizeInWorldCoordinates.x / 2 > NumericBoundaries.RightBoundary)
+                horizontalPos = NumericBoundaries.RightBoundary - ProCamera2D.ScreenSizeInWorldCoordinates.x / 2;
+
+            if (NumericBoundaries.UseBottomBoundary && verticalPos - ProCamera2D.ScreenSizeInWorldCoordinates.y / 2 < NumericBoundaries.BottomBoundary)
+                verticalPos = NumericBoundaries.BottomBoundary + ProCamera2D.ScreenSizeInWorldCoordinates.y / 2;
+            else if (NumericBoundaries.UseTopBoundary && verticalPos + ProCamera2D.ScreenSizeInWorldCoordinates.y / 2 > NumericBoundaries.TopBoundary)
+                verticalPos = NumericBoundaries.TopBoundary - ProCamera2D.ScreenSizeInWorldCoordinates.y / 2;
+        }
+
+        #if UNITY_EDITOR
+        protected override void DrawGizmos()
+        {
+            base.DrawGizmos();
+
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+
+            Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset - .01f * Mathf.Sign(Vector3D(ProCamera2D.transform.position))), "ProCamera2D/gizmo_icon_bg.png", false);
+
+            if (UseTopBoundary)
+            {
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_bound_top.png", false);
+            }
+
+            if (UseBottomBoundary)
+            {
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_bound_bottom.png", false);
+            }
+
+            if (UseRightBoundary)
+            {
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_bound_right.png", false);
+            }
+
+            if (UseLeftBoundary)
+            {
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_bound_left.png", false);
+            }
+
+            if (SetAsStartingBoundaries)
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_start.png", false);
+        }
+
+        void OnDrawGizmosSelected()
+        {
+            if (ProCamera2D == null)
+                return;
+            
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+            var cameraCenter = VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset);
+            var cameraDimensions = Utils.GetScreenSizeInWorldCoords(ProCamera2D.GetComponent<Camera>(), Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)));
+
+            GetTargetBoundaries();
+
+            Gizmos.color = EditorPrefsX.GetColor(PrefsData.BoundariesTriggerColorKey, PrefsData.BoundariesTriggerColorValue);
+            if (UseTopBoundary)
+            {
+                Gizmos.DrawRay(VectorHVD(Vector3H(transform.position) - cameraDimensions.x / 2, _targetTopBoundary, cameraDepthOffset), ProCamera2D.transform.right * cameraDimensions.x);
+                Utils.DrawArrowForGizmo(cameraCenter, VectorHV(0, _targetTopBoundary - Vector3V(transform.position)));
+            }
+
+            if (UseBottomBoundary)
+            {
+                Gizmos.DrawRay(VectorHVD(Vector3H(transform.position) - cameraDimensions.x / 2, _targetBottomBoundary, cameraDepthOffset), ProCamera2D.transform.right * cameraDimensions.x);
+                Utils.DrawArrowForGizmo(cameraCenter, VectorHV(0, _targetBottomBoundary - Vector3V(transform.position)));
+            }
+
+            if (UseRightBoundary)
+            {
+                Gizmos.DrawRay(VectorHVD(_targetRightBoundary, Vector3V(transform.position) - cameraDimensions.y / 2, cameraDepthOffset), ProCamera2D.transform.up * cameraDimensions.y);
+                Utils.DrawArrowForGizmo(cameraCenter, VectorHV(_targetRightBoundary - Vector3H(transform.position), 0));
+            }
+
+            if (UseLeftBoundary)
+            {
+                Gizmos.DrawRay(VectorHVD(_targetLeftBoundary, Vector3V(transform.position) - cameraDimensions.y / 2, cameraDepthOffset), ProCamera2D.transform.up * cameraDimensions.y);
+                Utils.DrawArrowForGizmo(cameraCenter, VectorHV(_targetLeftBoundary - Vector3H(transform.position), 0));
+            }
+        }
+        #endif
+    }
+}

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerBoundaries.cs.meta

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

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerInfluence.cs

@@ -0,0 +1,136 @@
+using UnityEngine;
+using System.Collections;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [HelpURLAttribute("http://www.procamera2d.com/user-guide/trigger-influence/")]
+    public class ProCamera2DTriggerInfluence : BaseTrigger
+    {
+		public enum TriggerInfluenceMode
+		{
+			BothAxis,
+			HorizontalAxis,
+			VerticalAxis
+		}
+
+        public static string TriggerName = "Influence Trigger";
+
+        public Transform FocusPoint;
+
+        public float InfluenceSmoothness = .3f;
+
+        [RangeAttribute(0, 1)]
+        public float ExclusiveInfluencePercentage = .25f;
+
+		public TriggerInfluenceMode Mode;
+
+        Vector2 _influence;
+        Vector2 _velocity;
+        Vector3 _exclusivePointVelocity;
+
+        Vector3 _tempExclusivePoint;
+
+        void Start()
+        {
+            if (FocusPoint == null)
+                FocusPoint = transform.Find("FocusPoint");
+            if (FocusPoint == null)
+                FocusPoint = transform;
+        }
+
+        protected override void EnteredTrigger()
+        {
+            base.EnteredTrigger();
+
+            StartCoroutine(InsideTriggerRoutine());
+        }
+
+        protected override void ExitedTrigger()
+        {
+            base.ExitedTrigger();
+
+            StartCoroutine(OutsideTriggerRoutine());
+        }
+
+        IEnumerator InsideTriggerRoutine()
+        {
+            yield return ProCamera2D.GetYield();
+
+            var previousDistancePercentage = 1f;
+
+            _tempExclusivePoint = VectorHV(Vector3H(ProCamera2D.transform.position), Vector3V(ProCamera2D.transform.position));
+            while (_insideTrigger)
+            {
+                _exclusiveInfluencePercentage = ExclusiveInfluencePercentage;
+
+                var distancePercentage = GetDistanceToCenterPercentage(new Vector2(Vector3H(ProCamera2D.TargetsMidPoint), Vector3V(ProCamera2D.TargetsMidPoint)));
+                var vectorFromPointToFocus = new Vector2(Vector3H(ProCamera2D.TargetsMidPoint) + Vector3H(ProCamera2D.TargetsMidPoint) - Vector3H(ProCamera2D.PreviousTargetsMidPoint), Vector3V(ProCamera2D.TargetsMidPoint) + Vector3V(ProCamera2D.TargetsMidPoint) - Vector3V(ProCamera2D.PreviousTargetsMidPoint)) - new Vector2(Vector3H(FocusPoint.position), Vector3V(FocusPoint.position));
+                if (distancePercentage == 0)
+                {
+					var exclusiveTargetPosition = VectorHV(Vector3H(FocusPoint.position), Vector3V(FocusPoint.position));
+                    ProCamera2D.ExclusiveTargetPosition = Vector3.SmoothDamp(_tempExclusivePoint, exclusiveTargetPosition, ref _exclusivePointVelocity, InfluenceSmoothness);
+                    _tempExclusivePoint = ProCamera2D.ExclusiveTargetPosition.Value;
+                    _influence = -vectorFromPointToFocus * (1 - distancePercentage);
+
+					if (Mode == TriggerInfluenceMode.HorizontalAxis)
+						_influence.y = 0;
+					else if (Mode == TriggerInfluenceMode.VerticalAxis)
+						_influence.x = 0;
+                    ProCamera2D.ApplyInfluence(_influence);
+                }
+                else
+                {
+                    if (previousDistancePercentage == 0)
+                        _influence = new Vector2(ProCamera2D.CameraTargetPositionSmoothed.x, ProCamera2D.CameraTargetPositionSmoothed.y) - new Vector2(Vector3H(ProCamera2D.TargetsMidPoint) + Vector3H(ProCamera2D.TargetsMidPoint) - Vector3H(ProCamera2D.PreviousTargetsMidPoint), Vector3V(ProCamera2D.TargetsMidPoint) + Vector3V(ProCamera2D.TargetsMidPoint) - Vector3V(ProCamera2D.PreviousTargetsMidPoint)) + new Vector2(Vector3H(ProCamera2D.ParentPosition), Vector3V(ProCamera2D.ParentPosition));
+
+                    _influence = Vector2.SmoothDamp(_influence, -vectorFromPointToFocus * (1 - distancePercentage), ref _velocity, InfluenceSmoothness, Mathf.Infinity, Time.deltaTime);
+
+					if (Mode == TriggerInfluenceMode.HorizontalAxis)
+						_influence.y = 0;
+					else if (Mode == TriggerInfluenceMode.VerticalAxis)
+						_influence.x = 0;
+                    ProCamera2D.ApplyInfluence(_influence);
+                    _tempExclusivePoint = VectorHV(Vector3H(ProCamera2D.CameraTargetPosition), Vector3V(ProCamera2D.CameraTargetPosition)) + VectorHV(Vector3H(ProCamera2D.ParentPosition), Vector3V(ProCamera2D.ParentPosition));
+                }
+
+                previousDistancePercentage = distancePercentage;
+
+                yield return ProCamera2D.GetYield();
+            }
+        }
+
+        IEnumerator OutsideTriggerRoutine()
+        {
+            yield return ProCamera2D.GetYield();
+
+            while (!_insideTrigger && _influence != Vector2.zero)
+            {
+                _influence = Vector2.SmoothDamp(_influence, Vector2.zero, ref _velocity, InfluenceSmoothness, Mathf.Infinity, Time.deltaTime);
+                ProCamera2D.ApplyInfluence(_influence);
+
+                yield return ProCamera2D.GetYield();
+            }
+        }
+
+        #if UNITY_EDITOR
+        override protected void DrawGizmos()
+        {
+            _exclusiveInfluencePercentage = ExclusiveInfluencePercentage;
+
+            base.DrawGizmos();
+
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+
+            if (FocusPoint != null)
+            {
+                if (FocusPoint.position != Vector3.zero)
+                    Gizmos.DrawLine(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), VectorHVD(Vector3H(FocusPoint.position), Vector3V(FocusPoint.position), cameraDepthOffset));
+
+                Gizmos.DrawIcon(VectorHVD(Vector3H(FocusPoint.position), Vector3V(FocusPoint.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_influence.png", false);
+            }
+            else
+                Gizmos.DrawIcon(VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset), "ProCamera2D/gizmo_icon_influence.png", false);
+        }
+        #endif
+    }
+}

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerInfluence.cs.meta

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

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerRails.cs

@@ -0,0 +1,62 @@
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    public enum TriggerRailsMode
+    {
+        Disable,
+        Enable
+    }
+
+    [HelpURLAttribute("http://www.procamera2d.com/user-guide/trigger-rails/")]
+    public class ProCamera2DTriggerRails : BaseTrigger
+    {
+        public static string TriggerName = "Rails Trigger";
+
+        [HideInInspector]
+        public ProCamera2DRails ProCamera2DRails;
+
+        public TriggerRailsMode Mode; 
+
+        public float TransitionDuration = 1f;
+        
+        void Start()
+        {
+            if (ProCamera2D == null)
+                return;
+                
+            if (ProCamera2DRails == null)
+                ProCamera2DRails = FindObjectOfType<ProCamera2DRails>();
+
+            if (ProCamera2DRails == null)
+                Debug.LogWarning("Rails extension couldn't be found on ProCamera2D. Please enable it to use this trigger.");
+        }
+
+        protected override void EnteredTrigger()
+        {
+            base.EnteredTrigger();
+            
+            if(Mode == TriggerRailsMode.Enable)
+                ProCamera2DRails.EnableTargets(TransitionDuration);
+            else
+                ProCamera2DRails.DisableTargets(TransitionDuration);
+        }
+
+        #if UNITY_EDITOR
+        override protected void DrawGizmos()
+        {
+            base.DrawGizmos();
+
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+
+            Gizmos.DrawIcon(
+                VectorHVD(
+                    Vector3H(transform.position), 
+                    Vector3V(transform.position), 
+                    cameraDepthOffset), 
+                Mode == TriggerRailsMode.Enable ? "ProCamera2D/gizmo_icon_rails_enable.png" : "ProCamera2D/gizmo_icon_rails_disable.png", 
+                false);
+        }
+        #endif
+    }
+}

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerRails.cs.meta

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

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerZoom.cs

@@ -0,0 +1,214 @@
+using System.Collections;
+using UnityEngine;
+
+namespace Com.LuisPedroFonseca.ProCamera2D
+{
+    [HelpURLAttribute("http://www.procamera2d.com/user-guide/trigger-zoom/")]
+    public class ProCamera2DTriggerZoom : BaseTrigger
+    {
+        public static string TriggerName = "Zoom Trigger";
+
+        public bool SetSizeAsMultiplier = true;
+
+        public float TargetZoom = 1.5f;
+
+        public float ZoomSmoothness = 1f;
+
+        [RangeAttribute(0, 1)]
+        public float ExclusiveInfluencePercentage = .25f;
+
+        public bool ResetSizeOnExit = false;
+        public float ResetSizeSmoothness = 1f;
+
+        float _startCamSize;
+        float _initialCamSize;
+        float _targetCamSize;
+        float _targetCamSizeSmoothed;
+        float _previousCamSize;
+        float _zoomVelocity;
+
+        float _initialCamDepth;
+
+        void Start()
+        {
+            if (ProCamera2D == null)
+                return;
+            
+            _startCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+            _initialCamSize = _startCamSize;
+            _targetCamSize = _startCamSize;
+            _targetCamSizeSmoothed = _startCamSize;
+
+            _initialCamDepth = Vector3D(ProCamera2D.LocalPosition);
+        }
+
+        protected override void EnteredTrigger()
+        {
+            base.EnteredTrigger();
+
+            ProCamera2D.CurrentZoomTriggerID = _instanceID;
+
+            if (ResetSizeOnExit)
+            {
+                _initialCamSize = _startCamSize;
+                _targetCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+                _targetCamSizeSmoothed = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+            }
+            else
+            {
+                _initialCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+                _targetCamSize = _initialCamSize;
+                _targetCamSizeSmoothed = _initialCamSize;
+            }
+
+            StartCoroutine(InsideTriggerRoutine());
+        }
+
+        protected override void ExitedTrigger()
+        {
+            base.ExitedTrigger();
+
+            if (ResetSizeOnExit)
+            {
+                _targetCamSize = _startCamSize;
+
+                StartCoroutine(OutsideTriggerRoutine());
+            }
+        }
+
+        IEnumerator InsideTriggerRoutine()
+        {
+            while (_insideTrigger &&
+                   _instanceID == ProCamera2D.CurrentZoomTriggerID)
+            {
+                _exclusiveInfluencePercentage = ExclusiveInfluencePercentage;
+
+                // Find percentage distance to center
+                var targetPos = new Vector2(Vector3H(UseTargetsMidPoint ? ProCamera2D.TargetsMidPoint : TriggerTarget.position), Vector3V(UseTargetsMidPoint ? ProCamera2D.TargetsMidPoint : TriggerTarget.position));
+                var distancePercentage = GetDistanceToCenterPercentage(targetPos);
+
+                // Calculate the target size
+                float finalTargetSize;
+                if (SetSizeAsMultiplier)
+                    finalTargetSize = _startCamSize / TargetZoom;
+                else if (ProCamera2D.GameCamera.orthographic)
+                    finalTargetSize = TargetZoom;
+                else
+                    finalTargetSize = Mathf.Abs(_initialCamDepth) * Mathf.Tan(TargetZoom * 0.5f * Mathf.Deg2Rad);
+
+                var newTargetOrtographicSize = (_initialCamSize * distancePercentage) + (finalTargetSize * (1 - distancePercentage));
+
+                if ((finalTargetSize > ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f
+                    && newTargetOrtographicSize > _targetCamSize) ||
+                    (finalTargetSize < ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f
+                    && newTargetOrtographicSize < _targetCamSize) ||
+                    ResetSizeOnExit)
+                {
+                    _targetCamSize = newTargetOrtographicSize;
+                }
+
+                // Detect if the camera size is bounded
+                _previousCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y;
+
+                // Yield
+                yield return ProCamera2D.GetYield();
+
+                // Update camera size if needed
+                if (Mathf.Abs(ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f - _targetCamSize) > .0001f)
+                    UpdateScreenSize(ResetSizeOnExit ? ResetSizeSmoothness : ZoomSmoothness);
+
+                // If the camera is bounded, reset the easing
+                if (_previousCamSize == ProCamera2D.ScreenSizeInWorldCoordinates.y)
+                {
+                    _targetCamSize = ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f;
+                    _targetCamSizeSmoothed = _targetCamSize;
+                    _zoomVelocity = 0f;
+                }
+            }
+        }
+
+        IEnumerator OutsideTriggerRoutine()
+        {
+            while (!_insideTrigger &&
+                   _instanceID == ProCamera2D.CurrentZoomTriggerID &&
+                    Mathf.Abs(ProCamera2D.ScreenSizeInWorldCoordinates.y * .5f - _targetCamSize) > .0001f)
+            {
+                UpdateScreenSize(ResetSizeOnExit ? ResetSizeSmoothness : ZoomSmoothness);
+                yield return ProCamera2D.GetYield();
+            }
+            _zoomVelocity = 0f;
+        }
+
+        protected void UpdateScreenSize(float smoothness)
+        {
+            _targetCamSizeSmoothed = Mathf.SmoothDamp(_targetCamSizeSmoothed, _targetCamSize, ref _zoomVelocity, smoothness, float.MaxValue, ProCamera2D.DeltaTime);
+
+            ProCamera2D.UpdateScreenSize(_targetCamSizeSmoothed);
+        }
+
+        #if UNITY_EDITOR
+        override protected void DrawGizmos()
+        {
+            _exclusiveInfluencePercentage = ExclusiveInfluencePercentage;
+
+            base.DrawGizmos();
+
+            var gameCamera = ProCamera2D.GetComponent<Camera>();
+            var cameraDimensions = Utils.GetScreenSizeInWorldCoords(gameCamera, Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)));
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+
+            var startCamSize = Application.isPlaying ? _startCamSize : cameraDimensions.y / 2;
+
+            float finalTargetSize;
+            if (SetSizeAsMultiplier)
+                finalTargetSize = startCamSize / TargetZoom;
+            else if (ProCamera2D.GameCamera.orthographic)
+                finalTargetSize = TargetZoom;
+            else
+                finalTargetSize = Mathf.Abs(Application.isPlaying ? _initialCamDepth : Vector3D(ProCamera2D.transform.localPosition)) * Mathf.Tan(TargetZoom * 0.5f * Mathf.Deg2Rad);
+            
+            Gizmos.DrawIcon(
+                VectorHVD(
+                    Vector3H(transform.position), 
+                    Vector3V(transform.position), 
+                    cameraDepthOffset), 
+                startCamSize > finalTargetSize ? "ProCamera2D/gizmo_icon_zoom_in.png" : "ProCamera2D/gizmo_icon_zoom_out.png", 
+                false);
+
+            if (ResetSizeOnExit)
+                Gizmos.DrawIcon(
+                    VectorHVD(
+                        Vector3H(transform.position), 
+                        Vector3V(transform.position), 
+                        cameraDepthOffset), 
+                    "ProCamera2D/gizmo_icon_reset.png", 
+                    false);
+        }
+
+        void OnDrawGizmosSelected()
+        {
+            if (ProCamera2D == null)
+                return;
+            
+            var gameCamera = ProCamera2D.GetComponent<Camera>();
+            var cameraDimensions = Utils.GetScreenSizeInWorldCoords(gameCamera, Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)));
+            float cameraDepthOffset = Vector3D(ProCamera2D.transform.localPosition) + Mathf.Abs(Vector3D(ProCamera2D.transform.localPosition)) * Vector3D(ProCamera2D.transform.forward);
+            var cameraCenter = VectorHVD(Vector3H(transform.position), Vector3V(transform.position), cameraDepthOffset);
+
+            var startCamSize = Application.isPlaying ? _startCamSize : cameraDimensions.y / 2;
+
+            float finalTargetSize;
+            if (SetSizeAsMultiplier)
+                finalTargetSize = startCamSize / TargetZoom;
+            else if (ProCamera2D.GameCamera.orthographic)
+                finalTargetSize = TargetZoom;
+            else
+                finalTargetSize = Mathf.Abs(Application.isPlaying ? _initialCamDepth : Vector3D(ProCamera2D.transform.localPosition)) * Mathf.Tan(TargetZoom * 0.5f * Mathf.Deg2Rad);
+
+            Gizmos.color = EditorPrefsX.GetColor(PrefsData.ZoomTriggerColorKey, PrefsData.ZoomTriggerColorValue);
+            Gizmos.color = new Color(Gizmos.color.r, Gizmos.color.g, Gizmos.color.b, 1f);
+            Gizmos.DrawWireCube(cameraCenter, VectorHV(finalTargetSize * 2 * ProCamera2D.GameCamera.aspect, finalTargetSize * 2));
+        }
+        #endif
+    }
+}

Assets/ProCamera2D/Runtime/Code/Triggers/ProCamera2DTriggerZoom.cs.meta

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