using System.Collections.Generic;
|
using UnityEngine;
|
using System;
|
|
namespace CnControls
|
{
|
/// <summary>
|
/// Common input manager class
|
/// Can be used instead of Input logic, as it replicates the standard behaviour but adds additional logic
|
/// </summary>
|
public class CnInputManager
|
{
|
private static CnInputManager _instance;
|
|
public static CnInputManager Instance
|
{
|
get { return _instance ?? (_instance = new CnInputManager()); }
|
}
|
|
private CnInputManager()
|
{ }
|
|
public event Action FingerTouchedEvent;
|
public event Action FingerLeftedEvent;
|
public event Action FingerMovedEvent;
|
|
/// <summary>
|
/// Dictionary of virtual axis
|
/// Every axis can be mapped to a number of actual virtual axis,
|
/// as with standard Unity Input system where you can create different buttons for, say, "Horizontal" axis
|
/// </summary>
|
private Dictionary<string, List<VirtualAxis>> _virtualAxisDictionary =
|
new Dictionary<string, List<VirtualAxis>>();
|
|
public void HandleTouched()
|
{
|
if (FingerTouchedEvent != null)
|
{
|
FingerTouchedEvent();
|
}
|
}
|
|
public void HandleTouchLefted()
|
{
|
if (FingerLeftedEvent != null)
|
{
|
FingerLeftedEvent();
|
}
|
}
|
|
public void HandleTouchMoved()
|
{
|
if (FingerMovedEvent != null)
|
{
|
FingerMovedEvent();
|
}
|
}
|
|
/// <summary>
|
/// Additional logic for touch retreival
|
/// It's possible to add some reflection-based emulated touches
|
/// </summary>
|
public static int TouchCount
|
{
|
get
|
{
|
return Input.touchCount;
|
}
|
}
|
|
/// <summary>
|
/// Additional logic for touch retreival
|
/// It's possible to add some reflection-based emulated touches
|
/// </summary>
|
public static Touch GetTouch(int touchIndex)
|
{
|
return Input.GetTouch(touchIndex);
|
}
|
|
/// <summary>
|
/// GetAxis method for getting current values for any desired axis
|
/// </summary>
|
/// <param name="axisName">The name of the axis to get value from</param>
|
/// <returns>
|
/// Current value of FIRST NON ZERO axis that are registered for that name
|
/// ZERO if non if the virtual axis are being tweaked
|
/// </returns>
|
public static float GetAxis(string axisName)
|
{
|
return GetAxis(axisName, false);
|
}
|
|
/// <summary>
|
/// "Copy" of the Input.GetAxisRaw method
|
/// </summary>
|
/// <param name="axisName">The name of the axis to get value from</param>
|
/// <returns>
|
/// Current value of FIRST NON ZERO axis that are registered for that name
|
/// ZERO if non if the virtual axis are being tweaked
|
/// </returns>
|
public static float GetAxisRaw(string axisName)
|
{
|
return GetAxis(axisName, true);
|
}
|
|
/// <summary>
|
/// Common private method for getting the axis values
|
/// </summary>
|
/// <param name="axisName">The name of the axis to get value from</param>
|
/// <param name="isRaw">Whether the method sould return the raw value of the axis</param>
|
/// <returns></returns>
|
private static float GetAxis(string axisName, bool isRaw)
|
{
|
// If we have the axis registered as virtual, we call the retreival logic
|
if (AxisExists(axisName))
|
{
|
return GetVirtualAxisValue(Instance._virtualAxisDictionary[axisName], axisName, isRaw);
|
}
|
|
// If we don't have the desired virtual axis registered, we just fallback to the default Unity Input behaviour
|
return isRaw ? Input.GetAxisRaw(axisName) : Input.GetAxis(axisName);
|
}
|
|
/// <summary>
|
/// Check whether the specified axis exists
|
/// </summary>
|
/// <param name="axisName">Name of the axis to check</param>
|
/// <returns>Does this axis exist?</returns>
|
public static bool AxisExists(string axisName)
|
{
|
return Instance._virtualAxisDictionary.ContainsKey(axisName);
|
}
|
|
/// <summary>
|
/// Registers the provided virtual axis
|
/// </summary>
|
/// <param name="virtualAxis">Virtual axis to register</param>
|
public static void RegisterVirtualAxis(VirtualAxis virtualAxis)
|
{
|
// If it's the first such virtual axis, create a new list for that axis name
|
if (!Instance._virtualAxisDictionary.ContainsKey(virtualAxis.Name))
|
{
|
Instance._virtualAxisDictionary[virtualAxis.Name] = new List<VirtualAxis>();
|
}
|
|
Instance._virtualAxisDictionary[virtualAxis.Name].Add(virtualAxis);
|
}
|
|
/// <summary>
|
/// Unregisters the provided virtual axis
|
/// </summary>
|
/// <param name="virtualAxis">Virtual axis to unregister</param>
|
public static void UnregisterVirtualAxis(VirtualAxis virtualAxis)
|
{
|
// If it's the first such virtual axis, create a new list for that axis name
|
if (Instance._virtualAxisDictionary.ContainsKey(virtualAxis.Name))
|
{
|
if (!Instance._virtualAxisDictionary[virtualAxis.Name].Remove(virtualAxis))
|
{
|
DebugEx.LogError("Requested axis " + virtualAxis.Name + " exists, but there's no such virtual axis that you're trying to unregister");
|
}
|
}
|
else
|
{
|
DebugEx.LogError("Trying to unregister an axis " + virtualAxis.Name + " that was never registered");
|
}
|
}
|
|
/// <summary>
|
/// Private method that get's the value of the first non-zero virtual axis, registered with the specified name
|
/// </summary>
|
/// <param name="virtualAxisList">List of virtual axis to search through</param>
|
/// <param name="axisName">Name of the axis (for the standard Input behaviour)</param>
|
/// <param name="isRaw">Whether the method should return the Raw value of the axis</param>
|
/// <returns></returns>
|
private static float GetVirtualAxisValue(List<VirtualAxis> virtualAxisList, string axisName, bool isRaw)
|
{
|
// The method is really straightforward here
|
// First, we check the standard Input.GetAxis method
|
// If it's not zero, we return the value
|
// If it IS zero, we return first non-zero value of any of the passed virtual axis
|
// Or zero if all of them are zero
|
|
float axisValue = isRaw ? Input.GetAxisRaw(axisName) : Input.GetAxis(axisName);
|
if (!Mathf.Approximately(axisValue, 0f))
|
{
|
return axisValue;
|
}
|
|
for (int i = 0; i < virtualAxisList.Count; i++)
|
{
|
var currentAxisValue = virtualAxisList[i].Value;
|
if (!Mathf.Approximately(currentAxisValue, 0f))
|
{
|
return currentAxisValue;
|
}
|
}
|
|
return 0f;
|
}
|
}
|
}
|
