bruh

Assets/Code.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 70d69235f3cd43ef9ceb4349270ff0da
+timeCreated: 1771430806

Assets/Code/DI.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c5ff52f5fb054d67bf29e3f537dcbb22
+timeCreated: 1771430840

Assets/Code/DI/Bootstrapper.cs

@@ -0,0 +1,18 @@
+using Code.Input;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace Code.DI
+{
+    public class Bootstrapper : MonoBehaviour
+    {
+        [SerializeField] private InputActionAsset inputActionAsset;
+
+        private void Awake()
+        {
+            var container = new GameObject("DIContainer").AddComponent<DIContainer>();
+        
+            container.Register<IInputService>(new InputService(inputActionAsset));
+        }
+    }
+}

Assets/Code/DI/Bootstrapper.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 65859af4acde4a76adb00a20e8f85134
+timeCreated: 1771430870

Assets/Code/DI/DIContainer.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Code.DI
+{
+    public class DIContainer : MonoBehaviour
+    {
+        private readonly Dictionary<Type, object> _services = new();
+
+        private void Awake()
+        {
+            DontDestroyOnLoad(gameObject);
+        }
+
+        public void Register<T>(T service)
+        {
+            var type = typeof(T);
+            if (!_services.TryAdd(type, service))
+            {
+                Debug.LogWarning($"Service {type} is already registered.");
+            }
+        }
+
+        public T Resolve<T>()
+        {
+            var type = typeof(T);
+            if (_services.TryGetValue(type, out var service))
+            {
+                return (T)service;
+            }
+            throw new Exception($"Service {type} not found.");
+        }
+    }
+}

Assets/Code/DI/DIContainer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9af57c4618e949c0a0242ed71006116f
+timeCreated: 1771430880

Assets/Code/Gameplay.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aff95e5ac5b74cc080a61d3f540cb997
+timeCreated: 1771430846

Assets/Code/Gameplay/Camera.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 84e1789d1c504243adf3e4622f43155d
+timeCreated: 1771432728

Assets/Code/Gameplay/Camera/CameraController.cs

@@ -0,0 +1,127 @@
+using Code.DI;
+using Code.Input;
+using UnityEngine;
+
+namespace Code.Gameplay.Camera
+{
+    public class CameraController : MonoBehaviour
+    {
+        [Header("Settings")]
+        [SerializeField] private float rotationSpeed = 300f;
+        [SerializeField] private float rotationSharpness = 10f;
+        [SerializeField] private float followSharpness = 10f;
+        [SerializeField] private float minVerticalAngle = -90f;
+        [SerializeField] private float maxVerticalAngle = 90f;
+        [SerializeField] private float defaultVerticalAngle = 0f;
+        
+        [Header("Target")]
+        [SerializeField] private Transform followTransform;
+        
+        private UnityEngine.Camera _camera;
+        private Vector3 _currentFollowPosition;
+        private Vector3 _planarDirection;
+        private float _targetVerticalAngle;
+        private IInputService _inputService;
+
+        private void Awake()
+        {
+            _camera = GetComponent<UnityEngine.Camera>();
+            if (_camera == null)
+            {
+                Debug.LogError("CameraController requires a Camera component!");
+                enabled = false;
+                return;
+            }
+
+            Initialize();
+        }
+
+        private void Start()
+        {
+            _inputService = FindFirstObjectByType<DIContainer>().Resolve<IInputService>();
+        }
+
+        private void Initialize()
+        {
+            _targetVerticalAngle = Mathf.Clamp(defaultVerticalAngle, minVerticalAngle, maxVerticalAngle);
+            _planarDirection = followTransform != null ? followTransform.forward : Vector3.forward;
+            _currentFollowPosition = followTransform != null ? followTransform.position : Vector3.zero;
+        }
+
+        private void LateUpdate()
+        {
+            if (followTransform != null)
+            {
+                UpdateCamera(Time.deltaTime, GetLookInput());
+            }
+        }
+
+        private void UpdateCamera(float deltaTime, Vector3 lookInput)
+        {
+            // Handle rotation
+            Quaternion targetRotation = HandleRotation(deltaTime, lookInput);
+            
+            // Handle position
+            HandlePosition(deltaTime, targetRotation);
+        }
+
+        private Quaternion HandleRotation(float deltaTime, Vector3 lookInput)
+        {
+            // Horizontal rotation
+            Quaternion horizontalRotation = Quaternion.Euler(Vector3.up * (lookInput.x * rotationSpeed));
+            _planarDirection = horizontalRotation * _planarDirection;
+            Quaternion planarRotation = Quaternion.LookRotation(_planarDirection, followTransform.up);
+            
+            // Vertical rotation
+            _targetVerticalAngle -= lookInput.y * rotationSpeed;
+            _targetVerticalAngle = Mathf.Clamp(_targetVerticalAngle, minVerticalAngle, maxVerticalAngle);
+            Quaternion verticalRotation = Quaternion.Euler(_targetVerticalAngle, 0, 0);
+
+            // Combine and apply
+            Quaternion targetRotation = planarRotation * verticalRotation;
+            transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, deltaTime * rotationSharpness);
+            
+            return targetRotation;
+        }
+
+        private void HandlePosition(float deltaTime, Quaternion targetRotation)
+        {
+            _currentFollowPosition = Vector3.Lerp(
+                _currentFollowPosition, 
+                followTransform.position, 
+                1f - Mathf.Exp(-followSharpness * deltaTime)
+            );
+            
+            transform.position = _currentFollowPosition;
+        }
+
+        private Vector3 GetLookInput()
+        {
+            // Получите здесь ваш инпут (например, из Input System)
+            // Это пример для стандартного инпута:
+            return _inputService.MoveInput;
+        }
+
+        // Публичные методы для получения данных
+        public Quaternion GetCameraRotation()
+        {
+            return transform.rotation;
+        }
+
+        public Vector3 GetPlanarDirection()
+        {
+            return _planarDirection;
+        }
+
+        // Метод для установки цели следования
+        public void SetFollowTransform(Transform target)
+        {
+            followTransform = target;
+            if (target != null)
+            {
+                _currentFollowPosition = target.position;
+                _planarDirection = target.forward;
+            }
+        }
+    }
+}

Assets/Code/Gameplay/Camera/CameraController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8f40748c010b4efda14731086ef26f0e
+timeCreated: 1771432941

Assets/Code/Gameplay/Character.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c1d04e06f32d4a15a8b3ec6da754bc0b
+timeCreated: 1771431576

Assets/Code/Gameplay/Character/Controller.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0e4799047a8c484abd6ff0e92a5ff093
+timeCreated: 1771431588

Assets/Code/Gameplay/Character/Controller/AirMovementSystem.cs

@@ -0,0 +1,19 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller
+{
+    public class AirMovementSystem
+    {
+        private readonly Vector3 _gravity;
+
+        public AirMovementSystem(Vector3 gravity)
+        {
+            _gravity = gravity;
+        }
+
+        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
+        {
+            currentVelocity += _gravity * deltaTime;
+        }
+    }
+}

Assets/Code/Gameplay/Character/Controller/AirMovementSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 60d5b036992c463590cada0327f0e4d4
+timeCreated: 1771431829

Assets/Code/Gameplay/Character/Controller/GroundMovementSystem.cs

@@ -0,0 +1,46 @@
+using UnityEngine;
+using KinematicCharacterController;
+
+namespace Code.Gameplay.Character.Controller
+{
+    public class GroundMovementSystem
+    {
+        private readonly float _maxStableMoveSpeed;
+        private readonly float _sprintMoveSpeed;
+        private readonly float _stableMovementSharpness;
+
+        public GroundMovementSystem(float maxStableMoveSpeed, float sprintMoveSpeed, float stableMovementSharpness)
+        {
+            _maxStableMoveSpeed = maxStableMoveSpeed;
+            _sprintMoveSpeed = sprintMoveSpeed;
+            _stableMovementSharpness = stableMovementSharpness;
+        }
+        
+        public void UpdateVelocity(
+            ref Vector3 currentVelocity,
+            CharacterInputHandler inputHandler,
+            KinematicCharacterMotor motor,
+            float deltaTime)
+        {
+            var currentVelocityMagnitude = currentVelocity.magnitude;
+
+            var effectiveGroundNormal = motor.GroundingStatus.GroundNormal;
+
+            currentVelocity = motor.GetDirectionTangentToSurface(currentVelocity, effectiveGroundNormal) *
+                              currentVelocityMagnitude;
+
+            var inputRight = Vector3.Cross(inputHandler.MoveInputVector, motor.CharacterUp);
+            var reorientedInput = Vector3.Cross(effectiveGroundNormal, inputRight).normalized *
+                                  inputHandler.MoveInputVector.magnitude;
+
+            var targetSpeed = inputHandler.IsSprinting ? _sprintMoveSpeed : _maxStableMoveSpeed;
+            var targetMovementVelocity = reorientedInput * targetSpeed;
+
+            currentVelocity = Vector3.Lerp(
+                currentVelocity,
+                targetMovementVelocity,
+                1f - Mathf.Exp(-_stableMovementSharpness * deltaTime)
+            );
+        }
+    }
+}

Assets/Code/Gameplay/Character/Controller/GroundMovementSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 65cbfbe68735468997f05a5e80b6910e
+timeCreated: 1771431851

Assets/Code/Gameplay/Character/Core.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0dce37a9def247adb97d183cf312fcde
+timeCreated: 1771431596

Assets/Code/Gameplay/Character/Core/CharacterInputHandler.cs

@@ -0,0 +1,63 @@
+using UnityEngine;
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+
+namespace Code.Gameplay.Character.Controller
+{
+    public class CharacterInputHandler
+    {
+        private readonly float _sprintAngleThresholdCos;
+        
+        public Vector3 MoveInputVector { get; set; }
+        public Vector3 LookInputVector { get; set; }
+        public bool IsSprinting { get; set; }
+
+        public Quaternion FirstPersonCameraRotation { get; set; }
+        
+        public bool ShouldApplyCameraRotation { get; private set; }
+        
+        public CharacterInputHandler(float sprintAngleThreshold)
+        {
+            _sprintAngleThresholdCos = Mathf.Cos(Mathf.Deg2Rad * sprintAngleThreshold);
+        }
+        
+        public void ProcessInputs(ref CharacterInputs inputs, KinematicCharacterMotor motor)
+        {
+            IsSprinting = inputs.SprintPressed && inputs.MoveAxisForward > _sprintAngleThresholdCos; // Спринт только при движении на заданный в конфиге угол
+
+            var moveInputVector = 
+                Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0, inputs.MoveAxisForward), 1f);
+
+            HandleFirstPersonInputs(ref inputs, moveInputVector, motor);
+
+        }
+
+        private void HandleFirstPersonInputs(ref CharacterInputs inputs, Vector3 moveInputVector, KinematicCharacterMotor motor)
+        {
+            FirstPersonCameraRotation = ExtractHorizontalRotation(inputs.CameraRotation, motor);
+            ShouldApplyCameraRotation = true;
+
+            var cameraPlanarDirection = inputs.CameraPlanarDirection;
+            
+            var cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, motor.CharacterUp);
+            
+            MoveInputVector = cameraPlanarRotation * moveInputVector;
+
+            LookInputVector = cameraPlanarDirection;
+        }
+
+        private static Quaternion ExtractHorizontalRotation(Quaternion cameraRotation, KinematicCharacterMotor motor)
+        {
+            var cameraForward = cameraRotation * Vector3.forward;
+            
+            var horizontalForward = Vector3.ProjectOnPlane(cameraForward, Vector3.up).normalized;
+            
+            if (horizontalForward.sqrMagnitude < 0.01f)
+            {
+                horizontalForward = motor.CharacterForward;
+            }
+            
+            return Quaternion.LookRotation(horizontalForward, motor.CharacterUp);
+        }
+    }
+}

