bool UpdateAxis(MappedAxis axis)
{
bool changed = false;
axesRaw[(int)axis] = GetAxisValueRaw (axis);
prevAxes [(int)axis] = axes [(int)axis];
axes [(int)axis] = GetSmoothValue (axes [(int)axis],axesRaw [(int)axis],sensitivity);
if (!Mathf.Approximately(axes[(int)axis], prevAxes[(int)axis]))
changed = true;
prevAxisButtonsActive [(int)axis] = axisButtonsActive [(int)axis];
int dir = 0;
if (axesRaw [(int)axis] > axisButtonActivateThreshold)
dir ++;
if (axesRaw [(int)axis] < -axisButtonActivateThreshold)
dir --;
if (Mathf.Abs(axesRaw [(int)axis]) < axisButtonResetThreshold)
dir = 0;
axisButtonsActive [(int)axis] = (AxisDirection)dir;
return changed;
}
public override Sprite GetAxisIcon(MappedAxis axis)
{
var KeyboardMapping = MappedInput.KeyBoard.GetAxisIcon(axis);
var MouseMapping = MappedInput.Mouse.GetAxisIcon(axis);
return(MouseMapping ?? KeyboardMapping);
}
protected override float GetAxisValueRaw(MappedAxis axis)
{
var MouseMapping = MappedInput.Mouse.GetAxis(axis);
var KeyboardMapping = MappedInput.KeyBoard.GetAxisRaw(axis);
return(MouseMapping != 0 ? MouseMapping : KeyboardMapping);
}
protected override float GetAxisValueRaw(MappedAxis axis)
{
var mapping = MappedInput.instance.keyboardInputMapping.GetAxisMapping(axis);
if (mapping == null)
{
return(0);
}
float rawVal = 0;
for (int i = 0; i < mapping.buttonsPositive.Length; i++)
{
if (Input.GetKey(mapping.buttonsPositive[i]))
{
rawVal++;
}
}
for (int i = 0; i < mapping.buttonsNegative.Length; i++)
{
if (Input.GetKey(mapping.buttonsNegative[i]))
{
rawVal--;
}
}
return(Mathf.Clamp(rawVal, -1, 1));
}
protected override float GetAxisValueRaw(MappedAxis axis)
{
float rawVal = 0;
var mapping = MappedInput.Instance.MouseInputMapping.GetMouseAxisMapping(axis);
if (mapping != null)
{
if (mapping.mouseAxisId == 0)
{
rawVal = Input.mousePosition.x;
}
else if (mapping.mouseAxisId == 1)
{
rawVal = Input.mousePosition.y;
}
else if (mapping.mouseAxisId == 2)
{
rawVal = Input.mousePosition.y;
}
else
{
throw new UnityException("Mouse axis " + mapping.mouseAxisId + " not found");
}
}
return(rawVal);
}
protected override float GetAxisValueRaw (MappedAxis axis)
{
float rawVal = 0;
var mapping = MappedInput.instance.gamepadInputMapping.GetGamepadAxisMapping (axis);
if (mapping == null)
{
Debug.LogWarningFormat ("Axis {0} is not mapped on device {1}", axis, this);
return 0;
}
for (int i = 0; i < mapping.axes.Length; i++)
{
rawVal += gamepad.GetAxis (mapping.axes [i]);
}
for (int i = 0; i < mapping.buttonsPositive.Length; i++)
{
if (gamepad.GetButton (mapping.buttonsPositive [i]))
rawVal += 1;
}
for (int i = 0; i < mapping.buttonsNegative.Length; i++)
{
if (gamepad.GetButton (mapping.buttonsNegative [i]))
rawVal -= 1;
}
if (mapping.inverted)
rawVal = -rawVal;
return Mathf.Clamp( rawVal,-1,1);
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.instance.mouseInputMapping.GetAxisMapping (axis);
if (mapping != null)
{
return string.Format ("Mouse Axis {0}", mapping.mouseAxisId);
}
return "";
}
public override string GetAxisName(MappedAxis axis)
{
var MouseMapping = MappedInput.Mouse.GetAxisName(axis);
var KeyboardMapping = MappedInput.KeyBoard.GetAxisName(axis);
var mapping = MouseMapping != "" ? MouseMapping : KeyboardMapping;
return(mapping);
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.instance.gamepadInputMapping.GetGamepadAxisMapping (axis);
if( mapping != null )
{
return gamepad.layout.GetAxisName(mapping.axes[0]);
}
return "";
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.Instance.MouseInputMapping.GetAxisMapping(axis);
if (mapping != null)
{
return(string.Format("Mouse Axis {0}", mapping.mouseAxisId));
}
return("");
}
public AxisMapping GetAxisMapping(MappedAxis target)
{
for (int i = 0; i < axisMappings.Count; i++)
{
if( axisMappings[i].target == target )
return axisMappings[i];
}
return null;
}
public AxisMapping GetAxisMapping(MappedAxis target)
{
for (int i = 0; i < keyboardAxisMapping.Count; i++)
{
if( keyboardAxisMapping[i].target == target )
return keyboardAxisMapping[i];
}
return null;
}
public override Sprite GetAxisIcon(MappedAxis axis)
{
// This needs to be changed to reflect the mouse
var mapping = MappedInput.Instance.MouseInputMapping.GetMouseAxisMapping(axis);
if (mapping != null)
{
return(MappedInput.Instance.MouseInputMapping.MouseIconMappings.GetMouseAxisIconMapping(mapping.mouseAxisId).Icon);
}
return(null);
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.instance.gamepadInputMapping.GetGamepadAxisMapping(axis);
if (mapping != null)
{
return(gamepad.layout.GetAxisName(mapping.axes[0]));
}
return("");
}
/// <summary>
/// Adds a mapping from an axis index to <see cref="GamePadAxis"/>
/// </summary>
/// <param name="index">The axis index of the axis on this device</param>
/// <param name="axis">The axis to map to</param>
/// <param name="invert">Should axis be inverted</param>
/// <param name="remap">Remap this axis from (-1,1) to (0,1)</param>
protected void AddAxisToAxis(int index, GamePadAxis axis, bool invert = false, bool remap = false)
{
while (axisMap.Count <= index)
{
axisMap.Add(new MappedAxis {
Axis = GamePadAxis.None
});
}
axisMap[index] = new MappedAxis {
Axis = axis, Invert = invert, Remap = remap
};
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.instance.keyboardInputMapping.GetAxisMapping (axis);
if (mapping != null) {
if (mapping.buttonsPositive.Length > 0 && mapping.buttonsNegative.Length > 0)
return string.Format ("{0}/{1}", mapping.buttonsPositive [0].ToString (), mapping.buttonsNegative [0].ToString ());
if (mapping.buttonsPositive.Length > 0)
return string.Format ("{0}", mapping.buttonsPositive [0].ToString ());
}
return "no binding";
}
public AxisMapping GetGamepadAxisMapping(MappedAxis target)
{
for (int i = 0; i < axisMappings.Count; i++)
{
if (axisMappings[i].target == target)
{
return(axisMappings[i]);
}
}
return(null);
}
public AxisMapping GetMouseAxisMapping(MappedAxis target)
{
for (int i = 0; i < mouseAxisMappings.Count; i++)
{
if (mouseAxisMappings[i].target == target)
{
return(mouseAxisMappings[i]);
}
}
return(null);
}
/// <summary>
/// Adds a mapping from a button index to <see cref="GamePadAxis"/>
/// </summary>
/// <param name="index">The button index of the button on this device</param>
/// <param name="axis">The axi to map to</param>
/// <param name="invert">Should axis be inverted, output -1 instead of 1 on press</param>
protected void AddButtonToAxis(int index, GamePadAxis axis, bool invert = false)
{
while (buttonsToTriggerMap.Count <= index)
{
buttonsToTriggerMap.Add(new MappedAxis {
Axis = GamePadAxis.None
});
}
buttonsToTriggerMap[index] = new MappedAxis {
Axis = axis, Invert = invert, Remap = false
};
}
public AxisMapping GetAxisMapping(MappedAxis target)
{
for (int i = 0; i < keyboardAxisMapping.Count; i++)
{
if (keyboardAxisMapping[i].target == target)
{
return(keyboardAxisMapping[i]);
}
}
return(null);
}
public override Sprite GetAxisIcon(MappedAxis axis)
{
//This needs to be able to return both the positive and negative button icon
var mapping = MappedInput.Instance.KeyboardInputMapping.GetKeyboardAxisMapping(axis);
if (mapping != null && mapping.axes.Length > 0)
{
return(MappedInput.Instance.KeyboardInputMapping.IconMappings.GetKeyboardAxisIconMapping(mapping.axes[0]).Icon);
}
return(null);
}
bool UpdateAxis(MappedAxis axis)
{
bool changed = false;
prevAxesRaw[(int)axis] = axesRaw[(int)axis];
axesRaw[(int)axis] = GetAxisValueRaw(axis);
prevAxes [(int)axis] = axes [(int)axis];
axes [(int)axis] = GetSmoothValue(axes [(int)axis], axesRaw [(int)axis], sensitivity);
if (!Mathf.Approximately(axes[(int)axis], prevAxes[(int)axis]))
{
changed = true;
}
prevAxisButtonsActive [(int)axis] = axisButtonsActive [(int)axis];
int dir = 0;
if (axesRaw [(int)axis] > axisButtonActivateThreshold)
{
dir++;
}
if (axesRaw [(int)axis] < -axisButtonActivateThreshold)
{
dir--;
}
if (Mathf.Abs(axesRaw [(int)axis]) < axisButtonResetThreshold)
{
dir = 0;
}
axisButtonsActive [(int)axis] = (AxisDirection)dir;
/*
* if (prevAxesRaw[(int)axis] > -.9f && val < -.9f)
* {
* AxisTappedNeg[(int)axis] = true;
* }
* else
* {
* AxisTappedNeg[(int)axis] = false;
* }
*/
return(changed);
}
public override string GetAxisName(MappedAxis axis)
{
var mapping = MappedInput.instance.keyboardInputMapping.GetAxisMapping(axis);
if (mapping != null)
{
if (mapping.buttonsPositive.Length > 0 && mapping.buttonsNegative.Length > 0)
{
return(string.Format("{0}/{1}", mapping.buttonsPositive [0].ToString(), mapping.buttonsNegative [0].ToString()));
}
if (mapping.buttonsPositive.Length > 0)
{
return(string.Format("{0}", mapping.buttonsPositive [0].ToString()));
}
}
return("no binding");
}
protected override float GetAxisValueRaw (MappedAxis axis)
{
float rawVal = 0;
var mapping = MappedInput.instance.mouseInputMapping.GetAxisMapping (axis);
if (mapping != null)
{
if (mapping.mouseAxisId == 0)
rawVal = Input.mousePosition.x;
else if (mapping.mouseAxisId == 1)
rawVal = Input.mousePosition.y;
else
throw new UnityException ("Mouse axis " + mapping.mouseAxisId + " not found");
}
return rawVal;
}
public override Sprite GetAxisIcon(MappedAxis axis)
{
var mapping = MappedInput.Instance.GamepadInputMapping.GetGamepadAxisMapping(axis);
if (mapping.axes.Count() > 0)
{
return(MappedInput.Instance.GamepadInputMapping.IconMapping.GetGamepadAxisIconMapping(mapping.axes[0]).Icon);
}
else if (mapping.buttonsNegative.Count() > 0)
{
return(MappedInput.Instance.GamepadInputMapping.IconMapping.GetGamepadAxisIconMapping(mapping.buttonsNegative[0]).Icon);
}
else if (mapping.buttonsPositive.Count() > 0)
{
return(MappedInput.Instance.GamepadInputMapping.IconMapping.GetGamepadAxisIconMapping(mapping.buttonsPositive[0]).Icon);
}
return(null);
}
protected override float GetAxisValueRaw(MappedAxis axis)
{
float rawVal = 0;
var mapping = MappedInput.instance.gamepadInputMapping.GetGamepadAxisMapping(axis);
if (mapping == null)
{
Debug.LogWarningFormat("Axis {0} is not mapped on device {1}", axis, this);
return(0);
}
for (int i = 0; i < mapping.axes.Length; i++)
{
rawVal += gamepad.GetAxis(mapping.axes [i]);
}
for (int i = 0; i < mapping.buttonsPositive.Length; i++)
{
if (gamepad.GetButton(mapping.buttonsPositive [i]))
{
rawVal += 1;
}
}
for (int i = 0; i < mapping.buttonsNegative.Length; i++)
{
if (gamepad.GetButton(mapping.buttonsNegative [i]))
{
rawVal -= 1;
}
}
if (mapping.inverted)
{
rawVal = -rawVal;
}
return(Mathf.Clamp(rawVal, -1, 1));
}
public virtual bool GetIsAxisTapped(MappedAxis axis)
{
float val = GetAxis(axis);
if (!PastAxisVals.ContainsKey(axis))
{
PastAxisVals.Add(axis, new List <float>());
}
PastAxisVals[axis].Add(val);
if (PastAxisVals[axis].Count > 3)
{
PastAxisVals[axis].RemoveAt(0);
}
if (PastAxisVals[axis].Count < 3)
{
return(false);
}
return(PastAxisVals[axis][0] >= PastAxisVals[axis][1] && PastAxisVals[axis][1] < PastAxisVals[axis][2]);
}
protected override float GetAxisValueRaw (MappedAxis axis)
{
var mapping = MappedInput.instance.keyboardInputMapping.GetAxisMapping (axis);
if (mapping == null)
return 0;
float rawVal = 0;
for(int i = 0; i < mapping.buttonsPositive.Length; i++)
{
if( Input.GetKey(mapping.buttonsPositive[i]) )
rawVal++;
}
for(int i = 0; i < mapping.buttonsNegative.Length; i++)
{
if( Input.GetKey(mapping.buttonsNegative[i]) )
rawVal--;
}
return Mathf.Clamp (rawVal, -1, 1);
}
public virtual bool GetIsAxisTappedNeg(MappedAxis axis, float threshold = -.9f)
{
float val = axesRaw[(int)axis];
return(prevAxesRaw[(int)axis] > threshold && val < threshold);
}
public Vector2 GetAxisRaw2DCircleClamp(MappedAxis axis1, MappedAxis axis2)
{
return Vector2.ClampMagnitude(GetAxisRaw2D(axis1,axis2), 1.0f );
}
public Vector2 GetAxisRaw2D(MappedAxis axis1, MappedAxis axis2)
{
return new Vector2(GetAxisRaw(axis1),GetAxisRaw(axis2));
}
public abstract Sprite GetAxisIcon(MappedAxis axis);
public abstract string GetAxisName (MappedAxis axis);
private void CompileInputNames()
{
FieldInfo[] fields = GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach(FieldInfo field in fields) {
object[] attrs = field.GetCustomAttributes(typeof(ButtonMapping), false);
foreach(object a in attrs) {
ButtonMapping attr = a as ButtonMapping;
string fmt;
if (0 < _joystickNumber) {
fmt = string.Format ("joystick {0} button {1}", _joystickNumber, attr.Id);
} else {
fmt = string.Format ("joystick button {0}", attr.Id);
}
field.SetValue(this, fmt);
_keycodes.Add(attr.Role, fmt);
}
attrs = field.GetCustomAttributes(typeof(AxisToButtonMapping), false);
string[] axes = SupportedAxes;
foreach(object a in attrs) {
AxisToButtonMapping attr = a as AxisToButtonMapping;
MappedAxis mapping = new MappedAxis();
mapping.Keycode = axes[attr.AxisIndex];
mapping.Reflected = attr.Reflected;
field.SetValue(this, axes[attr.AxisIndex]);
_mappedAxes.Add(attr.Role, mapping);
}
}
if (0 < _mappedAxes.Count) {
StartCoroutine(PollAnalogueButtons());
}
}
public bool GetAxisButtonUp(MappedAxis axis, AxisDirection dir)
{
return(axisButtonsActive[(int)axis] != dir && prevAxisButtonsActive[(int)axis] == dir);
}
public float GetAxis(MappedAxis axis)
{
return axes[(int)axis];
}
public Vector2 GetAxisRaw2D(MappedAxis axis1, MappedAxis axis2)
{
return(new Vector2(GetAxisRaw(axis1), GetAxisRaw(axis2)));
}
protected abstract float GetAxisValueRaw (MappedAxis axis);
public bool GetAxisButtonUp(MappedAxis axis, AxisDirection dir)
{
return axisButtonsActive[(int)axis] != dir && prevAxisButtonsActive[(int)axis] == dir;
}
public abstract string GetAxisName(MappedAxis axis);
public float GetAxisRaw(MappedAxis axis)
{
return axesRaw[(int)axis];
}
protected abstract float GetAxisValueRaw(MappedAxis axis);
public virtual bool GetIsAxisTapped(MappedAxis axis, float threshold = .9f)
{
return(GetIsAxisTappedPos(axis, threshold) || GetIsAxisTappedNeg(axis, -threshold));
}
public Vector2 GetAxisRaw2DCircleClamp(MappedAxis axis1, MappedAxis axis2)
{
return(Vector2.ClampMagnitude(GetAxisRaw2D(axis1, axis2), 1.0f));
}
public float GetAxisRaw(MappedAxis axis)
{
return(axesRaw[(int)axis]);
}
