using System.Collections;
using System.Collections.Generic;
using UnityEngine;
#if VIU_PLUGIN
using HTC.UnityPlugin.Vive;
#endif

// Sci-Fi Ship Controller. Copyright (c) 2018-2023 SCSM Pty Ltd. All rights reserved.
namespace SciFiShipController
{
    [AddComponentMenu("Sci-Fi Ship Controller/Ship Components/Player Input Module")]
    [HelpURL("http://scsmmedia.com/ssc-documentation")]
    [RequireComponent(typeof(ShipControlModule))]
    [DisallowMultipleComponent]
    public class PlayerInputModule : MonoBehaviour
    {
        #region Enumerations

        public enum InputMode
        {
            DirectKeyboard = 0,
            LegacyUnity = 10,
            UnityInputSystem = 20,
            OculusAPI = 23,
            Rewired = 30,
            Vive = 80,
            UnityXR = 85
        }

        public enum InputAxisMode
        {
            NoInput = 0,
            SingleAxis = 10,
            CombinedAxis = 20
        }
   
        public enum OculusInputType
        {
            Button = 0,
            Axis1D = 1,
            Axis2D = 2,
            Pose = 3
        }

        public enum ViveInputType
        {
            Button = 0,
            Axis = 1,
            Pose = 2
        }

        // Vive defines each of these as enums.
        // e.g. BodyRole is an enumeration, DeviceRole is an enumeration etc.
        public enum ViveRoleType
        {
            BodyRole = 0,
            DeviceRole = 1,
            HandRole = 2,
            TrackerRole = 3
        }

        // Typically used with a Head Mounted Display (HMD) 
        public enum VRPoseRotation
        {
            RotationX = 0,
            RotationY = 1,
            RotationZ = 2
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Gets a reference to the input being set from the PlayerInputModule to the ShipControlMode
        /// </summary>
        public ShipInput GetShipInput { get { return shipInput; } }

        /// <summary>
        /// Get a reference to the ShipControlModule that this PlayerInputModule will send input data to.
        /// </summary>
        public ShipControlModule GetShipControlModule { get { return shipControlModule; } }

        /// <summary>
        /// Is the Player Input Module initialised and ready for use?
        /// </summary>
        public bool IsInitialised { get; private set; }

        /// <summary>
        /// Is the PlayerInputModule currently enabled to send input to the ship?
        /// See EnableInput() and DisableInput(..)
        /// </summary>
        public bool IsInputEnabled { get { return isInputEnabled; } }

        /// <summary>
        /// Is all input except CustomerPlayerInputs ignored?
        /// See EnableInput() and DisableInput(..)
        /// </summary>
        public bool IsCustomPlayerInputOnlyEnabled { get { return isCustomPlayerInputsOnlyEnabled; } }

        /// <summary>
        /// Is the ship currently getting movement input from the ShipAIInputModule rather than PlayerInputModule?
        /// </summary>
        public bool IsShipAIModeEnabled { get { return isShipAIModeEnabled; } }

        #endregion

        #region Public Variables and properties

        public InputMode inputMode = InputMode.DirectKeyboard;

        /// <summary>
        /// The ship will attempt to maintain the same forward speed based on the last player longitudinal input [Default: OFF]
        /// </summary>
        public bool isAutoCruiseEnabled = false;

        /// <summary>
        /// If enabled, Initialise() will be called as soon as Awake() runs. This should be disabled if you want to control
        /// when the Player Input Module is enabled through code. You can also use with EnableInput().
        /// </summary>
        public bool initialiseOnAwake = true;

        /// <summary>
        /// Is input enabled when the module is first initialised?  See also EnableInput() and DisableInput().
        /// </summary>
        public bool isEnabledOnInitialise = true;

        /// <summary>
        /// Are only the custom player inputs enabled when the module is first initialised? See also DisableInput(..).
        /// </summary>
        public bool isCustomInputsOnlyOnInitialise = false;

        /// <summary>
        /// [INTERNAL ONLY]
        /// </summary>
        public bool allowRepaint = false;

        #region Direct Keyboard Input
        public KeyCode horizontalInputPositiveKeycode = KeyCode.None;
        public KeyCode horizontalInputNegativeKeycode = KeyCode.None;
        public KeyCode verticalInputPositiveKeycode = KeyCode.None;
        public KeyCode verticalInputNegativeKeycode = KeyCode.None;
        public KeyCode longitudinalInputPositiveKeycode = KeyCode.UpArrow;
        public KeyCode longitudinalInputNegativeKeycode = KeyCode.DownArrow;
        public KeyCode pitchInputPositiveKeycode = KeyCode.W;
        public KeyCode pitchInputNegativeKeycode = KeyCode.S;
        public KeyCode yawInputPositiveKeycode = KeyCode.D;
        public KeyCode yawInputNegativeKeycode = KeyCode.A;
        public KeyCode rollInputPositiveKeycode = KeyCode.RightArrow;
        public KeyCode rollInputNegativeKeycode = KeyCode.LeftArrow;
        public KeyCode primaryFireKeycode = KeyCode.Mouse0;
        public KeyCode secondaryFireKeycode = KeyCode.Mouse1;
        public KeyCode dockingKeycode = KeyCode.None;

        public bool isMouseForPitchEnabledDKI = false;
        public bool isMouseForYawEnabledDKI = false;

        // Currently only used with Mouse
        [Range(0.1f, 1.0f)] public float pitchSensitivityDKI = 0.5f;
        [Range(0.1f, 1.0f)] public float yawSensitivityDKI = 0.5f;
        [Range(0f, 0.25f)] public float pitchDeadzoneDKI = 0.0125f;
        [Range(0f, 0.25f)] public float yawDeadzoneDKI = 0.01f;

        #endregion

        #region Common input variables
        public InputAxisMode horizontalInputAxisMode = InputAxisMode.NoInput;
        public InputAxisMode verticalInputAxisMode = InputAxisMode.NoInput;
        public InputAxisMode longitudinalInputAxisMode = InputAxisMode.SingleAxis;
        public InputAxisMode pitchInputAxisMode = InputAxisMode.SingleAxis;
        public InputAxisMode yawInputAxisMode = InputAxisMode.SingleAxis;
        public InputAxisMode rollInputAxisMode = InputAxisMode.SingleAxis;
        // Used with Occulus, Vive, Rewired, Unity Input System
        public bool primaryFireButtonEnabled = false;
        public bool secondaryFireButtonEnabled = false;
        public bool dockingButtonEnabled = false;

        /// <summary>
        /// Used for force feedback or vibration. Typically there are 2 motors on a gamepad.
        /// This value is used for the left low frequency motor when present.
        /// Call ReinitialiseRumble() after changing this value at runtime.
        /// </summary>
        [Range(0f,1f)] public float maxRumble1 = 0f;

        /// <summary>
        /// Used for force feedback or vibration. Typically there are 2 motors on a gamepad.
        /// This value is used for the right high frequency motor when present.
        /// Call ReinitialiseRumble() after changing this value at runtime.
        /// </summary>
        [Range(0f,1f)] public float maxRumble2 = 0f;

        #endregion

        #region Common input sensitivity variables
        public bool isSensitivityForHorizontalEnabled = false;
        public bool isSensitivityForVerticalEnabled = false;
        public bool isSensitivityForLongitudinalEnabled = false;
        public bool isSensitivityForPitchEnabled = false;
        public bool isSensitivityForYawEnabled = false;
        public bool isSensitivityForRollEnabled = false;
        [Range(0.01f, 10f)] public float horizontalAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float verticalAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float longitudinalAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float pitchAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float yawAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float rollAxisSensitivity = 3f;
        [Range(0.01f, 10f)] public float horizontalAxisGravity = 3f;
        [Range(0.01f, 10f)] public float verticalAxisGravity = 3f;
        [Range(0.01f, 10f)] public float longitudinalAxisGravity = 3f;
        [Range(0.01f, 10f)] public float pitchAxisGravity = 3f;
        [Range(0.01f, 10f)] public float yawAxisGravity = 3f;
        [Range(0.01f, 10f)] public float rollAxisGravity = 3f;
        #endregion

        #region Common Input Invert variables
        public bool invertHorizontalInputAxis = false;
        public bool invertVerticalInputAxis = false;
        public bool invertLongitudinalInputAxis = false;
        public bool invertPitchInputAxis = false;
        public bool invertYawInputAxis = false;
        public bool invertRollInputAxis = false;
        #endregion

        #region Common Data Discard variables (Advanced)
        /// <summary>
        /// Should we use or discard data from the horizontal axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isHorizontalDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the vertical axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isVerticalDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the longitudinal axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isLongitudinalDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the pitch axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isPitchDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the yaw axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isYawDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the roll axis?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isRollDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the primaryFire button?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isPrimaryFireDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the secondaryFire button?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isSecondaryFireDataDiscarded;
        /// <summary>
        /// Should we use or discard data from the dock button?
        /// Call ReinitialiseDiscardData() after modifying this at runtime.
        /// </summary>
        public bool isDockDataDiscarded;
        #endregion

        #region Legacy Unity Input System
        public string positiveHorizontalInputAxisName = "Horizontal";
        public string negativeHorizontalInputAxisName = "Horizontal";
        public string positiveVerticalInputAxisName = "Vertical";
        public string negativeVerticalInputAxisName = "Vertical";
        public string positiveLongitudinalInputAxisName = "Vertical";
        public string negativeLongitudinalInputAxisName = "Vertical";
        public string positivePitchInputAxisName = "Vertical";
        public string negativePitchInputAxisName = "Vertical";
        public string positiveYawInputAxisName = "Horizontal";
        public string negativeYawInputAxisName = "Horizontal";
        public string positiveRollInputAxisName = "Horizontal";
        public string negativeRollInputAxisName = "Horizontal";
        public string primaryFireInputAxisName = "Fire1";
        public string secondaryFireInputAxisName = "Fire2";
        public string dockingInputAxisName = "Dock";
        public bool isPositiveHorizontalInputAxisValid = true;
        public bool isNegativeHorizontalInputAxisValid = true;
        public bool isPositiveVerticalInputAxisValid = true;
        public bool isNegativeVerticalInputAxisValid = true;
        public bool isPositiveLongitudinalInputAxisValid = true;
        public bool isNegativeLongitudinalInputAxisValid = true;
        public bool isPositivePitchInputAxisValid = true;
        public bool isNegativePitchInputAxisValid = true;
        public bool isPositiveYawInputAxisValid = true;
        public bool isNegativeYawInputAxisValid = true;
        public bool isPositiveRollInputAxisValid = true;
        public bool isNegativeRollInputAxisValid = true;
        public bool isPrimaryFireInputAxisValid = true;
        public bool isSecondaryFireInputAxisValid = true;
        public bool isDockingInputAxisValid = true;

        public bool isMouseForPitchEnabledLIS = false;
        public bool isMouseForYawEnabledLIS = false;

        // Currently only used with Mouse
        [Range(0.1f, 1.0f)] public float pitchSensitivityLIS = 0.5f;
        [Range(0.1f, 1.0f)] public float yawSensitivityLIS = 0.5f;
        [Range(0f, 0.25f)] public float pitchDeadzoneLIS = 0.05f;
        [Range(0f, 0.25f)] public float yawDeadzoneLIS = 0.05f;
        #endregion

        #region Oculus OVR API input
        public bool isOVRInputUpdatedIfRequired = false;
        /// <summary>
        /// Oculus API Input Type 0 = Button, 1 = Axis1D, 2 = Axis2D
        /// </summary>
        public OculusInputType ovrHorizontalInputType = OculusInputType.Axis1D;
        public OculusInputType ovrVerticalInputType = OculusInputType.Axis1D;
        public OculusInputType ovrLongitudinalInputType = OculusInputType.Axis1D;
        public OculusInputType ovrPitchInputType = OculusInputType.Axis1D;
        public OculusInputType ovrYawInputType = OculusInputType.Axis1D;
        public OculusInputType ovrRollInputType = OculusInputType.Axis1D;
        // primary and secondary fire and docking will always be Button input type.
        // Store as Int so can be included when OVR is not installed (0 = None in OVRInput)
        public int positiveHorizontalInputOVR = 0;
        public int negativeHorizontalInputOVR = 0;
        public int positiveVerticalInputOVR = 0;
        public int negativeVerticalInputOVR = 0;
        public int positiveLongitudinalInputOVR = 0;
        public int negativeLongitudinalInputOVR = 0;
        public int positivePitchInputOVR = 0;
        public int negativePitchInputOVR = 0;
        public int positiveYawInputOVR = 0;
        public int negativeYawInputOVR = 0;
        public int positiveRollInputOVR = 0;
        public int negativeRollInputOVR = 0;
        public int primaryFireInputOVR = 0;
        public int secondaryFireInputOVR = 0;
        public int dockingInputOVR = 0;
        #endregion

        #region Unity Input System
        // Unity Input System stores actionId internally as string rather than System.Guid
        // We don't require positive and negative as Input System supports Composite Bindings
        public string positiveHorizontalInputActionIdUIS = "";
        public string positiveVerticalInputActionIdUIS = "";
        public string positiveLongitudinalInputActionIdUIS = "";
        public string positivePitchInputActionIdUIS = "";
        public string positiveYawInputActionIdUIS = "";
        public string positiveRollInputActionIdUIS = "";
        public string primaryFireInputActionIdUIS = "";
        public string secondaryFireInputActionIdUIS = "";
        public string dockingInputActionIdUIS = "";
        // quit is a special action that is added with Add Quit onscreen controls
        public string quitInputActionIdUIS = "QuitApp";
        // An Action can return a Control Type with or or more values.
        // e.g. bool, float, Vector2, Vector3. The SSC zero-based DataSlot indicates which value to use.
        // For composite bindings e.g. 2DVector/Dpad, the slot matches the axis.
        // Left/Right = x-axis = slot 1, Up/Down = y-axis = slot 2.
        public int positiveHorizontalInputActionDataSlotUIS = 0;
        public int positiveVerticalInputActionDataSlotUIS = 0;
        public int positiveLongitudinalInputActionDataSlotUIS = 0;
        public int positivePitchInputActionDataSlotUIS = 0;
        public int positiveYawInputActionDataSlotUIS = 0;
        public int positiveRollInputActionDataSlotUIS = 0;
        public int primaryFireInputActionDataSlotUIS = 0;
        public int secondaryFireInputActionDataSlotUIS = 0;
        public int dockingInputActionDataSlotUIS = 0;

        public bool isMouseForPitchEnabledUIS = false;
        public bool isMouseForYawEnabledUIS = false;

        // Currently only used with Mouse
        [Range(0.1f, 1.0f)] public float pitchSensitivityUIS = 0.5f;
        [Range(0.1f, 1.0f)] public float yawSensitivityUIS = 0.5f;
        [Range(0f, 0.25f)] public float pitchDeadzoneUIS = 0.05f;
        [Range(0f, 0.25f)] public float yawDeadzoneUIS = 0.05f;

        public delegate void CallbackOnQuitGame(ShipControlModule shipControlModule);

        /// <summary>
        /// The name of the custom method that is called immediately
        /// after user presses button to quit the game. Your method
        /// must take 1 parameter of class ShipControlModule.
        /// NOTE: Currently only works with Unity Input System.
        /// </summary>
        public CallbackOnQuitGame callbackOnQuitGame = null;

        #endregion

        #region Rewired Input
        public int rewiredPlayerNumber = 0; // Human player number 1+ (0 = no player assigned)
        // Action Ids are more efficient than using Action Friendly Names
        public int positiveHorizontalInputActionId = -1;
        public int negativeHorizontalInputActionId = -1;
        public int positiveVerticalInputActionId = -1;
        public int negativeVerticalInputActionId = -1;
        public int positiveLongitudinalInputActionId = -1;
        public int negativeLongitudinalInputActionId = -1;
        public int positivePitchInputActionId = -1;
        public int negativePitchInputActionId = -1;
        public int positiveYawInputActionId = -1;
        public int negativeYawInputActionId = -1;
        public int positiveRollInputActionId = -1;
        public int negativeRollInputActionId = -1;
        public int primaryFireInputActionId = -1;
        public int secondaryFireInputActionId = -1;
        public int dockingInputActionId = -1;
        #endregion

        #region VIVE Input variables
        public ViveInputType viveHorizontalInputType = ViveInputType.Axis;
        public ViveInputType viveVerticalInputType = ViveInputType.Axis;
        public ViveInputType viveLongitudinalInputType = ViveInputType.Axis;
        public ViveInputType vivePitchInputType = ViveInputType.Axis;
        public ViveInputType viveYawInputType = ViveInputType.Axis;
        public ViveInputType viveRollInputType = ViveInputType.Axis;

        // Inputs can be from a Device, Hand, Tracker or Body role
        // These are then broken down into their enum elements
        public ViveRoleType viveHorizontalRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveVerticalRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveLongitudinalRoleType = ViveRoleType.HandRole;
        public ViveRoleType vivePitchRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveYawRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveRollRoleType = ViveRoleType.HandRole;
        public ViveRoleType vivePrimaryFireRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveSecondaryFireRoleType = ViveRoleType.HandRole;
        public ViveRoleType viveDockingRoleType = ViveRoleType.HandRole;

        // Each Role Type has an associated sub-category from an Enum called
        // rolevalue, named here the RoleId as an integer so that it can be stored
        // here even if Vive Input Utility is not installed.
        public int positiveHorizontalInputRoleId = 0;
        public int negativeHorizontalInputRoleId = 0;
        public int positiveVerticalInputRoleId = 0;
        public int negativeVerticalInputRoleId = 0;
        public int positiveLongitudinalInputRoleId = 0;
        public int negativeLongitudinalInputRoleId = 0;
        public int positivePitchInputRoleId = 0;
        public int negativePitchInputRoleId = 0;
        public int positiveYawInputRoleId = 0;
        public int negativeYawInputRoleId = 0;
        public int positiveRollInputRoleId = 0;
        public int negativeRollInputRoleId = 0;
        public int primaryFireInputRoleId = 0;
        public int secondaryFireInputRoleId = 0;
        public int dockingInputRoleId = 0;

        // Store as Int so can be included when Vive is not installed (0 = None in ViveInput)
        // This is the ControllerAxis, ControllerButton, or Pose Rotation enum value.
        public int positiveHorizontalInputCtrlVive = 0;
        public int negativeHorizontalInputCtrlVive = 0;
        public int positiveVerticalInputCtrlVive = 0;
        public int negativeVerticalInputCtrlVive = 0;
        public int positiveLongitudinalInputCtrlVive = 0;
        public int negativeLongitudinalInputCtrlVive = 0;
        public int positivePitchInputCtrlVive = 0;
        public int negativePitchInputCtrlVive = 0;
        public int positiveYawInputCtrlVive = 0;
        public int negativeYawInputCtrlVive = 0;
        public int positiveRollInputCtrlVive = 0;
        public int negativeRollInputCtrlVive = 0;
        public int primaryFireInputCtrlVive = 0;
        public int secondaryFireInputCtrlVive = 0;
        public int dockingInputCtrlVive = 0;
        #endregion

        #region UnityXR

        // Unity Input System (which XR uses) stores actionMapId internally as string rather than System.Guid
        // We don't require positive and negative as Input System supports Composite Bindings
        public string positiveHorizontalInputActionMapIdXR = "";
        public string positiveVerticalInputActionMapIdXR = "";
        public string positiveLongitudinalInputActionMapIdXR = "";
        public string positivePitchInputActionMapIdXR = "";
        public string positiveYawInputActionMapIdXR = "";
        public string positiveRollInputActionMapIdXR = "";
        public string primaryFireInputActionMapIdXR = "";
        public string secondaryFireInputActionMapIdXR = "";
        public string dockingInputActionMapIdXR = "";
        #endregion UnityXR

        #region Custom Inputs
        public List<CustomPlayerInput> customPlayerInputList;
        public bool isCustomPlayerInputListExpanded;
        #endregion

        #region Editor variables
        // Whether the input sections are shown as expanded in the inspector window of the editor.
        public bool horizontalShowInEditor;
        public bool verticalShowInEditor;
        public bool longitudinalShowInEditor;
        public bool pitchShowInEditor;
        public bool yawShowInEditor;
        public bool rollShowInEditor;
        public bool primaryFireShowInEditor;
        public bool secondaryFireShowInEditor;
        public bool dockingShowInEditor;
        public bool rumbleShowInEditor;
        public bool onscreenControlsShowInEditor;
        public bool customPlayerInputsShowInEditor;
        #endregion

        // General
        public bool primaryFireCanBeHeld = true;
        public bool secondaryFireCanBeHeld = true;

        #endregion

        #region Private Variables

        private ShipControlModule shipControlModule;
        private ShipInput shipInput;
        private ShipInput lastShipInput;
        private float targetCruiseSpeed = 0f;
        private float currentSpeed = 0f;

        // Currently only used by legacy input with mouse
        private float targetDisplayOffsetX = 0f;

        // Input is enabled by default after Initialise() runs.
        private bool isInputEnabled = false;

        /// <summary>
        /// This is true when everything except CustomPlayerInputs are disabled.
        /// See DisableInput(..) and EnableInput()
        /// </summary>
        private bool isCustomPlayerInputsOnlyEnabled = false;

        private int numberOfCustomPlayerInputs = 0;