Assets/Code/Gameplay/Character/Core/CharacterInputHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7cbc2ef1c7c14e1788d9633d4b9267c5
+timeCreated: 1771431877

Assets/Code/Gameplay/Character/Core/CharacterInputs.cs

@@ -0,0 +1,15 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Core
+{
+    public struct CharacterInputs
+    {
+        public float MoveAxisForward;
+        public float MoveAxisRight;
+        public Quaternion CameraRotation;
+        public Vector3 CameraPlanarDirection;
+        public bool JumpPressed;
+        public bool SprintPressed;             
+        public bool SlidePressed;
+    }
+}

Assets/Code/Gameplay/Character/Core/CharacterInputs.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f0b3699e82824e42832f381246741e90
+timeCreated: 1771431755

Assets/Code/Gameplay/Character/Core/CharacterProvider.cs

@@ -0,0 +1,42 @@
+using Code.Gameplay.Camera;
+using Code.Gameplay.Character.Controller;
+using Code.Input;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Core
+{
+    public class CharacterProvider : MonoBehaviour
+    {
+        [SerializeField] private CustomCharacterController customCharacterController;
+        public CustomCharacterController CustomCharacterController => customCharacterController;
+        
+        [SerializeField] private Transform cameraFollowPoint;
+        public Transform GetFollowTransform() => cameraFollowPoint;
+        
+        private IInputService _inputService;
+
+        public void Teleport(Vector3 position, Quaternion rotation)
+        {
+            customCharacterController.SetPosition(position);
+            customCharacterController.SetRotation(rotation);
+        }
+        private void HandleCharacterInput()
+        {
+            var inputs = new CharacterInputs();
+            var moveInput = _inputService.MoveInput;
+            inputs.MoveAxisForward = moveInput.y;
+            inputs.MoveAxisRight = moveInput.x;
+            inputs.SprintPressed = _inputService.SprintHeld;
+            
+            inputs.CameraRotation = FindFirstObjectByType<CameraController>().GetCameraRotation();
+            inputs.CameraPlanarDirection = FindFirstObjectByType<CameraController>().GetPlanarDirection();
+            
+            customCharacterController.SetInputs(ref inputs);
+        }
+
+        private void Update()
+        {
+            HandleCharacterInput();
+        }
+    }
+}

Assets/Code/Gameplay/Character/Core/CharacterProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0073ba8d33504841b4ec7ef63b747249
+timeCreated: 1771431716

Assets/Code/Gameplay/Character/Core/CustomCharacterController.cs

@@ -0,0 +1,78 @@
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller
+{
+    public class CustomCharacterController : MonoBehaviour, ICharacterController
+    {
+        [SerializeField] private KinematicCharacterMotor motor;
+        [SerializeField] private Transform characterTransform;
+
+        private CharacterInputHandler _inputHandler;
+        private GroundMovementSystem _groundMovement;
+        private AirMovementSystem _airMovement;
+        
+        [SerializeField] private float sprintAngleThreshold;
+        [SerializeField] private float maxStableMoveSpeed;
+        [SerializeField] private float sprintMoveSpeed;
+        [SerializeField] private float stableMovementSharpness;
+        [SerializeField] private Vector3 gravity;
+        
+        public void SetPosition(Vector3 position) => motor.SetPosition(position);
+        public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
+        
+        private void Construct()
+        {
+            _inputHandler = new CharacterInputHandler(
+                sprintAngleThreshold
+                );
+
+            _groundMovement = new GroundMovementSystem(
+                maxStableMoveSpeed,
+                sprintMoveSpeed,
+                stableMovementSharpness
+            );
+            _airMovement = new AirMovementSystem(
+                gravity
+                );
+            
+            motor.CharacterController = this;
+            _inputHandler.FirstPersonCameraRotation = motor.Transform.rotation;
+        }
+
+        public void SetInputs(ref CharacterInputs inputs)
+        { 
+            _inputHandler.ProcessInputs(ref inputs, motor);
+        }
+
+        public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
+        {
+            currentRotation = _inputHandler.FirstPersonCameraRotation;
+        }
+
+        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
+        {
+            var wasGrounded = motor.GroundingStatus.IsStableOnGround;
+            
+            if (wasGrounded)
+            {
+                _groundMovement?.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
+
+            }
+            else
+            {
+                _airMovement?.UpdateVelocity(ref currentVelocity, deltaTime);
+            }
+        }
+
+        public void BeforeCharacterUpdate(float deltaTime) { }
+        public void PostGroundingUpdate(float deltaTime) { }
+        public void AfterCharacterUpdate(float deltaTime) { }
+        public bool IsColliderValidForCollisions(Collider coll) => true;
+        public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport) { }
+        public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport) { }
+        public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition, Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport) { }
+        public void OnDiscreteCollisionDetected(Collider hitCollider) { }
+    }
+}

Assets/Code/Gameplay/Character/Core/CustomCharacterController.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3ab3cb1f5b954513a34e58dd8a96d027
+timeCreated: 1771431901

Assets/Code/Input.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6e7634bb316042e8a70ab984454b8d23
+timeCreated: 1771430852

Assets/Code/Input/ActionMapping.cs

@@ -0,0 +1,9 @@
+namespace Code.Input
+{
+    public enum ActionMapping
+    {
+        MainMenu,
+        Gameplay,
+        UI
+    }
+}

Assets/Code/Input/ActionMapping.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 79cf117afe77443992636e32b29782ec
+timeCreated: 1771430942

Assets/Code/Input/IInputService.cs

@@ -0,0 +1,23 @@
+using System;
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace Code.Input
+{
+    public interface IInputService
+    {
+        void EnableMap(ActionMapping actionMap);
+        void DisableMap(ActionMapping actionMap);
+        
+        Vector2 MainMenuParalax { get; }
+        
+        Vector2 LookInput { get; }
+        Vector2 MoveInput { get; }
+        bool JumpPressed { get; }
+        bool SprintHeld { get; }
+
+        
+        void DebugBindAction(int mapId, int actionId, Action<InputAction.CallbackContext> action);
+        void DebugUnbindAction(int mapId, int actionId, Action<InputAction.CallbackContext> action);
+    }
+}

Assets/Code/Input/IInputService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c8acf7d28cc74a7fb5fca2a6ffb2dee3
+timeCreated: 1771430932

Assets/Code/Input/InputService.cs

@@ -0,0 +1,95 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace Code.Input
+{
+    public class InputService : IInputService
+    {
+        private readonly InputActionAsset _inputActionAsset;
+        private InputAction _lmbInteractAction;
+        
+        public Vector2 MainMenuParalax { get; private set; }
+        
+        public Vector2 LookInput { get; private set; }
+        public Vector2 MoveInput { get; private set; }
+        public bool JumpPressed { get; private set; }
+        public bool SprintHeld { get; private set; }
+        public bool AttackPressed { get; private set; }
+
+        public InputService(InputActionAsset inputActionAsset)
+        {
+            _inputActionAsset = inputActionAsset;
+            SetupInputCallbacks();
+        }
+
+        private void SetupInputCallbacks()
+        {
+            SetupMainMenuInputCallbacks();
+            SetupGameplayInputCallbacks();
+        }
+
+        private void SetupGameplayInputCallbacks()
+        {
+            var map = _inputActionAsset.actionMaps[(int)ActionMapping.Gameplay];
+            BindVector2(map, "Move", v => MoveInput = v);
+            BindButton(map, "Jump", v => JumpPressed = v);
+            BindButton(map, "Sprint", v => SprintHeld = v);
+            BindButton(map, "Attack", v => AttackPressed = v);
+        }
+
+        private void SetupMainMenuInputCallbacks()
+        {
+            var map = _inputActionAsset.actionMaps[(int)ActionMapping.MainMenu];
+            BindVector2(map, "Parallax", v => MainMenuParalax = v);
+        }
+
+        private void BindButton(InputActionMap map, string actionName, System.Action<bool> setter)
+        {
+            var action = map.FindAction(actionName);
+
+            if (action == null)
+                return;
+
+            action.performed += _ => setter(true);
+            action.canceled += _ => setter(false);
+        }
+
+        private void BindVector2(InputActionMap map, string actionName, System.Action<Vector2> setter)
+        {
+            var action = map.FindAction(actionName);
+
+            if (action == null)
+                return;
+
+            action.performed += ctx => setter(ctx.ReadValue<Vector2>());
+            action.canceled += _ => setter(Vector2.zero);
+        }
+        
+        private void BindAxis(InputActionMap map, string actionName, System.Action<float> setter)
+        {
+            var action = map.FindAction(actionName);
+
+            if (action == null)
+                return;
+
+            action.performed += ctx => setter(ctx.ReadValue<float>());
+            action.canceled += _ => setter(0f);
+        }
+
+        public void EnableMap(ActionMapping actionMap)
+        {
+            _inputActionAsset.actionMaps[(int)actionMap].Enable();
+        }
+
+        public void DisableMap(ActionMapping actionMap)
+        {
+            _inputActionAsset.actionMaps[(int)actionMap].Disable();
+        }
+
+        public void DebugBindAction(int mapId, int actionId, System.Action<InputAction.CallbackContext> action) =>
+            _inputActionAsset.actionMaps[mapId].actions[actionId].performed += action;
+
+        public void DebugUnbindAction(int mapId, int actionId, System.Action<InputAction.CallbackContext> action) =>
+            _inputActionAsset.actionMaps[mapId].actions[actionId].performed -= action;
+    }
+}

Assets/Code/Input/InputService.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7a985f6fee1a476280bc4e54af892714
+timeCreated: 1771430923

Assets/Code/UI.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6c532ef1913b4c80be438be2b66525e3
+timeCreated: 1771430858

Assets/KinematicCharacterController.meta

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

Assets/KinematicCharacterController/APIReference.zip.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: aadf824e76564404c8d43d99803c60a1
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/APIReference.zip
+  uploadId: 505601

Assets/KinematicCharacterController/Core.meta

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

Assets/KinematicCharacterController/Core/Editor.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 220667f043f505a4eb52d0208e14818e
+folderAsset: yes
+timeCreated: 1504492780
+licenseType: Store
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/KinematicCharacterController/Core/Editor/KinematicCharacterMotorEditor.cs

@@ -0,0 +1,28 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+
+namespace KinematicCharacterController
+{
+    [CustomEditor(typeof(KinematicCharacterMotor))]
+    public class KinematicCharacterMotorEditor : Editor
+    {
+        protected virtual void OnSceneGUI()
+        {            
+            KinematicCharacterMotor motor = (target as KinematicCharacterMotor);
+            if (motor)
+            {
+                Vector3 characterBottom = motor.transform.position + (motor.Capsule.center + (-Vector3.up * (motor.Capsule.height * 0.5f)));
+
+                Handles.color = Color.yellow;
+                Handles.CircleHandleCap(
+                    0, 
+                    characterBottom + (motor.transform.up * motor.MaxStepHeight), 
+                    Quaternion.LookRotation(motor.transform.up, motor.transform.forward), 
+                    motor.Capsule.radius + 0.1f, 
+                    EventType.Repaint);
+            }
+        }
+    }
+}

Assets/KinematicCharacterController/Core/Editor/KinematicCharacterMotorEditor.cs.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: 7db3ed6d74cbf2b489cab5e1586bed7a
+timeCreated: 1518400757
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/Editor/KinematicCharacterMotorEditor.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/Editor/ReadOnlyPropertyDrawer.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+using UnityEditor;
+
+namespace KinematicCharacterController
+{
+    [CustomPropertyDrawer(typeof(ReadOnlyAttribute))]
+    public class ReadOnlyPropertyDrawer : PropertyDrawer
+    {
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+        {
+            return EditorGUI.GetPropertyHeight(property, label, true);
+        }
+
+        public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+        {
+            GUI.enabled = false;
+            EditorGUI.PropertyField(position, property, label, true);
+            GUI.enabled = true;
+        }
+    }
+}

