update

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl/Editor.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl/Editor/vCullingFadeControlEditor.cs

@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace Invector
+{
+    [CustomEditor(typeof(vCullingFadeControl))]
+    public class vCullingFadeControlEditor : UnityEditor.Editor
+    {
+        GUISkin skin;
+        vCullingFadeControl _fadeControl { get { return (vCullingFadeControl)target; } }
+        private Texture2D m_Logo = null;
+
+        void OnEnable()
+        {
+            m_Logo = (Texture2D)Resources.Load("icon_v2", typeof(Texture2D));
+        }
+
+        void OnSceneGUI()
+        {
+            if (!_fadeControl.targetObject) return;
+            var tpos = (_fadeControl.targetObject.position + _fadeControl.offset);
+            Handles.color = new Color(1, 1, 1, 0.5f);            
+            Handles.SphereHandleCap(0, tpos, Quaternion.identity, 0.1f, EventType.Ignore);
+            Ray ray = new Ray(tpos, _fadeControl.cameraTransform.position - tpos);
+            Handles.DrawLine(tpos, ray.GetPoint(_fadeControl.distanceToEndFade));
+            Handles.color = (_fadeControl.distanceToEndFade < _fadeControl.distanceToStartFade) ? Color.green : Color.red;
+            Handles.DrawAAPolyLine(10f, new Vector3[] { ray.GetPoint(_fadeControl.distanceToEndFade), ray.GetPoint(_fadeControl.distanceToStartFade) });
+            Handles.CubeHandleCap(0, ray.GetPoint(_fadeControl.distanceToEndFade), Quaternion.LookRotation(_fadeControl.cameraTransform.position - ray.GetPoint(_fadeControl.distanceToEndFade)), 0.05f, EventType.Ignore);
+            Handles.ConeHandleCap(0, ray.GetPoint(_fadeControl.distanceToStartFade), Quaternion.LookRotation(ray.GetPoint(_fadeControl.distanceToStartFade) - _fadeControl.cameraTransform.position), 0.1f, EventType.Ignore);
+            Handles.color = new Color(1, 1, 1, 0.5f);
+            Handles.DrawLine(ray.GetPoint(_fadeControl.distanceToStartFade), _fadeControl.cameraTransform.position);
+            Handles.DrawPolyLine(new Vector3[] { ray.GetPoint(_fadeControl.distanceToEndFade), ray.GetPoint(_fadeControl.distanceToStartFade) });
+        }
+
+        public override void OnInspectorGUI()
+        {
+            if (!skin) skin = Resources.Load("vSkin") as GUISkin;
+            GUI.skin = skin;
+
+            GUILayout.BeginVertical("Culling Fade", "window");
+            GUILayout.Label(m_Logo, GUILayout.MaxHeight(25));
+            GUILayout.Space(10);
+
+            base.OnInspectorGUI();
+            if (!Application.isPlaying)
+                CheckRenderers();
+            GUILayout.BeginHorizontal("box", GUILayout.ExpandHeight(false));
+
+            GUILayout.BeginVertical(GUILayout.ExpandHeight(false));
+            if (_fadeControl.fadeMeshRenderers != null && _fadeControl.fadeMeshRenderers.Count > 0)
+            {
+                for (int a = 0; a < _fadeControl.fadeMeshRenderers.Count; a++)
+                {
+                    EditorGUILayout.ObjectField("Renderer", _fadeControl.fadeMeshRenderers[a].renderer, typeof(Renderer), true);
+                    var renderer = _fadeControl.fadeMeshRenderers[a].renderer as MeshRenderer;
+                    GUILayout.BeginHorizontal();
+                    
+                    GUILayout.BeginVertical("window", GUILayout.ExpandHeight(false));
+
+                    for (int b = 0; b < renderer.sharedMaterials.Length; b++)
+                        renderer.sharedMaterials[b] = (Material)EditorGUILayout.ObjectField(renderer.sharedMaterials[b], typeof(Material), false);
+
+                    GUILayout.EndVertical();
+                    
+                    GUILayout.BeginVertical("window", GUILayout.ExpandHeight(false));
+
+                    for (int b = 0; b < _fadeControl.fadeMeshRenderers[a].fadeMaterials.Length; b++)
+                        _fadeControl.fadeMeshRenderers[a].fadeMaterials[b] = (Material)EditorGUILayout.ObjectField(_fadeControl.fadeMeshRenderers[a].fadeMaterials[b], typeof(Material), false);
+
+                    GUILayout.EndVertical();
+                    GUILayout.EndHorizontal();
+                }
+            }
+
+            if (_fadeControl.fadeSkinnedMeshRenderes != null && _fadeControl.fadeSkinnedMeshRenderes.Count > 0)
+            {
+                for (int a = 0; a < _fadeControl.fadeSkinnedMeshRenderes.Count; a++)
+                {
+                    EditorGUILayout.ObjectField("Renderer", _fadeControl.fadeSkinnedMeshRenderes[a].renderer, typeof(Renderer), true);
+                    var renderer = _fadeControl.fadeSkinnedMeshRenderes[a].renderer as SkinnedMeshRenderer;
+                    GUILayout.BeginHorizontal(GUILayout.ExpandHeight(false));
+                    
+                    GUILayout.BeginVertical("box", GUILayout.ExpandHeight(false));
+                    GUILayout.Label("Original Material");
+                    for (int b = 0; b < renderer.sharedMaterials.Length; b++)
+                        renderer.sharedMaterials[b] = (Material)EditorGUILayout.ObjectField(renderer.sharedMaterials[b], typeof(Material), false);
+
+                    GUILayout.EndVertical();
+                    
+                    GUILayout.BeginVertical("box", GUILayout.ExpandHeight(false));
+                    GUILayout.Label("Optional Fade");
+
+                    for (int b = 0; b < _fadeControl.fadeSkinnedMeshRenderes[a].fadeMaterials.Length; b++)
+                        _fadeControl.fadeSkinnedMeshRenderes[a].fadeMaterials[b] = (Material)EditorGUILayout.ObjectField(_fadeControl.fadeSkinnedMeshRenderes[a].fadeMaterials[b], typeof(Material), false);
+
+                    GUILayout.EndVertical();
+                    GUILayout.EndHorizontal();
+                }
+            }
+
+            EditorGUILayout.HelpBox("Your material has to be Transparent or Fade, you will also need to change the Z-write (check documentation for more information)", MessageType.Info);
+
+            GUILayout.EndVertical();
+            GUILayout.EndHorizontal();
+            GUILayout.EndVertical();
+            if (GUI.changed)
+                EditorUtility.SetDirty(_fadeControl);
+        }
+
+        [MenuItem("Invector/Basic Locomotion/Components/Culling Fade")]
+        static void MenuComponent()
+        {
+            Selection.activeGameObject.AddComponent<vCullingFadeControl>();
+        }
+
+        public void CheckRenderers()
+        {
+            if (_fadeControl.targetObject == null) return;
+            var meshRenderers = _fadeControl.targetObject.GetComponentsInChildren<MeshRenderer>(true);
+
+            if (_fadeControl.fadeMeshRenderers == null)
+                _fadeControl.fadeMeshRenderers = new List<FadeMaterials>();
+
+            if (_fadeControl.fadeMeshRenderers.Count != meshRenderers.Length)
+            {
+                _fadeControl.fadeMeshRenderers.Resize(meshRenderers.Length);
+                EditorUtility.SetDirty(_fadeControl);
+            }
+
+            for (int i = 0; i < meshRenderers.Length; i++)
+            {
+                if (_fadeControl.fadeMeshRenderers[i] == null)
+                    _fadeControl.fadeMeshRenderers[i] = new FadeMaterials();
+                if (_fadeControl.fadeMeshRenderers[i].renderer == null || (_fadeControl.fadeMeshRenderers[i].renderer != null && _fadeControl.fadeMeshRenderers[i].renderer != (meshRenderers[i] as Renderer)))
+                    _fadeControl.fadeMeshRenderers[i].renderer = meshRenderers[i] as Renderer;
+                if (_fadeControl.fadeMeshRenderers[i].originalMaterials == null || (_fadeControl.fadeMeshRenderers[i].originalMaterials != null && _fadeControl.fadeMeshRenderers[i].originalMaterials != meshRenderers[i].sharedMaterials))
+                    _fadeControl.fadeMeshRenderers[i].originalMaterials = meshRenderers[i].sharedMaterials;
+                if (_fadeControl.fadeMeshRenderers[i].fadeMaterials == null)
+                    _fadeControl.fadeMeshRenderers[i].fadeMaterials = new Material[meshRenderers[i].sharedMaterials.Length];
+                else if (_fadeControl.fadeMeshRenderers[i].fadeMaterials.Length != meshRenderers[i].sharedMaterials.Length)
+                    Array.Resize(ref _fadeControl.fadeMeshRenderers[i].fadeMaterials, meshRenderers[i].sharedMaterials.Length);
+            }
+                        
+            var skinnedRenderers = _fadeControl.targetObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
+            if (_fadeControl.fadeSkinnedMeshRenderes == null)
+                _fadeControl.fadeSkinnedMeshRenderes = new List<FadeMaterials>();
+            if (_fadeControl.fadeSkinnedMeshRenderes.Count != skinnedRenderers.Length)
+            {
+                _fadeControl.fadeSkinnedMeshRenderes.Resize(skinnedRenderers.Length);
+                EditorUtility.SetDirty(_fadeControl);
+            }
+
+            for (int i = 0; i < skinnedRenderers.Length; i++)
+            {
+                if (_fadeControl.fadeSkinnedMeshRenderes[i] == null)
+                    _fadeControl.fadeSkinnedMeshRenderes[i] = new FadeMaterials();
+                if (_fadeControl.fadeSkinnedMeshRenderes[i].renderer == null || (_fadeControl.fadeSkinnedMeshRenderes[i].renderer != null && _fadeControl.fadeSkinnedMeshRenderes[i].renderer != (skinnedRenderers[i] as Renderer)))
+                    _fadeControl.fadeSkinnedMeshRenderes[i].renderer = skinnedRenderers[i] as Renderer;
+                if (_fadeControl.fadeSkinnedMeshRenderes[i].originalMaterials == null || (_fadeControl.fadeSkinnedMeshRenderes[i].originalMaterials != null && _fadeControl.fadeSkinnedMeshRenderes[i].originalMaterials != skinnedRenderers[i].sharedMaterials))
+                    _fadeControl.fadeSkinnedMeshRenderes[i].originalMaterials = skinnedRenderers[i].sharedMaterials;
+                if (_fadeControl.fadeSkinnedMeshRenderes[i].fadeMaterials == null)
+                    _fadeControl.fadeSkinnedMeshRenderes[i].fadeMaterials = new Material[skinnedRenderers[i].sharedMaterials.Length];
+                else if (_fadeControl.fadeSkinnedMeshRenderes[i].fadeMaterials.Length != skinnedRenderers[i].sharedMaterials.Length)
+                    Array.Resize(ref _fadeControl.fadeSkinnedMeshRenderes[i].fadeMaterials, skinnedRenderers[i].sharedMaterials.Length);
+            }
+        }
+
+        #region Control Zwrite of Standard Material
+        [MenuItem("Assets/Change Zwrite of Standard Material")]
+        private static void ChangeZWRITE()
+        {
+            var material = Selection.activeObject as Material;
+            if (material != null)
+            {
+                if (material.GetInt("_ZWrite") == 0)
+                    material.SetInt("_ZWrite", 1);
+                else
+                    material.SetInt("_ZWrite", 0);
+            }
+        }
+
+        [MenuItem("Assets/Change Zwrite of Standard Material", true)]
+        private static bool ValidateChangeZWRITE()
+        {
+            var material = Selection.activeObject as Material;
+
+            if (material != null)
+            {
+                if (material.HasProperty("_ZWrite") && material.HasProperty("_Mode"))
+                    return true;
+            }
+            return false;
+        }
+        #endregion
+    }
+
+    public static class ListExtras
+    {
+        //    list: List<T> to resize
+        //    size: desired new size
+        // element: default value to insert
+
+        public static void Resize<T>(this List<T> list, int size, T element = default(T))
+        {
+            int count = list.Count;
+
+            if (size < count)
+                list.RemoveRange(size, count - size);
+            else if (size > count)
+            {
+                if (size > list.Capacity)   // Optimization
+                    list.Capacity = size;
+
+                list.AddRange(Enumerable.Repeat(element, size - count));
+            }
+        }
+    }
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl/Editor/vCullingFadeControlEditor.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl/vCullingFadeControl.cs

@@ -0,0 +1,199 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Invector
+{
+    public class vCullingFadeControl : MonoBehaviour
+    {
+        public Transform targetObject
+        {
+            get
+            {
+                Transform cT = transform;
+                return cT;
+            }
+        }
+
+        public float distanceToStartFade = 0.55f;
+        public float distanceToEndFade = 0.4f;
+        public Vector3 offset = new Vector3(0, 1.3f, 0);
+
+        // [HideInInspector]
+        public List<FadeMaterials> fadeMeshRenderers;
+        // [HideInInspector]
+        public List<FadeMaterials> fadeSkinnedMeshRenderes;
+        // [HideInInspector]
+        public bool usingTransp;
+
+        public Transform cameraTransform
+        {
+            get
+            {
+                Transform cT = transform;
+                if (Camera.main != null)
+                    cT = Camera.main.transform;
+                if (cT == transform)
+                {
+                    Debug.LogWarning("Invector : Missing MainCamera");
+                    this.enabled = false;
+                }
+                return cT;
+            }
+        }
+
+        void Start()
+        {
+            Init();
+        }
+
+        public void Init()
+        {
+            foreach (FadeMaterials fd in fadeMeshRenderers)
+            {
+                fd.originalAlpha = new float[fd.originalMaterials.Length];
+                for (int i = 0; i < fd.originalMaterials.Length; i++)
+                {
+                    if (fd.fadeMaterials[i] == null)
+                    {
+                        try
+                        {
+                            fd.originalAlpha[i] = fd.originalMaterials[i].color.a;
+                            fd.fadeMaterials[i] = fd.originalMaterials[i];
+                        }
+                        catch { }
+
+                    }
+                    else try { fd.originalAlpha[i] = fd.fadeMaterials[i].color.a; } catch { }
+                }
+            }
+
+            foreach (FadeMaterials fd in fadeSkinnedMeshRenderes)
+            {
+                fd.originalAlpha = new float[fd.originalMaterials.Length];
+                for (int i = 0; i < fd.originalMaterials.Length; i++)
+                {
+                    if (fd.fadeMaterials[i] == null)
+                    {
+                        try
+                        {
+                            fd.originalAlpha[i] = fd.originalMaterials[i].color.a;
+                            fd.fadeMaterials[i] = fd.originalMaterials[i];
+                        }
+                        catch { }
+
+                    }
+                    else try { fd.originalAlpha[i] = fd.fadeMaterials[i].color.a; } catch { }
+                }
+            }
+        }
+
+        void LateUpdate()
+        {
+            UpdateEffect();
+
+            if (usingTransp)
+                ChangeAlphaFromDistance();
+        }
+
+        /// <summary>
+        /// Update the effect to check if use fade or not
+        /// </summary>
+        private void UpdateEffect()
+        {
+            var currentDist = Vector3.Distance(cameraTransform.position, (targetObject.position + offset));
+            if (currentDist < distanceToStartFade && !usingTransp)
+            {
+                usingTransp = true;
+                ChangeMaterialsToFade();
+            }
+            else if (usingTransp && currentDist > distanceToStartFade)
+            {
+                usingTransp = false;
+                ChangeMaterialsToOriginal();
+            }
+        }
+
+        /// <summary>
+        /// Change the Renderer Materials to Original Materials
+        /// </summary>
+        private void ChangeMaterialsToOriginal()
+        {
+            foreach (FadeMaterials fd in fadeMeshRenderers)
+                try { fd.renderer.sharedMaterials = fd.originalMaterials; } catch { }
+
+
+            foreach (FadeMaterials fd in fadeSkinnedMeshRenderes)
+                try { fd.renderer.sharedMaterials = fd.originalMaterials; } catch { }
+        }
+
+        /// <summary>
+        /// Chenge the Renderer Materials to Fade Material
+        /// </summary>
+        private void ChangeMaterialsToFade()
+        {
+
+            foreach (FadeMaterials fd in fadeMeshRenderers)
+                try { fd.renderer.sharedMaterials = fd.fadeMaterials; } catch { }
+
+
+            foreach (FadeMaterials fd in fadeSkinnedMeshRenderes)
+                try { fd.renderer.sharedMaterials = fd.fadeMaterials; } catch { }
+
+
+
+        }
+
+        /// <summary>
+        /// Change the Alpha Color material From distance
+        /// </summary>
+        public void ChangeAlphaFromDistance()
+        {
+            var currentDist = Vector3.Distance(cameraTransform.position, (targetObject.position + offset));
+            // Mesh Renderer
+            for (int i = 0; i < fadeMeshRenderers.Count; i++)
+            {
+                for (int m = 0; m < fadeMeshRenderers[i].fadeMaterials.Length; m++)
+                {
+                    try
+                    {
+                        var multpler = fadeMeshRenderers[i].originalAlpha[m] / (distanceToStartFade - distanceToEndFade);
+                        var color = fadeMeshRenderers[i].renderer.sharedMaterials[m].color;
+                        var factor = (distanceToStartFade - distanceToEndFade) - ((distanceToStartFade - currentDist));
+                        color.a = multpler * factor;
+                        color.a = Mathf.Clamp(color.a, 0f, fadeMeshRenderers[i].originalAlpha[m]);
+                        fadeMeshRenderers[i].renderer.materials[m].color = color;
+                    }
+                    catch { }
+
+                }
+            }
+            //Skinned Mesh Renderer
+            for (int i = 0; i < fadeSkinnedMeshRenderes.Count; i++)
+            {
+                for (int m = 0; m < fadeSkinnedMeshRenderes[i].fadeMaterials.Length; m++)
+                {
+                    try
+                    {
+                        var multpler = fadeSkinnedMeshRenderes[i].originalAlpha[m] / (distanceToStartFade - distanceToEndFade);
+                        var color = fadeSkinnedMeshRenderes[i].renderer.sharedMaterials[m].color;
+                        var factor = (distanceToStartFade - distanceToEndFade) - ((distanceToStartFade - currentDist));
+                        color.a = multpler * factor;
+                        color.a = Mathf.Clamp(color.a, 0f, fadeSkinnedMeshRenderes[i].originalAlpha[m]);
+                        fadeSkinnedMeshRenderes[i].renderer.materials[m].color = color;
+                    }
+                    catch { }
+
+                }
+            }
+        }
+    }
+
+    [System.Serializable]
+    public class FadeMaterials
+    {
+        public Renderer renderer;
+        public Material[] originalMaterials;
+        public Material[] fadeMaterials;
+        public float[] originalAlpha;
+    }
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/CullingFadeControl/vCullingFadeControl.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/Editor.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/Editor/vScriptableObjectUtility.cs

@@ -0,0 +1,22 @@
+#if UNITY_EDITOR
+using UnityEngine;
+using UnityEditor;
+namespace Invector
+{
+    public static class vScriptableObjectUtility
+    {
+        /// <summary>
+        /// Create new asset from <see cref="ScriptableObject"/> type with unique Name at
+        /// selected folder in project window. Asset creation can be cancelled by pressing
+        /// escape key when asset is initially being named.
+        /// </summary>
+        /// <typeparam Name="T">Type of scriptable object.</typeparam>
+        /// 
+        public static void CreateAsset<T>() where T : ScriptableObject
+        {
+            var asset = ScriptableObject.CreateInstance<T>();
+            ProjectWindowUtil.CreateAsset(asset, "New " + typeof(T).Name + ".asset");
+        }
+    }
+}
+#endif

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/Editor/vScriptableObjectUtility.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/Editor/vThirdPersonCameraEditor.cs

@@ -0,0 +1,435 @@
+using UnityEngine;
+using UnityEditor;
+using System.Collections;
+using System.Collections.Generic;
+namespace Invector.vCamera
+{
+    [CustomEditor(typeof(vThirdPersonCamera),true)]
+    [CanEditMultipleObjects]
+    public class vThirdPersonCameraEditor : UnityEditor.Editor
+    {
+        protected virtual GUISkin skin { get; set; }
+        protected virtual vThirdPersonCamera tpCamera { get; set; }
+        protected virtual bool hasPointCopy { get; set; }
+        protected virtual Vector3 pointCopy { get; set; }
+        protected virtual int indexSelected { get; set; }
+        protected virtual Texture2D m_Logo { get; set; }
+
+        protected virtual void OnSceneGUI()
+        {
+            if (Application.isPlaying)
+                return;
+            tpCamera = (vThirdPersonCamera)target;
+
+            if (tpCamera.gameObject == Selection.activeGameObject)
+                if (tpCamera.CameraStateList != null && tpCamera.CameraStateList.tpCameraStates != null && tpCamera.CameraStateList.tpCameraStates.Count > 0)
+                {
+                    if (tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].cameraMode != TPCameraMode.FixedPoint) return;
+                    try
+                    {
+                        for (int i = 0; i < tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints.Count; i++)
+                        {
+                            if (indexSelected == i)
+                            {
+                                Handles.color = Color.blue;
+                                tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].positionPoint = tpCamera.transform.position;
+                                tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].eulerAngle = tpCamera.transform.eulerAngles;
+                                if (tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[indexSelected].freeRotation)
+                                {
+                                    Handles.SphereHandleCap(0, tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].eulerAngle, Quaternion.identity, 0.5f, EventType.Ignore);
+                                }
+                                else
+                                {
+                                    Handles.DrawLine(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].positionPoint,
+                                    tpCamera.mainTarget.position);
+                                }
+                            }
+                            else if (Handles.Button(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].positionPoint, Quaternion.identity, 0.5f, 0.3f, Handles.SphereHandleCap))
+                            {
+                                indexSelected = i;
+                                tpCamera.indexLookPoint = i;
+                                tpCamera.transform.position = tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].positionPoint;
+                                tpCamera.transform.rotation = Quaternion.Euler(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].eulerAngle);
+                            }
+                            Handles.color = Color.white;
+                            Handles.Label(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].positionPoint, tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[i].pointName);
+                        }
+                    }
+                    catch { if (tpCamera.indexList > tpCamera.CameraStateList.tpCameraStates.Count - 1) tpCamera.indexList = tpCamera.CameraStateList.tpCameraStates.Count - 1; }
+                }
+        }
+
+        protected virtual void OnEnable()
+        {
+            m_Logo = (Texture2D)Resources.Load("tp_camera", typeof(Texture2D));
+            indexSelected = 0;
+            tpCamera = (vThirdPersonCamera)target;
+            tpCamera.indexLookPoint = 0;
+            if (tpCamera.CameraStateList==null||tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].cameraMode != TPCameraMode.FixedPoint) return;
+            if (tpCamera.CameraStateList != null && (tpCamera.indexList < tpCamera.CameraStateList.tpCameraStates.Count) && tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints.Count > 0)
+            {
+                tpCamera.transform.position = tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[0].positionPoint;
+                tpCamera.transform.rotation = Quaternion.Euler(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList].lookPoints[0].eulerAngle);
+            }
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var oldskin = GUI.skin;
+            if (!skin) skin = Resources.Load("vSkin") as GUISkin;
+            GUI.skin = skin;
+
+            tpCamera = (vThirdPersonCamera)target;
+
+            EditorGUILayout.Space();
+            GUILayout.BeginVertical("Third Person Camera by Invector", "window");
+            GUILayout.Label(m_Logo, GUILayout.MaxHeight(25));
+            GUILayout.Space(5);
+
+            if (tpCamera.cullingLayer == 0)
+            {
+                EditorGUILayout.Space();
+                EditorGUILayout.HelpBox("Please assign the Culling Layer to 'Default' ", MessageType.Warning);
+                EditorGUILayout.Space();
+            }
+
+            EditorGUILayout.HelpBox("The target will be assign automatically to the current Character when start, check the InitialSetup method on the Motor.", MessageType.Info);
+            GUI.skin = oldskin;
+            base.OnInspectorGUI();
+            GUI.skin = skin;
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("Camera States", "window");
+
+            GUILayout.Label(m_Logo, GUILayout.MaxHeight(25));
+            GUILayout.Space(5);
+
+            EditorGUILayout.HelpBox("This settings will always load in this List, you can create more List's with different settings for another characters or scenes", MessageType.Info);
+
+            tpCamera.CameraStateList = (vThirdPersonCameraListData)EditorGUILayout.ObjectField("CameraState List", tpCamera.CameraStateList, typeof(vThirdPersonCameraListData), false);
+            if (tpCamera.CameraStateList == null)
+            {
+                GUILayout.EndVertical();
+                return;
+            }
+            GUILayout.BeginHorizontal();
+            if (GUILayout.Button(new GUIContent("New CameraState")))
+            {
+                if (tpCamera.CameraStateList.tpCameraStates == null)
+                    tpCamera.CameraStateList.tpCameraStates = new List<vThirdPersonCameraState>();
+
+                tpCamera.CameraStateList.tpCameraStates.Add(new vThirdPersonCameraState("New State" + tpCamera.CameraStateList.tpCameraStates.Count));
+                tpCamera.indexList = tpCamera.CameraStateList.tpCameraStates.Count - 1;
+            }
+
+            if (GUILayout.Button(new GUIContent("Delete State")) && tpCamera.CameraStateList.tpCameraStates.Count > 1 && tpCamera.indexList != 0)
+            {
+                tpCamera.CameraStateList.tpCameraStates.RemoveAt(tpCamera.indexList);
+                if (tpCamera.indexList - 1 >= 0)
+                    tpCamera.indexList--;
+            }
+
+            GUILayout.EndHorizontal();
+
+            if (tpCamera.CameraStateList.tpCameraStates.Count > 0)
+            {
+                if (tpCamera.indexList > tpCamera.CameraStateList.tpCameraStates.Count - 1) tpCamera.indexList = 0;
+                tpCamera.indexList = EditorGUILayout.Popup("State", tpCamera.indexList, getListName(tpCamera.CameraStateList.tpCameraStates));
+                StateData(tpCamera.CameraStateList.tpCameraStates[tpCamera.indexList]);
+            }
+
+            GUILayout.EndVertical();
+            EditorGUILayout.Space();
+
+            if (GUI.changed)
+            {
+                EditorUtility.SetDirty(tpCamera);
+                EditorUtility.SetDirty(tpCamera.CameraStateList);
+            }
+            GUI.skin = oldskin;
+        }
+
+        protected virtual void StateData(vThirdPersonCameraState camState)
+        {
+            EditorGUILayout.Space();
+
+            DrawEnumField("Camera Mode", ref camState.cameraMode);           
+            DrawTextField("State Name",ref camState.Name);
+
+            if (CheckName(camState.Name, tpCamera.indexList))
+            {
+                EditorGUILayout.HelpBox("This name already exist, choose another one", MessageType.Error);
+            }
+
+            switch (camState.cameraMode)
+            {
+                case TPCameraMode.FreeDirectional:
+                    FreeDirectionalMode(camState);
+                    break;
+                case TPCameraMode.FixedAngle:
+                    FixedAngleMode(camState);
+                    break;
+                case TPCameraMode.FixedPoint:
+                    FixedPointMode(camState);
+                    break;
+            }
+        }
+
+        protected virtual void DrawLookPoint(vThirdPersonCameraState camState)
+        {
+            if (camState.lookPoints == null) camState.lookPoints = new List<LookPoint>();
+            if (camState.lookPoints.Count > 0)
+            {
+                EditorGUILayout.HelpBox("You can create multiple camera points and change them using the TriggerChangeCameraState script.", MessageType.Info);
+
+                if (tpCamera.indexLookPoint > camState.lookPoints.Count - 1)
+                    tpCamera.indexLookPoint = 0;
+                if (tpCamera.indexLookPoint < 0)
+                    tpCamera.indexLookPoint = camState.lookPoints.Count - 1;
+                GUILayout.BeginHorizontal("box");
+                GUILayout.Label("Fixed Points");
+                GUILayout.FlexibleSpace();
+                if (GUILayout.Button("<", GUILayout.Width(20)))
+                {
+                    if (tpCamera.indexLookPoint - 1 < 0)
+                        tpCamera.indexLookPoint = camState.lookPoints.Count - 1;
+                    else
+                        tpCamera.indexLookPoint--;
+                    tpCamera.transform.position = camState.lookPoints[tpCamera.indexLookPoint].positionPoint;
+                    tpCamera.transform.rotation = Quaternion.Euler(camState.lookPoints[tpCamera.indexLookPoint].eulerAngle);
+
+                    indexSelected = tpCamera.indexLookPoint;
+                }
+                GUILayout.Box((tpCamera.indexLookPoint + 1).ToString("00") + "/" + camState.lookPoints.Count.ToString("00"));
+                if (GUILayout.Button(">", GUILayout.Width(20)))
+                {
+                    if (tpCamera.indexLookPoint + 1 > camState.lookPoints.Count - 1)
+                        tpCamera.indexLookPoint = 0;
+                    else
+                        tpCamera.indexLookPoint++;
+                    tpCamera.transform.position = camState.lookPoints[tpCamera.indexLookPoint].positionPoint;
+                    tpCamera.transform.rotation = Quaternion.Euler(camState.lookPoints[tpCamera.indexLookPoint].eulerAngle);
+                    indexSelected = tpCamera.indexLookPoint;
+                }
+                GUILayout.EndHorizontal();
+
+                GUILayout.BeginHorizontal("box");
+                GUILayout.Label("Point Name");
+                camState.lookPoints[tpCamera.indexLookPoint].pointName = GUILayout.TextField(camState.lookPoints[tpCamera.indexLookPoint].pointName, 100);
+                GUILayout.EndHorizontal();
+                EditorGUILayout.HelpBox("Check 'Static Camera' to create a static point and leave uncheck to look at the Player.", MessageType.Info);
+                camState.lookPoints[tpCamera.indexLookPoint].freeRotation = EditorGUILayout.Toggle("Static Camera", camState.lookPoints[tpCamera.indexLookPoint].freeRotation);
+
+                EditorGUILayout.Space();
+            }
+
+            GUILayout.BeginHorizontal("box");
+            if (GUILayout.Button("New Point"))
+            {
+                LookPoint p = new LookPoint();
+                p.pointName = "point_" + (camState.lookPoints.Count + 1).ToString("00");
+                p.positionPoint = tpCamera.transform.position;
+                p.eulerAngle = (tpCamera.mainTarget) ? tpCamera.mainTarget.position : (tpCamera.transform.position + tpCamera.transform.forward);
+                camState.lookPoints.Add(p);
+                tpCamera.indexLookPoint = camState.lookPoints.Count - 1;
+
+                tpCamera.transform.position = camState.lookPoints[tpCamera.indexLookPoint].positionPoint;
+                indexSelected = tpCamera.indexLookPoint;
+            }
+
+            if (GUILayout.Button("Remove current point "))
+            {
+                if (camState.lookPoints.Count > 0)
+                {
+                    camState.lookPoints.RemoveAt(tpCamera.indexLookPoint);
+                    tpCamera.indexLookPoint--;
+                    if (tpCamera.indexLookPoint > camState.lookPoints.Count - 1)
+                        tpCamera.indexLookPoint = 0;
+                    if (tpCamera.indexLookPoint < 0)
+                        tpCamera.indexLookPoint = camState.lookPoints.Count - 1;
+                    if (camState.lookPoints.Count > 0)
+                        tpCamera.transform.position = camState.lookPoints[tpCamera.indexLookPoint].positionPoint;
+                    indexSelected = tpCamera.indexLookPoint;
+                }
+            }
+
+            GUILayout.EndHorizontal();
+            EditorGUILayout.Space();
+        }
+
+        protected virtual void FreeDirectionalMode(vThirdPersonCameraState camState)
+        {
+
+            DrawSliderField("Forward", ref camState.forward, -1f, 1f);
+            DrawSliderField("Right", ref camState.right, -3f, 3f);
+            DrawFloatField("Distance",ref camState.defaultDistance);
+            DrawToogleField("Use Zoom",ref camState.useZoom);
+            if (camState.useZoom)
+            {
+                DrawFloatField("Max Distance", ref camState.maxDistance);
+                DrawFloatField("Min Distance",ref camState.minDistance);
+            }
+            DrawFloatField("Height", ref camState.height);
+            DrawSliderField("Field of View",ref camState.fov, 1, 179);
+            DrawFloatField("Smooth",ref camState.smooth);
+            DrawFloatField("Smooth Damp",ref camState.smoothDamp);
+            DrawFloatField("Culling Height",ref camState.cullingHeight);
+            DrawVector3Field("Rotation OffSet",ref camState.rotationOffSet);
+            DrawFloatField("MouseSensitivity X",ref camState.xMouseSensitivity);
+            DrawFloatField("MouseSensitivity Y",ref camState.yMouseSensitivity);
+            MinMaxSliderField("Limit Angle X", ref camState.xMinLimit, ref camState.xMaxLimit, -360, 360);
+            MinMaxSliderField("Limit Angle Y", ref camState.yMinLimit, ref camState.yMaxLimit, -180, 180);
+        }
+
+        protected virtual void FixedAngleMode(vThirdPersonCameraState camState)
+        {
+           DrawFloatField("Distance",ref  camState.defaultDistance);
+           DrawToogleField("Use Zoom",ref camState.useZoom);
+            if (camState.useZoom)
+            {
+                DrawFloatField("Max Distance",ref camState.maxDistance);
+                DrawFloatField("Min Distance",ref camState.minDistance);
+            }
+            DrawFloatField("Height",ref camState.height);
+            DrawSliderField("Field of View",ref camState.fov, 1, 179);
+            DrawFloatField("Smooth Follow",ref camState.smooth);
+            DrawFloatField("Culling Height",ref camState.cullingHeight);
+            DrawSliderField("Right",ref camState.right, -3f, 3f);
+            DrawSliderField("Angle X",ref camState.fixedAngle.x, -360, 360);
+            DrawSliderField("Angle Y",ref camState.fixedAngle.y, -360, 360);
+        }
+
+        protected virtual void FixedPointMode(vThirdPersonCameraState camState)
+        {
+            DrawFloatField("Smooth Follow",ref camState.smooth);
+            DrawSliderField("Field of View",ref camState.fov, 1, 179);
+            camState.fixedAngle.x = 0;
+            camState.fixedAngle.y = 0;
+
+            DrawLookPoint(camState);
+        }
+
+        protected virtual bool CheckName(string Name, int _index)
+        {
+            foreach (vThirdPersonCameraState state in tpCamera.CameraStateList.tpCameraStates)
+                if (state.Name.Equals(Name) && tpCamera.CameraStateList.tpCameraStates.IndexOf(state) != _index)
+                    return true;
+
+            return false;
+        }
+
+        #region Camera State Drawers with undo
+
+        protected virtual void DrawEnumField<T>(string name,ref T value)where T :System.Enum
+        {          
+            T _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value = (T)EditorGUILayout.EnumPopup(name, _value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void DrawTextField(string name, ref string value)
+        {
+            string _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value =EditorGUILayout.TextField(name, _value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void DrawVector3Field(string name, ref Vector3 value)
+        {
+            Vector3 _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value = EditorGUILayout.Vector3Field("Rotation OffSet", _value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void DrawSliderField(string name, ref float value, float min, float max)
+        {
+            float _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value = EditorGUILayout.Slider(name, _value, min, max);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void DrawFloatField(string name, ref float value)
+        {
+            float _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value = EditorGUILayout.FloatField(name, _value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void DrawToogleField(string name, ref bool value)
+        {
+            bool _value = value;
+            EditorGUI.BeginChangeCheck();
+            _value = EditorGUILayout.Toggle(name, _value);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                value = _value;
+            }
+        }
+
+        protected virtual void MinMaxSliderField(string name, ref float minVal, ref float maxVal, float minLimit, float maxLimit)
+        {
+            float _minVal = minVal;
+            float _maxVal = maxVal;
+            GUILayout.BeginVertical();
+            GUILayout.Label(name);
+            GUILayout.BeginHorizontal("box");
+
+            EditorGUI.BeginChangeCheck();
+            _minVal = EditorGUILayout.FloatField(_minVal, GUILayout.MaxWidth(60));
+            EditorGUILayout.MinMaxSlider(ref _minVal, ref _maxVal, minLimit, maxLimit);
+            _maxVal = EditorGUILayout.FloatField(_maxVal, GUILayout.MaxWidth(60));
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(tpCamera.CameraStateList, "ChangeCameraState");
+                minVal = _minVal;
+                maxVal = _maxVal;
+            }
+            GUILayout.EndHorizontal();
+            GUILayout.EndVertical();
+        }
+
+        #endregion
+
+        [MenuItem("Invector/Basic Locomotion/Resources/New CameraState List Data")]
+        protected static void NewCameraStateData()
+        {
+            vScriptableObjectUtility.CreateAsset<vThirdPersonCameraListData>();
+        }
+
+        protected virtual string[] getListName(List<vThirdPersonCameraState> list)
+        {
+            string[] names = new string[list.Count];
+            for (int i = 0; i < list.Count; i++)
+            {
+                names[i] = list[i].Name;
+            }
+            return names;
+        }
+    }
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/Editor/vThirdPersonCameraEditor.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCamera.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraExtensions.cs

@@ -0,0 +1,113 @@
+using UnityEngine;
+
+namespace Invector.vCamera
+{
+    public static class vThirdPersonCameraExtensions
+    {
+        /// <summary>
+        /// Lerp between CameraStates
+        /// </summary>
+        /// <param name="to"></param>
+        /// <param name="from"></param>
+        /// <param name="time"></param>
+        public static void Slerp(this vThirdPersonCameraState to, vThirdPersonCameraState from, float time)
+        {
+            to.Name = from.Name;
+            to.forward = Mathf.Lerp(to.forward, from.forward, time);
+            to.right = Mathf.Lerp(to.right, from.right, time);
+            to.defaultDistance = Mathf.Lerp(to.defaultDistance, from.defaultDistance, time);
+            to.maxDistance = Mathf.Lerp(to.maxDistance, from.maxDistance, time);
+            to.minDistance = Mathf.Lerp(to.minDistance, from.minDistance, time);
+            to.height = Mathf.Lerp(to.height, from.height, time);
+            to.fixedAngle = Vector2.Lerp(to.fixedAngle, from.fixedAngle, time);
+            to.smooth = Mathf.Lerp(to.smooth, from.smooth, time);
+            to.xMouseSensitivity = Mathf.Lerp(to.xMouseSensitivity, from.xMouseSensitivity, time);
+            to.yMouseSensitivity = Mathf.Lerp(to.yMouseSensitivity, from.yMouseSensitivity, time);
+            to.yMinLimit = Mathf.Lerp(to.yMinLimit, from.yMinLimit, time);
+            to.yMaxLimit = Mathf.Lerp(to.yMaxLimit, from.yMaxLimit, time);
+            to.xMinLimit = Mathf.Lerp(to.xMinLimit, from.xMinLimit, time);
+            to.xMaxLimit = Mathf.Lerp(to.xMaxLimit, from.xMaxLimit, time);
+            to.rotationOffSet = Vector3.Lerp(to.rotationOffSet, from.rotationOffSet, time);
+            to.cullingHeight = Mathf.Lerp(to.cullingHeight, from.cullingHeight, time);
+            to.cullingMinDist = Mathf.Lerp(to.cullingMinDist, from.cullingMinDist, time);
+            to.cameraMode = from.cameraMode;
+            to.useZoom = from.useZoom;
+            to.lookPoints = from.lookPoints;
+            to.fov = Mathf.Lerp(to.fov, from.fov, time);
+
+            if (to.fov <= 0) to.fov = 1f;
+        }
+
+        /// <summary>
+        /// Copy of CameraStates
+        /// </summary>
+        /// <param name="to"></param>
+        /// <param name="from"></param>
+        public static void CopyState(this vThirdPersonCameraState to, vThirdPersonCameraState from)
+        {
+            to.Name = from.Name;
+            to.forward = from.forward;
+            to.right = from.right;
+            to.defaultDistance = from.defaultDistance;
+            to.maxDistance = from.maxDistance;
+            to.minDistance = from.minDistance;
+            to.height = from.height;
+            to.fixedAngle = from.fixedAngle;
+            to.lookPoints = from.lookPoints;
+            to.smooth = from.smooth;
+            to.xMouseSensitivity = from.xMouseSensitivity;
+            to.yMouseSensitivity = from.yMouseSensitivity;
+            to.yMinLimit = from.yMinLimit;
+            to.yMaxLimit = from.yMaxLimit;
+            to.xMinLimit = from.xMinLimit;
+            to.xMaxLimit = from.xMaxLimit;
+            to.rotationOffSet = from.rotationOffSet;
+            to.cullingHeight = from.cullingHeight;
+            to.cullingMinDist = from.cullingMinDist;
+            to.cameraMode = from.cameraMode;
+            to.useZoom = from.useZoom;
+            to.fov = from.fov;
+
+            if (to.fov <= 0) to.fov = 1f;
+        }
+
+        public static ClipPlanePoints NearClipPlanePoints(this Camera camera, Vector3 pos, float clipPlaneMargin)
+        {
+            var clipPlanePoints = new ClipPlanePoints();
+
+            var transform = camera.transform;
+            var halfFOV = (camera.fieldOfView / 2) * Mathf.Deg2Rad;
+            var aspect = camera.aspect;
+            var distance = camera.nearClipPlane;
+            var height = distance * Mathf.Tan(halfFOV);
+            var width = height * aspect;
+            height *= 1 + clipPlaneMargin;
+            width *= 1 + clipPlaneMargin;
+            clipPlanePoints.LowerRight = pos + transform.right * width;
+            clipPlanePoints.LowerRight -= transform.up * height;
+            clipPlanePoints.LowerRight += transform.forward * distance;
+
+            clipPlanePoints.LowerLeft = pos - transform.right * width;
+            clipPlanePoints.LowerLeft -= transform.up * height;
+            clipPlanePoints.LowerLeft += transform.forward * distance;
+
+            clipPlanePoints.UpperRight = pos + transform.right * width;
+            clipPlanePoints.UpperRight += transform.up * height;
+            clipPlanePoints.UpperRight += transform.forward * distance;
+
+            clipPlanePoints.UpperLeft = pos - transform.right * width;
+            clipPlanePoints.UpperLeft += transform.up * height;
+            clipPlanePoints.UpperLeft += transform.forward * distance;
+
+            return clipPlanePoints;
+        }
+    }
+
+    public struct ClipPlanePoints
+    {
+        public Vector3 UpperLeft;
+        public Vector3 UpperRight;
+        public Vector3 LowerLeft;
+        public Vector3 LowerRight;
+    }
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraExtensions.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraListData.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+using System.Collections.Generic;
+namespace Invector
+{
+    [System.Serializable]
+    public class vThirdPersonCameraListData : ScriptableObject
+    {
+        [SerializeField] public string Name;
+        [SerializeField] public List<vThirdPersonCameraState> tpCameraStates;
+
+        public vThirdPersonCameraListData()
+        {
+            tpCameraStates = new List<vThirdPersonCameraState>();
+            tpCameraStates.Add(new vThirdPersonCameraState("Default"));
+        }
+    }
+
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraListData.cs.meta

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

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraState.cs

@@ -0,0 +1,76 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Invector
+{
+    [System.Serializable]
+    public class vThirdPersonCameraState
+    {
+        public string Name;
+        public float forward;
+        public float right;
+        public float defaultDistance;
+        public float maxDistance;
+        public float minDistance;
+        public float height;
+        public float smooth = 10f;
+        public float smoothDamp = 0f;
+        public float xMouseSensitivity;
+        public float yMouseSensitivity;
+        public float yMinLimit;
+        public float yMaxLimit;
+        public float xMinLimit;
+        public float xMaxLimit;
+
+        public Vector3 rotationOffSet;
+        public float cullingHeight;
+        public float cullingMinDist;
+        public float fov;
+        public bool useZoom;
+        public Vector2 fixedAngle;
+        public List<LookPoint> lookPoints;
+        public TPCameraMode cameraMode;
+
+        public vThirdPersonCameraState(string name)
+        {
+            Name = name;
+            forward = -1f;
+            right = 0f;
+            defaultDistance = 1.5f;
+            maxDistance = 3f;
+            minDistance = 0.5f;
+            height = 0f;
+            smooth = 10f;
+            smoothDamp = 0f;
+            xMouseSensitivity = 3f;
+            yMouseSensitivity = 3f;
+            yMinLimit = -40f;
+            yMaxLimit = 80f;
+            xMinLimit = -360f;
+            xMaxLimit = 360f;
+            cullingHeight = 0.2f;
+            cullingMinDist = 0.1f;
+            fov = 60f;
+            useZoom = false;
+            forward = 60;
+            fixedAngle = Vector2.zero;
+            cameraMode = TPCameraMode.FreeDirectional;
+        }
+    }
+
+    [System.Serializable]
+    public class LookPoint
+    {
+        public string pointName;
+        public Vector3 positionPoint;
+        public Vector3 eulerAngle;
+        public bool freeRotation;
+    }
+
+    public enum TPCameraMode
+    {
+        FreeDirectional,
+        FixedAngle,
+        FixedPoint
+    }
+}

Assets/Third Parties/Invector-3rdPersonController/Basic Locomotion/Scripts/Camera/vThirdPersonCameraState.cs.meta

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