        /// <summary>
        /// Has the ship been switched to Ship AI Input Module control?
        /// </summary>
        private bool isShipAIModeEnabled = false;

        #if SSC_OVR
        // See also CheckOVRManager()
        private bool isOVRInputUpdateRequired = false;
        private bool isOVRManagerPresent = false;
        private float poseRotation = 0f;
        #endif

        #if SSC_REWIRED
        private Rewired.Player rewiredPlayer = null;

        // Local variables that get populated at runtime
        // Use int rather than enum for speed
        // 0 = Axis, 1 = Button
        // See UpdateRewiredActionTypes()
        private int positiveHorizontalInputActionType = 0;
        private int negativeHorizontalInputActionType = 0;
        private int positiveVerticalInputActionType = 0;
        private int negativeVerticalInputActionType = 0;
        private int positiveLongitudinalInputActionType = 0;
        private int negativeLongitudinalInputActionType = 0;
        private int positivePitchInputActionType = 0;
        private int negativePitchInputActionType = 0;
        private int positiveYawInputActionType = 0;
        private int negativeYawInputActionType = 0;
        private int positiveRollInputActionType = 0;
        private int negativeRollInputActionType = 0;
        private int primaryFireInputActionType = 0;
        private int secondaryFireInputActionType = 0;
        private int dockingInputActionType = 0;
        #endif

        #if SSC_UIS
        // Ref to a Player Input component that should be attached to the same gameobject
        private UnityEngine.InputSystem.PlayerInput uisPlayerInput = null;
        // Used to map positive[inputtype]InputActionIdUIS to InputAction at runtime
        // We don't require positive and negative as Input System supports Composite Bindings
        // See UpdateUnityInputSystemActions()
        private UnityEngine.InputSystem.InputAction positiveHorizontalInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction positiveVerticalInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction positiveLongitudinalInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction positivePitchInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction positiveYawInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction positiveRollInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction primaryFireInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction secondaryFireInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction quitInputActionUIS = null;
        private UnityEngine.InputSystem.InputAction dockingInputActionUIS = null;

        // InputAction Control Types can be Axis, Vector2/Dpad, Vector3 + others.
        // They are stored in inputAction.expectedControlType as a string. To avoid GC
        // in Update, convert them to a hashed int32 value.
        private int positiveHorizontalCtrlTypeHashUIS = 0;
        private int positiveVerticalCtrlTypeHashUIS = 0;
        private int positiveLongitudinalCtrlTypeHashUIS = 0;
        private int positivePitchCtrlTypeHashUIS = 0;
        private int positiveYawCtrlTypeHashUIS = 0;
        private int positiveRollCtrlTypeHashUIS = 0;
        private int primaryFireCtrlTypeHashUIS = 0;
        private int secondaryFireCtrlTypeHashUIS = 0;
        private int dockingCtrlTypeHashUIS = 0;

        private int controlTypeButtonHashUIS = 0;
        private int controlTypeAxisHashUIS = 0;
        private int controlTypeVector2HashUIS = 0;
        private int controlTypeDpadHashUIS = 0;
        private int controlTypeVector3HashUIS = 0;
        #endif

        #if VIU_PLUGIN
        // Used for mapping the enum vive[..]RoleTypes to SystemTypes at runtime
        // See UpdateViveInput(..) method.
        private System.Type viveHorizontalRoleSystemType = null;
        private System.Type viveVerticalRoleSystemType = null;
        private System.Type viveLongitudinalRoleSystemType = null;
        private System.Type vivePitchRoleSystemType = null;
        private System.Type viveYawRoleSystemType = null;
        private System.Type viveRollRoleSystemType = null;
        private System.Type vivePrimaryFireRoleSystemType = null;
        private System.Type viveSecondaryFireRoleSystemType = null;
        private System.Type viveDockingRoleSystemType = null;

        // Used for mapping positiveHorizontalInputCtrlVive integer to ControllerAxis enum at runtime
        private ControllerAxis positiveHorizontalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativeHorizontalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis positiveVerticalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativeVerticalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis positiveLongitudinalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativeLongitudinalInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis positivePitchInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativePitchInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis positiveYawInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativeYawInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis positiveRollInputCtrlAxisVive = ControllerAxis.None;
        private ControllerAxis negativeRollInputCtrlAxisVive = ControllerAxis.None;

        // Used for mapping positiveHorizontalInputCtrlVive integer to ControllerButton enum at runtime
        private ControllerButton positiveHorizontalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativeHorizontalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton positiveVerticalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativeVerticalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton positiveLongitudinalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativeLongitudinalInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton positivePitchInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativePitchInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton positiveYawInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativeYawInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton positiveRollInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton negativeRollInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton primaryFireInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton secondaryFireInputCtrlBtnVive = ControllerButton.None;
        private ControllerButton dockingInputCtrlBtnVive = ControllerButton.None;
        #endif

        #if SCSM_XR && SSC_UIS
        /// <summary>
        /// The UIS scriptable object that contains the action maps and input actions.
        /// </summary>
        [SerializeField] private UnityEngine.InputSystem.InputActionAsset inputActionAssetXR = null;

        /// <summary>
        /// The main XR first person camera which is a child of the ship controller
        /// </summary>
        [SerializeField] private Camera firstPersonCamera1XR = null;

        /// <summary>
        /// The transform of the XR first person camera 
        /// </summary>
        [SerializeField] private Transform firstPersonTransform1XR = null;

        /// <summary>
        /// The transform of the XR left hand
        /// </summary>
        [SerializeField] private Transform leftHandTransformXR = null;

        /// <summary>
        /// The transform of the XR right hand
        /// </summary>
        [SerializeField] private Transform rightHandTransformXR = null;
        #endif

        #endregion

        #region Initalisation Methods

        // Use this for initialization
        void Awake()
        {
            if (initialiseOnAwake) { Initialise(); }
        }

        #endregion

        #region Update Methods