Assets/KinematicCharacterController/Core/Editor/ReadOnlyPropertyDrawer.cs.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: 0d4351ab88853824b85a8f458928d825
+timeCreated: 1504492796
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/Editor/ReadOnlyPropertyDrawer.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/ICharacterController.cs

@@ -0,0 +1,50 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    public interface ICharacterController
+    {
+        /// <summary>
+        /// This is called when the motor wants to know what its rotation should be right now
+        /// </summary>
+        void UpdateRotation(ref Quaternion currentRotation, float deltaTime);
+        /// <summary>
+        /// This is called when the motor wants to know what its velocity should be right now
+        /// </summary>
+        void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime);
+        /// <summary>
+        /// This is called before the motor does anything
+        /// </summary>
+        void BeforeCharacterUpdate(float deltaTime);
+        /// <summary>
+        /// This is called after the motor has finished its ground probing, but before PhysicsMover/Velocity/etc.... handling
+        /// </summary>
+        void PostGroundingUpdate(float deltaTime);
+        /// <summary>
+        /// This is called after the motor has finished everything in its update
+        /// </summary>
+        void AfterCharacterUpdate(float deltaTime);
+        /// <summary>
+        /// This is called after when the motor wants to know if the collider can be collided with (or if we just go through it)
+        /// </summary>
+        bool IsColliderValidForCollisions(Collider coll);
+        /// <summary>
+        /// This is called when the motor's ground probing detects a ground hit
+        /// </summary>
+        void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport);
+        /// <summary>
+        /// This is called when the motor's movement logic detects a hit
+        /// </summary>
+        void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport);
+        /// <summary>
+        /// This is called after every move hit, to give you an opportunity to modify the HitStabilityReport to your liking
+        /// </summary>
+        void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition, Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport);
+        /// <summary>
+        /// This is called when the character detects discrete collisions (collisions that don't result from the motor's capsuleCasts when moving)
+        /// </summary>
+        void OnDiscreteCollisionDetected(Collider hitCollider);
+    }
+}

Assets/KinematicCharacterController/Core/ICharacterController.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: f13aa252bd3bf9943b1d65e68d93dcfb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/ICharacterController.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/IMoverController.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    public interface IMoverController
+    {
+        /// <summary>
+        /// This is called to let you tell the PhysicsMover where it should be right now
+        /// </summary>
+        void UpdateMovement(out Vector3 goalPosition, out Quaternion goalRotation, float deltaTime);
+    }
+}

Assets/KinematicCharacterController/Core/IMoverController.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 8ae7eceec45f1be4c8450edc46c0ad36
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/IMoverController.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/KCCSettings.cs

@@ -0,0 +1,33 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    [CreateAssetMenu]
+    public class KCCSettings : ScriptableObject
+    {
+        /// <summary>
+        /// Determines if the system simulates automatically.
+        /// If true, the simulation is done on FixedUpdate
+        /// </summary>
+        [Tooltip("Determines if the system simulates automatically. If true, the simulation is done on FixedUpdate")]
+        public bool AutoSimulation = true;
+        /// <summary>
+        /// Should interpolation of characters and PhysicsMovers be handled
+        /// </summary>
+        [Tooltip("Should interpolation of characters and PhysicsMovers be handled")]
+        public bool Interpolate = true;
+        /// <summary>
+		
+        /// Initial capacity of the system's list of Motors (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)
+        /// </summary>
+        [Tooltip("Initial capacity of the system's list of Motors (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)")]
+        public int MotorsListInitialCapacity = 100;
+        /// <summary>
+        /// Initial capacity of the system's list of Movers (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)
+        /// </summary>
+        [Tooltip("Initial capacity of the system's list of Movers (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)")]
+        public int MoversListInitialCapacity = 100;
+    }
+}

Assets/KinematicCharacterController/Core/KCCSettings.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 2b43d8459fe4812488b2c47ac60e41c3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/KCCSettings.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/KinematicCharacterMotor.cs.meta

@@ -0,0 +1,18 @@
+fileFormatVersion: 2
+guid: 4d1bc5515e3ab954e80599c538834774
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/KinematicCharacterMotor.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/KinematicCharacterSystem.cs

