Init

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/CrossPlatformInputManager.cs

@@ -0,0 +1,299 @@
+using System;
+using UnityEngine;
+
+namespace DestroyIt
+{
+	public static class CrossPlatformInputManager
+	{
+		public enum ActiveInputMethod
+		{
+			Hardware,
+			Touch
+		}
+
+		private static VirtualInput activeInput;
+		private static VirtualInput s_TouchInput;
+		private static VirtualInput s_HardwareInput;
+
+		static CrossPlatformInputManager()
+		{
+			s_TouchInput = new MobileInput();
+			s_HardwareInput = new StandaloneInput();
+#if MOBILE_INPUT
+            activeInput = s_TouchInput;
+#else
+			activeInput = s_HardwareInput;
+#endif
+		}
+
+		public static void SwitchActiveInputMethod(ActiveInputMethod activeInputMethod)
+		{
+			switch (activeInputMethod)
+			{
+				case ActiveInputMethod.Hardware:
+					activeInput = s_HardwareInput;
+					break;
+
+				case ActiveInputMethod.Touch:
+					activeInput = s_TouchInput;
+					break;
+			}
+		}
+
+		public static bool AxisExists(string name)
+		{
+			return activeInput.AxisExists(name);
+		}
+
+		public static bool ButtonExists(string name)
+		{
+			return activeInput.ButtonExists(name);
+		}
+
+		public static void RegisterVirtualAxis(VirtualAxis axis)
+		{
+			activeInput.RegisterVirtualAxis(axis);
+		}
+
+
+		public static void RegisterVirtualButton(VirtualButton button)
+		{
+			activeInput.RegisterVirtualButton(button);
+		}
+
+
+		public static void UnRegisterVirtualAxis(string name)
+		{
+			if (name == null)
+			{
+				throw new ArgumentNullException("name");
+			}
+			activeInput.UnRegisterVirtualAxis(name);
+		}
+
+
+		public static void UnRegisterVirtualButton(string name)
+		{
+			activeInput.UnRegisterVirtualButton(name);
+		}
+
+
+		// returns a reference to a named virtual axis if it exists otherwise null
+		public static VirtualAxis VirtualAxisReference(string name)
+		{
+			return activeInput.VirtualAxisReference(name);
+		}
+
+
+		// returns the platform appropriate axis for the given name
+		public static float GetAxis(string name)
+		{
+			return GetAxis(name, false);
+		}
+
+
+		public static float GetAxisRaw(string name)
+		{
+			return GetAxis(name, true);
+		}
+
+
+		// private function handles both types of axis (raw and not raw)
+		private static float GetAxis(string name, bool raw)
+		{
+			return activeInput.GetAxis(name, raw);
+		}
+
+
+		// -- Button handling --
+		public static bool GetButton(string name)
+		{
+			return activeInput.GetButton(name);
+		}
+
+
+		public static bool GetButtonDown(string name)
+		{
+			return activeInput.GetButtonDown(name);
+		}
+
+
+		public static bool GetButtonUp(string name)
+		{
+			return activeInput.GetButtonUp(name);
+		}
+
+
+		public static void SetButtonDown(string name)
+		{
+			activeInput.SetButtonDown(name);
+		}
+
+
+		public static void SetButtonUp(string name)
+		{
+			activeInput.SetButtonUp(name);
+		}
+
+
+		public static void SetAxisPositive(string name)
+		{
+			activeInput.SetAxisPositive(name);
+		}
+
+
+		public static void SetAxisNegative(string name)
+		{
+			activeInput.SetAxisNegative(name);
+		}
+
+
+		public static void SetAxisZero(string name)
+		{
+			activeInput.SetAxisZero(name);
+		}
+
+
+		public static void SetAxis(string name, float value)
+		{
+			activeInput.SetAxis(name, value);
+		}
+
+
+		public static Vector3 mousePosition
+		{
+			get { return activeInput.MousePosition(); }
+		}
+
+
+		public static void SetVirtualMousePositionX(float f)
+		{
+			activeInput.SetVirtualMousePositionX(f);
+		}
+
+
+		public static void SetVirtualMousePositionY(float f)
+		{
+			activeInput.SetVirtualMousePositionY(f);
+		}
+
+
+		public static void SetVirtualMousePositionZ(float f)
+		{
+			activeInput.SetVirtualMousePositionZ(f);
+		}
+
+		// virtual axis and button classes - applies to mobile input
+		// Can be mapped to touch joysticks, tilt, gyro, etc, depending on desired implementation.
+		// Could also be implemented by other input devices - kinect, electronic sensors, etc
+		public class VirtualAxis
+		{
+			public string name { get; private set; }
+			private float m_Value;
+			public bool matchWithInputManager { get; private set; }
+
+			public VirtualAxis(string name)
+				: this(name, true)
+			{
+			}
+
+			public VirtualAxis(string name, bool matchToInputSettings)
+			{
+				this.name = name;
+				matchWithInputManager = matchToInputSettings;
+			}
+
+			// removes an axes from the cross platform input system
+			public void Remove()
+			{
+				UnRegisterVirtualAxis(name);
+			}
+
+			// a controller gameobject (eg. a virtual thumbstick) should update this class
+			public void Update(float value)
+			{
+				m_Value = value;
+			}
+
+			public float GetValue
+			{
+				get { return m_Value; }
+			}
+
+			public float GetValueRaw
+			{
+				get { return m_Value; }
+			}
+		}
+
+		// a controller gameobject (eg. a virtual GUI button) should call the
+		// 'pressed' function of this class. Other objects can then read the
+		// Get/Down/Up state of this button.
+		public class VirtualButton
+		{
+			public string name { get; private set; }
+			public bool matchWithInputManager { get; private set; }
+
+			private int m_LastPressedFrame = -5;
+			private int m_ReleasedFrame = -5;
+			private bool m_Pressed;
+
+			public VirtualButton(string name)
+				: this(name, true)
+			{
+			}
+
+			public VirtualButton(string name, bool matchToInputSettings)
+			{
+				this.name = name;
+				matchWithInputManager = matchToInputSettings;
+			}
+
+			// A controller gameobject should call this function when the button is pressed down
+			public void Pressed()
+			{
+				if (m_Pressed)
+				{
+					return;
+				}
+				m_Pressed = true;
+				m_LastPressedFrame = Time.frameCount;
+			}
+
+			// A controller gameobject should call this function when the button is released
+			public void Released()
+			{
+				m_Pressed = false;
+				m_ReleasedFrame = Time.frameCount;
+			}
+
+			// the controller gameobject should call Remove when the button is destroyed or disabled
+			public void Remove()
+			{
+				UnRegisterVirtualButton(name);
+			}
+
+			// these are the states of the button which can be read via the cross platform input system
+			public bool GetButton
+			{
+				get { return m_Pressed; }
+			}
+
+			public bool GetButtonDown
+			{
+				get
+				{
+					return m_LastPressedFrame - Time.frameCount == -1;
+				}
+			}
+
+			public bool GetButtonUp
+			{
+				get
+				{
+					return (m_ReleasedFrame == Time.frameCount - 1);
+				}
+			}
+		}
+	}
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/CrossPlatformInputManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f49091ed45769774391e7704a20c863a
+labels:
+- Done
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: -1010
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/FirstPersonController.cs

@@ -0,0 +1,152 @@
+using UnityEngine;
+
+namespace DestroyIt
+{
+    [RequireComponent(typeof (CharacterController))]
+    [RequireComponent(typeof (AudioSource))]
+    public class FirstPersonController : MonoBehaviour
+    {
+        [SerializeField] private bool m_IsWalking = false;
+        [SerializeField] private float m_WalkSpeed = 0f;
+        [SerializeField] private float m_RunSpeed = 0f;
+        [SerializeField] [Range(0f, 1f)] private float m_RunstepLenghten = 0f;
+        [SerializeField] private float m_JumpSpeed = 0f;
+        [SerializeField] private float m_StickToGroundForce = 0f;
+        [SerializeField] private float m_GravityMultiplier = 0f;
+        [SerializeField] private MouseLook m_MouseLook = new MouseLook();
+        [SerializeField] private float m_StepInterval = 0f;
+
+        private Camera m_Camera;
+        private bool m_Jump;
+        private float m_YRotation;
+        private Vector2 m_Input;
+        private Vector3 m_MoveDir = Vector3.zero;
+        private CharacterController m_CharacterController;
+        private CollisionFlags m_CollisionFlags;
+        private bool m_PreviouslyGrounded;
+        private float m_StepCycle;
+        private float m_NextStep;
+        private bool m_Jumping;
+
+        // Use this for initialization
+        private void Start()
+        {
+            m_CharacterController = GetComponent<CharacterController>();
+            m_Camera = Camera.main;
+            m_StepCycle = 0f;
+            m_NextStep = m_StepCycle/2f;
+            m_Jumping = false;
+			m_MouseLook.Init(transform , m_Camera.transform);
+        }
+
+
+        // Update is called once per frame
+        private void Update()
+        {
+            RotateView();
+            // the jump state needs to read here to make sure it is not missed
+            if (!m_Jump)
+                m_Jump = CrossPlatformInputManager.GetButtonDown("Jump");
+
+            if (!m_PreviouslyGrounded && m_CharacterController.isGrounded)
+            {
+                m_MoveDir.y = 0f;
+                m_Jumping = false;
+            }
+            if (!m_CharacterController.isGrounded && !m_Jumping && m_PreviouslyGrounded)
+                m_MoveDir.y = 0f;
+
+            m_PreviouslyGrounded = m_CharacterController.isGrounded;
+        }
+
+        private void FixedUpdate()
+        {
+            float speed;
+            GetInput(out speed);
+            // always move along the camera forward as it is the direction that it being aimed at
+            Vector3 desiredMove = transform.forward*m_Input.y + transform.right*m_Input.x;
+
+            // get a normal for the surface that is being touched to move along it
+            RaycastHit hitInfo;
+            Physics.SphereCast(transform.position, m_CharacterController.radius, Vector3.down, out hitInfo,
+                               m_CharacterController.height/2f, Physics.AllLayers, QueryTriggerInteraction.Ignore);
+            desiredMove = Vector3.ProjectOnPlane(desiredMove, hitInfo.normal).normalized;
+
+            m_MoveDir.x = desiredMove.x*speed;
+            m_MoveDir.z = desiredMove.z*speed;
+
+
+            if (m_CharacterController.isGrounded)
+            {
+                m_MoveDir.y = -m_StickToGroundForce;
+
+                if (m_Jump)
+                {
+                    m_MoveDir.y = m_JumpSpeed;
+                    m_Jump = false;
+                    m_Jumping = true;
+                }
+            }
+            else
+            {
+                m_MoveDir += Physics.gravity*m_GravityMultiplier*Time.fixedDeltaTime;
+            }
+            m_CollisionFlags = m_CharacterController.Move(m_MoveDir*Time.fixedDeltaTime);
+
+            ProgressStepCycle(speed);
+
+            m_MouseLook.UpdateCursorLock();
+        }
+
+        private void ProgressStepCycle(float speed)
+        {
+            if (m_CharacterController.velocity.sqrMagnitude > 0 && (m_Input.x != 0 || m_Input.y != 0))
+            {
+                m_StepCycle += (m_CharacterController.velocity.magnitude + (speed*(m_IsWalking ? 1f : m_RunstepLenghten)))*
+                             Time.fixedDeltaTime;
+            }
+
+            if (!(m_StepCycle > m_NextStep)) return;
+
+            m_NextStep = m_StepCycle + m_StepInterval;
+        }
+
+        private void GetInput(out float speed)
+        {
+            // Read input
+            float horizontal = CrossPlatformInputManager.GetAxis("Horizontal");
+            float vertical = CrossPlatformInputManager.GetAxis("Vertical");
+
+#if !MOBILE_INPUT
+            // On standalone builds, walk/run speed is modified by a key press.
+            // keep track of whether or not the character is walking or running
+            m_IsWalking = !Input.GetKey(KeyCode.LeftShift);
+#endif
+            // set the desired speed to be walking or running
+            speed = m_IsWalking ? m_WalkSpeed : m_RunSpeed;
+            m_Input = new Vector2(horizontal, vertical);
+
+            // normalize input if it exceeds 1 in combined length:
+            if (m_Input.sqrMagnitude > 1)
+                m_Input.Normalize();
+        }
+
+
+        private void RotateView()
+        {
+            m_MouseLook.LookRotation (transform, m_Camera.transform);
+        }
+
+
+        private void OnControllerColliderHit(ControllerColliderHit hit)
+        {
+            Rigidbody body = hit.collider.attachedRigidbody;
+            //dont move the rigidbody if the character is on top of it
+            if (m_CollisionFlags == CollisionFlags.Below) return;
+
+            if (body == null || body.isKinematic) return;
+
+            body.AddForceAtPosition(m_CharacterController.velocity*0.1f, hit.point, ForceMode.Impulse);
+        }
+    }
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/FirstPersonController.cs.meta

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

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/MobileInput.cs

@@ -0,0 +1,120 @@
+using UnityEngine;
+
+namespace DestroyIt
+{
+    public class MobileInput : VirtualInput
+    {
+        private void AddButton(string name)
+        {
+            // we have not registered this button yet so add it, happens in the constructor
+            CrossPlatformInputManager.RegisterVirtualButton(new CrossPlatformInputManager.VirtualButton(name));
+        }
+
+        private void AddAxes(string name)
+        {
+            // we have not registered this button yet so add it, happens in the constructor
+            CrossPlatformInputManager.RegisterVirtualAxis(new CrossPlatformInputManager.VirtualAxis(name));
+        }
+
+        public override float GetAxis(string name, bool raw)
+        {
+            if (!m_VirtualAxes.ContainsKey(name))
+            {
+                AddAxes(name);
+            }
+            return m_VirtualAxes[name].GetValue;
+        }
+
+        public override void SetButtonDown(string name)
+        {
+            if (!m_VirtualButtons.ContainsKey(name))
+            {
+                AddButton(name);
+            }
+            m_VirtualButtons[name].Pressed();
+        }
+
+        public override void SetButtonUp(string name)
+        {
+            if (!m_VirtualButtons.ContainsKey(name))
+            {
+                AddButton(name);
+            }
+            m_VirtualButtons[name].Released();
+        }
+
+        public override void SetAxisPositive(string name)
+        {
+            if (!m_VirtualAxes.ContainsKey(name))
+            {
+                AddAxes(name);
+            }
+            m_VirtualAxes[name].Update(1f);
+        }
+
+        public override void SetAxisNegative(string name)
+        {
+            if (!m_VirtualAxes.ContainsKey(name))
+            {
+                AddAxes(name);
+            }
+            m_VirtualAxes[name].Update(-1f);
+        }
+
+        public override void SetAxisZero(string name)
+        {
+            if (!m_VirtualAxes.ContainsKey(name))
+            {
+                AddAxes(name);
+            }
+            m_VirtualAxes[name].Update(0f);
+        }
+
+        public override void SetAxis(string name, float value)
+        {
+            if (!m_VirtualAxes.ContainsKey(name))
+            {
+                AddAxes(name);
+            }
+            m_VirtualAxes[name].Update(value);
+        }
+
+        public override bool GetButtonDown(string name)
+        {
+            if (m_VirtualButtons.ContainsKey(name))
+            {
+                return m_VirtualButtons[name].GetButtonDown;
+            }
+
+            AddButton(name);
+            return m_VirtualButtons[name].GetButtonDown;
+        }
+
+        public override bool GetButtonUp(string name)
+        {
+            if (m_VirtualButtons.ContainsKey(name))
+            {
+                return m_VirtualButtons[name].GetButtonUp;
+            }
+
+            AddButton(name);
+            return m_VirtualButtons[name].GetButtonUp;
+        }
+
+        public override bool GetButton(string name)
+        {
+            if (m_VirtualButtons.ContainsKey(name))
+            {
+                return m_VirtualButtons[name].GetButton;
+            }
+
+            AddButton(name);
+            return m_VirtualButtons[name].GetButton;
+        }
+
+        public override Vector3 MousePosition()
+        {
+            return virtualMousePosition;
+        }
+    }
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/MobileInput.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 77cd10d817ddc0044868a6ec0e2ddb74
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/MouseLook.cs

@@ -0,0 +1,114 @@
+using System;
+using UnityEngine;
+
+namespace DestroyIt
+{
+    [Serializable]
+    public class MouseLook
+    {
+        public float XSensitivity = 2f;
+        public float YSensitivity = 2f;
+        public bool clampVerticalRotation = true;
+        public float MinimumX = -90F;
+        public float MaximumX = 90F;
+        public bool smooth;
+        public float smoothTime = 5f;
+        public bool lockCursor = true;
+
+
+        private Quaternion m_CharacterTargetRot;
+        private Quaternion m_CameraTargetRot;
+        private bool m_cursorIsLocked = true; 
+
+        public void Init(Transform character, Transform camera)
+        {
+            m_CharacterTargetRot = character.localRotation;
+            m_CameraTargetRot = camera.localRotation;
+        }
+
+
+        public void LookRotation(Transform character, Transform camera)
+        {
+            float yRot = CrossPlatformInputManager.GetAxis("Mouse X") * XSensitivity;
+            float xRot = CrossPlatformInputManager.GetAxis("Mouse Y") * YSensitivity;
+
+            m_CharacterTargetRot *= Quaternion.Euler (0f, yRot, 0f);
+            m_CameraTargetRot *= Quaternion.Euler (-xRot, 0f, 0f);
+
+            if(clampVerticalRotation)
+                m_CameraTargetRot = ClampRotationAroundXAxis (m_CameraTargetRot);
+
+            if(smooth)
+            {
+                character.localRotation = Quaternion.Slerp (character.localRotation, m_CharacterTargetRot,
+                    smoothTime * Time.deltaTime);
+                camera.localRotation = Quaternion.Slerp (camera.localRotation, m_CameraTargetRot,
+                    smoothTime * Time.deltaTime);
+            }
+            else
+            {
+                character.localRotation = m_CharacterTargetRot;
+                camera.localRotation = m_CameraTargetRot;
+            }
+
+            UpdateCursorLock();
+        }
+
+        public void SetCursorLock(bool value)
+        {
+            lockCursor = value;
+            if(!lockCursor)
+            {//we force unlock the cursor if the user disable the cursor locking helper
+                Cursor.lockState = CursorLockMode.None;
+                Cursor.visible = true;
+            }
+        }
+
+        public void UpdateCursorLock()
+        {
+            //if the user set "lockCursor" we check & properly lock the cursos
+            if (lockCursor)
+                InternalLockUpdate();
+        }
+
+        private void InternalLockUpdate()
+        {
+            if(Input.GetKeyUp(KeyCode.Escape))
+            {
+                m_cursorIsLocked = false;
+            }
+            else if(Input.GetMouseButtonUp(0))
+            {
+                m_cursorIsLocked = true;
+            }
+
+            if (m_cursorIsLocked)
+            {
+                Cursor.lockState = CursorLockMode.Locked;
+                Cursor.visible = false;
+            }
+            else if (!m_cursorIsLocked)
+            {
+                Cursor.lockState = CursorLockMode.None;
+                Cursor.visible = true;
+            }
+        }
+
+        Quaternion ClampRotationAroundXAxis(Quaternion q)
+        {
+            q.x /= q.w;
+            q.y /= q.w;
+            q.z /= q.w;
+            q.w = 1.0f;
+
+            float angleX = 2.0f * Mathf.Rad2Deg * Mathf.Atan (q.x);
+
+            angleX = Mathf.Clamp (angleX, MinimumX, MaximumX);
+
+            q.x = Mathf.Tan (0.5f * Mathf.Deg2Rad * angleX);
+
+            return q;
+        }
+
+    }
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/MouseLook.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 33a5e50bf6d3c7947b0c2f67a85b6873
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/StandaloneInput.cs

@@ -0,0 +1,64 @@
+using System;
+using UnityEngine;
+
+namespace DestroyIt
+{
+    public class StandaloneInput : VirtualInput
+    {
+        private string exceptionMsg = " This is not possible to be called for standalone input. Please check your platform and code where this is called";
+        public override float GetAxis(string name, bool raw)
+        {
+            return raw ? Input.GetAxisRaw(name) : Input.GetAxis(name);
+        }
+
+        public override bool GetButton(string name)
+        {
+            return Input.GetButton(name);
+        }
+
+        public override bool GetButtonDown(string name)
+        {
+            return Input.GetButtonDown(name);
+        }
+
+        public override bool GetButtonUp(string name)
+        {
+            return Input.GetButtonUp(name);
+        }
+
+        public override void SetButtonDown(string name)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override void SetButtonUp(string name)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override void SetAxisPositive(string name)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override void SetAxisNegative(string name)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override void SetAxisZero(string name)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override void SetAxis(string name, float value)
+        {
+            throw new Exception(exceptionMsg);
+        }
+
+        public override Vector3 MousePosition()
+        {
+            return Input.mousePosition;
+        }
+    }
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/StandaloneInput.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4f3a931e5929b2b469be65087c8bf9b9
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/VirtualInput.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DestroyIt
+{
+    public abstract class VirtualInput
+    {
+        public Vector3 virtualMousePosition { get; private set; }
+        
+        protected Dictionary<string, CrossPlatformInputManager.VirtualAxis> m_VirtualAxes =
+            new Dictionary<string, CrossPlatformInputManager.VirtualAxis>();
+            // Dictionary to store the name relating to the virtual axes
+        protected Dictionary<string, CrossPlatformInputManager.VirtualButton> m_VirtualButtons =
+            new Dictionary<string, CrossPlatformInputManager.VirtualButton>();
+        protected List<string> m_AlwaysUseVirtual = new List<string>();
+            // list of the axis and button names that have been flagged to always use a virtual axis or button
+
+        public bool AxisExists(string name)
+        {
+            return m_VirtualAxes.ContainsKey(name);
+        }
+
+        public bool ButtonExists(string name)
+        {
+            return m_VirtualButtons.ContainsKey(name);
+        }
+
+        public void RegisterVirtualAxis(CrossPlatformInputManager.VirtualAxis axis)
+        {
+            // check if we already have an axis with that name and log and error if we do
+            if (m_VirtualAxes.ContainsKey(axis.name))
+                Debug.LogError("There is already a virtual axis named " + axis.name + " registered.");
+            else
+            {
+                // add any new axes
+                m_VirtualAxes.Add(axis.name, axis);
+
+                // if we dont want to match with the input manager setting then revert to always using virtual
+                if (!axis.matchWithInputManager)
+                    m_AlwaysUseVirtual.Add(axis.name);
+            }
+        }
+
+        public void RegisterVirtualButton(CrossPlatformInputManager.VirtualButton button)
+        {
+            // check if already have a buttin with that name and log an error if we do
+            if (m_VirtualButtons.ContainsKey(button.name))
+                Debug.LogError("There is already a virtual button named " + button.name + " registered.");
+            else
+            {
+                // add any new buttons
+                m_VirtualButtons.Add(button.name, button);
+
+                // if we dont want to match to the input manager then always use a virtual axis
+                if (!button.matchWithInputManager)
+                    m_AlwaysUseVirtual.Add(button.name);
+            }
+        }
+
+        public void UnRegisterVirtualAxis(string name)
+        {
+            // if we have an axis with that name then remove it from our dictionary of registered axes
+            if (m_VirtualAxes.ContainsKey(name))
+                m_VirtualAxes.Remove(name);
+        }
+
+        public void UnRegisterVirtualButton(string name)
+        {
+            // if we have a button with this name then remove it from our dictionary of registered buttons
+            if (m_VirtualButtons.ContainsKey(name))
+                m_VirtualButtons.Remove(name);
+        }
+
+        // returns a reference to a named virtual axis if it exists otherwise null
+        public CrossPlatformInputManager.VirtualAxis VirtualAxisReference(string name)
+        {
+            return m_VirtualAxes.ContainsKey(name) ? m_VirtualAxes[name] : null;
+        }
+
+        public void SetVirtualMousePositionX(float f)
+        {
+            virtualMousePosition = new Vector3(f, virtualMousePosition.y, virtualMousePosition.z);
+        }
+
+        public void SetVirtualMousePositionY(float f)
+        {
+            virtualMousePosition = new Vector3(virtualMousePosition.x, f, virtualMousePosition.z);
+        }
+
+        public void SetVirtualMousePositionZ(float f)
+        {
+            virtualMousePosition = new Vector3(virtualMousePosition.x, virtualMousePosition.y, f);
+        }
+
+        public abstract float GetAxis(string name, bool raw);
+        public abstract bool GetButton(string name);
+        public abstract bool GetButtonDown(string name);
+        public abstract bool GetButtonUp(string name);
+        public abstract void SetButtonDown(string name);
+        public abstract void SetButtonUp(string name);
+        public abstract void SetAxisPositive(string name);
+        public abstract void SetAxisNegative(string name);
+        public abstract void SetAxisZero(string name);
+        public abstract void SetAxis(string name, float value);
+        public abstract Vector3 MousePosition();
+    }
+}

Assets/ThirdParty/DestroyIt/Demos (safe to delete)/Scripts/FirstPersonController/VirtualInput.cs.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 51db5542f58ff344383ef823fe66ae1e
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: