Input.cs

Go to the documentation of this file.

/*
 * Copyright (C) 2020-2022 Tilt Five, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using UnityEngine;
 
#if UNITY_2019_1_OR_NEWER && INPUTSYSTEM_AVAILABLE
using UnityEngine.InputSystem;
#endif
 
using TiltFive.Logging;
 
namespace TiltFive
{
    public static class Input
    {
        #region Public Enums
 
        public enum WandButton : UInt32
        {
            T5      = 1 << 0,
            One     = 1 << 1,
            Two     = 1 << 2,
            Three   = 1 << 7,
            Y       = 1 << 3,
            B       = 1 << 4,
            A       = 1 << 5,
            X       = 1 << 6,
            [Obsolete("WandButton.System is deprecated, please use Wandbutton.T5 instead.")]
            System  = T5,
            [Obsolete("WandButton.Z is deprecated, please use Wandbutton.Three instead.")]
            Z       = Three,
        }
 
        #endregion Public Enums
 
 
        #region Private Fields
 
#if UNITY_2019_1_OR_NEWER && INPUTSYSTEM_AVAILABLE
        internal static GlassesDevice[] glassesDevices = new GlassesDevice[PlayerSettings.MAX_SUPPORTED_PLAYERS];
        internal static WandDevice[,] wandDevices = new WandDevice[PlayerSettings.MAX_SUPPORTED_PLAYERS, 2];
#endif
 
        #endregion
 
 
        #region Public Functions
 
        public static bool GetButton(WandButton button,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            return TryGetButton(button, out var pressed, controllerIndex, playerIndex) && pressed;
        }
 
        public static bool TryGetButton(WandButton button, out bool pressed,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                pressed = false;
                return false;
            }
 
            return Wand.TryGetButton(button, out pressed, glassesHandle, controllerIndex);
        }
 
        public static bool GetButtonDown(WandButton button,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            return TryGetButtonDown(button, out var buttonDown, controllerIndex, playerIndex) && buttonDown;
        }
 
        public static bool TryGetButtonDown(WandButton button, out bool buttonDown,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            // The specified player's glasses aren't even connected, let alone the wand. No way to get a rising edge here.
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                buttonDown = false;
                return false;
            }
 
            return Wand.TryGetButtonDown(button, out buttonDown, glassesHandle, controllerIndex);
        }
 
        public static bool GetButtonUp(WandButton button,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            return TryGetButtonUp(button, out var buttonUp, controllerIndex, playerIndex) && buttonUp;
        }
 
        public static bool TryGetButtonUp(WandButton button, out bool buttonUp,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            // TODO: Tweak the Wand.cs TryGetButtonDown to check if the glasses disconnected this frame.
            // If it did, and the button was held last frame, then buttonUp can be true.
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                buttonUp = false;
                return false;
            }
 
            return Wand.TryGetButtonUp(button, out buttonUp, glassesHandle, controllerIndex);
        }
 
        public static Vector2 GetStickTilt(ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            if(TryGetStickTilt(out var stickTilt, controllerIndex, playerIndex))
            {
                return stickTilt;
            }
            return Vector2.zero;
        }
 
        public static bool TryGetStickTilt(out Vector2 stickTilt,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                stickTilt = Vector2.zero;
                return false;
            }
            return Wand.TryGetStickTilt(out stickTilt, glassesHandle, controllerIndex);
        }
 
        public static float GetTrigger(ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            if(TryGetTrigger(out var triggerDisplacement, controllerIndex, playerIndex))
            {
                return triggerDisplacement;
            }
            return 0f;
        }
 
        public static bool TryGetTrigger(out float triggerDisplacement,
            ControllerIndex controllerIndex = ControllerIndex.Right, PlayerIndex playerIndex = PlayerIndex.One)
        {
            if (!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                triggerDisplacement = 0f;
                return false;
            }
            return Wand.TryGetTrigger(out triggerDisplacement, glassesHandle, controllerIndex);
        }
 
        public static bool GetWandAvailability(ControllerIndex controllerIndex = ControllerIndex.Right)
        {
            return Wand.TryCheckConnected(out var connected, PlayerIndex.One, controllerIndex) && connected;
        }
 
        // Legacy code, might remove soon.
        public static bool SetRumbleMotor(uint motor, float intensity)
        {
 
            int result = 0;
            try
            {
                result = NativePlugin.SetRumbleMotor(motor, intensity);
            }
            catch (Exception e)
            {
                Log.Error(e.Message);
            }
 
            return (0 != result);
        }
 
        public static void Update()
        {
            // Deleting this function would be appropriate, but since it's public,
            // there's a small chance it could break someone's code...
            // ...not that I can think of a use-case that involves calling TiltFive.Input.Update()
        }
 
        #endregion Public Functions
 
 
        #region Internal Functions
 
        internal static bool GetButton(this T5_ControllerState controllerState, WandButton button)
        {
            var buttonsState = controllerState.ButtonsState;
 
            switch (button)
            {
                case WandButton.T5:
                    return buttonsState.T5;
                case WandButton.One:
                    return buttonsState.One;
                case WandButton.Two:
                    return buttonsState.Two;
                case WandButton.Y:
                    return buttonsState.Y;
                case WandButton.B:
                    return buttonsState.B;
                case WandButton.A:
                    return buttonsState.A;
                case WandButton.X:
                    return buttonsState.X;
                case WandButton.Three:
                    return buttonsState.Three;
                default:
                    throw new ArgumentException("Invalid WandButton argument - enum value does not exist");
            }
 
        }
 
        internal static bool TryGetButton(this T5_ControllerState controllerState, WandButton button)
        {
            return controllerState.ButtonsValid && controllerState.GetButton(button);
        }
 
        internal static Vector2 TryGetStick(this T5_ControllerState controllerState)
        {
            return controllerState.AnalogValid ? controllerState.Stick : Vector2.zero;
        }
 
        internal static float TryGetTrigger(this T5_ControllerState controllerState)
        {
            return controllerState.AnalogValid ? controllerState.Trigger : 0f;
        }
 
#if UNITY_2019_1_OR_NEWER && INPUTSYSTEM_AVAILABLE
        internal static GlassesDevice GetGlassesDevice(PlayerIndex playerIndex)
        {
            return glassesDevices[(int)playerIndex - 1];
        }
 
        internal static WandDevice GetWandDevice(PlayerIndex playerIndex, ControllerIndex controllerIndex)
        {
            return wandDevices[(int)playerIndex - 1, (int)controllerIndex];
        }
#endif
 
        #endregion Internal Functions
 
 
        #region Private Functions
 
        static Input()
        {
            Wand.ScanForWands();
        }
 
#if UNITY_2019_1_OR_NEWER && INPUTSYSTEM_AVAILABLE
        internal static void AddGlassesDevice(PlayerIndex playerIndex)
        {
            var glassesDevices = Input.glassesDevices;
            int i = (int)playerIndex - 1;
 
            // Create a GlassesDevice if necessary
            if (glassesDevices[i] == null)
            {
                var preexistingGlassesDevice = InputSystem.GetDevice<GlassesDevice>($"Player{playerIndex}");
                if (preexistingGlassesDevice != null)
                {
                    glassesDevices[i] = preexistingGlassesDevice;
                    glassesDevices[i].PlayerIndex = playerIndex;
                }
                else
                {
                    glassesDevices[i] = InputSystem.AddDevice<GlassesDevice>($"T5 Glasses - Player {playerIndex}");
                    glassesDevices[i].PlayerIndex = playerIndex;
                    InputSystem.AddDeviceUsage(glassesDevices[i], $"Player{playerIndex}");
                }
 
            }
            else if (!glassesDevices[i].added)
            {
                InputSystem.AddDevice(glassesDevices[i]);
            }
        }
 
        internal static void AddWandDevice(PlayerIndex playerIndex, ControllerIndex controllerIndex)
        {
            var wandDevices = Input.wandDevices;
            int i = (int)playerIndex - 1;
            int j = (int)controllerIndex;
 
            // Unfortunately, the enum ControllerIndex.Primary still exists, and Unity seems to have a habit
            // of substituting its display name when we're trying to get the display name for ControllerIndex.Right.
            // TODO: Localize
            var handednessLabel = controllerIndex == ControllerIndex.Right ? "Right" : "Left";
 
            // If we already know about a wandDevice corresponding to our input parameters, add it to the input system if it isn't already added
            if (wandDevices[i, j] != null && !wandDevices[i, j].added)
            {
                var wandDevice = wandDevices[i, j];
                InputSystem.AddDevice(wandDevice);
                wandDevice.ControllerIndex = controllerIndex;
                InputSystem.QueueConfigChangeEvent(wandDevice);
                InputSystem.AddDevice(wandDevice);
            }
            else
            {
                // Otherwise, ask the input system if it has a matching wandDevice.
                // This corner case (in which a matching wandDevice exists, but the static field in Player.cs is empty)
                // can occur when reloading scripts. Unity's input system keeps the device alive, but this class suffers amnesia.
                WandDevice currentWandDevice = InputSystem.GetDevice<WandDevice>($"Player{playerIndex}-{handednessLabel}Hand");
 
                // If the input system does have a matching wandDevice, just remember it and we're done
                if (currentWandDevice != null)
                {
                    wandDevices[i, j] = currentWandDevice;
                }
                // Otherwise, add a brand new wandDevice to the input system and remember it.
                else
                {
                    wandDevices[i, j] = InputSystem.AddDevice<WandDevice>($"T5 Wand - P{(int)playerIndex} {handednessLabel}");
                }
 
                wandDevices[i, j].playerIndex = playerIndex;
                wandDevices[i, j].ControllerIndex = controllerIndex;
                InputSystem.AddDeviceUsage(wandDevices[i, j], $"Player{playerIndex}");
                InputSystem.AddDeviceUsage(wandDevices[i, j], $"Player{playerIndex}-{handednessLabel}Hand");
                InputSystem.QueueConfigChangeEvent(wandDevices[i, j]);
            }
        }
#endif
 
        #endregion Private Functions
    }
 
}