@@ -0,0 +1,294 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    /// <summary>
+    /// The system that manages the simulation of KinematicCharacterMotor and PhysicsMover
+    /// </summary>
+    [DefaultExecutionOrder(-100)]
+    public class KinematicCharacterSystem : MonoBehaviour
+    {
+        private static KinematicCharacterSystem _instance;
+
+        public static List<KinematicCharacterMotor> CharacterMotors = new List<KinematicCharacterMotor>();
+        public static List<PhysicsMover> PhysicsMovers = new List<PhysicsMover>();
+
+        private static float _lastCustomInterpolationStartTime = -1f;
+        private static float _lastCustomInterpolationDeltaTime = -1f;
+
+        public static KCCSettings Settings;
+
+        /// <summary>
+        /// Creates a KinematicCharacterSystem instance if there isn't already one
+        /// </summary>
+        public static void EnsureCreation()
+        {
+            if (_instance == null)
+            {
+                GameObject systemGameObject = new GameObject("KinematicCharacterSystem");
+                _instance = systemGameObject.AddComponent<KinematicCharacterSystem>();
+
+                systemGameObject.hideFlags = HideFlags.NotEditable;
+                _instance.hideFlags = HideFlags.NotEditable;
+
+                Settings = ScriptableObject.CreateInstance<KCCSettings>();
+
+                GameObject.DontDestroyOnLoad(systemGameObject);
+            }
+        }
+
+        /// <summary>
+        /// Gets the KinematicCharacterSystem instance if any
+        /// </summary>
+        /// <returns></returns>
+        public static KinematicCharacterSystem GetInstance()
+        {
+            return _instance;
+        }
+
+        /// <summary>
+        /// Sets the maximum capacity of the character motors list, to prevent allocations when adding characters
+        /// </summary>
+        /// <param name="capacity"></param>
+        public static void SetCharacterMotorsCapacity(int capacity)
+        {
+            if (capacity < CharacterMotors.Count)
+            {
+                capacity = CharacterMotors.Count;
+            }
+            CharacterMotors.Capacity = capacity;
+        }
+
+        /// <summary>
+        /// Registers a KinematicCharacterMotor into the system
+        /// </summary>
+        public static void RegisterCharacterMotor(KinematicCharacterMotor motor)
+        {
+            CharacterMotors.Add(motor);
+        }
+
+        /// <summary>
+        /// Unregisters a KinematicCharacterMotor from the system
+        /// </summary>
+        public static void UnregisterCharacterMotor(KinematicCharacterMotor motor)
+        {
+            CharacterMotors.Remove(motor);
+        }
+
+        /// <summary>
+        /// Sets the maximum capacity of the physics movers list, to prevent allocations when adding movers
+        /// </summary>
+        /// <param name="capacity"></param>
+        public static void SetPhysicsMoversCapacity(int capacity)
+        {
+            if (capacity < PhysicsMovers.Count)
+            {
+                capacity = PhysicsMovers.Count;
+            }
+            PhysicsMovers.Capacity = capacity;
+        }
+
+        /// <summary>
+        /// Registers a PhysicsMover into the system
+        /// </summary>
+        public static void RegisterPhysicsMover(PhysicsMover mover)
+        {
+            PhysicsMovers.Add(mover);
+
+            mover.Rigidbody.interpolation = RigidbodyInterpolation.None;
+        }
+
+        /// <summary>
+        /// Unregisters a PhysicsMover from the system
+        /// </summary>
+        public static void UnregisterPhysicsMover(PhysicsMover mover)
+        {
+            PhysicsMovers.Remove(mover);
+        }
+
+        // This is to prevent duplicating the singleton gameobject on script recompiles
+        private void OnDisable()
+        {
+            Destroy(this.gameObject);
+        }
+
+        private void Awake()
+        {
+            _instance = this;
+        }
+
+        private void FixedUpdate()
+        {
+            if (Settings.AutoSimulation)
+            {
+                float deltaTime = Time.deltaTime;
+
+                if (Settings.Interpolate)
+                {
+                    PreSimulationInterpolationUpdate(deltaTime);
+                }
+
+                Simulate(deltaTime, CharacterMotors, PhysicsMovers);
+
+                if (Settings.Interpolate)
+                {
+                    PostSimulationInterpolationUpdate(deltaTime);
+                }
+            }
+        }
+
+        private void LateUpdate()
+        {
+            if (Settings.Interpolate)
+            {
+                CustomInterpolationUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Remembers the point to interpolate from for KinematicCharacterMotors and PhysicsMovers
+        /// </summary>
+        public static void PreSimulationInterpolationUpdate(float deltaTime)
+        {
+            // Save pre-simulation poses and place transform at transient pose
+            for (int i = 0; i < CharacterMotors.Count; i++)
+            {
+                KinematicCharacterMotor motor = CharacterMotors[i];
+
+                motor.InitialTickPosition = motor.TransientPosition;
+                motor.InitialTickRotation = motor.TransientRotation;
+
+                motor.Transform.SetPositionAndRotation(motor.TransientPosition, motor.TransientRotation);
+            }
+
+            for (int i = 0; i < PhysicsMovers.Count; i++)
+            {
+                PhysicsMover mover = PhysicsMovers[i];
+
+                mover.InitialTickPosition = mover.TransientPosition;
+                mover.InitialTickRotation = mover.TransientRotation;
+
+                mover.Transform.SetPositionAndRotation(mover.TransientPosition, mover.TransientRotation);
+                mover.Rigidbody.position = mover.TransientPosition;
+                mover.Rigidbody.rotation = mover.TransientRotation;
+            }
+        }
+
+        /// <summary>
+        /// Ticks characters and/or movers
+        /// </summary>
+        public static void Simulate(float deltaTime, List<KinematicCharacterMotor> motors, List<PhysicsMover> movers)
+        {
+            int characterMotorsCount = motors.Count;
+            int physicsMoversCount = movers.Count;
+
+#pragma warning disable 0162
+            // Update PhysicsMover velocities
+            for (int i = 0; i < physicsMoversCount; i++)
+            {
+                movers[i].VelocityUpdate(deltaTime);
+            }
+
+            // Character controller update phase 1
+            for (int i = 0; i < characterMotorsCount; i++)
+            {
+                motors[i].UpdatePhase1(deltaTime);
+            }
+
+            // Simulate PhysicsMover displacement
+            for (int i = 0; i < physicsMoversCount; i++)
+            {
+                PhysicsMover mover = movers[i];
+
+                mover.Transform.SetPositionAndRotation(mover.TransientPosition, mover.TransientRotation);
+                mover.Rigidbody.position = mover.TransientPosition;
+                mover.Rigidbody.rotation = mover.TransientRotation;
+            }
+
+            // Character controller update phase 2 and move
+            for (int i = 0; i < characterMotorsCount; i++)
+            {
+                KinematicCharacterMotor motor = motors[i];
+
+                motor.UpdatePhase2(deltaTime);
+
+                motor.Transform.SetPositionAndRotation(motor.TransientPosition, motor.TransientRotation);
+            }
+#pragma warning restore 0162
+        }
+
+        /// <summary>
+        /// Initiates the interpolation for KinematicCharacterMotors and PhysicsMovers
+        /// </summary>
+        public static void PostSimulationInterpolationUpdate(float deltaTime)
+        {
+            _lastCustomInterpolationStartTime = Time.time;
+            _lastCustomInterpolationDeltaTime = deltaTime;
+
+            // Return interpolated roots to their initial poses
+            for (int i = 0; i < CharacterMotors.Count; i++)
+            {
+                KinematicCharacterMotor motor = CharacterMotors[i];
+
+                motor.Transform.SetPositionAndRotation(motor.InitialTickPosition, motor.InitialTickRotation);
+            }
+
+            for (int i = 0; i < PhysicsMovers.Count; i++)
+            {
+                PhysicsMover mover = PhysicsMovers[i];
+
+                if (mover.MoveWithPhysics)
+                {
+                    mover.Rigidbody.position = mover.InitialTickPosition;
+                    mover.Rigidbody.rotation = mover.InitialTickRotation;
+
+                    mover.Rigidbody.MovePosition(mover.TransientPosition);
+                    mover.Rigidbody.MoveRotation(mover.TransientRotation);
+                }
+                else
+                {
+                    mover.Rigidbody.position = (mover.TransientPosition);
+                    mover.Rigidbody.rotation = (mover.TransientRotation);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handles per-frame interpolation
+        /// </summary>
+        private static void CustomInterpolationUpdate()
+        {
+            float interpolationFactor = Mathf.Clamp01((Time.time - _lastCustomInterpolationStartTime) / _lastCustomInterpolationDeltaTime);
+
+            // Handle characters interpolation
+            for (int i = 0; i < CharacterMotors.Count; i++)
+            {
+                KinematicCharacterMotor motor = CharacterMotors[i];
+
+                motor.Transform.SetPositionAndRotation(
+                    Vector3.Lerp(motor.InitialTickPosition, motor.TransientPosition, interpolationFactor),
+                    Quaternion.Slerp(motor.InitialTickRotation, motor.TransientRotation, interpolationFactor));
+            }
+
+            // Handle PhysicsMovers interpolation
+            for (int i = 0; i < PhysicsMovers.Count; i++)
+            {
+                PhysicsMover mover = PhysicsMovers[i];
+                
+                mover.Transform.SetPositionAndRotation(
+                    Vector3.Lerp(mover.InitialTickPosition, mover.TransientPosition, interpolationFactor),
+                    Quaternion.Slerp(mover.InitialTickRotation, mover.TransientRotation, interpolationFactor));
+
+                Vector3 newPos = mover.Transform.position;
+                Quaternion newRot = mover.Transform.rotation;
+                mover.PositionDeltaFromInterpolation = newPos - mover.LatestInterpolationPosition;
+                mover.RotationDeltaFromInterpolation = Quaternion.Inverse(mover.LatestInterpolationRotation) * newRot;
+                mover.LatestInterpolationPosition = newPos;
+                mover.LatestInterpolationRotation = newRot;
+            }
+        }
+    }
+}

Assets/KinematicCharacterController/Core/KinematicCharacterSystem.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: dbd80c9a62d41084aad50ae44255beb9
+timeCreated: 1500241576
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/KinematicCharacterSystem.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/PhysicsMover.cs

@@ -0,0 +1,261 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    /// <summary>
+    /// Represents the entire state of a PhysicsMover that is pertinent for simulation.
+    /// Use this to save state or revert to past state
+    /// </summary>
+    [System.Serializable]
+    public struct PhysicsMoverState
+    {
+        public Vector3 Position;
+        public Quaternion Rotation;
+        public Vector3 Velocity;
+        public Vector3 AngularVelocity;
+    }
+
+    /// <summary>
+    /// Component that manages the movement of moving kinematic rigidbodies for
+    /// proper interaction with characters
+    /// </summary>
+    [RequireComponent(typeof(Rigidbody))]
+    public class PhysicsMover : MonoBehaviour
+    {
+        /// <summary>
+        /// The mover's Rigidbody
+        /// </summary>
+        [ReadOnly]
+        public Rigidbody Rigidbody;
+
+        /// <summary>
+        /// Determines if the platform moves with rigidbody.MovePosition (when true), or with rigidbody.position (when false)
+        /// </summary>
+        public bool MoveWithPhysics = true;
+
+        /// <summary>
+        /// Index of this motor in KinematicCharacterSystem arrays
+        /// </summary>
+        [NonSerialized]
+        public IMoverController MoverController;
+        /// <summary>
+        /// Remembers latest position in interpolation
+        /// </summary>
+        [NonSerialized]
+        public Vector3 LatestInterpolationPosition;
+        /// <summary>
+        /// Remembers latest rotation in interpolation
+        /// </summary>
+        [NonSerialized]
+        public Quaternion LatestInterpolationRotation;
+        /// <summary>
+        /// The latest movement made by interpolation
+        /// </summary>
+        [NonSerialized]
+        public Vector3 PositionDeltaFromInterpolation;
+        /// <summary>
+        /// The latest rotation made by interpolation
+        /// </summary>
+        [NonSerialized]
+        public Quaternion RotationDeltaFromInterpolation;
+
+        /// <summary>
+        /// Index of this motor in KinematicCharacterSystem arrays
+        /// </summary>
+        public int IndexInCharacterSystem { get; set; }
+        /// <summary>
+        /// Remembers initial position before all simulation are done
+        /// </summary>
+        public Vector3 Velocity { get; protected set; }
+        /// <summary>
+        /// Remembers initial position before all simulation are done
+        /// </summary>
+        public Vector3 AngularVelocity { get; protected set; }
+        /// <summary>
+        /// Remembers initial position before all simulation are done
+        /// </summary>
+        public Vector3 InitialTickPosition { get; set; }
+        /// <summary>
+        /// Remembers initial rotation before all simulation are done
+        /// </summary>
+        public Quaternion InitialTickRotation { get; set; }
+
+        /// <summary>
+        /// The mover's Transform
+        /// </summary>
+        public Transform Transform { get; private set; }
+        /// <summary>
+        /// The character's position before the movement calculations began
+        /// </summary>
+        public Vector3 InitialSimulationPosition { get; private set; }
+        /// <summary>
+        /// The character's rotation before the movement calculations began
+        /// </summary>
+        public Quaternion InitialSimulationRotation { get; private set; }
+
+        private Vector3 _internalTransientPosition;
+
+        /// <summary>
+        /// The mover's rotation (always up-to-date during the character update phase)
+        /// </summary>
+        public Vector3 TransientPosition
+        {
+            get
+            {
+                return _internalTransientPosition;
+            }
+            private set
+            {
+                _internalTransientPosition = value;
+            }
+        }
+
+        private Quaternion _internalTransientRotation;
+        /// <summary>
+        /// The mover's rotation (always up-to-date during the character update phase)
+        /// </summary>
+        public Quaternion TransientRotation
+        {
+            get
+            {
+                return _internalTransientRotation;
+            }
+            private set
+            {
+                _internalTransientRotation = value;
+            }
+        }
+
+
+        private void Reset()
+        {
+            ValidateData();
+        }
+
+        private void OnValidate()
+        {
+            ValidateData();
+        }
+
+        /// <summary>
+        /// Handle validating all required values
+        /// </summary>
+        public void ValidateData()
+        {
+            Rigidbody = gameObject.GetComponent<Rigidbody>();
+
+            Rigidbody.centerOfMass = Vector3.zero;
+            Rigidbody.maxAngularVelocity = Mathf.Infinity;
+            Rigidbody.maxDepenetrationVelocity = Mathf.Infinity;
+            Rigidbody.isKinematic = true;
+            Rigidbody.interpolation = RigidbodyInterpolation.None;
+        }
+
+        private void OnEnable()
+        {
+            KinematicCharacterSystem.EnsureCreation();
+            KinematicCharacterSystem.RegisterPhysicsMover(this);
+        }
+
+        private void OnDisable()
+        {
+            KinematicCharacterSystem.UnregisterPhysicsMover(this);
+        }
+
+        private void Awake()
+        {
+            Transform = this.transform;
+            ValidateData();
+
+            TransientPosition = Rigidbody.position;
+            TransientRotation = Rigidbody.rotation;
+            InitialSimulationPosition = Rigidbody.position;
+            InitialSimulationRotation = Rigidbody.rotation;
+            LatestInterpolationPosition = Transform.position;
+            LatestInterpolationRotation = Transform.rotation;
+        }
+
+        /// <summary>
+        /// Sets the mover's position directly
+        /// </summary>
+        public void SetPosition(Vector3 position)
+        {
+            Transform.position = position;
+            Rigidbody.position = position;
+            InitialSimulationPosition = position;
+            TransientPosition = position;
+        }
+
+        /// <summary>
+        /// Sets the mover's rotation directly
+        /// </summary>
+        public void SetRotation(Quaternion rotation)
+        {
+            Transform.rotation = rotation;
+            Rigidbody.rotation = rotation;
+            InitialSimulationRotation = rotation;
+            TransientRotation = rotation;
+        }
+
+        /// <summary>
+        /// Sets the mover's position and rotation directly
+        /// </summary>
+        public void SetPositionAndRotation(Vector3 position, Quaternion rotation)
+        {
+            Transform.SetPositionAndRotation(position, rotation);
+            Rigidbody.position = position;
+            Rigidbody.rotation = rotation;
+            InitialSimulationPosition = position;
+            InitialSimulationRotation = rotation;
+            TransientPosition = position;
+            TransientRotation = rotation;
+        }
+
+        /// <summary>
+        /// Returns all the state information of the mover that is pertinent for simulation
+        /// </summary>
+        public PhysicsMoverState GetState()
+        {
+            PhysicsMoverState state = new PhysicsMoverState();
+
+            state.Position = TransientPosition;
+            state.Rotation = TransientRotation;
+            state.Velocity = Velocity;
+            state.AngularVelocity = AngularVelocity;
+
+            return state;
+        }
+
+        /// <summary>
+        /// Applies a mover state instantly
+        /// </summary>
+        public void ApplyState(PhysicsMoverState state)
+        {
+            SetPositionAndRotation(state.Position, state.Rotation);
+            Velocity = state.Velocity;
+            AngularVelocity = state.AngularVelocity;
+        }
+
+        /// <summary>
+        /// Caches velocity values based on deltatime and target position/rotations
+        /// </summary>
+        public void VelocityUpdate(float deltaTime)
+        {
+            InitialSimulationPosition = TransientPosition;
+            InitialSimulationRotation = TransientRotation;
+
+            MoverController.UpdateMovement(out _internalTransientPosition, out _internalTransientRotation, deltaTime);
+
+            if (deltaTime > 0f)
+            {
+                Velocity = (TransientPosition - InitialSimulationPosition) / deltaTime;
+                                
+                Quaternion rotationFromCurrentToGoal = TransientRotation * (Quaternion.Inverse(InitialSimulationRotation));
+                AngularVelocity = (Mathf.Deg2Rad * rotationFromCurrentToGoal.eulerAngles) / deltaTime;
+            }
+        }
+    }
+}

Assets/KinematicCharacterController/Core/PhysicsMover.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 075ccbe9837b0744985e09ba3f015b9b
+timeCreated: 1488089271
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/PhysicsMover.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Core/ReadOnlyAttribute.cs

@@ -0,0 +1,8 @@
+using UnityEngine;
+
+namespace KinematicCharacterController
+{
+    public class ReadOnlyAttribute : PropertyAttribute
+    {
+    }
+}

Assets/KinematicCharacterController/Core/ReadOnlyAttribute.cs.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: 63e8828991cf67f42bfeb498686aad0b
+timeCreated: 1504493014
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Core/ReadOnlyAttribute.cs
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter.meta

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

Assets/KinematicCharacterController/ExampleCharacter/Materials.meta

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

Assets/KinematicCharacterController/ExampleCharacter/Materials/White.mat

@@ -0,0 +1,76 @@
+%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: White
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.661
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/ExampleCharacter/Materials/White.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cf774b4c734b1d04e9fbf6d71e964591
+timeCreated: 1493180259
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Materials/White.mat
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter/Prefabs.meta

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

Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCamera.prefab

@@ -0,0 +1,127 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &1937979026721672
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4353896453404184}
+  - component: {fileID: 20127477809793788}
+  - component: {fileID: 124551908420297706}
+  - component: {fileID: 81410469953920030}
+  - component: {fileID: 114014416615829144}
+  m_Layer: 0
+  m_Name: ExampleCamera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4353896453404184
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1937979026721672}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -5}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!20 &20127477809793788
+Camera:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1937979026721672}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_projectionMatrixMode: 1
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_GateFitMode: 2
+  m_FocalLength: 50
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 75
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_AllowDynamicResolution: 0
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+--- !u!124 &124551908420297706
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1937979026721672}
+  m_Enabled: 1
+--- !u!81 &81410469953920030
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1937979026721672}
+  m_Enabled: 1
+--- !u!114 &114014416615829144
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1937979026721672}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 24092a40b02616e479baeb940325e339, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  Camera: {fileID: 20127477809793788}
+  FollowPointFraming: {x: 0, y: 0}
+  FollowingSharpness: 10000
+  DefaultDistance: 6
+  MinDistance: 0
+  MaxDistance: 10
+  DistanceMovementSpeed: 5
+  DistanceMovementSharpness: 10
+  InvertX: 0
+  InvertY: 0
+  DefaultVerticalAngle: 20
+  MinVerticalAngle: -90
+  MaxVerticalAngle: 90
+  RotationSpeed: 1.3
+  RotationSharpness: 10000
+  ObstructionCheckRadius: 0.2
+  ObstructionLayers:
+    serializedVersion: 2
+    m_Bits: 4294965759
+  ObstructionSharpness: 10000
+  IgnoredColliders: []

Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCamera.prefab.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: c75e91cf060bbf04e89204fa400606df
+timeCreated: 1499181144
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCamera.prefab
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCharacter.prefab