        // Update is called once per frame
        void Update()
        {
            if (!isInputEnabled && !isCustomPlayerInputsOnlyEnabled) { return; }

            if (inputMode == InputMode.DirectKeyboard)
            {
                #region Direct Keyboard Input
                
                if (isInputEnabled)
                {
                    // Reset input axes
                    shipInput.horizontal = 0f;
                    shipInput.vertical = 0f;
                    shipInput.longitudinal = 0f;
                    shipInput.pitch = 0f;
                    shipInput.yaw = 0f;
                    shipInput.roll = 0f;
                    shipInput.dock = false;

                    #if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER

                    if (Input.GetKey(horizontalInputPositiveKeycode)) { shipInput.horizontal += 1f; }
                    if (Input.GetKey(horizontalInputNegativeKeycode)) { shipInput.horizontal -= 1f; }

                    if (Input.GetKey(verticalInputPositiveKeycode)) { shipInput.vertical += 1f; }
                    if (Input.GetKey(verticalInputNegativeKeycode)) { shipInput.vertical -= 1f; }

                    if (Input.GetKey(longitudinalInputPositiveKeycode)) { shipInput.longitudinal += 1f; }
                    if (Input.GetKey(longitudinalInputNegativeKeycode)) { shipInput.longitudinal -= 1f; }

                    if (isMouseForPitchEnabledDKI)
                    {
                        shipInput.pitch = CalculateMouseYInput(Input.mousePosition.y, pitchSensitivityDKI, pitchDeadzoneDKI);
                    }
                    else
                    {
                        if (Input.GetKey(pitchInputPositiveKeycode)) { shipInput.pitch += 1f; }
                        if (Input.GetKey(pitchInputNegativeKeycode)) { shipInput.pitch -= 1f; }
                    }

                    if (isMouseForYawEnabledDKI)
                    {
                        shipInput.yaw = CalculateMouseXInput(Input.mousePosition.x, yawSensitivityDKI, yawDeadzoneDKI);
                    }
                    else
                    {
                        if (Input.GetKey(yawInputPositiveKeycode)) { shipInput.yaw += 1f; }
                        if (Input.GetKey(yawInputNegativeKeycode)) { shipInput.yaw -= 1f; }
                    }

                    if (Input.GetKey(rollInputPositiveKeycode)) { shipInput.roll += 1f; }
                    if (Input.GetKey(rollInputNegativeKeycode)) { shipInput.roll -= 1f; }

                    if (primaryFireCanBeHeld) { shipInput.primaryFire = Input.GetKey(primaryFireKeycode); }
                    else { shipInput.primaryFire = Input.GetKeyDown(primaryFireKeycode); }

                    if (secondaryFireCanBeHeld) { shipInput.secondaryFire = Input.GetKey(secondaryFireKeycode); }
                    else { shipInput.secondaryFire = Input.GetKeyDown(secondaryFireKeycode); }

                    shipInput.dock = Input.GetKeyDown(dockingKeycode);
                    #endif
                }

                #region Custom Player Input
                #if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
                if (numberOfCustomPlayerInputs > 0)
                {
                    for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                        if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                        {
                            // CustomPlayerInput.CustomPlayerInputEventType is Key (10).
                            if (customPlayerInput.canBeHeldDown)
                            {
                                if (Input.GetKey(customPlayerInput.dkmPositiveKeycode)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f,0f,0f), 10); }
                                if (!customPlayerInput.isButton && Input.GetKey(customPlayerInput.dkmNegativeKeycode)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(-1f, 0f, 0f), 10); }
                            }
                            else
                            {
                                if (Input.GetKeyDown(customPlayerInput.dkmPositiveKeycode)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 10); }
                                if (!customPlayerInput.isButton && Input.GetKeyDown(customPlayerInput.dkmNegativeKeycode)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(-1f, 0f, 0f), 10); }
                            }
                        }
                    }
                }
                #endif
                #endregion Custom Player Input

                #endregion
            }
            else if (inputMode == InputMode.LegacyUnity)
            {
                #region Legacy Unity Input System

                #if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER

                if (isInputEnabled)
                {
                    #region Legacy Unity Input System Horizontal Input

                    // Horizontal input
                    if (horizontalInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (horizontalInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.horizontal = Input.GetAxis(positiveHorizontalInputAxisName);
                            if (invertHorizontalInputAxis) { shipInput.horizontal *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.horizontal = Input.GetAxis(positiveHorizontalInputAxisName) - Input.GetAxis(negativeHorizontalInputAxisName);
                        }
                    }
                    else { shipInput.horizontal = 0f; }

                    #endregion Legacy Unity Input System Horizontal Input

                    #region Legacy Unity Input System Vertical Input

                    // Vertical input
                    if (verticalInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (verticalInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.vertical = Input.GetAxis(positiveVerticalInputAxisName);
                            if (invertVerticalInputAxis) { shipInput.vertical *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.vertical = Input.GetAxis(positiveVerticalInputAxisName) - Input.GetAxis(negativeVerticalInputAxisName);
                        }
                    }
                    else { shipInput.vertical = 0f; }

                    #endregion Legacy Unity Input System Vertical Input

                    #region Legacy Unity Input System Longitudinal Input

                    // Longitudinal input
                    if (longitudinalInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (longitudinalInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.longitudinal = Input.GetAxis(positiveLongitudinalInputAxisName);
                            if (invertLongitudinalInputAxis) { shipInput.longitudinal *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.longitudinal = Input.GetAxis(positiveLongitudinalInputAxisName) - Input.GetAxis(negativeLongitudinalInputAxisName);
                        }
                    }
                    else { shipInput.longitudinal = 0f; }

                    #endregion Legacy Unity Input System Longitudinal Input

                    #region Legacy Unity Input System Pitch Input

                    // Pitch input
                    if (isMouseForPitchEnabledLIS)
                    {
                        shipInput.pitch = CalculateMouseYInput(Input.mousePosition.y, pitchSensitivityLIS, pitchDeadzoneLIS);
                    }
                    else if (pitchInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (pitchInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.pitch = Input.GetAxis(positivePitchInputAxisName);
                            if (invertPitchInputAxis) { shipInput.pitch *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.pitch = Input.GetAxis(positivePitchInputAxisName) - Input.GetAxis(negativePitchInputAxisName);
                        }
                    }
                    else { shipInput.pitch = 0f; }

                    #endregion Legacy Unity Input System Pitch Input

                    #region Legacy Unity Input System Yaw Input

                    // Yaw input
                    if (isMouseForYawEnabledLIS)
                    {
                        shipInput.yaw = CalculateMouseXInput(Input.mousePosition.x, yawSensitivityLIS, yawDeadzoneLIS);
                    }
                    else if (yawInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (yawInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.yaw = Input.GetAxis(positiveYawInputAxisName);
                            if (invertYawInputAxis) { shipInput.yaw *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.yaw = Input.GetAxis(positiveYawInputAxisName) - Input.GetAxis(negativeYawInputAxisName);
                        }
                    }
                    else { shipInput.yaw = 0f; }

                    #endregion Legacy Unity Input System Yaw Input

                    #region Legacy Unity Input System Roll Input

                    // Roll input
                    if (rollInputAxisMode != InputAxisMode.NoInput)
                    {
                        if (rollInputAxisMode == InputAxisMode.SingleAxis)
                        {
                            // Single axis
                            shipInput.roll = Input.GetAxis(positiveRollInputAxisName);
                            if (invertRollInputAxis) { shipInput.roll *= -1f; }
                        }
                        else
                        {
                            // Combined axis - two axes combined together for a single input
                            shipInput.roll = Input.GetAxis(positiveRollInputAxisName) - Input.GetAxis(negativeRollInputAxisName);
                        }
                    }
                    else { shipInput.roll = 0f; }

                    #endregion Legacy Unity Input System Roll Input

                    #region Legacy Unity Input System Primary Fire Input

                    if (primaryFireCanBeHeld) { shipInput.primaryFire = Input.GetButton(primaryFireInputAxisName); }
                    else { shipInput.primaryFire = Input.GetButtonDown(primaryFireInputAxisName); }

                    #endregion Legacy Unity Input System Primary Fire Input

                    #region Legacy Unity Input System Secondary Fire Input

                    if (secondaryFireCanBeHeld) { shipInput.secondaryFire = Input.GetButton(secondaryFireInputAxisName); }
                    else { shipInput.secondaryFire = Input.GetButtonDown(secondaryFireInputAxisName); }

                    #endregion Legacy Unity Input System Secondary Fire Input

                    #region Legacy Unity Input System Docking Input

                    // By default, there is no docking legacy input axis so check every time to avoid errors
                    shipInput.dock = isDockingInputAxisValid ? Input.GetButtonDown(dockingInputAxisName) : false;

                    #endregion Legacy Unity Input System Docking Input
                }

                #region Custom Player Input
                if (numberOfCustomPlayerInputs > 0)
                {
                    for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                        if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                        {
                            if (customPlayerInput.isButton)
                            {
                                // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                if (customPlayerInput.canBeHeldDown && Input.GetButton(customPlayerInput.lisPositiveAxisName)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5); }
                                else if (Input.GetButtonDown(customPlayerInput.lisPositiveAxisName)) { customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5); }
                            }
                            else if (customPlayerInput.inputAxisMode == InputAxisMode.SingleAxis)
                            {
                                Vector3 inputValue = new Vector3(Input.GetAxis(customPlayerInput.lisPositiveAxisName) * (customPlayerInput.lisInvertAxis ? -1f : 1f), 0f, 0f);
                                if (customPlayerInput.isSensitivityEnabled)
                                {
                                    inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                    customPlayerInput.lastInputValueX = inputValue.x;
                                    customPlayerInput.lastInputValueY = 0f;
                                }
                                // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 1);
                            }
                            else if (customPlayerInput.inputAxisMode == InputAxisMode.CombinedAxis)
                            {
                                // Combined axis - two axes combined together for a single input
                                Vector3 inputValue = new Vector3((Input.GetAxis(customPlayerInput.lisPositiveAxisName) - Input.GetAxis(customPlayerInput.lisNegativeAxisName)) * (customPlayerInput.lisInvertAxis ? -1f : 1f), 0f, 0f);
                                if (customPlayerInput.isSensitivityEnabled)
                                {
                                    inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                    customPlayerInput.lastInputValueX = inputValue.x;
                                    customPlayerInput.lastInputValueY = 0f;
                                }
                                // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 1);
                            }
                        }
                    }
                }
                #endregion Custom Player Input

                #else
                // Reset input axes
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.dock = false;
                #endif

                #endregion
            }
            else if (inputMode == InputMode.UnityInputSystem)
            {
                #region Unity Input System
                
                #if SSC_UIS

                // By default actions are enabled
                // InputAction needs to consider the ControlType returned.
                if (isInputEnabled)
                {
                    #region Unity Input System Horizontal Input
                    shipInput.horizontal = UISReadActionInputFloat(positiveHorizontalInputActionUIS, positiveHorizontalInputActionDataSlotUIS, positiveHorizontalCtrlTypeHashUIS);
                    if (invertHorizontalInputAxis) { shipInput.horizontal *= -1f; }
                    #endregion Unity Input System Horizontal Input

                    #region Unity Input System Vertical Input
                    shipInput.vertical = UISReadActionInputFloat(positiveVerticalInputActionUIS, positiveVerticalInputActionDataSlotUIS, positiveVerticalCtrlTypeHashUIS);
                    if (invertVerticalInputAxis) { shipInput.vertical *= -1f; }
                    #endregion Unity Input System Vertical Input

                    #region Unity Input System Longitudinal Input
                    shipInput.longitudinal = UISReadActionInputFloat(positiveLongitudinalInputActionUIS, positiveLongitudinalInputActionDataSlotUIS, positiveLongitudinalCtrlTypeHashUIS);
                    if (invertLongitudinalInputAxis) { shipInput.longitudinal *= -1f; }
                    #endregion Unity Input System Longitudinal Input

                    #region Unity Input System Pitch Input
                    if (isMouseForPitchEnabledUIS)
                    {
                        shipInput.pitch = CalculateMouseYInput(UnityEngine.InputSystem.Mouse.current.position.ReadValue().y, 
                            pitchSensitivityUIS, pitchDeadzoneUIS);
                    }
                    else
                    {
                        shipInput.pitch = UISReadActionInputFloat(positivePitchInputActionUIS, positivePitchInputActionDataSlotUIS, positivePitchCtrlTypeHashUIS);
                    }
                    if (invertPitchInputAxis) { shipInput.pitch *= -1f; }
                    #endregion Unity Input System Pitch Input

                    #region Unity Input System Yaw Input

                    if (isMouseForYawEnabledUIS)
                    {
                        shipInput.yaw = CalculateMouseXInput(UnityEngine.InputSystem.Mouse.current.position.ReadValue().x,
                            yawSensitivityUIS, yawDeadzoneUIS);
                    }
                    else
                    {
                        shipInput.yaw = UISReadActionInputFloat(positiveYawInputActionUIS, positiveYawInputActionDataSlotUIS, positiveYawCtrlTypeHashUIS);
                    }
                    if (invertYawInputAxis) { shipInput.yaw *= -1f; }
                    #endregion Unity Input System Yaw Input

                    #region Unity Input System Roll Input
                    shipInput.roll = UISReadActionInputFloat(positiveRollInputActionUIS, positiveRollInputActionDataSlotUIS, positiveRollCtrlTypeHashUIS);
                    if (invertRollInputAxis) { shipInput.roll *= -1f; }
                    #endregion Unity Input System Roll Input

                    #region Unity Input System Primary Fire Input
                    shipInput.primaryFire = UISReadActionInputBool(primaryFireInputActionUIS, primaryFireInputActionDataSlotUIS, primaryFireCtrlTypeHashUIS, primaryFireCanBeHeld);
                    #endregion  Unity Input System Primary Fire Input

                    #region Unity Input System Secondary Fire Input
                    shipInput.secondaryFire = UISReadActionInputBool(secondaryFireInputActionUIS, secondaryFireInputActionDataSlotUIS, secondaryFireCtrlTypeHashUIS, secondaryFireCanBeHeld);
                    #endregion  Unity Input System Secondary Fire Input

                    #region Unity Input System Docking Input
                    shipInput.dock = UISReadActionInputBool(dockingInputActionUIS, dockingInputActionDataSlotUIS, dockingCtrlTypeHashUIS, false);
                    #endregion

                    #region Unity Input System Quit
                    if (UISReadActionInputBool(quitInputActionUIS, 0, controlTypeButtonHashUIS, false))
                    {
                        if (callbackOnQuitGame != null) {  callbackOnQuitGame.Invoke(shipControlModule); }
                        else
                        {
                            #if UNITY_EDITOR
                            UnityEditor.EditorApplication.isPlaying = false;
                            #else
                            Application.Quit();
                            #endif
                        }
                    }
                    #endregion
                }

                #region Custom Player Input
                if (numberOfCustomPlayerInputs > 0)
                {
                    for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                        if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                        {
                            if (customPlayerInput.isButton)
                            {
                                if (UISReadActionInputBool(customPlayerInput.uisPositiveInputAction, customPlayerInput.uisPositiveInputActionDataSlot, customPlayerInput.uisPositiveCtrlTypeHash, customPlayerInput.canBeHeldDown))
                                {
                                    // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                    customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                }
                            }
                            else
                            {
                                Vector3 inputValue = Vector3.zero;

                                if (customPlayerInput.uisPositiveInputAction != null)
                                {
                                    if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeAxisHashUIS || customPlayerInput.uisPositiveCtrlTypeHash == controlTypeButtonHashUIS)
                                    {
                                        // 1D axis and Buttons both retrun a float
                                        inputValue.x = customPlayerInput.uisPositiveInputAction.ReadValue<float>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 1);
                                    }
                                    else if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeVector2HashUIS || customPlayerInput.uisPositiveCtrlTypeHash == controlTypeDpadHashUIS)
                                    {
                                        inputValue = customPlayerInput.uisPositiveInputAction.ReadValue<Vector2>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            inputValue.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValue.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        customPlayerInput.lastInputValueY = inputValue.y;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis2D (2).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 2);
                                    }
                                    else if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeVector3HashUIS)
                                    {
                                        inputValue = customPlayerInput.uisPositiveInputAction.ReadValue<Vector3>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            // Currently only works on x,y axes
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            inputValue.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValue.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        customPlayerInput.lastInputValueY = inputValue.y;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis3D (3).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 3);
                                    }
                                }
                            }
                        }
                    }
                }
                #endregion Custom Player Input

                #else
                // Do nothing if Unity Input System is set but not installed in the project
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;
                #endif

                #endregion
            }
            else if (inputMode == InputMode.OculusAPI)
            {
                #region Oculus API
                #if SSC_OVR
                
                // NOTE:
                // Assumes input is from first active controller
                // We may need to allow this to be configurable

                try
                {
                    if (isOVRInputUpdateRequired) { OVRInput.Update(); }

                    if (isInputEnabled)
                    {
                        #region Oculus Horizontal Input
                        if (horizontalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (horizontalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrHorizontalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.horizontal = OVRInput.Get((OVRInput.Axis1D)positiveHorizontalInputOVR);
                                }
                                else if (ovrHorizontalInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +X is left, -X is right. + Y is push forward, -Y is pull back
                                    shipInput.horizontal = OVRInput.Get((OVRInput.Axis2D)positiveHorizontalInputOVR).x;
                                }
                                else if (ovrHorizontalInputType == OculusInputType.Button)
                                {
                                    shipInput.horizontal = OVRInput.Get((OVRInput.Button)positiveHorizontalInputOVR) ? 1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveHorizontalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveHorizontalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveHorizontalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.horizontal = poseRotation / 360f;
                                }
                                else { shipInput.horizontal = 0f; }
                            }
                            else
                            {
                                if (ovrHorizontalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.horizontal = OVRInput.Get((OVRInput.Axis1D)positiveHorizontalInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativeHorizontalInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrHorizontalInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.horizontal = OVRInput.Get((OVRInput.Axis2D)positiveHorizontalInputOVR).x - OVRInput.Get((OVRInput.Axis2D)negativeHorizontalInputOVR).x;
                                }
                                else if (ovrHorizontalInputType == OculusInputType.Button)
                                {
                                    shipInput.horizontal = (OVRInput.Get((OVRInput.Button)positiveHorizontalInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativeHorizontalInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveHorizontalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveHorizontalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveHorizontalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.horizontal = poseRotation / 360f;
                                }
                                else { shipInput.horizontal = 0f; }
                            }
                        }
                        else { shipInput.horizontal = 0f; }
                        #endregion Oculus Horizontal Input

                        #region Oculus Vertical Input
                        if (verticalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (verticalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrVerticalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.vertical = OVRInput.Get((OVRInput.Axis1D)positiveVerticalInputOVR);
                                }
                                else if (ovrVerticalInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +Y is push forward, -Y is pull back
                                    shipInput.vertical = OVRInput.Get((OVRInput.Axis2D)positiveVerticalInputOVR).y;
                                }
                                else if (ovrVerticalInputType == OculusInputType.Button)
                                {
                                    shipInput.vertical = OVRInput.Get((OVRInput.Button)positiveVerticalInputOVR) ? 1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveVerticalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveVerticalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveVerticalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.vertical = poseRotation / 360f;
                                }
                                else { shipInput.vertical = 0f; }
                            }
                            else
                            {
                                if (ovrVerticalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.vertical = OVRInput.Get((OVRInput.Axis1D)positiveVerticalInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativeVerticalInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrVerticalInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.vertical = OVRInput.Get((OVRInput.Axis2D)positiveVerticalInputOVR).y - OVRInput.Get((OVRInput.Axis2D)negativeVerticalInputOVR).y;
                                }
                                else if (ovrVerticalInputType == OculusInputType.Button)
                                {
                                    shipInput.vertical = (OVRInput.Get((OVRInput.Button)positiveVerticalInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativeVerticalInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveVerticalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveVerticalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveVerticalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.vertical = poseRotation / 360f;
                                }
                                else { shipInput.vertical = 0f; }
                            }
                        }
                        else { shipInput.vertical = 0f; }
                        #endregion Oculus Vertical Input

                        #region Oculus Longitudinal Input
                        if (longitudinalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (longitudinalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrLongitudinalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.longitudinal = OVRInput.Get((OVRInput.Axis1D)positiveLongitudinalInputOVR);
                                }
                                else if (ovrLongitudinalInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +Y is push forward, -Y is pull back
                                    shipInput.longitudinal = OVRInput.Get((OVRInput.Axis2D)positiveLongitudinalInputOVR).y;
                                }
                                else if (ovrLongitudinalInputType == OculusInputType.Button)
                                {
                                    shipInput.longitudinal = OVRInput.Get((OVRInput.Button)positiveLongitudinalInputOVR) ? 1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveLongitudinalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveLongitudinalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveLongitudinalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.longitudinal = poseRotation / 360f;
                                }
                                else { shipInput.longitudinal = 0f; }
                            }
                            else
                            {
                                if (ovrLongitudinalInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.longitudinal = OVRInput.Get((OVRInput.Axis1D)positiveLongitudinalInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativeLongitudinalInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrLongitudinalInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.longitudinal = OVRInput.Get((OVRInput.Axis2D)positiveLongitudinalInputOVR).y - OVRInput.Get((OVRInput.Axis2D)negativeLongitudinalInputOVR).y;
                                }
                                else if (ovrLongitudinalInputType == OculusInputType.Button)
                                {
                                    shipInput.longitudinal = (OVRInput.Get((OVRInput.Button)positiveLongitudinalInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativeLongitudinalInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveLongitudinalInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveLongitudinalInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveLongitudinalInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.longitudinal = poseRotation / 360f;
                                }
                                else { shipInput.longitudinal = 0f; }
                            }
                        }
                        else { shipInput.longitudinal = 0f; }
                        #endregion Oculus Longitudinal Input

                        #region Oculus Pitch Input
                        if (pitchInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (pitchInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrPitchInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.pitch = OVRInput.Get((OVRInput.Axis1D)positivePitchInputOVR);
                                }
                                else if (ovrPitchInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +Y is push forward, -Y is pull back
                                    shipInput.pitch = OVRInput.Get((OVRInput.Axis2D)positivePitchInputOVR).y;
                                }
                                else if (ovrPitchInputType == OculusInputType.Button)
                                {
                                    shipInput.pitch = OVRInput.Get((OVRInput.Button)positivePitchInputOVR) ? 1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positivePitchInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positivePitchInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positivePitchInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.pitch = poseRotation / 360f;
                                }
                                else { shipInput.pitch = 0f; }
                            }
                            else
                            {
                                if (ovrPitchInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.pitch = OVRInput.Get((OVRInput.Axis1D)positivePitchInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativePitchInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrPitchInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.pitch = OVRInput.Get((OVRInput.Axis2D)positivePitchInputOVR).y - OVRInput.Get((OVRInput.Axis2D)negativePitchInputOVR).y;
                                }
                                else if (ovrPitchInputType == OculusInputType.Button)
                                {
                                    shipInput.pitch = (OVRInput.Get((OVRInput.Button)positivePitchInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativePitchInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positivePitchInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positivePitchInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positivePitchInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.pitch = poseRotation / 360f;
                                }
                                else { shipInput.pitch = 0f; }
                            }
                        }
                        else { shipInput.pitch = 0f; }
                        #endregion Oculus Pitch Input

                        #region Oculus Yaw Input
                        if (yawInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (yawInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrYawInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.yaw = OVRInput.Get((OVRInput.Axis1D)positiveYawInputOVR);
                                }
                                else if (ovrYawInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +X is left, -X is right. + Y is push forward, -Y is pull back
                                    shipInput.yaw = OVRInput.Get((OVRInput.Axis2D)positiveYawInputOVR).x;
                                }
                                else if (ovrYawInputType == OculusInputType.Button)
                                {
                                    shipInput.yaw = OVRInput.Get((OVRInput.Button)positiveYawInputOVR) ? 1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveYawInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveYawInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveYawInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.yaw = poseRotation / 360f;
                                }
                                else { shipInput.yaw = 0f; }
                            }
                            else
                            {
                                if (ovrYawInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.yaw = OVRInput.Get((OVRInput.Axis1D)positiveYawInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativeYawInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrYawInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.yaw = OVRInput.Get((OVRInput.Axis2D)positiveYawInputOVR).x - OVRInput.Get((OVRInput.Axis2D)negativeYawInputOVR).x;
                                }
                                else if (ovrYawInputType == OculusInputType.Button)
                                {
                                    shipInput.yaw = (OVRInput.Get((OVRInput.Button)positiveYawInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativeYawInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveYawInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveYawInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveYawInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.yaw = poseRotation / 360f;
                                }
                                else { shipInput.yaw = 0f; }
                            }
                        }
                        else { shipInput.yaw = 0f; }
                        #endregion Oculus Yaw Input

                        #region Oculus Roll Input
                        if (rollInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (rollInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (ovrRollInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.roll = OVRInput.Get((OVRInput.Axis1D)positiveRollInputOVR);
                                }
                                else if (ovrRollInputType == OculusInputType.Axis2D)
                                {
                                    // Axis2D is like a joystick. +X is left, -X is right. + Y is push forward, -Y is pull back
                                    shipInput.roll = OVRInput.Get((OVRInput.Axis2D)positiveRollInputOVR).x;
                                }
                                else if (ovrRollInputType == OculusInputType.Button)
                                {
                                    shipInput.roll = OVRInput.Get((OVRInput.Button)positiveRollInputOVR) ?  1f : 0f;
                                }
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveRollInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveRollInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveRollInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.roll = poseRotation / 360f;
                                }
                                else { shipInput.roll = 0f; }
                            }
                            else
                            {
                                if (ovrRollInputType == OculusInputType.Axis1D)
                                {
                                    shipInput.roll = OVRInput.Get((OVRInput.Axis1D)positiveRollInputOVR) - OVRInput.Get((OVRInput.Axis1D)negativeRollInputOVR);
                                }
                                // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                else if (ovrRollInputType == OculusInputType.Axis2D)
                                {
                                    shipInput.roll = OVRInput.Get((OVRInput.Axis2D)positiveRollInputOVR).x - OVRInput.Get((OVRInput.Axis2D)negativeRollInputOVR).x;
                                }
                                else if (ovrRollInputType == OculusInputType.Button)
                                {
                                    shipInput.roll = (OVRInput.Get((OVRInput.Button)positiveRollInputOVR) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)negativeRollInputOVR) ? 1f : 0f);
                                }
                                // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                {
                                    // positiveRollInputOVR 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                    if (positiveRollInputOVR == 0)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                    }
                                    else if (positiveRollInputOVR == 1)
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                    }
                                    else
                                    {
                                        poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                    }

                                    // Convert to a value between -1 and 1
                                    if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                    else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                    shipInput.roll = poseRotation / 360f;
                                }
                                else { shipInput.roll = 0f; }
                            }
                        }
                        else { shipInput.roll = 0f; }
                        #endregion Oculus Roll Input

                        #region Oculus Primary Fire Input
                        // There is no need to check if it is enabled, because by default it is 0 and the PlayerInputModuleEditor
                        // ensures it is 0 when not enabled. Also, it is possible to be enabled but set the input to None (0)
                        if (primaryFireInputOVR > 0)
                        {
                            if (primaryFireCanBeHeld) { shipInput.primaryFire = OVRInput.Get((OVRInput.Button)primaryFireInputOVR); }
                            else { shipInput.primaryFire = OVRInput.GetDown((OVRInput.Button)primaryFireInputOVR); }
                        }
                        else { shipInput.primaryFire = false; }

                        #endregion Oculus Primary Fire Input

                        #region Oculus Secondary Fire Input
                        // There is no need to check if it is enabled, because by default it is 0 and the PlayerInputModuleEditor
                        // ensures it is 0 when not enabled. Also, it is possible to be enabled but set the input to None (0)
                        if (secondaryFireInputOVR > 0)
                        {
                            if (primaryFireCanBeHeld) { shipInput.secondaryFire = OVRInput.Get((OVRInput.Button)secondaryFireInputOVR); }
                            else { shipInput.secondaryFire = OVRInput.GetDown((OVRInput.Button)secondaryFireInputOVR); }
                        }
                        else { shipInput.secondaryFire = false; }
                        #endregion Oculus Secondary Fire Input

                        #region Oculus Docking Input
                        // There is no need to check if it is enabled, because by default it is 0 and the PlayerInputModuleEditor
                        // ensures it is 0 when not enabled. Also, it is possible to be enabled but set the input to None (0)
                        if (dockingInputOVR > 0)
                        {
                            shipInput.dock = OVRInput.GetDown((OVRInput.Button)dockingInputOVR);
                        }
                        else { shipInput.dock = false; }
                        #endregion Oculus Docking Input
                    }

                    #region Custom Player Input
                    if (numberOfCustomPlayerInputs > 0)
                    {
                        for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                        {
                            CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                            if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                            {
                                if (customPlayerInput.isButton)
                                {
                                    // Is the button configured?
                                    if (customPlayerInput.ovrPositiveInput > 0)
                                    {
                                        if (customPlayerInput.canBeHeldDown)
                                        {
                                            // If the button is down, send a valve in Vector3.x of 1f.
                                            if (OVRInput.Get((OVRInput.Button)customPlayerInput.ovrPositiveInput))
                                            {
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                            }
                                        }
                                        else if(OVRInput.GetDown((OVRInput.Button)customPlayerInput.ovrPositiveInput))
                                        {
                                            // If the button is pressed this frame, send a value in Vector3.x of 1f.
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                        }
                                    }
                                }
                                else if (customPlayerInput.inputAxisMode != InputAxisMode.NoInput)
                                {
                                    if (customPlayerInput.inputAxisMode == InputAxisMode.SingleAxis)
                                    {
                                        if (customPlayerInput.ovrInputType == OculusInputType.Axis1D)
                                        {
                                            float inputValueF = OVRInput.Get((OVRInput.Axis1D)customPlayerInput.ovrPositiveInput);

                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueF;

                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                        }
                                        else if (customPlayerInput.ovrInputType == OculusInputType.Axis2D)
                                        {
                                            // Axis2D is like a joystick. +X is left, -X is right. + Y is push forward, -Y is pull back
                                            Vector2 inputValueV2 = OVRInput.Get((OVRInput.Axis2D)customPlayerInput.ovrPositiveInput);

                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueV2.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueV2.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                                inputValueV2.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValueV2.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueV2.x;
                                            customPlayerInput.lastInputValueY = inputValueV2.y;

                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueV2.x, inputValueV2.y, 0f), 2);
                                        }
                                        else if (customPlayerInput.ovrInputType == OculusInputType.Button)
                                        {
                                            if (OVRInput.Get((OVRInput.Button)customPlayerInput.ovrPositiveInput))
                                            {
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                            }
                                        }
                                        else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                        {
                                            // ovrPositiveInput 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                            if (customPlayerInput.ovrPositiveInput == 0)
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                            }
                                            else if (customPlayerInput.ovrPositiveInput == 1)
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                            }
                                            else
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                            }

                                            // Convert to a value between -1 and 1
                                            if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                            else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }

                                            // We "may" want to pass this as the raw rotation angle..
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(poseRotation / 360f, 0f, 0f), 1);
                                        }
                                    }
                                    // Combined Axes
                                    else
                                    {
                                        if (customPlayerInput.ovrInputType == OculusInputType.Axis1D)
                                        {
                                            float inputValueF = OVRInput.Get((OVRInput.Axis1D)customPlayerInput.ovrPositiveInput) - OVRInput.Get((OVRInput.Axis1D)customPlayerInput.ovrNegativeInput);

                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueF;

                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                        }
                                        // Axis2D joystick probably doesn't make much sense with CombinedAxis
                                        else if (customPlayerInput.ovrInputType == OculusInputType.Axis2D)
                                        {
                                            Vector2 inputValueV2 = OVRInput.Get((OVRInput.Axis2D)customPlayerInput.ovrPositiveInput) - OVRInput.Get((OVRInput.Axis2D)customPlayerInput.ovrNegativeInput);

                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueV2.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueV2.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                                inputValueV2.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValueV2.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueV2.x;
                                            customPlayerInput.lastInputValueY = inputValueV2.y;

                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueV2.x, inputValueV2.y, 0f), 2);
                                        }
                                        else if (customPlayerInput.ovrInputType == OculusInputType.Button)
                                        {
                                            float inputValueF = (OVRInput.Get((OVRInput.Button)customPlayerInput.ovrPositiveInput) ? 1f : 0f) - (OVRInput.Get((OVRInput.Button)customPlayerInput.ovrNegativeInput) ? 1f : 0f);

                                            if (inputValueF != 0f)
                                            {
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 5);
                                            }
                                        }
                                        // Combined Axis with Pose works EXACTLY the same way as Single Axis and cannot be selected in the PlayerInputModuleEditor
                                        else if (isOVRManagerPresent) // Pose which requires the OVRManager in the scene
                                        {
                                            // ovrPositiveInput 0 = RotationX, 1 = RotationY, 2 = RotationZ
                                            if (customPlayerInput.ovrPositiveInput == 0)
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.x;
                                            }
                                            else if (customPlayerInput.ovrPositiveInput == 1)
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.y;
                                            }
                                            else
                                            {
                                                poseRotation = OVRManager.instance.headPoseRelativeOffsetRotation.z;
                                            }

                                            // Convert to a value between -1 and 1
                                            if (poseRotation > 0) { while (poseRotation > 359.999f) { poseRotation -= 360f; } }
                                            else if (poseRotation < 0) { while (poseRotation < -359.999f) { poseRotation += 360f; } }
                                            
                                            // We "may" want to pass this as the raw rotation angle..
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(poseRotation / 360f, 0f, 0f), 1);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion Custom Player Input
                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("PlayerInputModule Oculus API " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }

                #else                
                // Do nothing if Oculus is set but not installed
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;
                #endif
                #endregion
            }
            else if (inputMode == InputMode.Rewired)
            {
                #region Rewired Input
                #if SSC_REWIRED
                
                if (rewiredPlayer != null)
                {
                    // GetAxis is safe to call with an invalid ActionId
                    // Rewired ignores -ve values and gracefully handles missing actions
                    // by raising a single warning, rather than outputting a zillion msgs.
            
                    if (isInputEnabled)
                    {
                        #region Rewired Horizontal Input
                        if (horizontalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (horizontalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.horizontal = positiveHorizontalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveHorizontalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveHorizontalInputActionId);
                            }
                            else
                            {
                                shipInput.horizontal = (positiveHorizontalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveHorizontalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveHorizontalInputActionId)) -
                                                       (negativeHorizontalInputActionType == 1 ? (rewiredPlayer.GetButton(negativeHorizontalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativeHorizontalInputActionId));
                            }
                        }
                        else { shipInput.horizontal = 0f; }
                        #endregion Rewired Horizontal Input

                        #region Rewired Vertical Input
                        if (verticalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (verticalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.vertical = positiveVerticalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveVerticalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveVerticalInputActionId);
                            }
                            else
                            {
                                shipInput.vertical = (positiveVerticalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveVerticalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveVerticalInputActionId)) -
                                                     (negativeVerticalInputActionType == 1 ? (rewiredPlayer.GetButton(negativeVerticalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativeVerticalInputActionId));
                            }
                        }
                        else { shipInput.vertical = 0f; }
                        #endregion Rewired Vertical Input

                        #region Rewired Longitudinal Input
                        if (longitudinalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (longitudinalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.longitudinal = positiveLongitudinalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveLongitudinalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveLongitudinalInputActionId);
                            }
                            else
                            {
                                shipInput.longitudinal = (positiveLongitudinalInputActionType == 1 ? (rewiredPlayer.GetButton(positiveLongitudinalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveLongitudinalInputActionId)) -
                                                         (negativeLongitudinalInputActionType == 1 ? (rewiredPlayer.GetButton(negativeLongitudinalInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativeLongitudinalInputActionId));
                            }
                        }
                        else { shipInput.longitudinal = 0f; }
                        #endregion Rewired Longitudinal Input

                        #region Rewired Pitch Input
                        if (pitchInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (pitchInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.pitch = positivePitchInputActionType == 1 ? (rewiredPlayer.GetButton(positivePitchInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positivePitchInputActionId);
                            }
                            else
                            {
                                shipInput.pitch = (positivePitchInputActionType == 1 ? (rewiredPlayer.GetButton(positivePitchInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positivePitchInputActionId)) -
                                                  (negativePitchInputActionType == 1 ? (rewiredPlayer.GetButton(negativePitchInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativePitchInputActionId));
                            }
                        }
                        else { shipInput.pitch = 0f; }
                        #endregion Rewired Pitch Input

                        #region Rewired Yaw Input
                        if (yawInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (yawInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.yaw = positiveYawInputActionType == 1 ? (rewiredPlayer.GetButton(positiveYawInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveYawInputActionId);
                            }
                            else
                            {
                                shipInput.yaw = (positiveYawInputActionType == 1 ? (rewiredPlayer.GetButton(positiveYawInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveYawInputActionId)) -
                                                (negativeYawInputActionType == 1 ? (rewiredPlayer.GetButton(negativeYawInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativeYawInputActionId));
                            }
                        }
                        else { shipInput.yaw = 0f; }
                        #endregion Rewired Yaw Input

                        #region Rewired Roll Input
                        if (rollInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (rollInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                shipInput.roll = positiveRollInputActionType == 1 ? (rewiredPlayer.GetButton(positiveRollInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveRollInputActionId);
                            }
                            else
                            {
                                shipInput.roll = (positiveRollInputActionType == 1 ? (rewiredPlayer.GetButton(positiveRollInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(positiveRollInputActionId)) -
                                                 (negativeRollInputActionType == 1 ? (rewiredPlayer.GetButton(negativeRollInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(negativeRollInputActionId));
                            }
                        }
                        else { shipInput.roll = 0f; }
                        #endregion Rewired Roll Input

                        #region Rewired Primary Fire Input
                        // There is no need to check if it is enabled, because by default it is -1 and the PlayerInputModuleEditor
                        // ensures it is -1 when not enabled. Also, it is possible to be enabled but not yet set to +ve ActionId
                        if (primaryFireInputActionId >= 0)
                        {
                            if (primaryFireCanBeHeld)
                            {
                                shipInput.primaryFire = primaryFireInputActionType == 1 ? rewiredPlayer.GetButton(primaryFireInputActionId) : rewiredPlayer.GetAxis(primaryFireInputActionId) > 0.01f;
                            }
                            else
                            {
                                shipInput.primaryFire = primaryFireInputActionType == 1 ? rewiredPlayer.GetButtonDown(primaryFireInputActionId) : !shipInput.primaryFire && rewiredPlayer.GetAxis(primaryFireInputActionId) > 0.01f;
                            }
                        }
                        else { shipInput.primaryFire = false; }

                        #endregion Rewired Primary Fire Input

                        #region Rewired Secondary Fire Input

                        // There is no need to check if it is enabled, because by default it is -1 and the PlayerInputModuleEditor
                        // ensures it is -1 when not enabled. Also, it is possible to be enabled but not yet set to +ve ActionId
                        if (secondaryFireInputActionId >= 0)
                        {
                            if (secondaryFireCanBeHeld)
                            {
                                shipInput.secondaryFire = secondaryFireInputActionType == 1 ? rewiredPlayer.GetButton(secondaryFireInputActionId) : rewiredPlayer.GetAxis(secondaryFireInputActionId) > 0.01f;
                            }
                            else
                            {
                                shipInput.secondaryFire = secondaryFireInputActionType == 1 ? rewiredPlayer.GetButtonDown(secondaryFireInputActionId) : !shipInput.secondaryFire && rewiredPlayer.GetAxis(secondaryFireInputActionId) > 0.01f;
                            }
                        }
                        else { shipInput.secondaryFire = false; }

                        #endregion Rewired Secondary Fire Input

                        #region Rewired Docking Input

                        // There is no need to check if it is enabled, because by default it is -1 and the PlayerInputModuleEditor
                        // ensures it is -1 when not enabled. Also, it is possible to be enabled but not yet set to +ve ActionId
                        if (dockingInputActionId >= 0)
                        {
                            shipInput.dock = dockingInputActionType == 1 ? rewiredPlayer.GetButtonDown(dockingInputActionId) : !shipInput.dock && rewiredPlayer.GetAxis(dockingInputActionId) > 0.01f;
                        }
                        else { shipInput.dock = false; }
                        #endregion Rewired Docking Input
                    }

                    #region Custom Player Input
                    if (numberOfCustomPlayerInputs > 0)
                    {
                        for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                        {
                            CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                            if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                            {
                                if (customPlayerInput.isButton)
                                {
                                    if (customPlayerInput.rwdPositiveInputActionId >= 0)
                                    {
                                        if (customPlayerInput.canBeHeldDown)
                                        {
                                            customPlayerInput.rwLastIsButtonPressed = customPlayerInput.rwdPositiveInputActionType == 1 ? rewiredPlayer.GetButton(customPlayerInput.rwdPositiveInputActionId) : rewiredPlayer.GetAxis(customPlayerInput.rwdPositiveInputActionId) > 0.01f;
                                        }
                                        else
                                        {
                                            customPlayerInput.rwLastIsButtonPressed = customPlayerInput.rwdPositiveInputActionType == 1 ? rewiredPlayer.GetButtonDown(customPlayerInput.rwdPositiveInputActionId) : !customPlayerInput.rwLastIsButtonPressed && rewiredPlayer.GetAxis(customPlayerInput.rwdPositiveInputActionId) > 0.01f;
                                        }

                                        if (customPlayerInput.rwLastIsButtonPressed)
                                        {
                                            // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                        }
                                    }
                                }
                                else if (customPlayerInput.inputAxisMode != InputAxisMode.NoInput)
                                {
                                    if (customPlayerInput.inputAxisMode == InputAxisMode.SingleAxis)
                                    {
                                        float inputValueF = customPlayerInput.rwdPositiveInputActionType == 1 ? (rewiredPlayer.GetButton(customPlayerInput.rwdPositiveInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(customPlayerInput.rwdPositiveInputActionId);
                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValueF;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                        customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                    }
                                    else // Combined
                                    {
                                        float inputValueF = (customPlayerInput.rwdPositiveInputActionType == 1 ? (rewiredPlayer.GetButton(customPlayerInput.rwdPositiveInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(customPlayerInput.rwdPositiveInputActionId)) -
                                                            (customPlayerInput.rwdNegativeInputActionType == 1 ? (rewiredPlayer.GetButton(customPlayerInput.rwdNegativeInputActionId) ? 1f : 0f) : rewiredPlayer.GetAxis(customPlayerInput.rwdNegativeInputActionId));
                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValueF;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                        customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                    }
                                }
                            }
                        }
                    }
                    #endregion Custom Player Input
                }
                else
                {
                    // Do nothing
                    shipInput.horizontal = 0f;
                    shipInput.vertical = 0f;
                    shipInput.longitudinal = 0f;
                    shipInput.pitch = 0f;
                    shipInput.yaw = 0f;
                    shipInput.roll = 0f;
                    shipInput.primaryFire = false;
                    shipInput.secondaryFire = false;
                    shipInput.dock = false;
                }
                #else
                // Do nothing if rewired is set but not installed in the project
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;
                #endif
                #endregion Rewired Input
            }
            else if (inputMode == InputMode.Vive)
            {
                #region Vive Input
                
                #if VIU_PLUGIN

                // If viveHorizontalRoleSystemType etc is null, in the Unity Editor at runtime the following error will be raised:
                // PlayerInputModule VIVE Argument cannot be null.
                // The viveHorizontalRoleType enum in this class is converted into a System.Type at runtime by calling UpdateViveInput(..).
                // Axis or Button integers are converted to ControllerAxis or ControllerButton in UpdateViveInput(..) to avoid conversion overhead
                // in this event.

                // Head Mounted Device (HMD), VivePose.GetPoseEx(..) returns rot (rotation) property. viveRigidPose.rot.eulerAngles.x returns
                // the Unity -ve Y-axis where down is +ve and up is -ve starting at 359.99.. and decreasing in the up direction.
                // GetPoseEx seems to return X values 0-90 deg (down) and 359.9-270 (up). We convert these into Y 0.0 to 1.0 (down) and 0.0 to -1.0 (up).
                // GetPoseEx returns Y 0-360 deg. We convert them to X-axis in Unity. 0-179.99.. (right) becomes 0.0 to 1.0 (right). 180-359.99.. (left) becomes -1.0 to 0.0

                try
                {
                    if (isInputEnabled)
                    {
                        #region Vive Horizontal Input
                        if (horizontalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (horizontalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (viveHorizontalInputType == ViveInputType.Axis)
                                {
                                    shipInput.horizontal = ViveInput.GetAxisEx(viveHorizontalRoleSystemType, positiveHorizontalInputRoleId, positiveHorizontalInputCtrlAxisVive);
                                }
                                else if (viveHorizontalInputType == ViveInputType.Button)
                                {
                                    shipInput.horizontal = ViveInput.GetPressEx(viveHorizontalRoleSystemType, positiveHorizontalInputRoleId, positiveHorizontalInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveHorizontalRoleSystemType, positiveHorizontalInputRoleId);
                                    // positiveHorizontalInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveHorizontalInputCtrlVive == 0)
                                    {
                                        float horizontalX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.horizontal = horizontalX < 180f ? horizontalX / -180f : (horizontalX - 180f) / 180f;
                                    }
                                    else if (positiveHorizontalInputCtrlVive == 1)
                                    {
                                        float horizontalY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.horizontal = horizontalY <= 90f ? horizontalY / -90f : (360f - horizontalY) / 90f;
                                    }
                                    else
                                    {
                                        float horizontalZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.horizontal = horizontalZ < 180f ? horizontalZ / 180f : (horizontalZ - 180f) / -180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (viveHorizontalInputType == ViveInputType.Axis)
                                {
                                    shipInput.horizontal = ViveInput.GetAxisEx(viveHorizontalRoleSystemType, positiveHorizontalInputRoleId, positiveHorizontalInputCtrlAxisVive) - ViveInput.GetAxisEx(viveHorizontalRoleSystemType, negativeHorizontalInputRoleId, negativeHorizontalInputCtrlAxisVive);
                                }
                                else if (viveHorizontalInputType == ViveInputType.Button)
                                {
                                    shipInput.horizontal = (ViveInput.GetPressEx(viveHorizontalRoleSystemType, positiveHorizontalInputRoleId, positiveHorizontalInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(viveHorizontalRoleSystemType, negativeHorizontalInputRoleId, negativeHorizontalInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - currently only supports single-axis
                                {

                                }
                            }
                        }
                        else { shipInput.horizontal = 0f; }
                        #endregion  Vive Horizontal Input

                        #region Vive Vertical Input
                        if (verticalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (verticalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (viveVerticalInputType == ViveInputType.Axis)
                                {
                                    shipInput.vertical = ViveInput.GetAxisEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId, positiveVerticalInputCtrlAxisVive);
                                }
                                else if (viveVerticalInputType == ViveInputType.Button)
                                {
                                    shipInput.vertical = ViveInput.GetPressEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId, positiveVerticalInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId);
                                    // positiveVerticalInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveVerticalInputCtrlVive == 0)
                                    {
                                        float verticalX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.vertical = verticalX < 180f ? verticalX / 180f : (verticalX - 180f) / -180f;
                                    }
                                    else if (positiveVerticalInputCtrlVive == 1)
                                    {
                                        float verticalY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.vertical = verticalY <= 90f ? verticalY / 90f : (360f - verticalY) / -90f;
                                    }
                                    else
                                    {
                                        float verticalZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.vertical = verticalZ < 180f ? verticalZ / 180f : (verticalZ - 180f) / -180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (viveVerticalInputType == ViveInputType.Axis)
                                {
                                    shipInput.vertical = ViveInput.GetAxisEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId, positiveVerticalInputCtrlAxisVive) - ViveInput.GetAxisEx(viveVerticalRoleSystemType, negativeVerticalInputRoleId, negativeVerticalInputCtrlAxisVive);
                                }
                                else if (viveVerticalInputType == ViveInputType.Button)
                                {
                                    shipInput.vertical = (ViveInput.GetPressEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId, positiveVerticalInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(viveVerticalRoleSystemType, negativeVerticalInputRoleId, negativeVerticalInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - currently only supports single-axis
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveVerticalRoleSystemType, positiveVerticalInputRoleId);
                                    // positiveVerticalInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveVerticalInputCtrlVive == 0)
                                    {
                                        float verticalX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.vertical = verticalX < 180f ? verticalX / 180f : (verticalX - 180f) / -180f;
                                    }
                                    else if (positiveVerticalInputCtrlVive == 1)
                                    {
                                        float verticalY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.vertical = verticalY <= 90f ? verticalY / 90f : (360f - verticalY) / -90f;
                                    }
                                    else
                                    {
                                        float verticalZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.vertical = verticalZ < 180f ? verticalZ / 180f : (verticalZ - 180f) / -180f;
                                    }
                                }
                            }
                        }
                        else{ shipInput.vertical = 0f; }

                        #endregion Vive Vertical Input

                        #region Vive Longitudinal Input
                        if (longitudinalInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (longitudinalInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (viveLongitudinalInputType == ViveInputType.Axis)
                                {
                                    shipInput.longitudinal = ViveInput.GetAxisEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId, positiveLongitudinalInputCtrlAxisVive);
                                }
                                else if (viveLongitudinalInputType == ViveInputType.Button)
                                {
                                    shipInput.longitudinal = ViveInput.GetPressEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId, positiveLongitudinalInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId);
                                    // positiveLongitudinalInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveLongitudinalInputCtrlVive == 0)
                                    {
                                        float longitudinalX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.longitudinal = longitudinalX < 180f ? longitudinalX / 180f : (longitudinalX - 180f) / -180f;                                
                                    }
                                    else if (positiveLongitudinalInputCtrlVive == 1)
                                    {
                                        float longitudinalY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.longitudinal = longitudinalY <= 90f ? longitudinalY / 90f : (360f - longitudinalY) / -90f;
                                    }
                                    else
                                    {
                                        float longitudinalZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.longitudinal = longitudinalZ < 180f ? longitudinalZ / 180f : (longitudinalZ - 180f) / -180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (viveLongitudinalInputType == ViveInputType.Axis)
                                {
                                    shipInput.longitudinal = ViveInput.GetAxisEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId, positiveLongitudinalInputCtrlAxisVive) - ViveInput.GetAxisEx(viveLongitudinalRoleSystemType, negativeLongitudinalInputRoleId, negativeLongitudinalInputCtrlAxisVive);
                                }
                                else if (viveLongitudinalInputType == ViveInputType.Button)
                                {
                                    shipInput.longitudinal = (ViveInput.GetPressEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId, positiveLongitudinalInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(viveLongitudinalRoleSystemType, negativeLongitudinalInputRoleId, negativeLongitudinalInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - currently only supports single-axis
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveLongitudinalRoleSystemType, positiveLongitudinalInputRoleId);
                                    // positiveLongitudinalInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveLongitudinalInputCtrlVive == 0)
                                    {
                                        float longitudinalX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.longitudinal = longitudinalX < 180f ? longitudinalX / 180f : (longitudinalX - 180f) / -180f;
                                    }
                                    else if (positiveLongitudinalInputCtrlVive == 1)
                                    {
                                        float longitudinalY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.longitudinal = longitudinalY <= 90f ? longitudinalY / 90f : (360f - longitudinalY) / -90f;
                                    }
                                    else
                                    {
                                        float longitudinalZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.longitudinal = longitudinalZ < 180f ? longitudinalZ / 180f : (longitudinalZ - 180f) / -180f;
                                    }
                                }
                            }
                        }
                        else { shipInput.longitudinal = 0f; }
                        #endregion Vive Longitudinal Input

                        #region Vive Pitch Input
                        if (pitchInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (pitchInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (vivePitchInputType == ViveInputType.Axis)
                                {
                                    shipInput.pitch = ViveInput.GetAxisEx(vivePitchRoleSystemType, positivePitchInputRoleId, positivePitchInputCtrlAxisVive);
                                }
                                else if (vivePitchInputType == ViveInputType.Button)
                                {
                                    shipInput.pitch = ViveInput.GetPressEx(vivePitchRoleSystemType, positivePitchInputRoleId, positivePitchInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(vivePitchRoleSystemType, positivePitchInputRoleId);
                                    // positivePitchInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positivePitchInputCtrlVive == 0)
                                    {
                                        float pitchX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.pitch = pitchX < 180f ? pitchX / -180f : (pitchX - 180f) / 180f;
                                    }
                                    else if (positivePitchInputCtrlVive == 1)
                                    {
                                        float pitchY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.pitch = pitchY <= 90f ? pitchY/90f : (360f - pitchY) / -90f;
                                    }
                                    else
                                    {
                                        float pitchZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.pitch = pitchZ < 180f ? pitchZ / -180f : (pitchZ - 180f) / 180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (vivePitchInputType == ViveInputType.Axis)
                                {
                                    shipInput.pitch = ViveInput.GetAxisEx(vivePitchRoleSystemType, positivePitchInputRoleId, positivePitchInputCtrlAxisVive) - ViveInput.GetAxisEx(vivePitchRoleSystemType, negativePitchInputRoleId, negativePitchInputCtrlAxisVive);
                                }
                                else if (vivePitchInputType == ViveInputType.Button)
                                {
                                    shipInput.pitch = (ViveInput.GetPressEx(vivePitchRoleSystemType, positivePitchInputRoleId, positivePitchInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(vivePitchRoleSystemType, negativePitchInputRoleId, negativePitchInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - currently only supports single axis
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(vivePitchRoleSystemType, positivePitchInputRoleId);
                                    // positivePitchInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positivePitchInputCtrlVive == 0)
                                    {
                                        float pitchX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.pitch = pitchX < 180f ? pitchX / -180f : (pitchX - 180f) / 180f;
                                    }
                                    else if (positivePitchInputCtrlVive == 1)
                                    {
                                        float pitchY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.pitch = pitchY <= 90f ? pitchY / 90f : (360f - pitchY) / -90f;
                                    }
                                    else
                                    {
                                        float pitchZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.pitch = pitchZ < 180f ? pitchZ / -180f : (pitchZ - 180f) / 180f;
                                    }
                                }
                            }
                        }
                        else { shipInput.pitch = 0f; }
                        #endregion Vive Pitch Input

                        #region Vive Yaw Input
                        if (yawInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (yawInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (viveYawInputType == ViveInputType.Axis)
                                {
                                    shipInput.yaw = ViveInput.GetAxisEx(viveYawRoleSystemType, positiveYawInputRoleId, positiveYawInputCtrlAxisVive);
                                }
                                else if (viveYawInputType == ViveInputType.Button)
                                {
                                    shipInput.yaw = ViveInput.GetPressEx(viveYawRoleSystemType, positiveYawInputRoleId, positiveYawInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveYawRoleSystemType, positiveYawInputRoleId);
                                    // positiveYawInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveYawInputCtrlVive == 0)
                                    {
                                        float yawX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.yaw = yawX < 180f ? yawX / 180f : (yawX - 180f) / -180f;
                                    }
                                    else if (positiveYawInputCtrlVive == 1)
                                    {
                                        float yawY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.yaw = yawY <= 90f ? yawY / 90f : (360f - yawY) / -90f;
                                    }
                                    else
                                    {
                                        float yawZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.yaw = yawZ < 180f ? yawZ / 180f : (yawZ - 180f) / -180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (viveYawInputType == ViveInputType.Axis)
                                {
                                    shipInput.yaw = ViveInput.GetAxisEx(viveYawRoleSystemType, positiveYawInputRoleId, positiveYawInputCtrlAxisVive) - ViveInput.GetAxisEx(viveYawRoleSystemType, negativeYawInputRoleId, negativeYawInputCtrlAxisVive);
                                }
                                else if (viveYawInputType == ViveInputType.Button)
                                {
                                    shipInput.yaw = (ViveInput.GetPressEx(viveYawRoleSystemType, positiveYawInputRoleId, positiveYawInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(viveYawRoleSystemType, negativeYawInputRoleId, negativeYawInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - currently only supports single axis
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveYawRoleSystemType, positiveYawInputRoleId);
                                    // positiveYawInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveYawInputCtrlVive == 0)
                                    {
                                        float yawX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.yaw = yawX < 180f ? yawX / 180f : (yawX - 180f) / -180f;
                                    }
                                    else if (positiveYawInputCtrlVive == 1)
                                    {
                                        float yawY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.yaw = yawY <= 90f ? yawY / 90f : (360f - yawY) / -90f;
                                    }
                                    else
                                    {
                                        float yawZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.yaw = yawZ < 180f ? yawZ / 180f : (yawZ - 180f) / -180f;
                                    }
                                }
                            }
                        }
                        else { shipInput.yaw = 0f; }
                        #endregion Vive Yaw Input

                        #region Vive Roll Input
                        if (rollInputAxisMode != InputAxisMode.NoInput)
                        {
                            if (rollInputAxisMode == InputAxisMode.SingleAxis)
                            {
                                if (viveRollInputType == ViveInputType.Axis)
                                {
                                    shipInput.roll = ViveInput.GetAxisEx(viveRollRoleSystemType, positiveRollInputRoleId, positiveRollInputCtrlAxisVive);
                                }
                                else if (viveRollInputType == ViveInputType.Button)
                                {
                                    shipInput.roll = ViveInput.GetPressEx(viveRollRoleSystemType, positiveRollInputRoleId, positiveRollInputCtrlBtnVive) ? 1f : 0f;
                                }
                                else // Pose
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveRollRoleSystemType, positiveRollInputRoleId);
                                    // positiveRollInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveRollInputCtrlVive == 0)
                                    {
                                        float rollX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.roll = rollX < 180f ? rollX / 180f : (rollX - 180f) / -180f;
                                    }
                                    else if (positiveRollInputCtrlVive == 1)
                                    {
                                        float rollY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.roll = rollY <= 90f ? rollY / 90f : (360f - rollY) / -90f;
                                    }
                                    else
                                    {
                                        float rollZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.roll = rollZ < 180f ? rollZ / 180f : (rollZ - 180f) / -180f;
                                    }
                                }
                            }
                            else // Combined Axis
                            {
                                if (viveRollInputType == ViveInputType.Axis)
                                {
                                    shipInput.roll = ViveInput.GetAxisEx(viveRollRoleSystemType, positiveRollInputRoleId, positiveRollInputCtrlAxisVive) - ViveInput.GetAxisEx(viveRollRoleSystemType, negativeRollInputRoleId, negativeRollInputCtrlAxisVive);
                                }
                                else if (viveRollInputType == ViveInputType.Button)
                                {
                                    shipInput.roll = (ViveInput.GetPressEx(viveRollRoleSystemType, positiveRollInputRoleId, positiveRollInputCtrlBtnVive) ? 1f : 0f) - (ViveInput.GetPressEx(viveRollRoleSystemType, negativeRollInputRoleId, negativeRollInputCtrlBtnVive) ? 1f : 0f);
                                }
                                else // Pose - Currently only supports single axis
                                {
                                    HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(viveRollRoleSystemType, positiveRollInputRoleId);
                                    // positiveRollInputCtrlVive 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                    if (positiveRollInputCtrlVive == 0)
                                    {
                                        float rollX = viveRigidPose.rot.eulerAngles.y;
                                        shipInput.roll = rollX < 180f ? rollX / 180f : (rollX - 180f) / -180f;
                                    }
                                    else if (positiveRollInputCtrlVive == 1)
                                    {
                                        float rollY = viveRigidPose.rot.eulerAngles.x;
                                        shipInput.roll = rollY <= 90f ? rollY / 90f : (360f - rollY) / -90f;
                                    }
                                    else
                                    {
                                        float rollZ = viveRigidPose.rot.eulerAngles.z;
                                        shipInput.roll = rollZ < 180f ? rollZ / 180f : (rollZ - 180f) / -180f;
                                    }
                                }
                            }
                        }
                        else { shipInput.roll = 0f; }
                        #endregion Vive Roll Input

                        #region Vive Primary Fire Input

                        if (primaryFireInputCtrlVive > 0)
                        {
                            if (primaryFireCanBeHeld)
                            {
                                shipInput.primaryFire = ViveInput.GetPressEx(vivePrimaryFireRoleSystemType, primaryFireInputRoleId, primaryFireInputCtrlBtnVive);
                            }
                            else
                            {
                                shipInput.primaryFire = ViveInput.GetPressDownEx(vivePrimaryFireRoleSystemType, primaryFireInputRoleId, primaryFireInputCtrlBtnVive);
                            }
                        }
                        else { shipInput.primaryFire = false; }
                        #endregion Vive Primary Fire Input

                        #region Vive Secondary Fire Input

                        if (secondaryFireInputCtrlVive > 0)
                        {
                            if (secondaryFireCanBeHeld)
                            {
                                shipInput.secondaryFire = ViveInput.GetPressEx(viveSecondaryFireRoleSystemType, secondaryFireInputRoleId, secondaryFireInputCtrlBtnVive);
                            }
                            else
                            {
                                shipInput.secondaryFire = ViveInput.GetPressDownEx(viveSecondaryFireRoleSystemType, secondaryFireInputRoleId, secondaryFireInputCtrlBtnVive);
                            }
                        }
                        else { shipInput.secondaryFire = false; }
                        #endregion Vive Secondary Fire Input

                        #region Vive Docking Input

                        if (dockingInputCtrlVive > 0)
                        {
                            shipInput.dock = ViveInput.GetPressDownEx(viveDockingRoleSystemType, dockingInputRoleId, dockingInputCtrlBtnVive);
                        }
                        else { shipInput.dock = false; }
                        #endregion Vive Docking Input
                    }

                    #region Custom Player Input
                    if (numberOfCustomPlayerInputs > 0)
                    {
                        for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                        {
                            CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                            if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                            {
                                if (customPlayerInput.isButton)
                                {
                                    if (customPlayerInput.vivePositiveInputCtrl > 0)
                                    {
                                        if (primaryFireCanBeHeld)
                                        {
                                            if (ViveInput.GetPressEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlBtn))
                                            {
                                                // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                            }
                                        }
                                        else if (ViveInput.GetPressDownEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlBtn))
                                        {
                                            // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                        }
                                    }
                                }
                                else if (customPlayerInput.inputAxisMode != InputAxisMode.NoInput)
                                {
                                    if (customPlayerInput.inputAxisMode == InputAxisMode.SingleAxis)
                                    {
                                        if (customPlayerInput.viveInputType == ViveInputType.Axis)
                                        {
                                            float inputValueF = ViveInput.GetAxisEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlAxis);
                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueF;
                                            // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                        }
                                        else if (customPlayerInput.viveInputType == ViveInputType.Button)
                                        {
                                            // Allow the user to send 0 or 1.
                                            float inputValueF = ViveInput.GetPressEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlBtn) ? 1f : 0f;
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 5);
                                        }
                                        else // Pose
                                        {
                                            HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId);
                                            // customPlayerInput.vivePositiveInputCtrl 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                            // We "may" want to pass these as the raw rotation angle..
                                            if (customPlayerInput.vivePositiveInputCtrl == 0)
                                            {
                                                float rollX = viveRigidPose.rot.eulerAngles.y;
                                                rollX = rollX < 180f ? rollX / 180f : (rollX - 180f) / -180f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollX, 0f, 0f), 1);
                                            }
                                            else if (customPlayerInput.vivePositiveInputCtrl == 1)
                                            {
                                                float rollY = viveRigidPose.rot.eulerAngles.x;
                                                rollY = rollY <= 90f ? rollY / 90f : (360f - rollY) / -90f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollY, 0f, 0f), 1);
                                            }
                                            else
                                            {
                                                float rollZ = viveRigidPose.rot.eulerAngles.z;
                                                rollZ = rollZ < 180f ? rollZ / 180f : (rollZ - 180f) / -180f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollZ, 0f, 0f), 1);
                                            }
                                        }
                                    }
                                    else // Combined
                                    {
                                        if (customPlayerInput.viveInputType == ViveInputType.Axis)
                                        {
                                            float inputValueF = ViveInput.GetAxisEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlAxis) - ViveInput.GetAxisEx(customPlayerInput.viveRoleSystemType, customPlayerInput.viveNegativeInputRoleId, customPlayerInput.viveNegativeInputCtrlAxis);
                                            if (customPlayerInput.isSensitivityEnabled)
                                            {
                                                inputValueF = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValueF, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            }
                                            customPlayerInput.lastInputValueX = inputValueF;
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 1);
                                        }
                                        else if (customPlayerInput.viveInputType == ViveInputType.Button)
                                        {
                                            // Allow the user to send -1, 0, or 1
                                            float inputValueF = (ViveInput.GetPressEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId, customPlayerInput.vivePositiveInputCtrlBtn) ? 1f : 0f) - (ViveInput.GetPressEx(customPlayerInput.viveRoleSystemType, customPlayerInput.viveNegativeInputRoleId, customPlayerInput.viveNegativeInputCtrlBtn) ? 1f : 0f);
                                            customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(inputValueF, 0f, 0f), 5);
                                        }
                                        else // Pose - currently only supports single axis
                                        {
                                            HTC.UnityPlugin.Utility.RigidPose viveRigidPose = VivePose.GetPoseEx(customPlayerInput.viveRoleSystemType, customPlayerInput.vivePositiveInputRoleId);
                                            // customPlayerInput.vivePositiveInputCtrl 0 = RotationX, 1 = RotationY, 2 = RotationZ

                                            // We "may" want to pass these as the raw rotation angle..
                                            if (customPlayerInput.vivePositiveInputCtrl == 0)
                                            {
                                                float rollX = viveRigidPose.rot.eulerAngles.y;
                                                rollX = rollX < 180f ? rollX / 180f : (rollX - 180f) / -180f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollX, 0f, 0f), 1);
                                            }
                                            else if (customPlayerInput.vivePositiveInputCtrl == 1)
                                            {
                                                float rollY = viveRigidPose.rot.eulerAngles.x;
                                                rollY = rollY <= 90f ? rollY / 90f : (360f - rollY) / -90f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollY, 0f, 0f), 1);
                                            }
                                            else
                                            {
                                                float rollZ = viveRigidPose.rot.eulerAngles.z;
                                                rollZ = rollZ < 180f ? rollZ / 180f : (rollZ - 180f) / -180f;
                                                customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(rollZ, 0f, 0f), 1);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    #endregion Custom Player Input

                }
                catch (System.Exception ex)
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("PlayerInputModule VIVE " + ex.Message);
                    #else
                    // Keep compiler happy
                    if (ex != null) { }
                    #endif
                }
                #else
                // Do nothing if VIVE is set but not installed
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;
                #endif
                #endregion
            }
            else if (inputMode == InputMode.UnityXR)
            {
                #region Unity XR
                #if SCSM_XR && SSC_UIS

                // By default actions are enabled
                // InputAction needs to consider the ControlType returned.
                if (isInputEnabled)
                {
                    #region Unity XR Horizontal Input
                    shipInput.horizontal = UISReadActionInputFloat(positiveHorizontalInputActionUIS, positiveHorizontalInputActionDataSlotUIS, positiveHorizontalCtrlTypeHashUIS);
                    #endregion Unity XR Horizontal Input

                    #region Unity XR Vertical Input
                    shipInput.vertical = UISReadActionInputFloat(positiveVerticalInputActionUIS, positiveVerticalInputActionDataSlotUIS, positiveVerticalCtrlTypeHashUIS);
                    #endregion Unity XR Verical Input

                    #region Unity XR Longitudinal Input
                    shipInput.longitudinal = UISReadActionInputFloat(positiveLongitudinalInputActionUIS, positiveLongitudinalInputActionDataSlotUIS, positiveLongitudinalCtrlTypeHashUIS);
                    #endregion Unity XR Longitudinal Input

                    #region Unity XR Pitch Input
                    shipInput.pitch = UISReadActionInputFloat(positivePitchInputActionUIS, positivePitchInputActionDataSlotUIS, positivePitchCtrlTypeHashUIS);
                    #endregion Unity XR Pitch Input

                    #region Unity XR Yaw Input
                    shipInput.yaw = UISReadActionInputFloat(positiveYawInputActionUIS, positiveYawInputActionDataSlotUIS, positiveYawCtrlTypeHashUIS);
                    #endregion Unity XR Yaw Input

                    #region Unity XR Roll Input
                    shipInput.roll = UISReadActionInputFloat(positiveRollInputActionUIS, positiveRollInputActionDataSlotUIS, positiveRollCtrlTypeHashUIS);
                    #endregion Unity XR Roll Input

                    #region Unity XR Primary Fire Input
                    shipInput.primaryFire = UISReadActionInputBool(primaryFireInputActionUIS, primaryFireInputActionDataSlotUIS, primaryFireCtrlTypeHashUIS, primaryFireCanBeHeld);
                    #endregion Unity XR Primary Fire Input

                    #region Unity XR Secondary Fire Input
                    shipInput.secondaryFire = UISReadActionInputBool(secondaryFireInputActionUIS, secondaryFireInputActionDataSlotUIS, secondaryFireCtrlTypeHashUIS, secondaryFireCanBeHeld);
                    #endregion Unity XR Secondary Fire Input

                    #region Unity XR Dock Input
                    shipInput.dock = UISReadActionInputBool(dockingInputActionUIS, dockingInputActionDataSlotUIS, dockingCtrlTypeHashUIS, false);
                    #endregion Unity XR Dock Input

                    #region Unity XR Quit - currently disabled
                    //if (UISReadActionInputBool(quitInputActionUIS, 0, controlTypeButtonHashUIS, false))
                    //{
                    //    if (callbackOnQuitGame != null) {  callbackOnQuitGame.Invoke(shipControlModule); }
                    //    else
                    //    {
                    //        #if UNITY_EDITOR
                    //        UnityEditor.EditorApplication.isPlaying = false;
                    //        #else
                    //        Application.Quit();
                    //        #endif
                    //    }
                    //}
                    #endregion
                }

                #region XR Custom Player Input
                if (numberOfCustomPlayerInputs > 0)
                {
                    for (int cpiIdx = 0; cpiIdx < numberOfCustomPlayerInputs; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];

                        if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                        {
                            if (customPlayerInput.isButton)
                            {
                                if (UISReadActionInputBool(customPlayerInput.uisPositiveInputAction, customPlayerInput.uisPositiveInputActionDataSlot, customPlayerInput.uisPositiveCtrlTypeHash, customPlayerInput.canBeHeldDown))
                                {
                                    // CustomPlayerInput.CustomPlayerInputEventType is Button (5).
                                    customPlayerInput.customPlayerInputEvt.Invoke(new Vector3(1f, 0f, 0f), 5);
                                }
                            }
                            else
                            {
                                Vector3 inputValue = Vector3.zero;

                                if (customPlayerInput.uisPositiveInputAction != null)
                                {
                                    if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeAxisHashUIS || customPlayerInput.uisPositiveCtrlTypeHash == controlTypeButtonHashUIS)
                                    {
                                        // 1D axis and Buttons both retrun a float
                                        inputValue.x = customPlayerInput.uisPositiveInputAction.ReadValue<float>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis1D (1).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 1);
                                    }
                                    else if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeVector2HashUIS || customPlayerInput.uisPositiveCtrlTypeHash == controlTypeDpadHashUIS)
                                    {
                                        inputValue = customPlayerInput.uisPositiveInputAction.ReadValue<Vector2>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            inputValue.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValue.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        customPlayerInput.lastInputValueY = inputValue.y;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis2D (2).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 2);
                                    }
                                    else if (customPlayerInput.uisPositiveCtrlTypeHash == controlTypeVector3HashUIS)
                                    {
                                        inputValue = customPlayerInput.uisPositiveInputAction.ReadValue<Vector3>();

                                        if (customPlayerInput.isSensitivityEnabled)
                                        {
                                            // Currently only works on x,y axes
                                            inputValue.x = CalculateAxisInput(customPlayerInput.lastInputValueX, inputValue.x, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                            inputValue.y = CalculateAxisInput(customPlayerInput.lastInputValueY, inputValue.y, customPlayerInput.sensitivity, customPlayerInput.gravity);
                                        }
                                        customPlayerInput.lastInputValueX = inputValue.x;
                                        customPlayerInput.lastInputValueY = inputValue.y;
                                        // CustomPlayerInput.CustomPlayerInputEventType is Axis3D (3).
                                        customPlayerInput.customPlayerInputEvt.Invoke(inputValue, 3);
                                    }
                                }
                            }
                        }

                    }
                }
                #endregion

                #else
                // Do nothing if XR or Unity Input System is set but not installed in the project
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;
                #endif
                #endregion
            }
            #if UNITY_EDITOR
            else { Debug.Log("Invalid input mode: " + inputMode.ToString()); }
            #endif

            // cater for situation where input is disabled but CustomPlayerInput is allowed.
            if (!isInputEnabled) { return; }

            #region Sensitivity Implementation

            if (isSensitivityForHorizontalEnabled && !isHorizontalDataDiscarded)
            {
                shipInput.horizontal = CalculateAxisInput(lastShipInput.horizontal, shipInput.horizontal, horizontalAxisSensitivity, horizontalAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.horizontal = shipInput.horizontal;
            }

            if (isSensitivityForVerticalEnabled && !isVerticalDataDiscarded)
            {
                shipInput.vertical = CalculateAxisInput(lastShipInput.vertical, shipInput.vertical, verticalAxisSensitivity, verticalAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.vertical = shipInput.vertical;
            }

            if (isSensitivityForLongitudinalEnabled && !isLongitudinalDataDiscarded)
            {
                shipInput.longitudinal = CalculateAxisInput(lastShipInput.longitudinal, shipInput.longitudinal, longitudinalAxisSensitivity, longitudinalAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.longitudinal = shipInput.longitudinal;
            }

            if (isSensitivityForPitchEnabled && !isPitchDataDiscarded)
            {
                shipInput.pitch = CalculateAxisInput(lastShipInput.pitch, shipInput.pitch, pitchAxisSensitivity, pitchAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.pitch = shipInput.pitch;
            }

            if (isSensitivityForYawEnabled && !isYawDataDiscarded)
            {
                shipInput.yaw = CalculateAxisInput(lastShipInput.yaw, shipInput.yaw, yawAxisSensitivity, yawAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.yaw = shipInput.yaw;
            }

            if (isSensitivityForRollEnabled && !isRollDataDiscarded)
            {
                shipInput.roll = CalculateAxisInput(lastShipInput.roll, shipInput.roll, rollAxisSensitivity, rollAxisGravity);
                // Store the calculated ship input from this frame for reference next frame
                lastShipInput.roll = shipInput.roll;
            }

            #endregion

            #region Send calculated input to the ship control module
            if (shipControlModule != null)
            {
                // If auto cruise is enabled, check to see if we need more forwards thrust
                if (isAutoCruiseEnabled && shipControlModule.IsInitialised && !isLongitudinalDataDiscarded && shipControlModule.ShipIsEnabled())
                {
                    currentSpeed = (shipControlModule.shipInstance.TransformInverseRotation * shipControlModule.shipInstance.WorldVelocity).z;
                    if (shipInput.longitudinal == 0f)
                    {
                        /// TODO - as the current speed approaches the target speed we need to apply less thrust.
                        if (targetCruiseSpeed > 0f && currentSpeed < targetCruiseSpeed)
                        {
                            shipInput.longitudinal = 0.25f;
                        }
                    }
                    else
                    {
                        targetCruiseSpeed = currentSpeed;
                    }
                }

                shipControlModule.SendInput(shipInput);
            }
            #endregion
        }

        #endregion

        #region Event Methods

        private void OnEnable()
        {
            #if SCSM_XR && SSC_UIS
            if (inputMode == InputMode.UnityXR)
            {
                EnableOrDisableActions(inputActionAssetXR, true);
            }
            #endif
        }

        private void OnDisable()
        {
            #if SCSM_XR && SSC_UIS
            if (inputMode == InputMode.UnityXR)
            {
                EnableOrDisableActions(inputActionAssetXR, false);
            }
            #endif
        }

        private void OnDestroy()
        {
            #if SCSM_XR && SSC_UIS
            if (inputMode == InputMode.UnityXR)
            {
                EnableOrDisableActions(inputActionAssetXR, false);
            }
            #endif
        }

        #endregion

        #region Private or Internal Member Methods

        /// <summary>
        /// Calculates a mouse X input for an axis, taking into account sensitivity and deadzone settings.
        /// In a build, can also compensate for getting input from another display or monitor.
        /// See also SetTargetDisplay(displayNumber).
        /// </summary>
        /// <param name="mouseX"></param>
        /// <param name="mouseXSensitivity"></param>
        /// <param name="mouseXDeadzone"></param>
        /// <returns></returns>
        private float CalculateMouseXInput (float mouseX, float mouseXSensitivity, float mouseXDeadzone)
        {
            // TODO call this from Unity Input System code
            // Mouse position can be outside gameview

            #if !UNITY_EDITOR
            mouseX -= targetDisplayOffsetX;
            #endif

            // Make sure to clamp it to be inside bounds of the screen
            if (mouseX < 0f) { mouseX = 0f; }
            else if (mouseX > Screen.width) { mouseX = Screen.width; }
            // Normalise between -1.0 and +1.0
            mouseX = ((mouseX - (Screen.width / 2f)) * 2f / Screen.width);
            // Make any values inside the deadzone zero
            if (mouseX > -mouseXDeadzone * 2f && mouseX < mouseXDeadzone * 2f) { mouseX = 0; }

            // Multiply by sensitivity
            return mouseX * mouseXSensitivity;
        }

        /// <summary>
        /// Calculates a mouse Y input for an axis, taking into account sensitivity and deadzone settings.
        /// </summary>
        /// <param name="mouseX"></param>
        /// <param name="mouseXSensitivity"></param>
        /// <param name="mouseXDeadzone"></param>
        /// <returns></returns>
        private float CalculateMouseYInput(float mouseY, float mouseYSensitivity, float mouseYDeadzone)
        {
            // TODO call this from Unity Input System code
            // Mouse position can be outside gameview
            // Make sure to clamp it to be inside bounds of the screen
            if (mouseY < 0f) { mouseY = 0f; }
            else if (mouseY > Screen.height) { mouseY = Screen.height; }
            // Normalise between -1.0 and +1.0
            mouseY = -((mouseY - (Screen.height / 2f)) * 2f / Screen.height);
            // Make any values inside the deadzone zero
            if (mouseY > -mouseYDeadzone * 2f && mouseY < mouseYDeadzone * 2f) { mouseY = 0; }
            // Multiply by sensitivity
            return mouseY * mouseYSensitivity;
        }

        /// <summary>
        /// Attempt to enable or disable Ship AI mode.
        /// When AI mode is enabled, the Custom Inputs are still enabled.
        /// </summary>
        /// <param name="isEnabled"></param>
        private void EnableOrDisableAIMode(bool isEnabled)
        {
            ShipAIInputModule aiShip = shipControlModule == null ? null : shipControlModule.GetShipAIInputModule(false);

            if (aiShip != null)
            {
                if (aiShip.IsInitialised)
                {
                    if (isEnabled)
                    {
                        DisableInput(true);
                        isShipAIModeEnabled = true;
                    }
                    else
                    {
                        EnableInput();
                        isShipAIModeEnabled = false;
                    }
                }
                #if UNITY_EDITOR
                else { Debug.LogWarning("ERROR: PlayerInputModule.EnableOrDisableAIMode - cannot " + (isEnabled ? "enable" : "disable") + " AI mode as Ship AI Input Module is not initialised"); }
                #endif
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: PlayerInputModule.EnableOrDisableAIMode - cannot " + (isEnabled ? "enable" : "disable") + " AI mode as Ship AI Input Module may not be attached to " + gameObject.name); }
            #endif
        }

#if SSC_UIS
         
        /// <summary>
        /// Enable or disable Actions in a InputActionAsset
        /// </summary>
        /// <param name="inputActionAsset"></param>
        /// <param name="isEnabled"></param>
        private void EnableOrDisableActions(UnityEngine.InputSystem.InputActionAsset inputActionAsset, bool isEnabled)
        {
            if (inputActionAsset != null)
            {
                if (isEnabled)
                {
                    inputActionAsset.Enable();
                }
                else
                {
                    inputActionAsset.Disable();
                }
            }
        }

        /// <summary>
        /// Get an InputAction from a scriptableobject InputActionAsset in a given ActionMap. We are using strings so DO NOT run this every frame.
        /// </summary>
        /// <param name="inputActionAsset"></param>
        /// <param name="actionMapId"></param>
        /// <param name="actionId"></param>
        /// <returns></returns>
        private UnityEngine.InputSystem.InputAction UISGetAction(UnityEngine.InputSystem.InputActionAsset inputActionAsset, string actionMapId, string actionId)
        {
            UnityEngine.InputSystem.InputAction inputAction = null;

            if (inputActionAsset != null && !string.IsNullOrEmpty(actionMapId) || !string.IsNullOrEmpty(actionId))
            {
                UnityEngine.InputSystem.InputActionMap actionMap = inputActionAsset.FindActionMap(actionMapId);

                if (actionMap != null)
                {
                    inputAction = actionMap.FindAction(actionId);
                }
            }

            return inputAction;
        }
        
        /// <summary>
        /// Given a Unity Input System action, read the current value being generated by that
        /// action. This assumes the inputAction will be null if it has not been configured
        /// in the PlayerInputModuleEditor. It doesn't check the inputAxisMode.
        /// </summary>
        /// <param name="inputAction"></param>
        /// <param name="inputActionDataSlot"></param>
        /// <param name="actionControlTypeHash"></param>
        /// <returns></returns>
        private float UISReadActionInputFloat(UnityEngine.InputSystem.InputAction inputAction, int inputActionDataSlot, int actionControlTypeHash)
        {
            float inputActionValue = 0f;

            // Unity Input System only requires SingleAxis as multiple can be supported by
            // using Composite Bindings. It doesn't check if the inputAxisMode is NoInput or CombinedAxis.

            if (inputAction != null)
            {
                // Use int32 hashcodes to avoid GC
                if (actionControlTypeHash == controlTypeAxisHashUIS)
                {
                    inputActionValue = inputAction.ReadValue<float>();
                }
                else if (actionControlTypeHash == controlTypeVector2HashUIS || actionControlTypeHash == controlTypeDpadHashUIS)
                {
                    if (inputActionDataSlot == 0)
                    {
                        inputActionValue = inputAction.ReadValue<Vector2>().x;
                    }
                    else { inputActionValue = inputAction.ReadValue<Vector2>().y; }
                }
                else if (actionControlTypeHash == controlTypeVector3HashUIS)
                {
                    if (inputActionDataSlot == 0)
                    {
                        inputActionValue = inputAction.ReadValue<Vector3>().x;
                    }
                    else if (inputActionDataSlot == 1)
                    {
                        inputActionValue = inputAction.ReadValue<Vector3>().y;
                    }
                    else { inputActionValue = inputAction.ReadValue<Vector3>().z; }
                }
                else if (actionControlTypeHash == controlTypeButtonHashUIS)
                {
                    // Buttons return a float (not a bool)
                    inputActionValue = inputAction.ReadValue<float>();
                }
            }

            return inputActionValue;
        }

        /// <summary>
        /// Given a Unity Input System action, read the current value being generated by that
        /// action. This assumes the inputAction will be null if it has not been configured
        /// in the PlayerInputModuleEditor. It doesn't check the inputAxisMode or
        /// [primary/secondary]FireButtonEnabled values.
        /// </summary>
        /// <param name="inputAction"></param>
        /// <param name="inputActionDataSlot"></param>
        /// <param name="actionControlTypeHash"></param>
        /// <param name="canBeHeldDown"></param>
        /// <returns></returns>
        private bool UISReadActionInputBool(UnityEngine.InputSystem.InputAction inputAction, int inputActionDataSlot, int actionControlTypeHash, bool canBeHeldDown)
        {
            bool inputActioned = false;
            float inputActionValue = 0f;

            // It doesn't check if the primary/secondaryFireButtonEnabled are enabled.

            if (inputAction != null)
            {
                // Use int32 hashcodes to avoid GC
                if (actionControlTypeHash == controlTypeButtonHashUIS)
                {
                    if (canBeHeldDown)
                    {
                        // Buttons return a float (not a bool)
                        inputActionValue = inputAction.ReadValue<float>();
                        inputActioned = inputActionValue < -0.1f || inputActionValue > 0.1f;
                    }
                    // Only respond the first time it is pressed
                    else { inputActioned = inputAction.triggered; }
                }
                else if (actionControlTypeHash == controlTypeAxisHashUIS || actionControlTypeHash == controlTypeDpadHashUIS)
                {
                    inputActionValue = inputAction.ReadValue<float>();
                    inputActioned = inputActionValue > 0.1f || inputActionValue < 0.1f;
                }
                else if (actionControlTypeHash == controlTypeVector2HashUIS)
                {
                    if (inputActionDataSlot == 0)
                    {
                        inputActionValue = inputAction.ReadValue<Vector2>().x;
                    }
                    else { inputActionValue = inputAction.ReadValue<Vector2>().y; }
                    inputActioned = inputActionValue > 0.1f || inputActionValue < 0.1f;
                }
                else if (actionControlTypeHash == controlTypeVector3HashUIS)
                {
                    if (inputActionDataSlot == 0)
                    {
                        inputActionValue = inputAction.ReadValue<Vector3>().x;
                    }
                    else if (inputActionDataSlot == 1)
                    {
                        inputActionValue = inputAction.ReadValue<Vector3>().y;
                    }
                    else { inputActionValue = inputAction.ReadValue<Vector3>().z; }
                    inputActioned = inputActionValue < -0.1f || inputActionValue > 0.1f;
                }
            }

            return inputActioned;
        }

#endif

        #endregion

        #region Private XR Methods


        #if SCSM_XR && SSC_UIS

        private void ConfigureLeftHandXR()
        {
            // Prevent XR hands causing damage when colliding with ship
            if (leftHandTransformXR != null)
            {
                // The ship shouldn't have to be initialised for this to work
                shipControlModule.shipInstance.AttachColliders(leftHandTransformXR.GetComponentsInChildren<Collider>());
            }
        }

        private void ConfigureRightHandXR()
        {
            // Prevent XR hands causing damage when colliding with ship
            if (rightHandTransformXR != null)
            {
                // The ship shouldn't have to be initialised for this to work
                shipControlModule.shipInstance.AttachColliders(rightHandTransformXR.GetComponentsInChildren<Collider>());
            }
        }

        /// <summary>
        /// Attempt to enable or disable the XRCamera
        /// </summary>
        /// <param name="isEnabled"></param>
        private void EnableOrDisableXRCamera(bool isEnabled)
        {
            if (firstPersonTransform1XR != null) { firstPersonTransform1XR.gameObject.SetActive(isEnabled); }
        }

        /// <summary>
        /// Attempt to enable or disble the XR Hands
        /// </summary>
        /// <param name="isEnabled"></param>
        private void EnableOrDisableXRHands(bool isEnabled)
        {
            if (leftHandTransformXR != null) { leftHandTransformXR.gameObject.SetActive(isEnabled); }
            if (rightHandTransformXR != null) { rightHandTransformXR.gameObject.SetActive(isEnabled); }
        }

        #endif

        #endregion

        #region Public Member Methods

        /// <summary>
        /// Validate all the legacy input axis names. Update their status.
        /// </summary>
        public void ValidateLegacyInput()
        {
            isPositiveHorizontalInputAxisValid = IsLegacyAxisValid(positiveHorizontalInputAxisName, false);
            isNegativeHorizontalInputAxisValid = IsLegacyAxisValid(negativeHorizontalInputAxisName, false);
            isPositiveVerticalInputAxisValid = IsLegacyAxisValid(positiveVerticalInputAxisName, false);
            isNegativeVerticalInputAxisValid = IsLegacyAxisValid(negativeVerticalInputAxisName, false);
            isPositiveLongitudinalInputAxisValid = IsLegacyAxisValid(positiveLongitudinalInputAxisName, false);
            isNegativeLongitudinalInputAxisValid = IsLegacyAxisValid(negativeLongitudinalInputAxisName, false);
            isPositivePitchInputAxisValid = IsLegacyAxisValid(positivePitchInputAxisName, false);
            isNegativePitchInputAxisValid = IsLegacyAxisValid(negativePitchInputAxisName, false);
            isPositiveYawInputAxisValid = IsLegacyAxisValid(positiveYawInputAxisName, false);
            isNegativeYawInputAxisValid = IsLegacyAxisValid(negativeYawInputAxisName, false);
            isPositiveRollInputAxisValid = IsLegacyAxisValid(positiveRollInputAxisName, false);
            isNegativeRollInputAxisValid = IsLegacyAxisValid(negativeRollInputAxisName, false);
            isPrimaryFireInputAxisValid = IsLegacyAxisValid(primaryFireInputAxisName, false);
            isSecondaryFireInputAxisValid = IsLegacyAxisValid(secondaryFireInputAxisName, false);
            isDockingInputAxisValid = IsLegacyAxisValid(dockingInputAxisName, false);
        }

        #endregion

        #region Public Static Methods

        /// <summary>
        /// Check that a Unity Legacy Input system axis is defined
        /// </summary>
        /// <param name="axisName"></param>
        /// <param name="showError"></param>
        /// <returns></returns>
        public static bool IsLegacyAxisValid(string axisName, bool showError)
        {
            bool isValid = true;

            try
            {
                #if ENABLE_LEGACY_INPUT_MANAGER || !UNITY_2019_2_OR_NEWER
                Input.GetAxis(axisName);
                #else
                isValid = false;
                #endif
            }
            catch (System.Exception ex)
            {
                isValid = false;
                if (showError) { Debug.LogWarning("PlayerInputModule: " + ex.Message); }
            }

            return isValid;
        }

        #endregion

        #region Public Static Rewired Integration Methods
        #if SSC_REWIRED

        /// <summary>
        /// Verify that Rewired's Input Manager is in the scene
        /// and has been initialised.
        /// </summary>
        /// <param name="showErrors"></param>
        /// <returns></returns>
        public static bool CheckRewired(bool showErrors)
        {
            bool isInitialised = false;

            try
            {
                isInitialised = Rewired.ReInput.isReady;
            }
            catch (System.Exception ex)
            {
                #if UNITY_EDITOR
                if (showErrors) { Debug.LogWarning("SSC.PlayerInputModule.CheckRewired - Rewired Input Manager is not initialised.\n" + ex.Message); }
                #else
                // Keep compiler happy
                if (ex != null) {}
                #endif
            }

            return isInitialised;
        }

        /// <summary>
        /// Get the Rewired Player class instance given a human user number.
        /// e.g. Get the first human player. 
        /// Rewired.Player rewiredPlayer = PlayerInputModule.GetRewiredPlayer(1, false);
        /// </summary>
        /// <param name="userNumber"></param>
        /// <param name="showErrors"></param>
        /// <returns></returns>
        public static Rewired.Player GetRewiredPlayer(int userNumber, bool showErrors)
        {
            Rewired.Player rwPlayer = null;

            if (CheckRewired(showErrors))
            {
                int numRewiredPlayers = Rewired.ReInput.players == null ? 0 : Rewired.ReInput.players.playerCount;

                if (userNumber < 1 || userNumber > numRewiredPlayers)
                {
                    #if UNITY_EDITOR
                    if (showErrors)
                    {
                        if (numRewiredPlayers < 1)
                        {
                            Debug.LogWarning("ERROR: PlayerInputModule.GetRewiredPlayer - there does not seem to be any Players setup in Rewired. Check the Players tab in the Rewired Editor.");
                        }
                        else
                        {
                            Debug.LogWarning("ERROR: PlayerInputModule.GetRewiredPlayer - invalid UserNumber " + userNumber);
                        }
                    }
                    #endif
                }
                else
                {
                    rwPlayer = Rewired.ReInput.players.Players[userNumber - 1];
                }
            }

            return rwPlayer;
        }

        #endif
        #endregion Rewired Integration Methods

        #region Public API Methods

        #region Public API - General

        /// <summary>
        /// This must be called on Awake or via code before the Player Input Module can be used.
        /// </summary>
        public void Initialise()
        {
            if (IsInitialised) { return; }

            shipControlModule = GetComponent<ShipControlModule>();
            shipInput = new ShipInput();
            lastShipInput = new ShipInput();

            ReinitialiseDiscardData();

            #if UNITY_EDITOR
            bool showErrors = true;
            #else
            bool showErrors = false;
            #endif

            if (inputMode == InputMode.UnityInputSystem)
            {
                #if SSC_UIS
                UpdateUnityInputSystemActions(showErrors);
                #endif
            }
            else if (inputMode == InputMode.Rewired)
            {
                #if SSC_REWIRED

                UpdateRewiredActionTypes(showErrors);
                
                if (rewiredPlayerNumber > 0)
                {
                    // The player number has been configured in the editor, so attempt to find the rewired player
                    SetRewiredPlayer(rewiredPlayerNumber, showErrors);

                   //Debug.Log("[DEBUG] roll: " +  Rewired.ReInput.mapping.GetAction(negativeRollInputActionId).descriptiveName);
                }
                #else
                #if UNITY_EDITOR
                Debug.LogWarning("PlayerInputModule.Awake - the InputMode is set to Rewired on " + gameObject.name + ", however Rewired does not seem to be installed in this project.");
                #endif                
                #endif
            }
            else if (inputMode == InputMode.OculusAPI)
            {
                #if SSC_OVR
                // OVRInput requires either OVRManager to be present in the scene OR OVRInput.Update() to called once per frame at the beginning of any component's Update() method.
                CheckOVRManager();
                #endif
            }
            else if (inputMode == InputMode.Vive)
            {
                #if VIU_PLUGIN
                UpdateViveInput(showErrors);
                #else
                #if UNITY_EDITOR
                Debug.LogWarning("PlayerInputModule.Awake - the InputMode is set to Vive on " + gameObject.name + ", however Vive Input Utility does not seem to be installed in this project.");
                #endif 
                #endif
            }
            else if (inputMode == InputMode.UnityXR)
            {
                #if SCSM_XR && SSC_UIS
                UpdateUnityXRActions(showErrors);
                EnableOrDisableActions(inputActionAssetXR, true);
                ConfigureLeftHandXR();
                ConfigureRightHandXR();
                #endif
            }
            else if (inputMode == InputMode.LegacyUnity)
            {
                ValidateLegacyInput();
            }

            ReinitialiseRumble();
            ReinitialiseCustomPlayerInput();

            // Keep compiler happy
            if (showErrors) { }
            if (isOVRInputUpdatedIfRequired) { }
          
            if (isEnabledOnInitialise)
            {
                isCustomPlayerInputsOnlyEnabled = isCustomInputsOnlyOnInitialise;
                isInputEnabled = !isCustomInputsOnlyOnInitialise;
            }
            else
            {
                isInputEnabled = false;
                // This option is only available when isEnabledOnInitialise is true
                // This restriction is enforced in the editor
                isCustomPlayerInputsOnlyEnabled = false;

                DisableXRCamera();
                DisableXRHands();
            }          

            IsInitialised = true;
        }

        /// <summary>
        /// Enable the Player Input Module to receive input from the configured device.
        /// The module will be initialised if it isn't already.
        /// </summary>
        public void EnableInput()
        {
            if (!IsInitialised) { Initialise(); }

            if (IsInitialised)
            {
                isInputEnabled = true;
                isCustomPlayerInputsOnlyEnabled = false;
            }
        }

        /// <summary>
        /// Disable input or stop the Player Input Module from receiving input from the configured device.
        /// When allowCustomPlayerInput is true, all other input except CustomPlayerInputs are ignored.
        /// This can be useful when you want to still receive actions that generally don't involve ship movement.
        /// </summary>
        /// <param name="allowCustomPlayerInput"></param>
        public void DisableInput(bool allowCustomPlayerInput = false)
        {
            if (IsInitialised)
            {
                ResetInput();
                isInputEnabled = false;
                isCustomPlayerInputsOnlyEnabled = allowCustomPlayerInput;
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: PlayerInputModule.DisableInput() was called before Awake() or Initialise() ran. DisableInput will have no effect."); }
            #endif
        }

        /// <summary>
        /// Call this when you wish to remove any custom event listeners, like
        /// after creating them in code and then destroying the object.
        /// You could add this to your game play OnDestroy code.
        /// </summary>
        public void RemoveListeners()
        {
            if (IsInitialised && numberOfCustomPlayerInputs > 0)
            {
                for (int cpi = 0; cpi < numberOfCustomPlayerInputs; cpi++)
                {
                    CustomPlayerInput customPlayerInput = customPlayerInputList[cpi];

                    if (customPlayerInput != null && customPlayerInput.customPlayerInputEvt != null)
                    {
                        customPlayerInput.customPlayerInputEvt.RemoveAllListeners();
                    }
                }
            }
        }

        /// <summary>
        /// Reset and send 0 input on each axis to the ship
        /// Also calls ReinitialiseDiscardData().
        /// </summary>
        public void ResetInput()
        {
            if (IsInitialised)
            {
                shipInput.horizontal = 0f;
                shipInput.vertical = 0f;
                shipInput.longitudinal = 0f;
                shipInput.pitch = 0f;
                shipInput.yaw = 0f;
                shipInput.roll = 0f;
                shipInput.primaryFire = false;
                shipInput.secondaryFire = false;
                shipInput.dock = false;

                lastShipInput.horizontal = 0f;
                lastShipInput.vertical = 0f;
                lastShipInput.longitudinal = 0f;
                lastShipInput.pitch = 0f;
                lastShipInput.yaw = 0f;
                lastShipInput.roll = 0f;
                lastShipInput.primaryFire = false;
                lastShipInput.secondaryFire = false;
                lastShipInput.dock = false;

                targetCruiseSpeed = 0f;

                ReinitialiseDiscardData();

                if (shipControlModule != null)
                {
                    shipControlModule.SendInput(shipInput);
                }
            }
            #if UNITY_EDITOR
            else { Debug.LogWarning("ERROR: PlayerInputModule.ResetInput() was called before Awake() or Initialise() ran. ResetInput will have no effect."); }
            #endif
        }

        /// <summary>
        /// Re-initialise (set) the shipInput based on the is[axis/button]DataDiscard field settings.
        /// Must be called after each change to any of those fields/variables.
        /// Retrospectively also updates lastShipInput with same DataDiscard values.
        /// </summary>
        public void ReinitialiseDiscardData()
        {
            shipInput.isHorizontalDataEnabled = !isHorizontalDataDiscarded;
            shipInput.isVerticalDataEnabled = !isVerticalDataDiscarded;
            shipInput.isLongitudinalDataEnabled = !isLongitudinalDataDiscarded;
            shipInput.isPitchDataEnabled = !isPitchDataDiscarded;
            shipInput.isYawDataEnabled = !isYawDataDiscarded;
            shipInput.isRollDataEnabled = !isRollDataDiscarded;
            shipInput.isPrimaryFireDataEnabled = !isPrimaryFireDataDiscarded;
            shipInput.isSecondaryFireDataEnabled = !isSecondaryFireDataDiscarded;
            shipInput.isDockDataEnabled = !isDockDataDiscarded;

            lastShipInput.isHorizontalDataEnabled = !isHorizontalDataDiscarded;
            lastShipInput.isVerticalDataEnabled = !isVerticalDataDiscarded;
            lastShipInput.isLongitudinalDataEnabled = !isLongitudinalDataDiscarded;
            lastShipInput.isPitchDataEnabled = !isPitchDataDiscarded;
            lastShipInput.isYawDataEnabled = !isYawDataDiscarded;
            lastShipInput.isRollDataEnabled = !isRollDataDiscarded;
            lastShipInput.isPrimaryFireDataEnabled = !isPrimaryFireDataDiscarded;
            lastShipInput.isSecondaryFireDataEnabled = !isSecondaryFireDataDiscarded;
            lastShipInput.isDockDataEnabled = !isDockDataDiscarded;
        }

        /// <summary>
        /// This should be called if you modify the CustomPlayerInputs at runtime
        /// </summary>
        public void ReinitialiseCustomPlayerInput()
        {
            numberOfCustomPlayerInputs = customPlayerInputList == null ? 0 : customPlayerInputList.Count;
        }

        /// <summary>
        /// Used on a PC with multiple screens (display monitors) to adjust mouse position when player
        /// wants to use a screen other than Display 1.
        /// </summary>
        /// <param name="displayNumber">1 to 8</param>
        public void SetTargetDisplay(int displayNumber)
        {
            targetDisplayOffsetX = 0f;

            #if UNITY_EDITOR
            // keep compiler happy - do nothing
            if (targetDisplayOffsetX > 0f) { }
            #else
            // In the editor it reports the mouse position within the (single) game view which has focus.
            // In a build the mouse position spans all displays.
            if (IsInitialised && SSCUtils.VerifyTargetDisplay(displayNumber, true))
            {
                for (int tgtdIdx = 0; tgtdIdx < displayNumber - 1; tgtdIdx++)
                {
                    targetDisplayOffsetX += Display.displays[tgtdIdx].renderingWidth;
                }
            }
            #endif
        }

        #endregion

        #region Public API - Static General

        /// <summary>
        /// Calculates an input for this frame for an axis, taking into account sensitivity and gravity settings.
        /// </summary>
        /// <param name="currentInput"></param>
        /// <param name="targetInput"></param>
        /// <param name="axisSensitivity"></param>
        /// <param name="axisGravity"></param>
        /// <returns></returns>
        public static float CalculateAxisInput (float currentInput, float targetInput, float axisSensitivity, float axisGravity)
        {
            // Check that the current input is different from the target input
            if (currentInput != targetInput)
            {
                #region Pre-Calculation

                // Check which side of the origin the current input position is
                bool currentInputPositive = currentInput > 0f;
                // Check which side of the origin the target input position is
                bool targetInputPositive = targetInput > 0f;
                // Calculate the distance from the origin to the current input position
                float currentDistFromOrigin = currentInputPositive ? currentInput : -currentInput;
                // Calculate the distance from the origin to the target input position
                float targetDistFromOrigin = targetInputPositive ? targetInput : -targetInput;

                #endregion

                #region Calculate Speed

                // Now, calculate speed to move towards target position at
                float inputMoveSpeed = 0f;
                // If the current input position and the target input position are on opposite sides of the origin,
                // move towards target position at speed of sensitivity + gravity
                if (currentInputPositive != targetInputPositive && currentInput != 0f && targetInput != 0f)
                {
                    inputMoveSpeed = axisSensitivity + axisGravity;
                }
                // Otherwise, if the current input position and the target input position are on the same side of the origin:
                // If the target input position is farther from the origin than the actual input position,
                // move towards target position at speed of sensitivity
                else if (targetDistFromOrigin > currentDistFromOrigin)
                {
                    inputMoveSpeed = axisSensitivity;
                }
                // If the target input position is closer to the origin than the actual input position,
                // move towards target position at speed of gravity
                else
                {
                    inputMoveSpeed = axisGravity;
                }

                #endregion

                #region Calculate New input

                // Calculate the difference between the target input and the current input
                float targetInputDelta = targetInput - currentInput;
                float absTargetInputDelta = targetInputDelta > 0f ? targetInputDelta : -targetInputDelta;
                // Calculate how far the input is able to move this frame, purely due to speed constraints
                float thisFrameInputMovement = inputMoveSpeed * Time.deltaTime;
                // If the possible frame movement is more than the difference between the target input and the current input,
                // simply jump straight to the target input
                if (thisFrameInputMovement > absTargetInputDelta)
                {
                    return targetInput;
                }
                // Otherwise, simply add this frame's input movement to the current input
                else
                {
                    // If the difference between the target input and the current input is negative, 
                    // apply a negative movement
                    return currentInput + (targetInputDelta > 0f ? thisFrameInputMovement : -thisFrameInputMovement);
                }

                #endregion
            }
            else
            {
                // If the current input is the same as the target input, leave it unchanged
                return currentInput;
            }
        }

        #endregion

        #region Public API Oculus API

        /// <summary>
        /// Check if the OVRManager is in the scene. If Oculus API is not installed,
        /// it does nothing. If the OVRManager is add or removed from the scene at runtime,
        /// call this method after making the change.
        /// </summary>
        public void CheckOVRManager()
        {
            #if SSC_OVR
            if (FindObjectOfType<OVRManager>() == null)
            {
                isOVRInputUpdateRequired = isOVRInputUpdatedIfRequired;
                isOVRManagerPresent = false;
            }
            else
            {
                isOVRManagerPresent = true;
                // If the OVRManager is in the scene, we never need to call OVRInput.Update() in PlayerInputModule.
                isOVRInputUpdateRequired = false;
            }
            #endif
        }


        #endregion

        #region Public API Unity Input System Methods
        #if SSC_UIS

        /// <summary>
        /// Get the Unity Input System PlayerInput component attached to this (player) ship.
        /// The component reference is cached so that GetComponent isn't called multiple times.
        /// </summary>
        /// <returns></returns>
        public UnityEngine.InputSystem.PlayerInput GetUISPlayerInput()
        {
            if (uisPlayerInput == null) { uisPlayerInput = GetComponent<UnityEngine.InputSystem.PlayerInput>(); }

            return uisPlayerInput;
        }

        #endif

        /// <summary>
        /// Used at runtime to convert string unique identifiers for actions (GUIDs) into
        /// Unity Input System ActionInputs to avoid looking them up and incurring GC overhead each Update.
        /// If actions are modified at runtime, call this method.
        /// Has no effect if Unity Input System package is not installed.
        /// </summary>
        /// <param name="showErrors"></param>
        public void UpdateUnityInputSystemActions(bool showErrors = false)
        {
            #if SSC_UIS

            #if UNITY_EDITOR
            string methodName = "PlayerInputModule.UpdateUnityInputSystemActions";
            #endif

            // Get the hashcodes for the Control Types that we support
            controlTypeButtonHashUIS = SSCMath.GetHashCode("Button");
            controlTypeAxisHashUIS = SSCMath.GetHashCode("Axis");
            // Dpad and Vector2 are equivalent
            controlTypeDpadHashUIS = SSCMath.GetHashCode("Dpad");
            controlTypeVector2HashUIS = SSCMath.GetHashCode("Vector2");
            controlTypeVector3HashUIS = SSCMath.GetHashCode("Vector3");

            // Make sure PlayerInput component is available
            // The current version of SSC depends on this Unity component to be attached to the same gameobject
            if (GetUISPlayerInput() != null)
            {
                int numCPI = customPlayerInputList == null ? 0 : customPlayerInputList.Count;

                if (uisPlayerInput.actions != null)
                {
                    //UnityEngine.InputSystem.InputAction inputAction = null;

                    positiveHorizontalInputActionUIS = uisPlayerInput.actions.FindAction(positiveHorizontalInputActionIdUIS);
                    positiveVerticalInputActionUIS = uisPlayerInput.actions.FindAction(positiveVerticalInputActionIdUIS);
                    positiveLongitudinalInputActionUIS = uisPlayerInput.actions.FindAction(positiveLongitudinalInputActionIdUIS);
                    positivePitchInputActionUIS = uisPlayerInput.actions.FindAction(positivePitchInputActionIdUIS);
                    positiveYawInputActionUIS = uisPlayerInput.actions.FindAction(positiveYawInputActionIdUIS);
                    positiveRollInputActionUIS = uisPlayerInput.actions.FindAction(positiveRollInputActionIdUIS);
                    primaryFireInputActionUIS = uisPlayerInput.actions.FindAction(primaryFireInputActionIdUIS);
                    secondaryFireInputActionUIS = uisPlayerInput.actions.FindAction(secondaryFireInputActionIdUIS);
                    quitInputActionUIS = uisPlayerInput.actions.FindAction(quitInputActionIdUIS);
                    dockingInputActionUIS = uisPlayerInput.actions.FindAction(dockingInputActionIdUIS);

                    positiveHorizontalCtrlTypeHashUIS = positiveHorizontalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveHorizontalInputActionUIS.expectedControlType);
                    positiveVerticalCtrlTypeHashUIS = positiveVerticalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveVerticalInputActionUIS.expectedControlType);
                    positiveLongitudinalCtrlTypeHashUIS = positiveLongitudinalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveLongitudinalInputActionUIS.expectedControlType);
                    positivePitchCtrlTypeHashUIS = positivePitchInputActionUIS == null ? 0 : SSCMath.GetHashCode(positivePitchInputActionUIS.expectedControlType);
                    positiveYawCtrlTypeHashUIS = positiveYawInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveYawInputActionUIS.expectedControlType);
                    positiveRollCtrlTypeHashUIS = positiveRollInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveRollInputActionUIS.expectedControlType);
                    primaryFireCtrlTypeHashUIS = primaryFireInputActionUIS == null ? 0 : SSCMath.GetHashCode(primaryFireInputActionUIS.expectedControlType);
                    secondaryFireCtrlTypeHashUIS = secondaryFireInputActionUIS == null ? 0 : SSCMath.GetHashCode(secondaryFireInputActionUIS.expectedControlType);
                    dockingCtrlTypeHashUIS = dockingInputActionUIS == null ? 0 : SSCMath.GetHashCode(dockingInputActionUIS.expectedControlType);

                    // Update all the Custom Player Inputs
                    for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];
                        if (customPlayerInput != null)
                        {
                            customPlayerInput.uisPositiveInputAction = uisPlayerInput.actions.FindAction(customPlayerInput.uisPositiveInputActionId);
                            customPlayerInput.uisPositiveCtrlTypeHash = customPlayerInput.uisPositiveInputAction == null ? 0 : SSCMath.GetHashCode(customPlayerInput.uisPositiveInputAction.expectedControlType);
                            customPlayerInput.lastInputValueX = 0f;
                            customPlayerInput.lastInputValueY = 0f;
                        }
                    }
                }
                else
                {
                    // set all actions to null
                    positiveHorizontalInputActionUIS = null;
                    positiveVerticalInputActionUIS = null;
                    positiveLongitudinalInputActionUIS = null;
                    positivePitchInputActionUIS = null;
                    positiveYawInputActionUIS = null;
                    positiveRollInputActionUIS = null;
                    primaryFireInputActionUIS = null;
                    secondaryFireInputActionUIS = null;
                    quitInputActionUIS = null;
                    dockingInputActionUIS = null;

                    positiveHorizontalCtrlTypeHashUIS = 0;
                    positiveVerticalCtrlTypeHashUIS = 0;
                    positiveLongitudinalCtrlTypeHashUIS = 0;
                    positivePitchCtrlTypeHashUIS = 0;
                    positiveYawCtrlTypeHashUIS = 0;
                    positiveRollCtrlTypeHashUIS = 0;
                    primaryFireCtrlTypeHashUIS = 0;
                    secondaryFireCtrlTypeHashUIS = 0;
                    dockingCtrlTypeHashUIS = 0;

                    // Update all the Custom Player Inputs
                    for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
                    {
                        CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];
                        if (customPlayerInput != null)
                        {
                            customPlayerInput.uisPositiveInputAction = null;
                            customPlayerInput.uisPositiveCtrlTypeHash = 0;
                        }
                    }

                    #if UNITY_EDITOR
                    if (showErrors) { Debug.LogWarning(methodName + " - PlayerInput component attached to " + this.name + " has no Input Action Asset."); }
                    #endif
                }
            }
            #if UNITY_EDITOR
            else { if (showErrors) { Debug.LogWarning(methodName + " couldn't find PlayerInput component attached to " + this.name); } }
            #endif

            #endif
        }

        #endregion

        #region Public API Rewired Methods
        /// <summary>
        /// Set the human player number. This should be 1 or greater. The player
        /// must be first assigned in Rewired, before this is called.
        /// NOTE: If Rewired is not installed or the InputMode is not Rewired,
        /// the rewiredPlayerNumber is set to 0 (unassigned).
        /// </summary>
        /// <param name="playerNumber"></param>
        /// <param name="showErrors"></param>
        public void SetRewiredPlayer(int playerNumber, bool showErrors = false)
        {
            if (playerNumber > 0)
            {
                #if SSC_REWIRED
                rewiredPlayer = GetRewiredPlayer(playerNumber, showErrors);
                // Only assign player number if the rewired player is found
                rewiredPlayerNumber = rewiredPlayer == null ? 0 : playerNumber;
                #else
                rewiredPlayerNumber = playerNumber;
                #endif
            }
            else
            {
                rewiredPlayerNumber = 0;
                #if SSC_REWIRED
                rewiredPlayer = null;
                #endif
            }
        }

        /// <summary>
        /// A Rewired Action can be an Axis or a Button. To avoid looking up the Action
        /// within the Update event, the type is set outside the loop and need only be
        /// called once at runtime for this ship, and then when ever the Actions are
        /// changed. Has no effect if Rewired is not installed.
        /// </summary>
        public void UpdateRewiredActionTypes(bool showErrors)
        {
            #if SSC_REWIRED
            if (CheckRewired(showErrors))
            {
                Rewired.InputAction inputAction = null;
                inputAction = Rewired.ReInput.mapping.GetAction(positiveHorizontalInputActionId);
                if (inputAction != null) { positiveHorizontalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativeHorizontalInputActionId);
                if (inputAction != null) { negativeHorizontalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(positiveVerticalInputActionId);
                if (inputAction != null) { positiveVerticalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativeVerticalInputActionId);
                if (inputAction != null) { negativeVerticalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(positiveLongitudinalInputActionId);
                if (inputAction != null) { positiveLongitudinalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativeLongitudinalInputActionId);
                if (inputAction != null) { negativeLongitudinalInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(positivePitchInputActionId);
                if (inputAction != null) { positivePitchInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativePitchInputActionId);
                if (inputAction != null) { negativePitchInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(positiveYawInputActionId);
                if (inputAction != null) { positiveYawInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativeYawInputActionId);
                if (inputAction != null) { negativeYawInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(positiveRollInputActionId);
                if (inputAction != null) { positiveRollInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(negativeRollInputActionId);
                if (inputAction != null) { negativeRollInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(primaryFireInputActionId);
                if (inputAction != null) { primaryFireInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(secondaryFireInputActionId);
                if (inputAction != null) { secondaryFireInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                inputAction = Rewired.ReInput.mapping.GetAction(dockingInputActionId);
                if (inputAction != null) { dockingInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }

                int numCPI = customPlayerInputList == null ? 0 : customPlayerInputList.Count;

                for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
                {
                    CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];
                    if (customPlayerInput != null)
                    {
                        inputAction = Rewired.ReInput.mapping.GetAction(customPlayerInput.rwdPositiveInputActionId);
                        if (inputAction != null) { customPlayerInput.rwdPositiveInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }
                        else { customPlayerInput.rwdPositiveInputActionType = 0; }

                        customPlayerInput.lastInputValueX = 0f;
                        customPlayerInput.lastInputValueY = 0f;
                        customPlayerInput.rwLastIsButtonPressed = false;

                        inputAction = Rewired.ReInput.mapping.GetAction(customPlayerInput.rwdNegativeInputActionId);
                        if (inputAction != null) { customPlayerInput.rwdNegativeInputActionType = inputAction.type == Rewired.InputActionType.Button ? 1 : 0; }
                        else { customPlayerInput.rwdNegativeInputActionType = 0; }
                    }
                }
            }
            #endif
        }

        #endregion

        #region Public API Vive Methods
        /// <summary>
        /// Vive Input configuration is stored in SSC in a generic form. To avoid converting it with the Update event loops,
        /// it is converted here once. If the Vive Input is changed via the PlayerInputModule at runtime, call this method.
        /// If this is not called, in the Editor you might receive 'PlayerInputModule VIVE Argument cannot be null.'
        /// </summary>
        /// <param name="showErrors"></param>
        public void UpdateViveInput(bool showErrors)
        {
            // We could get the type from the assembly OR we could just check for the current known types...
            #if VIU_PLUGIN
            viveHorizontalRoleSystemType = viveHorizontalRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveHorizontalRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveHorizontalRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveVerticalRoleSystemType = viveVerticalRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveVerticalRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveVerticalRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveLongitudinalRoleSystemType = viveLongitudinalRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveLongitudinalRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveLongitudinalRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            vivePitchRoleSystemType = vivePitchRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (vivePitchRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (vivePitchRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveYawRoleSystemType = viveYawRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveYawRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveYawRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveRollRoleSystemType = viveRollRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveRollRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveRollRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            vivePrimaryFireRoleSystemType = vivePrimaryFireRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (vivePrimaryFireRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (vivePrimaryFireRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveSecondaryFireRoleSystemType = viveSecondaryFireRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveSecondaryFireRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveSecondaryFireRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));
            viveDockingRoleSystemType = viveDockingRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (viveDockingRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (viveDockingRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));

            // Avoid Enum conversion in Update event
            // Assume +ve and -ve must always be the same type (Axis or Button)

            if (viveHorizontalInputType == ViveInputType.Axis)
            {
                positiveHorizontalInputCtrlAxisVive = (ControllerAxis)positiveHorizontalInputCtrlVive;
                negativeHorizontalInputCtrlAxisVive = (ControllerAxis)negativeHorizontalInputCtrlVive;
                positiveHorizontalInputCtrlBtnVive = ControllerButton.None;
                negativeHorizontalInputCtrlBtnVive = ControllerButton.None;
            }
            else if (viveHorizontalInputType == ViveInputType.Button)
            {
                positiveHorizontalInputCtrlBtnVive = (ControllerButton)positiveHorizontalInputCtrlVive;
                negativeHorizontalInputCtrlBtnVive = (ControllerButton)negativeHorizontalInputCtrlVive;
                positiveHorizontalInputCtrlAxisVive = ControllerAxis.None;
                negativeHorizontalInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positiveHorizontalInputCtrlAxisVive = ControllerAxis.None;
                negativeHorizontalInputCtrlAxisVive = ControllerAxis.None;
                positiveHorizontalInputCtrlBtnVive = ControllerButton.None;
                negativeHorizontalInputCtrlBtnVive = ControllerButton.None;
            }

            if (viveVerticalInputType == ViveInputType.Axis)
            {
                positiveVerticalInputCtrlAxisVive = (ControllerAxis)positiveVerticalInputCtrlVive;
                negativeVerticalInputCtrlAxisVive = (ControllerAxis)negativeVerticalInputCtrlVive;
                positiveVerticalInputCtrlBtnVive = ControllerButton.None;
                negativeVerticalInputCtrlBtnVive = ControllerButton.None;
            }
            else if (viveVerticalInputType == ViveInputType.Button)
            {
                positiveVerticalInputCtrlBtnVive = (ControllerButton)positiveVerticalInputCtrlVive;
                negativeVerticalInputCtrlBtnVive = (ControllerButton)negativeVerticalInputCtrlVive;
                positiveVerticalInputCtrlAxisVive = ControllerAxis.None;
                negativeVerticalInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positiveVerticalInputCtrlAxisVive = ControllerAxis.None;
                negativeVerticalInputCtrlAxisVive = ControllerAxis.None;
                positiveVerticalInputCtrlBtnVive = ControllerButton.None;
                negativeVerticalInputCtrlBtnVive = ControllerButton.None;
            }

            if (viveLongitudinalInputType == ViveInputType.Axis)
            {
                positiveLongitudinalInputCtrlAxisVive = (ControllerAxis)positiveLongitudinalInputCtrlVive;
                negativeLongitudinalInputCtrlAxisVive = (ControllerAxis)negativeLongitudinalInputCtrlVive;
                positiveLongitudinalInputCtrlBtnVive = ControllerButton.None;
                negativeLongitudinalInputCtrlBtnVive = ControllerButton.None;
            }
            else if (viveLongitudinalInputType == ViveInputType.Button)
            {
                positiveLongitudinalInputCtrlBtnVive = (ControllerButton)positiveLongitudinalInputCtrlVive;
                negativeLongitudinalInputCtrlBtnVive = (ControllerButton)negativeLongitudinalInputCtrlVive;
                positiveLongitudinalInputCtrlAxisVive = ControllerAxis.None;
                negativeLongitudinalInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positiveLongitudinalInputCtrlAxisVive = ControllerAxis.None;
                negativeLongitudinalInputCtrlAxisVive = ControllerAxis.None;
                positiveLongitudinalInputCtrlBtnVive = ControllerButton.None;
                negativeLongitudinalInputCtrlBtnVive = ControllerButton.None;
            }

            if (vivePitchInputType == ViveInputType.Axis)
            {
                positivePitchInputCtrlAxisVive = (ControllerAxis)positivePitchInputCtrlVive;
                negativePitchInputCtrlAxisVive = (ControllerAxis)negativePitchInputCtrlVive;
                positivePitchInputCtrlBtnVive = ControllerButton.None;
                negativePitchInputCtrlBtnVive = ControllerButton.None;
            }
            else if (vivePitchInputType == ViveInputType.Button)
            {
                positivePitchInputCtrlBtnVive = (ControllerButton)positivePitchInputCtrlVive;
                negativePitchInputCtrlBtnVive = (ControllerButton)negativePitchInputCtrlVive;
                positivePitchInputCtrlAxisVive = ControllerAxis.None;
                negativePitchInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positivePitchInputCtrlAxisVive = ControllerAxis.None;
                negativePitchInputCtrlAxisVive = ControllerAxis.None;
                positivePitchInputCtrlBtnVive = ControllerButton.None;
                negativePitchInputCtrlBtnVive = ControllerButton.None;
            }

            if (viveYawInputType == ViveInputType.Axis)
            {
                positiveYawInputCtrlAxisVive = (ControllerAxis)positiveYawInputCtrlVive;
                negativeYawInputCtrlAxisVive = (ControllerAxis)negativeYawInputCtrlVive;
                positiveYawInputCtrlBtnVive = ControllerButton.None;
                negativeYawInputCtrlBtnVive = ControllerButton.None;
            }
            else if (viveYawInputType == ViveInputType.Button)
            {
                positiveYawInputCtrlBtnVive = (ControllerButton)positiveYawInputCtrlVive;
                negativeYawInputCtrlBtnVive = (ControllerButton)negativeYawInputCtrlVive;
                positiveYawInputCtrlAxisVive = ControllerAxis.None;
                negativeYawInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positiveYawInputCtrlAxisVive = ControllerAxis.None;
                negativeYawInputCtrlAxisVive = ControllerAxis.None;
                positiveYawInputCtrlBtnVive = ControllerButton.None;
                negativeYawInputCtrlBtnVive = ControllerButton.None;
            }

            if (viveRollInputType == ViveInputType.Axis)
            {
                positiveRollInputCtrlAxisVive = (ControllerAxis)positiveRollInputCtrlVive;
                negativeRollInputCtrlAxisVive = (ControllerAxis)negativeRollInputCtrlVive;
                positiveRollInputCtrlBtnVive = ControllerButton.None;
                negativeRollInputCtrlBtnVive = ControllerButton.None;
            }
            else if (viveRollInputType == ViveInputType.Button)
            {
                positiveRollInputCtrlBtnVive = (ControllerButton)positiveRollInputCtrlVive;
                negativeRollInputCtrlBtnVive = (ControllerButton)negativeRollInputCtrlVive;
                positiveRollInputCtrlAxisVive = ControllerAxis.None;
                negativeRollInputCtrlAxisVive = ControllerAxis.None;
            }
            else
            {
                positiveRollInputCtrlAxisVive = ControllerAxis.None;
                negativeRollInputCtrlAxisVive = ControllerAxis.None;
                positiveRollInputCtrlBtnVive = ControllerButton.None;
                negativeRollInputCtrlBtnVive = ControllerButton.None;
            }

            // Primary and Secondary Fire and Docking will always be buttons
            primaryFireInputCtrlBtnVive = (ControllerButton)primaryFireInputCtrlVive;
            secondaryFireInputCtrlBtnVive = (ControllerButton)secondaryFireInputCtrlVive;
            dockingInputCtrlBtnVive = (ControllerButton)dockingInputCtrlVive;

            int numCPI = customPlayerInputList == null ? 0 : customPlayerInputList.Count;

            for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
            {
                CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];
                if (customPlayerInput != null)
                {
                    // Check for the known types
                    customPlayerInput.viveRoleSystemType = customPlayerInput.viveRoleType == ViveRoleType.BodyRole ? typeof(BodyRole) : (customPlayerInput.viveRoleType == ViveRoleType.DeviceRole ? typeof(DeviceRole) : (customPlayerInput.viveRoleType == ViveRoleType.TrackerRole ? typeof(TrackerRole) : typeof(HandRole)));

                    // Avoid Enum conversion in Update event
                    // Assume +ve and -ve must always be the same type (Axis or Button)
                    if (customPlayerInput.viveInputType == ViveInputType.Axis)
                    {
                        customPlayerInput.vivePositiveInputCtrlAxis = (ControllerAxis)positiveYawInputCtrlVive;
                        customPlayerInput.viveNegativeInputCtrlAxis = (ControllerAxis)negativeYawInputCtrlVive;
                        customPlayerInput.vivePositiveInputCtrlBtn = ControllerButton.None;
                        customPlayerInput.viveNegativeInputCtrlBtn = ControllerButton.None;
                    }
                    else if (customPlayerInput.viveInputType == ViveInputType.Button)
                    {
                        customPlayerInput.vivePositiveInputCtrlBtn = (ControllerButton)positiveYawInputCtrlVive;
                        customPlayerInput.viveNegativeInputCtrlBtn = (ControllerButton)negativeYawInputCtrlVive;
                        customPlayerInput.vivePositiveInputCtrlAxis = ControllerAxis.None;
                        customPlayerInput.viveNegativeInputCtrlAxis = ControllerAxis.None;
                    }
                    else
                    {
                        customPlayerInput.vivePositiveInputCtrlAxis = ControllerAxis.None;
                        customPlayerInput.viveNegativeInputCtrlAxis = ControllerAxis.None;
                        customPlayerInput.vivePositiveInputCtrlBtn = ControllerButton.None;
                        customPlayerInput.viveNegativeInputCtrlBtn = ControllerButton.None;
                    }

                    customPlayerInput.lastInputValueX = 0f;
                    customPlayerInput.lastInputValueY = 0f;
                }
            }

            #endif
        }

        #endregion

        #region Public API Rumble Methods

        /// <summary>
        /// Set the rumble / vibration / force feedback amount on the current
        /// device. Currently only applies to Unity Input System and Rewired.
        /// </summary>
        /// <param name="rumbleAmount"></param>
        public void SetRumble(float rumbleAmount)
        {
            // Clamp 0.0 - 1.0
            float actualRumbleAmount = rumbleAmount < 0f ? 0f : rumbleAmount > 1f ? 1f : rumbleAmount;

            try
            {
                if (inputMode == InputMode.UnityInputSystem)
                {
                    #if SSC_UIS
                    /// TODO - check for device assigned to this player ship
                    if (UnityEngine.InputSystem.Gamepad.current != null)
                    {
                        UnityEngine.InputSystem.Gamepad.current.SetMotorSpeeds(actualRumbleAmount * maxRumble1, actualRumbleAmount * maxRumble2);
                    }
                    #endif
                }
                else if (inputMode == InputMode.Rewired)
                {
                    #if SSC_REWIRED
                    if (rewiredPlayer != null && rewiredPlayer.controllers.joystickCount > 0)
                    {
                        float rumble1Amount = actualRumbleAmount * maxRumble1;
                        float rumble2Amount = actualRumbleAmount * maxRumble2;

                        if (rumble1Amount > 0.01f || rumble2Amount > 0.01f)
                        {
                            // Set the motor values to be proportional to the maximum specified
                            rewiredPlayer.controllers.Joysticks[0].SetVibration(0, rumble1Amount);
                            rewiredPlayer.controllers.Joysticks[0].SetVibration(1, rumble2Amount);
                        }
                        else { rewiredPlayer.controllers.Joysticks[0].StopVibration(); }
                    }
                    #endif
                }
                else
                {
                    // keep compiler happy but do nothing
                    if (actualRumbleAmount > 0f) { }
                }
            }
            catch (System.Exception ex)
            {
                #if UNITY_EDITOR
                Debug.LogWarning("ERROR: SetRumble - something went wrong. " + ex.Message);
                #else
                if (ex != null) { }
                #endif
            }
        }

        /// <summary>
        /// This should be called if you change maxRumble1 or maxRumble2 at runtime.
        /// </summary>
        public void ReinitialiseRumble()
        {
            if (shipControlModule != null)
            {
                // Is rumble enabled and within acceptable values?
                if ((maxRumble1 > 0f || maxRumble2 > 0f) && maxRumble1 <= 1f && maxRumble2 <= 1f)
                {
                    shipControlModule.callbackOnRumble = SetRumble;
                }
                else { shipControlModule.callbackOnRumble = null; }
            }
        }

        #endregion

        #region Public API XR Methods

        /// <summary>
        /// Attempt to disable the XR Camera. Has no effect if UnityXR is not configured.
        /// </summary>
        public void DisableXRCamera()
        {
            #if SCSM_XR && SSC_UIS
            EnableOrDisableXRCamera(false);
            #endif
        }

        /// <summary>
        /// Attempt to disable the XR Hands. Has no effect if UnityXR is not configured.
        /// </summary>
        public void DisableXRHands()
        {
            #if SCSM_XR && SSC_UIS
            EnableOrDisableXRHands(false);
            #endif
        }

        /// <summary>
        /// Attempt to enable the XR Camera. Has no effect if UnityXR is not configured.
        /// </summary>
        public void EnableXRCamera()
        {
            #if SCSM_XR && SSC_UIS
            EnableOrDisableXRCamera(true);
            #endif
        }

        /// <summary>
        /// Attempt to enable the XR Hands. Has no effect if UnityXR is not configured.
        /// </summary>
        public void EnableXRHands()
        {
            #if SCSM_XR && SSC_UIS
            EnableOrDisableXRHands(true);
            #endif
        }

        #if SCSM_XR && SSC_UIS

        /// <summary>
        /// Get the Unity Input System InputActionAsset scriptableobject for XR
        /// </summary>
        /// <returns></returns>
        public UnityEngine.InputSystem.InputActionAsset GetXRInputActionAsset()
        {
            return inputActionAssetXR;
        }

        /// <summary>
        /// Set the XR camera which will be rotated by the Tracked Pose Driver.
        /// </summary>
        /// <param name="newCamera"></param>
        /// <param name="cameraTrfm"></param>
        /// <param name="isAutoEnable"></param>
        /// <returns></returns>
        public bool SetXRFirstPersonCamera1 (Camera newCamera, Transform cameraTrfm, bool isAutoEnable)
        {
            bool isSuccessful = false;

            if (newCamera == null || cameraTrfm == null)
            {
                firstPersonCamera1XR = null;
                firstPersonTransform1XR = null;
            }
            // Ensure camera is a child of the PlayerInputModule (and ShipControlModule) and the camera is on the transform being passed in.
            else if (cameraTrfm.IsChildOf(transform) && newCamera.transform.GetInstanceID() == cameraTrfm.GetInstanceID())
            {
                firstPersonCamera1XR = newCamera;
                firstPersonTransform1XR = cameraTrfm;

                firstPersonCamera1XR.enabled = isAutoEnable;
            }

            return isSuccessful;
        }

        /// <summary>
        /// Used at runtime to convert string unique identifiers for actions (GUIDs) into
        /// Unity Input System ActionInputs to avoid looking them up and incurring GC overhead each Update.
        /// If actions are modified at runtime, call this method.
        /// Has no effect if Unity Input System package is not installed.
        /// </summary>
        /// <param name="showErrors"></param>
        public void UpdateUnityXRActions (bool showErrors = false)
        {
            #if UNITY_EDITOR
            string methodName = "PlayerInputModule.UpdateUnityXRActions";
            #endif

            // Get the hashcodes for the Control Types that we support
            controlTypeButtonHashUIS = SSCMath.GetHashCode("Button");
            controlTypeAxisHashUIS = SSCMath.GetHashCode("Axis");
            // Dpad and Vector2 are equivalent
            controlTypeDpadHashUIS = SSCMath.GetHashCode("Dpad");
            controlTypeVector2HashUIS = SSCMath.GetHashCode("Vector2");
            controlTypeVector3HashUIS = SSCMath.GetHashCode("Vector3");

            if (inputActionAssetXR != null)
            {
                int numCPI = customPlayerInputList == null ? 0 : customPlayerInputList.Count;

                //UnityEngine.InputSystem.InputAction inputAction = null;

                positiveHorizontalInputActionUIS = UISGetAction(inputActionAssetXR, positiveHorizontalInputActionMapIdXR, positiveHorizontalInputActionIdUIS);
                positiveVerticalInputActionUIS = UISGetAction(inputActionAssetXR, positiveVerticalInputActionMapIdXR, positiveVerticalInputActionIdUIS);
                positiveLongitudinalInputActionUIS = UISGetAction(inputActionAssetXR, positiveLongitudinalInputActionMapIdXR, positiveLongitudinalInputActionIdUIS);
                positivePitchInputActionUIS = UISGetAction(inputActionAssetXR, positivePitchInputActionMapIdXR, positivePitchInputActionIdUIS);
                positiveYawInputActionUIS = UISGetAction(inputActionAssetXR, positiveYawInputActionMapIdXR, positiveYawInputActionIdUIS);
                positiveRollInputActionUIS = UISGetAction(inputActionAssetXR, positiveRollInputActionMapIdXR, positiveRollInputActionIdUIS);
                primaryFireInputActionUIS = UISGetAction(inputActionAssetXR, primaryFireInputActionMapIdXR, primaryFireInputActionIdUIS);
                secondaryFireInputActionUIS = UISGetAction(inputActionAssetXR, secondaryFireInputActionMapIdXR, secondaryFireInputActionIdUIS);
                dockingInputActionUIS = UISGetAction(inputActionAssetXR, dockingInputActionMapIdXR, dockingInputActionIdUIS);

                positiveHorizontalCtrlTypeHashUIS = positiveHorizontalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveHorizontalInputActionUIS.expectedControlType);
                positiveVerticalCtrlTypeHashUIS = positiveVerticalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveVerticalInputActionUIS.expectedControlType);
                positiveLongitudinalCtrlTypeHashUIS = positiveLongitudinalInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveLongitudinalInputActionUIS.expectedControlType);
                positivePitchCtrlTypeHashUIS = positivePitchInputActionUIS == null ? 0 : SSCMath.GetHashCode(positivePitchInputActionUIS.expectedControlType);
                positiveYawCtrlTypeHashUIS = positiveYawInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveYawInputActionUIS.expectedControlType);
                positiveRollCtrlTypeHashUIS = positiveRollInputActionUIS == null ? 0 : SSCMath.GetHashCode(positiveRollInputActionUIS.expectedControlType);
                primaryFireCtrlTypeHashUIS = primaryFireInputActionUIS == null ? 0 : SSCMath.GetHashCode(primaryFireInputActionUIS.expectedControlType);
                secondaryFireCtrlTypeHashUIS = secondaryFireInputActionUIS == null ? 0 : SSCMath.GetHashCode(secondaryFireInputActionUIS.expectedControlType);
                dockingCtrlTypeHashUIS = dockingInputActionUIS == null ? 0 : SSCMath.GetHashCode(dockingInputActionUIS.expectedControlType);

                // Update all the Custom Player Inputs
                for (int cpiIdx = 0; cpiIdx < numCPI; cpiIdx++)
                {
                    CustomPlayerInput customPlayerInput = customPlayerInputList[cpiIdx];
                    if (customPlayerInput != null)
                    {
                        customPlayerInput.uisPositiveInputAction = UISGetAction(inputActionAssetXR, customPlayerInput.xrPositiveInputActionMapId, customPlayerInput.uisPositiveInputActionId);
                        customPlayerInput.uisPositiveCtrlTypeHash = customPlayerInput.uisPositiveInputAction == null ? 0 : SSCMath.GetHashCode(customPlayerInput.uisPositiveInputAction.expectedControlType);
                        customPlayerInput.lastInputValueX = 0f;
                        customPlayerInput.lastInputValueY = 0f;
                    }
                }
            }
            #if UNITY_EDITOR
            else { if (showErrors) { Debug.LogWarning(methodName + " couldn't find inputActionAssetXR for " + this.name); } }
            #endif
        }

        #endif
        #endregion

        #region Public API - AI Assist Methods

        /// <summary>
        /// Attempt to enter Ship AI-assisted mode, then attempt docking.
        /// </summary>
        public void EnableAIDocking()
        {
            bool originalAIMode = isShipAIModeEnabled;

            if (!isShipAIModeEnabled) { EnableOrDisableAIMode(true); }

            // Is AI mode now enabled?
            if (isShipAIModeEnabled)
            {
                ShipDocking shipDocking = shipControlModule.GetShipDocking(false);

                if (shipDocking != null)
                {
                    int dockingStateInt = shipDocking.GetStateInt();

                    //Debug.Log("[DEBUG] EnableAIDocking T:" + Time.time);

                    // v1.2.3 add ability to dock when in undocking state
                    if (dockingStateInt == ShipDocking.notDockedInt || dockingStateInt == ShipDocking.undockingInt)
                    {
                        shipDocking.SetState(ShipDocking.DockingState.Docking);
                    }
                    else
                    {
                        #if UNITY_EDITOR
                        Debug.LogWarning("ERROR: PlayerInputModule.EnableAIDocking - cannot enable AI Docking as " + gameObject.name + " is " + shipDocking.GetState().ToString() + ". It must be in the NotDocked or UnDocking state.");
                        #endif

                        // Attempt to restore original AI Mode
                        if (!originalAIMode) { EnableOrDisableAIMode(false); }
                    }
                }
                else
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: PlayerInputModule.EnableAIDocking - cannot enable AI Docking as Ship Docking component may not be attached to " + gameObject.name);
                    #endif

                    // Attempt to restore original AI Mode
                    if (!originalAIMode) { EnableOrDisableAIMode(false); }
                }
            }
        }

        /// <summary>
        /// Attempt to enter Ship AI-assisted mode, then attempt undocking.
        /// </summary>
        public void EnableAIUndocking()
        {
            bool originalAIMode = isShipAIModeEnabled;

            if (!isShipAIModeEnabled) { EnableOrDisableAIMode(true); }

            // Is AI mode now enabled?
            if (isShipAIModeEnabled)
            {
                ShipDocking shipDocking = shipControlModule.GetShipDocking(false);

                if (shipDocking != null)
                {
                    int dockingStateInt = shipDocking.GetStateInt();

                    //Debug.Log("[DEBUG] EnableAIUndocking T:" + Time.time);

                    // v1.2.3 add ability to undock when in docking state
                    if (dockingStateInt == ShipDocking.dockedInt || dockingStateInt == ShipDocking.dockingInt)
                    {
                        shipDocking.SetState(ShipDocking.DockingState.Undocking);
                    }
                    else
                    {
                        #if UNITY_EDITOR
                        Debug.LogWarning("ERROR: PlayerInputModule.EnableAIUnDocking - cannot enable AI Undocking as " + gameObject.name + " is " + shipDocking.GetState().ToString() + ". It must be in the Docked or Docking state.");
                        #endif

                        // Attempt to restore original AI Mode
                        if (!originalAIMode) { EnableOrDisableAIMode(false); }
                    }
                }
                else
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: PlayerInputModule.EnableAIDocking - cannot enable AI Docking as Ship Docking component may not be attached to " + gameObject.name);
                    #endif

                    // Attempt to restore original AI Mode
                    if (!originalAIMode) { EnableOrDisableAIMode(false); }
                }
            }
        }

        /// <summary>
        /// Attempt to disable AI control mode. This requires a Ship AI Input Module to also be attached
        /// to the player ship. After calling this method, check if it was successful with the
        /// IsShipAIModeEnabled property.
        /// </summary>
        public void DisableAIMode()
        {
            EnableOrDisableAIMode(false);
        }

        /// <summary>
        /// Attempt to enable AI control mode. This requires a Ship AI Input Module to also be attached
        /// to the player ship. After calling this method, check if it was successful with the
        /// IsShipAIModeEnabled property.
        /// </summary>
        public void EnableAIMode()
        {
            EnableOrDisableAIMode(true);
        }

        /// <summary>
        /// Attempt to switch between Player and AI control or vis versa.
        /// If the mode is changed during this method, we can assume that the Ship AI Input Module
        /// component is present and initialised.
        /// </summary>
        public void ToggleAIMode()
        {
            EnableOrDisableAIMode(!isShipAIModeEnabled);
        }

        /// <summary>
        /// Currently in Technical Preview
        /// Attempt to enter Ship AI-assisted mode, then attempt docking or undocking depending upon the current DockignState.
        /// </summary>
        public void ToggleAIDocking()
        {
            bool originalAIMode = isShipAIModeEnabled;

            if (!isShipAIModeEnabled) { EnableOrDisableAIMode(true); }

            // Is AI mode now enabled?
            if (isShipAIModeEnabled)
            {
                ShipDocking shipDocking = shipControlModule.GetShipDocking(false);

                if (shipDocking != null)
                {
                    int currentDockingState = shipDocking.GetStateInt();
                    
                    if (currentDockingState == ShipDocking.dockedInt)
                    {
                        shipDocking.SetState(ShipDocking.DockingState.Undocking);
                    }
                    else if (currentDockingState == ShipDocking.notDockedInt)
                    {
                        shipDocking.SetState(ShipDocking.DockingState.Docking);
                    }
                    else
                    {
                        // Attempt to restore original AI Mode
                        if (!originalAIMode) { EnableOrDisableAIMode(false); }
                    }
                }
                else
                {
                    #if UNITY_EDITOR
                    Debug.LogWarning("ERROR: PlayerInputModule.ToggleAIDocking - cannot toggle AI Docking as Ship Docking component may not be attached to " + gameObject.name);
                    #endif

                    // Attempt to restore original AI Mode
                    if (!originalAIMode) { EnableOrDisableAIMode(false); }
                }
            }
        }

        #endregion

        #endregion
    }
}