@@ -0,0 +1,394 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &43330285
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 43330286}
+  m_Layer: 0
+  m_Name: Root
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &43330286
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 43330285}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4036232530805280}
+  - {fileID: 4718917724592500}
+  m_Father: {fileID: 4898694727102280}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1072008595159340
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4036232530805280}
+  m_Layer: 0
+  m_Name: Meshes
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4036232530805280
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1072008595159340}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4903610365175460}
+  m_Father: {fileID: 43330286}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1339159333115884
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4903610365175460}
+  - component: {fileID: 33711778101729860}
+  - component: {fileID: 23310449951372792}
+  m_Layer: 0
+  m_Name: Capsule
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4903610365175460
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1339159333115884}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4485742127011420}
+  m_Father: {fileID: 4036232530805280}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33711778101729860
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1339159333115884}
+  m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23310449951372792
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1339159333115884}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: cf774b4c734b1d04e9fbf6d71e964591, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!1 &1398904762131290
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4898694727102280}
+  - component: {fileID: 136457490459165436}
+  - component: {fileID: 114565867274256808}
+  - component: {fileID: 114967586934651944}
+  - component: {fileID: 6177337246575538918}
+  m_Layer: 0
+  m_Name: ExampleCharacter
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4898694727102280
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1398904762131290}
+  m_LocalRotation: {x: 0, y: 0.7071068, z: 0, w: 0.70710677}
+  m_LocalPosition: {x: -40.14, y: 0, z: -29.24}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 43330286}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 90.00001, z: 0}
+--- !u!136 &136457490459165436
+CapsuleCollider:
+  m_ObjectHideFlags: 8
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1398904762131290}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  m_Radius: 0.5
+  m_Height: 2
+  m_Direction: 1
+  m_Center: {x: 0, y: 1, z: 0}
+--- !u!114 &114565867274256808
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1398904762131290}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76020eee813ed7844bcea94c5d5ce76a, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  Motor: {fileID: 114967586934651944}
+  MaxStableMoveSpeed: 10
+  StableMovementSharpness: 15
+  OrientationSharpness: 10
+  OrientationMethod: 1
+  MaxAirMoveSpeed: 15
+  AirAccelerationSpeed: 18
+  Drag: 0.1
+  AllowJumpingWhenSliding: 0
+  JumpUpSpeed: 10
+  JumpScalableForwardSpeed: 10
+  JumpPreGroundingGraceTime: 0
+  JumpPostGroundingGraceTime: 0
+  IgnoredColliders:
+  - {fileID: 0}
+  - {fileID: 0}
+  BonusOrientationMethod: 0
+  BonusOrientationSharpness: 10
+  Gravity: {x: 0, y: -30, z: 0}
+  MeshRoot: {fileID: 4036232530805280}
+  CameraFollowPoint: {fileID: 4718917724592500}
+--- !u!114 &114967586934651944
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1398904762131290}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 4d1bc5515e3ab954e80599c538834774, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  Capsule: {fileID: 136457490459165436}
+  CapsuleRadius: 0.5
+  CapsuleHeight: 2
+  CapsuleYOffset: 1
+  CapsulePhysicsMaterial: {fileID: 0}
+  GroundDetectionExtraDistance: 0
+  MaxStableSlopeAngle: 60
+  StableGroundLayers:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  DiscreteCollisionEvents: 0
+  StepHandling: 1
+  MaxStepHeight: 0.5
+  AllowSteppingWithoutStableGrounding: 0
+  MinRequiredStepDepth: 0.1
+  LedgeAndDenivelationHandling: 1
+  MaxStableDistanceFromLedge: 0.5
+  MaxVelocityForLedgeSnap: 0
+  MaxStableDenivelationAngle: 180
+  InteractiveRigidbodyHandling: 1
+  RigidbodyInteractionType: 0
+  SimulatedCharacterMass: 1
+  PreserveAttachedRigidbodyMomentum: 1
+  HasPlanarConstraint: 0
+  PlanarConstraintAxis: {x: 0, y: 0, z: 1}
+  MaxMovementIterations: 5
+  MaxDecollisionIterations: 1
+  CheckMovementInitialOverlaps: 1
+  KillVelocityWhenExceedMaxMovementIterations: 1
+  KillRemainingMovementWhenExceedMaxMovementIterations: 1
+--- !u!54 &6177337246575538918
+Rigidbody:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1398904762131290}
+  serializedVersion: 2
+  m_Mass: 1
+  m_Drag: 0
+  m_AngularDrag: 0.05
+  m_UseGravity: 0
+  m_IsKinematic: 1
+  m_Interpolate: 0
+  m_Constraints: 0
+  m_CollisionDetection: 0
+--- !u!1 &1758411822872852
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4485742127011420}
+  - component: {fileID: 33111717300596878}
+  - component: {fileID: 23624829931232870}
+  m_Layer: 0
+  m_Name: Cylinder
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4485742127011420
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1758411822872852}
+  m_LocalRotation: {x: 0.70710677, y: -0, z: -0, w: 0.7071068}
+  m_LocalPosition: {x: 0, y: 0.44099998, z: 0.18199922}
+  m_LocalScale: {x: 0.88040376, y: 0.34093377, z: 0.51656276}
+  m_Children: []
+  m_Father: {fileID: 4903610365175460}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 90.00001, y: 0, z: 0}
+--- !u!33 &33111717300596878
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1758411822872852}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23624829931232870
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1758411822872852}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RenderingLayerMask: 4294967295
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: cf774b4c734b1d04e9fbf6d71e964591, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!1 &1854746833484672
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 4718917724592500}
+  m_Layer: 0
+  m_Name: CameraTarget
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4718917724592500
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1854746833484672}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 1.43, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 43330286}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCharacter.prefab.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: d295472d4ce25404e9aed2627c34801f
+timeCreated: 1499181148
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCharacter.prefab
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter/Scripts.meta

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

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterCamera.cs

@@ -0,0 +1,179 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace KinematicCharacterController.Examples
+{
+    public class ExampleCharacterCamera : MonoBehaviour
+    {
+        [Header("Framing")]
+        public Camera Camera;
+        public Vector2 FollowPointFraming = new Vector2(0f, 0f);
+        public float FollowingSharpness = 10000f;
+
+        [Header("Distance")]
+        public float DefaultDistance = 6f;
+        public float MinDistance = 0f;
+        public float MaxDistance = 10f;
+        public float DistanceMovementSpeed = 5f;
+        public float DistanceMovementSharpness = 10f;
+
+        [Header("Rotation")]
+        public bool InvertX = false;
+        public bool InvertY = false;
+        [Range(-90f, 90f)]
+        public float DefaultVerticalAngle = 20f;
+        [Range(-90f, 90f)]
+        public float MinVerticalAngle = -90f;
+        [Range(-90f, 90f)]
+        public float MaxVerticalAngle = 90f;
+        public float RotationSpeed = 1f;
+        public float RotationSharpness = 10000f;
+        public bool RotateWithPhysicsMover = false;
+
+        [Header("Obstruction")]
+        public float ObstructionCheckRadius = 0.2f;
+        public LayerMask ObstructionLayers = -1;
+        public float ObstructionSharpness = 10000f;
+        public List<Collider> IgnoredColliders = new List<Collider>();
+
+        public Transform Transform { get; private set; }
+        public Transform FollowTransform { get; private set; }
+
+        public Vector3 PlanarDirection { get; set; }
+        public float TargetDistance { get; set; }
+
+        private bool _distanceIsObstructed;
+        private float _currentDistance;
+        private float _targetVerticalAngle;
+        private RaycastHit _obstructionHit;
+        private int _obstructionCount;
+        private RaycastHit[] _obstructions = new RaycastHit[MaxObstructions];
+        private float _obstructionTime;
+        private Vector3 _currentFollowPosition;
+
+        private const int MaxObstructions = 32;
+
+        void OnValidate()
+        {
+            DefaultDistance = Mathf.Clamp(DefaultDistance, MinDistance, MaxDistance);
+            DefaultVerticalAngle = Mathf.Clamp(DefaultVerticalAngle, MinVerticalAngle, MaxVerticalAngle);
+        }
+
+        void Awake()
+        {
+            Transform = this.transform;
+
+            _currentDistance = DefaultDistance;
+            TargetDistance = _currentDistance;
+
+            _targetVerticalAngle = 0f;
+
+            PlanarDirection = Vector3.forward;
+        }
+
+        // Set the transform that the camera will orbit around
+        public void SetFollowTransform(Transform t)
+        {
+            FollowTransform = t;
+            PlanarDirection = FollowTransform.forward;
+            _currentFollowPosition = FollowTransform.position;
+        }
+
+        public void UpdateWithInput(float deltaTime, float zoomInput, Vector3 rotationInput)
+        {
+            if (FollowTransform)
+            {
+                if (InvertX)
+                {
+                    rotationInput.x *= -1f;
+                }
+                if (InvertY)
+                {
+                    rotationInput.y *= -1f;
+                }
+
+                // Process rotation input
+                Quaternion rotationFromInput = Quaternion.Euler(FollowTransform.up * (rotationInput.x * RotationSpeed));
+                PlanarDirection = rotationFromInput * PlanarDirection;
+                PlanarDirection = Vector3.Cross(FollowTransform.up, Vector3.Cross(PlanarDirection, FollowTransform.up));
+                Quaternion planarRot = Quaternion.LookRotation(PlanarDirection, FollowTransform.up);
+
+                _targetVerticalAngle -= (rotationInput.y * RotationSpeed);
+                _targetVerticalAngle = Mathf.Clamp(_targetVerticalAngle, MinVerticalAngle, MaxVerticalAngle);
+                Quaternion verticalRot = Quaternion.Euler(_targetVerticalAngle, 0, 0);
+                Quaternion targetRotation = Quaternion.Slerp(Transform.rotation, planarRot * verticalRot, 1f - Mathf.Exp(-RotationSharpness * deltaTime));
+
+                // Apply rotation
+                Transform.rotation = targetRotation;
+
+                // Process distance input
+                if (_distanceIsObstructed && Mathf.Abs(zoomInput) > 0f)
+                {
+                    TargetDistance = _currentDistance;
+                }
+                TargetDistance += zoomInput * DistanceMovementSpeed;
+                TargetDistance = Mathf.Clamp(TargetDistance, MinDistance, MaxDistance);
+
+                // Find the smoothed follow position
+                _currentFollowPosition = Vector3.Lerp(_currentFollowPosition, FollowTransform.position, 1f - Mathf.Exp(-FollowingSharpness * deltaTime));
+
+                // Handle obstructions
+                {
+                    RaycastHit closestHit = new RaycastHit();
+                    closestHit.distance = Mathf.Infinity;
+                    _obstructionCount = Physics.SphereCastNonAlloc(_currentFollowPosition, ObstructionCheckRadius, -Transform.forward, _obstructions, TargetDistance, ObstructionLayers, QueryTriggerInteraction.Ignore);
+                    for (int i = 0; i < _obstructionCount; i++)
+                    {
+                        bool isIgnored = false;
+                        for (int j = 0; j < IgnoredColliders.Count; j++)
+                        {
+                            if (IgnoredColliders[j] == _obstructions[i].collider)
+                            {
+                                isIgnored = true;
+                                break;
+                            }
+                        }
+                        for (int j = 0; j < IgnoredColliders.Count; j++)
+                        {
+                            if (IgnoredColliders[j] == _obstructions[i].collider)
+                            {
+                                isIgnored = true;
+                                break;
+                            }
+                        }
+
+                        if (!isIgnored && _obstructions[i].distance < closestHit.distance && _obstructions[i].distance > 0)
+                        {
+                            closestHit = _obstructions[i];
+                        }
+                    }
+
+                    // If obstructions detecter
+                    if (closestHit.distance < Mathf.Infinity)
+                    {
+                        _distanceIsObstructed = true;
+                        _currentDistance = Mathf.Lerp(_currentDistance, closestHit.distance, 1 - Mathf.Exp(-ObstructionSharpness * deltaTime));
+                    }
+                    // If no obstruction
+                    else
+                    {
+                        _distanceIsObstructed = false;
+                        _currentDistance = Mathf.Lerp(_currentDistance, TargetDistance, 1 - Mathf.Exp(-DistanceMovementSharpness * deltaTime));
+                    }
+                }
+
+                // Find the smoothed camera orbit position
+                Vector3 targetPosition = _currentFollowPosition - ((targetRotation * Vector3.forward) * _currentDistance);
+
+                // Handle framing
+                targetPosition += Transform.right * FollowPointFraming.x;
+                targetPosition += Transform.up * FollowPointFraming.y;
+
+                // Apply position
+                Transform.position = targetPosition;
+            }
+        }
+    }
+}

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterCamera.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 24092a40b02616e479baeb940325e339
+timeCreated: 1485657083
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterCamera.cs
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterController.cs

@@ -0,0 +1,516 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using KinematicCharacterController;
+using System;
+
+namespace KinematicCharacterController.Examples
+{
+    public enum CharacterState
+    {
+        Default,
+    }
+
+    public enum OrientationMethod
+    {
+        TowardsCamera,
+        TowardsMovement,
+    }
+
+    public struct PlayerCharacterInputs
+    {
+        public float MoveAxisForward;
+        public float MoveAxisRight;
+        public Quaternion CameraRotation;
+        public bool JumpDown;
+        public bool CrouchDown;
+        public bool CrouchUp;
+    }
+
+    public struct AICharacterInputs
+    {
+        public Vector3 MoveVector;
+        public Vector3 LookVector;
+    }
+
+    public enum BonusOrientationMethod
+    {
+        None,
+        TowardsGravity,
+        TowardsGroundSlopeAndGravity,
+    }
+
+    public class ExampleCharacterController : MonoBehaviour, ICharacterController
+    {
+        public KinematicCharacterMotor Motor;
+
+        [Header("Stable Movement")]
+        public float MaxStableMoveSpeed = 10f;
+        public float StableMovementSharpness = 15f;
+        public float OrientationSharpness = 10f;
+        public OrientationMethod OrientationMethod = OrientationMethod.TowardsCamera;
+
+        [Header("Air Movement")]
+        public float MaxAirMoveSpeed = 15f;
+        public float AirAccelerationSpeed = 15f;
+        public float Drag = 0.1f;
+
+        [Header("Jumping")]
+        public bool AllowJumpingWhenSliding = false;
+        public float JumpUpSpeed = 10f;
+        public float JumpScalableForwardSpeed = 10f;
+        public float JumpPreGroundingGraceTime = 0f;
+        public float JumpPostGroundingGraceTime = 0f;
+
+        [Header("Misc")]
+        public List<Collider> IgnoredColliders = new List<Collider>();
+        public BonusOrientationMethod BonusOrientationMethod = BonusOrientationMethod.None;
+        public float BonusOrientationSharpness = 10f;
+        public Vector3 Gravity = new Vector3(0, -30f, 0);
+        public Transform MeshRoot;
+        public Transform CameraFollowPoint;
+        public float CrouchedCapsuleHeight = 1f;
+
+        public CharacterState CurrentCharacterState { get; private set; }
+
+        private Collider[] _probedColliders = new Collider[8];
+        private RaycastHit[] _probedHits = new RaycastHit[8];
+        private Vector3 _moveInputVector;
+        private Vector3 _lookInputVector;
+        private bool _jumpRequested = false;
+        private bool _jumpConsumed = false;
+        private bool _jumpedThisFrame = false;
+        private float _timeSinceJumpRequested = Mathf.Infinity;
+        private float _timeSinceLastAbleToJump = 0f;
+        private Vector3 _internalVelocityAdd = Vector3.zero;
+        private bool _shouldBeCrouching = false;
+        private bool _isCrouching = false;
+
+        private Vector3 lastInnerNormal = Vector3.zero;
+        private Vector3 lastOuterNormal = Vector3.zero;
+
+        private void Awake()
+        {
+            // Handle initial state
+            TransitionToState(CharacterState.Default);
+
+            // Assign the characterController to the motor
+            Motor.CharacterController = this;
+        }
+
+        /// <summary>
+        /// Handles movement state transitions and enter/exit callbacks
+        /// </summary>
+        public void TransitionToState(CharacterState newState)
+        {
+            CharacterState tmpInitialState = CurrentCharacterState;
+            OnStateExit(tmpInitialState, newState);
+            CurrentCharacterState = newState;
+            OnStateEnter(newState, tmpInitialState);
+        }
+
+        /// <summary>
+        /// Event when entering a state
+        /// </summary>
+        public void OnStateEnter(CharacterState state, CharacterState fromState)
+        {
+            switch (state)
+            {
+                case CharacterState.Default:
+                    {
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Event when exiting a state
+        /// </summary>
+        public void OnStateExit(CharacterState state, CharacterState toState)
+        {
+            switch (state)
+            {
+                case CharacterState.Default:
+                    {
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// This is called every frame by ExamplePlayer in order to tell the character what its inputs are
+        /// </summary>
+        public void SetInputs(ref PlayerCharacterInputs inputs)
+        {
+            // Clamp input
+            Vector3 moveInputVector = Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0f, inputs.MoveAxisForward), 1f);
+
+            // Calculate camera direction and rotation on the character plane
+            Vector3 cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.forward, Motor.CharacterUp).normalized;
+            if (cameraPlanarDirection.sqrMagnitude == 0f)
+            {
+                cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.up, Motor.CharacterUp).normalized;
+            }
+            Quaternion cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, Motor.CharacterUp);
+
+            switch (CurrentCharacterState)
+            {
+                case CharacterState.Default:
+                    {
+                        // Move and look inputs
+                        _moveInputVector = cameraPlanarRotation * moveInputVector;
+
+                        switch (OrientationMethod)
+                        {
+                            case OrientationMethod.TowardsCamera:
+                                _lookInputVector = cameraPlanarDirection;
+                                break;
+                            case OrientationMethod.TowardsMovement:
+                                _lookInputVector = _moveInputVector.normalized;
+                                break;
+                        }
+
+                        // Jumping input
+                        if (inputs.JumpDown)
+                        {
+                            _timeSinceJumpRequested = 0f;
+                            _jumpRequested = true;
+                        }
+
+                        // Crouching input
+                        if (inputs.CrouchDown)
+                        {
+                            _shouldBeCrouching = true;
+
+                            if (!_isCrouching)
+                            {
+                                _isCrouching = true;
+                                Motor.SetCapsuleDimensions(0.5f, CrouchedCapsuleHeight, CrouchedCapsuleHeight * 0.5f);
+                                MeshRoot.localScale = new Vector3(1f, 0.5f, 1f);
+                            }
+                        }
+                        else if (inputs.CrouchUp)
+                        {
+                            _shouldBeCrouching = false;
+                        }
+
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// This is called every frame by the AI script in order to tell the character what its inputs are
+        /// </summary>
+        public void SetInputs(ref AICharacterInputs inputs)
+        {
+            _moveInputVector = inputs.MoveVector;
+            _lookInputVector = inputs.LookVector;
+        }
+
+        private Quaternion _tmpTransientRot;
+
+        /// <summary>
+        /// (Called by KinematicCharacterMotor during its update cycle)
+        /// This is called before the character begins its movement update
+        /// </summary>
+        public void BeforeCharacterUpdate(float deltaTime)
+        {
+        }
+
+        /// <summary>
+        /// (Called by KinematicCharacterMotor during its update cycle)
+        /// This is where you tell your character what its rotation should be right now. 
+        /// This is the ONLY place where you should set the character's rotation
+        /// </summary>
+        public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
+        {
+            switch (CurrentCharacterState)
+            {
+                case CharacterState.Default:
+                    {
+                        if (_lookInputVector.sqrMagnitude > 0f && OrientationSharpness > 0f)
+                        {
+                            // Smoothly interpolate from current to target look direction
+                            Vector3 smoothedLookInputDirection = Vector3.Slerp(Motor.CharacterForward, _lookInputVector, 1 - Mathf.Exp(-OrientationSharpness * deltaTime)).normalized;
+
+                            // Set the current rotation (which will be used by the KinematicCharacterMotor)
+                            currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, Motor.CharacterUp);
+                        }
+
+                        Vector3 currentUp = (currentRotation * Vector3.up);
+                        if (BonusOrientationMethod == BonusOrientationMethod.TowardsGravity)
+                        {
+                            // Rotate from current up to invert gravity
+                            Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, -Gravity.normalized, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
+                            currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
+                        }
+                        else if (BonusOrientationMethod == BonusOrientationMethod.TowardsGroundSlopeAndGravity)
+                        {
+                            if (Motor.GroundingStatus.IsStableOnGround)
+                            {
+                                Vector3 initialCharacterBottomHemiCenter = Motor.TransientPosition + (currentUp * Motor.Capsule.radius);
+
+                                Vector3 smoothedGroundNormal = Vector3.Slerp(Motor.CharacterUp, Motor.GroundingStatus.GroundNormal, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
+                                currentRotation = Quaternion.FromToRotation(currentUp, smoothedGroundNormal) * currentRotation;
+
+                                // Move the position to create a rotation around the bottom hemi center instead of around the pivot
+                                Motor.SetTransientPosition(initialCharacterBottomHemiCenter + (currentRotation * Vector3.down * Motor.Capsule.radius));
+                            }
+                            else
+                            {
+                                Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, -Gravity.normalized, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
+                                currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
+                            }
+                        }
+                        else
+                        {
+                            Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, Vector3.up, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
+                            currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
+                        }
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// (Called by KinematicCharacterMotor during its update cycle)
+        /// This is where you tell your character what its velocity should be right now. 
+        /// This is the ONLY place where you can set the character's velocity
+        /// </summary>
+        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
+        {
+            switch (CurrentCharacterState)
+            {
+                case CharacterState.Default:
+                    {
+                        // Ground movement
+                        if (Motor.GroundingStatus.IsStableOnGround)
+                        {
+                            float currentVelocityMagnitude = currentVelocity.magnitude;
+
+                            Vector3 effectiveGroundNormal = Motor.GroundingStatus.GroundNormal;
+
+                            // Reorient velocity on slope
+                            currentVelocity = Motor.GetDirectionTangentToSurface(currentVelocity, effectiveGroundNormal) * currentVelocityMagnitude;
+
+                            // Calculate target velocity
+                            Vector3 inputRight = Vector3.Cross(_moveInputVector, Motor.CharacterUp);
+                            Vector3 reorientedInput = Vector3.Cross(effectiveGroundNormal, inputRight).normalized * _moveInputVector.magnitude;
+                            Vector3 targetMovementVelocity = reorientedInput * MaxStableMoveSpeed;
+
+                            // Smooth movement Velocity
+                            currentVelocity = Vector3.Lerp(currentVelocity, targetMovementVelocity, 1f - Mathf.Exp(-StableMovementSharpness * deltaTime));
+                        }
+                        // Air movement
+                        else
+                        {
+                            // Add move input
+                            if (_moveInputVector.sqrMagnitude > 0f)
+                            {
+                                Vector3 addedVelocity = _moveInputVector * AirAccelerationSpeed * deltaTime;
+
+                                Vector3 currentVelocityOnInputsPlane = Vector3.ProjectOnPlane(currentVelocity, Motor.CharacterUp);
+
+                                // Limit air velocity from inputs
+                                if (currentVelocityOnInputsPlane.magnitude < MaxAirMoveSpeed)
+                                {
+                                    // clamp addedVel to make total vel not exceed max vel on inputs plane
+                                    Vector3 newTotal = Vector3.ClampMagnitude(currentVelocityOnInputsPlane + addedVelocity, MaxAirMoveSpeed);
+                                    addedVelocity = newTotal - currentVelocityOnInputsPlane;
+                                }
+                                else
+                                {
+                                    // Make sure added vel doesn't go in the direction of the already-exceeding velocity
+                                    if (Vector3.Dot(currentVelocityOnInputsPlane, addedVelocity) > 0f)
+                                    {
+                                        addedVelocity = Vector3.ProjectOnPlane(addedVelocity, currentVelocityOnInputsPlane.normalized);
+                                    }
+                                }
+
+                                // Prevent air-climbing sloped walls
+                                if (Motor.GroundingStatus.FoundAnyGround)
+                                {
+                                    if (Vector3.Dot(currentVelocity + addedVelocity, addedVelocity) > 0f)
+                                    {
+                                        Vector3 perpenticularObstructionNormal = Vector3.Cross(Vector3.Cross(Motor.CharacterUp, Motor.GroundingStatus.GroundNormal), Motor.CharacterUp).normalized;
+                                        addedVelocity = Vector3.ProjectOnPlane(addedVelocity, perpenticularObstructionNormal);
+                                    }
+                                }
+
+                                // Apply added velocity
+                                currentVelocity += addedVelocity;
+                            }
+
+                            // Gravity
+                            currentVelocity += Gravity * deltaTime;
+
+                            // Drag
+                            currentVelocity *= (1f / (1f + (Drag * deltaTime)));
+                        }
+
+                        // Handle jumping
+                        _jumpedThisFrame = false;
+                        _timeSinceJumpRequested += deltaTime;
+                        if (_jumpRequested)
+                        {
+                            // See if we actually are allowed to jump
+                            if (!_jumpConsumed && ((AllowJumpingWhenSliding ? Motor.GroundingStatus.FoundAnyGround : Motor.GroundingStatus.IsStableOnGround) || _timeSinceLastAbleToJump <= JumpPostGroundingGraceTime))
+                            {
+                                // Calculate jump direction before ungrounding
+                                Vector3 jumpDirection = Motor.CharacterUp;
+                                if (Motor.GroundingStatus.FoundAnyGround && !Motor.GroundingStatus.IsStableOnGround)
+                                {
+                                    jumpDirection = Motor.GroundingStatus.GroundNormal;
+                                }
+
+                                // Makes the character skip ground probing/snapping on its next update. 
+                                // If this line weren't here, the character would remain snapped to the ground when trying to jump. Try commenting this line out and see.
+                                Motor.ForceUnground();
+
+                                // Add to the return velocity and reset jump state
+                                currentVelocity += (jumpDirection * JumpUpSpeed) - Vector3.Project(currentVelocity, Motor.CharacterUp);
+                                currentVelocity += (_moveInputVector * JumpScalableForwardSpeed);
+                                _jumpRequested = false;
+                                _jumpConsumed = true;
+                                _jumpedThisFrame = true;
+                            }
+                        }
+
+                        // Take into account additive velocity
+                        if (_internalVelocityAdd.sqrMagnitude > 0f)
+                        {
+                            currentVelocity += _internalVelocityAdd;
+                            _internalVelocityAdd = Vector3.zero;
+                        }
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// (Called by KinematicCharacterMotor during its update cycle)
+        /// This is called after the character has finished its movement update
+        /// </summary>
+        public void AfterCharacterUpdate(float deltaTime)
+        {
+            switch (CurrentCharacterState)
+            {
+                case CharacterState.Default:
+                    {
+                        // Handle jump-related values
+                        {
+                            // Handle jumping pre-ground grace period
+                            if (_jumpRequested && _timeSinceJumpRequested > JumpPreGroundingGraceTime)
+                            {
+                                _jumpRequested = false;
+                            }
+
+                            if (AllowJumpingWhenSliding ? Motor.GroundingStatus.FoundAnyGround : Motor.GroundingStatus.IsStableOnGround)
+                            {
+                                // If we're on a ground surface, reset jumping values
+                                if (!_jumpedThisFrame)
+                                {
+                                    _jumpConsumed = false;
+                                }
+                                _timeSinceLastAbleToJump = 0f;
+                            }
+                            else
+                            {
+                                // Keep track of time since we were last able to jump (for grace period)
+                                _timeSinceLastAbleToJump += deltaTime;
+                            }
+                        }
+
+                        // Handle uncrouching
+                        if (_isCrouching && !_shouldBeCrouching)
+                        {
+                            // Do an overlap test with the character's standing height to see if there are any obstructions
+                            Motor.SetCapsuleDimensions(0.5f, 2f, 1f);
+                            if (Motor.CharacterOverlap(
+                                Motor.TransientPosition,
+                                Motor.TransientRotation,
+                                _probedColliders,
+                                Motor.CollidableLayers,
+                                QueryTriggerInteraction.Ignore) > 0)
+                            {
+                                // If obstructions, just stick to crouching dimensions
+                                Motor.SetCapsuleDimensions(0.5f, CrouchedCapsuleHeight, CrouchedCapsuleHeight * 0.5f);
+                            }
+                            else
+                            {
+                                // If no obstructions, uncrouch
+                                MeshRoot.localScale = new Vector3(1f, 1f, 1f);
+                                _isCrouching = false;
+                            }
+                        }
+                        break;
+                    }
+            }
+        }
+
+        public void PostGroundingUpdate(float deltaTime)
+        {
+            // Handle landing and leaving ground
+            if (Motor.GroundingStatus.IsStableOnGround && !Motor.LastGroundingStatus.IsStableOnGround)
+            {
+                OnLanded();
+            }
+            else if (!Motor.GroundingStatus.IsStableOnGround && Motor.LastGroundingStatus.IsStableOnGround)
+            {
+                OnLeaveStableGround();
+            }
+        }
+
+        public bool IsColliderValidForCollisions(Collider coll)
+        {
+            if (IgnoredColliders.Count == 0)
+            {
+                return true;
+            }
+
+            if (IgnoredColliders.Contains(coll))
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        public void AddVelocity(Vector3 velocity)
+        {
+            switch (CurrentCharacterState)
+            {
+                case CharacterState.Default:
+                    {
+                        _internalVelocityAdd += velocity;
+                        break;
+                    }
+            }
+        }
+
+        public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition, Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        protected void OnLanded()
+        {
+        }
+
+        protected void OnLeaveStableGround()
+        {
+        }
+
+        public void OnDiscreteCollisionDetected(Collider hitCollider)
+        {
+        }
+    }
+}

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterController.cs.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: 76020eee813ed7844bcea94c5d5ce76a
+timeCreated: 1503446428
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterController.cs
+  uploadId: 505601

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExamplePlayer.cs

@@ -0,0 +1,99 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using KinematicCharacterController;
+using KinematicCharacterController.Examples;
+
+namespace KinematicCharacterController.Examples
+{
+    public class ExamplePlayer : MonoBehaviour
+    {
+        public ExampleCharacterController Character;
+        public ExampleCharacterCamera CharacterCamera;
+
+        private const string MouseXInput = "Mouse X";
+        private const string MouseYInput = "Mouse Y";
+        private const string MouseScrollInput = "Mouse ScrollWheel";
+        private const string HorizontalInput = "Horizontal";
+        private const string VerticalInput = "Vertical";
+
+        private void Start()
+        {
+            Cursor.lockState = CursorLockMode.Locked;
+
+            // Tell camera to follow transform
+            CharacterCamera.SetFollowTransform(Character.CameraFollowPoint);
+
+            // Ignore the character's collider(s) for camera obstruction checks
+            CharacterCamera.IgnoredColliders.Clear();
+            CharacterCamera.IgnoredColliders.AddRange(Character.GetComponentsInChildren<Collider>());
+        }
+
+        private void Update()
+        {
+            if (Input.GetMouseButtonDown(0))
+            {
+                Cursor.lockState = CursorLockMode.Locked;
+            }
+
+            HandleCharacterInput();
+        }
+
+        private void LateUpdate()
+        {
+            // Handle rotating the camera along with physics movers
+            if (CharacterCamera.RotateWithPhysicsMover && Character.Motor.AttachedRigidbody != null)
+            {
+                CharacterCamera.PlanarDirection = Character.Motor.AttachedRigidbody.GetComponent<PhysicsMover>().RotationDeltaFromInterpolation * CharacterCamera.PlanarDirection;
+                CharacterCamera.PlanarDirection = Vector3.ProjectOnPlane(CharacterCamera.PlanarDirection, Character.Motor.CharacterUp).normalized;
+            }
+
+            HandleCameraInput();
+        }
+
+        private void HandleCameraInput()
+        {
+            // Create the look input vector for the camera
+            float mouseLookAxisUp = Input.GetAxisRaw(MouseYInput);
+            float mouseLookAxisRight = Input.GetAxisRaw(MouseXInput);
+            Vector3 lookInputVector = new Vector3(mouseLookAxisRight, mouseLookAxisUp, 0f);
+
+            // Prevent moving the camera while the cursor isn't locked
+            if (Cursor.lockState != CursorLockMode.Locked)
+            {
+                lookInputVector = Vector3.zero;
+            }
+
+            // Input for zooming the camera (disabled in WebGL because it can cause problems)
+            float scrollInput = -Input.GetAxis(MouseScrollInput);
+#if UNITY_WEBGL
+        scrollInput = 0f;
+#endif
+
+            // Apply inputs to the camera
+            CharacterCamera.UpdateWithInput(Time.deltaTime, scrollInput, lookInputVector);
+
+            // Handle toggling zoom level
+            if (Input.GetMouseButtonDown(1))
+            {
+                CharacterCamera.TargetDistance = (CharacterCamera.TargetDistance == 0f) ? CharacterCamera.DefaultDistance : 0f;
+            }
+        }
+
+        private void HandleCharacterInput()
+        {
+            PlayerCharacterInputs characterInputs = new PlayerCharacterInputs();
+
+            // Build the CharacterInputs struct
+            characterInputs.MoveAxisForward = Input.GetAxisRaw(VerticalInput);
+            characterInputs.MoveAxisRight = Input.GetAxisRaw(HorizontalInput);
+            characterInputs.CameraRotation = CharacterCamera.Transform.rotation;
+            characterInputs.JumpDown = Input.GetKeyDown(KeyCode.Space);
+            characterInputs.CrouchDown = Input.GetKeyDown(KeyCode.C);
+            characterInputs.CrouchUp = Input.GetKeyUp(KeyCode.C);
+
+            // Apply inputs to character
+            Character.SetInputs(ref characterInputs);
+        }
+    }
+}

Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExamplePlayer.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 461cd396e3fc7cc4eb9c92bde05c1b9a
+timeCreated: 1485657184
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/ExampleCharacter/Scripts/ExamplePlayer.cs
+  uploadId: 505601

Assets/KinematicCharacterController/Examples.meta

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

Assets/KinematicCharacterController/Examples/Animation.meta

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

Assets/KinematicCharacterController/Examples/Animation/boatTimeline.playable

@@ -0,0 +1,515 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 337831424, guid: 6a10b2909283487f913b00d94cd3faf5, type: 3}
+  m_Name: boatTimeline
+  m_EditorClassIdentifier: 
+  m_NextId: 0
+  m_Tracks:
+  - {fileID: 114058333835397466}
+  m_FixedDuration: 0
+  m_EditorSettings:
+    m_Framerate: 60
+  m_DurationMode: 0
+  m_Version: 0
+--- !u!74 &74433855136485492
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Recorded
+  serializedVersion: 6
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_EulerCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: {x: 0.00000002135315, y: -0.00004577637, z: -0.000003814697}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 0.25
+        value: {x: -4.392822, y: -3.885072, z: 5.683667}
+        inSlope: {x: 2.9766836, y: 13.287476, z: 4.0816956}
+        outSlope: {x: 2.9766836, y: 13.287476, z: 4.0816956}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 0.5
+        value: {x: 1.488342, y: 6.643692, z: 2.040844}
+        inSlope: {x: 25.622435, y: 25.996264, z: -7.745982}
+        outSlope: {x: 25.622435, y: 25.996264, z: -7.745982}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 0.75
+        value: {x: 8.418396, y: 9.11306, z: 1.810676}
+        inSlope: {x: -2.9766846, y: -13.28746, z: -4.0816746}
+        outSlope: {x: -2.9766846, y: -13.28746, z: -4.0816746}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 1
+        value: {x: 0, y: -0.00003814697, z: 0.00000667572}
+        inSlope: {x: -25.622437, y: -25.996264, z: 7.745982}
+        outSlope: {x: -25.622437, y: -25.996264, z: 7.745982}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    path: 
+  m_PositionCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: {x: -0.32999802, y: 0, z: 0.069999695}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 0.5
+        value: {x: -0.32999802, y: 1.21, z: 0.069999695}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 1
+        value: {x: -0.32999802, y: 0, z: 0.069999695}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    path: 
+  m_ScaleCurves: []
+  m_FloatCurves: []
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - serializedVersion: 2
+      path: 0
+      attribute: 1
+      script: {fileID: 0}
+      typeID: 4
+      customType: 0
+      isPPtrCurve: 0
+    - serializedVersion: 2
+      path: 0
+      attribute: 4
+      script: {fileID: 0}
+      typeID: 4
+      customType: 4
+      isPPtrCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_AdditiveReferencePoseClip: {fileID: 0}
+    m_AdditiveReferencePoseTime: 0
+    m_StartTime: 0
+    m_StopTime: 1
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_HasAdditiveReferencePose: 0
+    m_LoopTime: 0
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0.00000002135315
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.25
+        value: -4.392822
+        inSlope: 2.9766836
+        outSlope: 2.9766836
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: 1.488342
+        inSlope: 25.622435
+        outSlope: 25.622435
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.75
+        value: 8.418396
+        inSlope: -2.9766846
+        outSlope: -2.9766846
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0
+        inSlope: -25.622437
+        outSlope: -25.622437
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: -0.00004577637
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.25
+        value: -3.885072
+        inSlope: 13.287476
+        outSlope: 13.287476
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: 6.643692
+        inSlope: 25.996264
+        outSlope: 25.996264
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.75
+        value: 9.11306
+        inSlope: -13.28746
+        outSlope: -13.28746
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: -0.00003814697
+        inSlope: -25.996264
+        outSlope: -25.996264
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: -0.000003814697
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.25
+        value: 5.683667
+        inSlope: 4.0816956
+        outSlope: 4.0816956
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: 2.040844
+        inSlope: -7.745982
+        outSlope: -7.745982
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.75
+        value: 1.810676
+        inSlope: -4.0816746
+        outSlope: -4.0816746
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0.00000667572
+        inSlope: 7.745982
+        outSlope: 7.745982
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: -0.32999802
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: -0.32999802
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: -0.32999802
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalPosition.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: 1.21
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalPosition.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0.069999695
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 0.5
+        value: 0.069999695
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 34
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0.069999695
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 1
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalPosition.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  m_EulerEditorCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  - curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+  m_HasGenericRootTransform: 1
+  m_HasMotionFloatCurves: 0
+  m_Events: []
+--- !u!114 &114058333835397466
+MonoBehaviour:
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1467732076, guid: 6a10b2909283487f913b00d94cd3faf5, type: 3}
+  m_Name: Animation Track
+  m_EditorClassIdentifier: 
+  m_Locked: 0
+  m_Muted: 0
+  m_CustomPlayableFullTypename: 
+  m_AnimClip: {fileID: 74433855136485492}
+  m_Parent: {fileID: 11400000}
+  m_Children: []
+  m_Clips: []
+  m_Version: 2
+  m_OpenClipPreExtrapolation: 1
+  m_OpenClipPostExtrapolation: 1
+  m_OpenClipOffsetPosition: {x: -35.07, y: 0, z: -45.329998}
+  m_OpenClipOffsetEulerAngles: {x: -0, y: 90.000046, z: 0}
+  m_OpenClipTimeOffset: 0
+  m_OpenClipRemoveOffset: 0
+  m_InfiniteClipApplyFootIK: 1
+  m_MatchTargetFields: 63
+  m_Position: {x: 0, y: 0, z: 0}
+  m_EulerAngles: {x: 0, y: 0, z: 0}
+  m_AvatarMask: {fileID: 0}
+  m_ApplyAvatarMask: 1
+  m_TrackOffset: 2
+  m_OpenClipOffsetRotation: {x: 0, y: 0.70710707, z: 0, w: 0.70710653}
+  m_Rotation: {x: 0, y: 0, z: 0, w: 1}
+  m_ApplyOffsets: 0

Assets/KinematicCharacterController/Examples/Animation/boatTimeline.playable.meta

@@ -0,0 +1,17 @@
+fileFormatVersion: 2
+guid: 4545f35d0ad75664aa686adccdeec124
+timeCreated: 1523122860
+licenseType: Store
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Animation/boatTimeline.playable
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials.meta

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

Assets/KinematicCharacterController/Examples/Materials/Blue.mat

@@ -0,0 +1,76 @@
+%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: Blue
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.125
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.18382347, g: 0.6622718, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Blue.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 60c42fb470eea2b4198867ba20e2b905
+timeCreated: 1493180259
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Blue.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Dark.mat

@@ -0,0 +1,76 @@
+%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: Dark
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.661
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.43382353, g: 0.43382353, b: 0.43382353, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Dark.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: ac0fa2f3d7139704ba1ad516325833cc
+timeCreated: 1493180259
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Dark.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Ghost.mat

@@ -0,0 +1,77 @@
+%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: Ghost
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _ALPHABLEND_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 2
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 0.484}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Ghost.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 95ff44eaf07f3af4a8f8506dc52b2f49
+timeCreated: 1493180259
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Ghost.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/GhostRed.mat

@@ -0,0 +1,77 @@
+%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: GhostRed
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _ALPHAPREMULTIPLY_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 1
+    - _Glossiness: 0.568
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 3
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 0.77205884, g: 0, b: 0, a: 0.553}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/GhostRed.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: e74834ba16a1b134194339ebb525adf0
+timeCreated: 1499189578
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/GhostRed.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Green.mat

@@ -0,0 +1,76 @@
+%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: Green
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.17088658, g: 0.45588237, b: 0.14749137, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Green.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 83b277cab1b0a6146b3877fdc32581fe
+timeCreated: 1499189578
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Green.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Grid20.mat

@@ -0,0 +1,76 @@
+%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: Grid20
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 20, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: e2571d7568539cd489b45b0927fd895b, type: 3}
+        m_Scale: {x: 20, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.19852942, g: 0.19852942, b: 0.19852942, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Grid20.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 362a6030a4cf94047aea778b2ee3f1ea
+timeCreated: 1485658110
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Grid20.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Grid200.mat

@@ -0,0 +1,76 @@
+%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: Grid200
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 75, y: 75}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: e2571d7568539cd489b45b0927fd895b, type: 3}
+        m_Scale: {x: 75, y: 75}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.19852942, g: 0.19852942, b: 0.19852942, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Grid200.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: a6501adaf78814c43b95d27ec855fc02
+timeCreated: 1485658110
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Grid200.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/GridBlue.mat

@@ -0,0 +1,76 @@
+%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: GridBlue
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 20, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: e2571d7568539cd489b45b0927fd895b, type: 3}
+        m_Scale: {x: 20, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.22577855, g: 0.39120635, b: 0.5294118, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/GridBlue.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: b2741a1cd6e468f44b7d6494dee261a2
+timeCreated: 1485658110
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/GridBlue.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Light.mat

@@ -0,0 +1,76 @@
+%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: Light
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1, g: 0.79401857, b: 0.6084906, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Light.mat.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: 3c9ad66f585bfb341b5f346a1ebd06b7
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Light.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Orange.mat

@@ -0,0 +1,75 @@
+%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: Orange
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.661
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 0.57221097, b: 0.1838235, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/Orange.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cdd98aff9e51e5b4c9f98f2d337d0fb1
+timeCreated: 1493180259
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/Orange.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/PlanetMaterial.mat

@@ -0,0 +1,76 @@
+%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: PlanetMaterial
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 35, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 36b5b147a1e526747bad753e77aa33c1, type: 3}
+        m_Scale: {x: 35, y: 20}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 0
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/KinematicCharacterController/Examples/Materials/PlanetMaterial.mat.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 27fb3f3f32e1b9948ae86dac6add45e7
+timeCreated: 1485658110
+licenseType: Store
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 99131
+  packageName: Kinematic Character Controller
+  packageVersion: 3.4.4
+  assetPath: Assets/KinematicCharacterController/Examples/Materials/PlanetMaterial.mat
+  uploadId: 505601

Assets/KinematicCharacterController/Examples/Materials/Purple.mat

@@ -0,0 +1,76 @@
+%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: Purple
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _GLOSSYREFLECTIONS_OFF _SPECULARHIGHLIGHTS_OFF
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 4, y: 4}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 0
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 0
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.86206913, g: 0, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}