588 lines
15 KiB
C#
588 lines
15 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Rewired.Integration.UnityUI;
|
|
using Rewired.Utils;
|
|
using UnityEngine;
|
|
using UnityEngine.UI;
|
|
|
|
namespace Rewired.UI.ControlMapper
|
|
{
|
|
[AddComponentMenu("")]
|
|
public class CalibrationWindow : Window
|
|
{
|
|
public enum ButtonIdentifier
|
|
{
|
|
Done = 0,
|
|
Cancel = 1,
|
|
Default = 2,
|
|
Calibrate = 3
|
|
}
|
|
|
|
private const float minSensitivityOtherAxes = 0.1f;
|
|
|
|
private const float maxDeadzone = 0.8f;
|
|
|
|
[SerializeField]
|
|
private RectTransform rightContentContainer;
|
|
|
|
[SerializeField]
|
|
private RectTransform valueDisplayGroup;
|
|
|
|
[SerializeField]
|
|
private RectTransform calibratedValueMarker;
|
|
|
|
[SerializeField]
|
|
private RectTransform rawValueMarker;
|
|
|
|
[SerializeField]
|
|
private RectTransform calibratedZeroMarker;
|
|
|
|
[SerializeField]
|
|
private RectTransform deadzoneArea;
|
|
|
|
[SerializeField]
|
|
private Slider deadzoneSlider;
|
|
|
|
[SerializeField]
|
|
private Slider zeroSlider;
|
|
|
|
[SerializeField]
|
|
private Slider sensitivitySlider;
|
|
|
|
[SerializeField]
|
|
private Toggle invertToggle;
|
|
|
|
[SerializeField]
|
|
private RectTransform axisScrollAreaContent;
|
|
|
|
[SerializeField]
|
|
private Button doneButton;
|
|
|
|
[SerializeField]
|
|
private Button calibrateButton;
|
|
|
|
[SerializeField]
|
|
private Text doneButtonLabel;
|
|
|
|
[SerializeField]
|
|
private Text cancelButtonLabel;
|
|
|
|
[SerializeField]
|
|
private Text defaultButtonLabel;
|
|
|
|
[SerializeField]
|
|
private Text deadzoneSliderLabel;
|
|
|
|
[SerializeField]
|
|
private Text zeroSliderLabel;
|
|
|
|
[SerializeField]
|
|
private Text sensitivitySliderLabel;
|
|
|
|
[SerializeField]
|
|
private Text invertToggleLabel;
|
|
|
|
[SerializeField]
|
|
private Text calibrateButtonLabel;
|
|
|
|
[SerializeField]
|
|
private GameObject axisButtonPrefab;
|
|
|
|
private Joystick joystick;
|
|
|
|
private string origCalibrationData;
|
|
|
|
private int selectedAxis = -1;
|
|
|
|
private AxisCalibrationData origSelectedAxisCalibrationData;
|
|
|
|
private float displayAreaWidth;
|
|
|
|
private List<Button> axisButtons;
|
|
|
|
private Dictionary<int, Action<int>> buttonCallbacks;
|
|
|
|
private int playerId;
|
|
|
|
private RewiredStandaloneInputModule rewiredStandaloneInputModule;
|
|
|
|
private int menuHorizActionId = -1;
|
|
|
|
private int menuVertActionId = -1;
|
|
|
|
private float minSensitivity;
|
|
|
|
private bool axisSelected
|
|
{
|
|
get
|
|
{
|
|
if (joystick == null)
|
|
{
|
|
return false;
|
|
}
|
|
if (selectedAxis < 0 || selectedAxis >= joystick.calibrationMap.axisCount)
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private AxisCalibration axisCalibration
|
|
{
|
|
get
|
|
{
|
|
if (!axisSelected)
|
|
{
|
|
return null;
|
|
}
|
|
return joystick.calibrationMap.GetAxis(selectedAxis);
|
|
}
|
|
}
|
|
|
|
public override void Initialize(int id, Func<int, bool> isFocusedCallback)
|
|
{
|
|
if (rightContentContainer == null || valueDisplayGroup == null || calibratedValueMarker == null || rawValueMarker == null || calibratedZeroMarker == null || deadzoneArea == null || deadzoneSlider == null || sensitivitySlider == null || zeroSlider == null || invertToggle == null || axisScrollAreaContent == null || doneButton == null || calibrateButton == null || axisButtonPrefab == null || doneButtonLabel == null || cancelButtonLabel == null || defaultButtonLabel == null || deadzoneSliderLabel == null || zeroSliderLabel == null || sensitivitySliderLabel == null || invertToggleLabel == null || calibrateButtonLabel == null)
|
|
{
|
|
Debug.LogError("Rewired Control Mapper: All inspector values must be assigned!");
|
|
return;
|
|
}
|
|
axisButtons = new List<Button>();
|
|
buttonCallbacks = new Dictionary<int, Action<int>>();
|
|
doneButtonLabel.text = ControlMapper.GetLanguage().done;
|
|
cancelButtonLabel.text = ControlMapper.GetLanguage().cancel;
|
|
defaultButtonLabel.text = ControlMapper.GetLanguage().default_;
|
|
deadzoneSliderLabel.text = ControlMapper.GetLanguage().calibrateWindow_deadZoneSliderLabel;
|
|
zeroSliderLabel.text = ControlMapper.GetLanguage().calibrateWindow_zeroSliderLabel;
|
|
sensitivitySliderLabel.text = ControlMapper.GetLanguage().calibrateWindow_sensitivitySliderLabel;
|
|
invertToggleLabel.text = ControlMapper.GetLanguage().calibrateWindow_invertToggleLabel;
|
|
calibrateButtonLabel.text = ControlMapper.GetLanguage().calibrateWindow_calibrateButtonLabel;
|
|
base.Initialize(id, isFocusedCallback);
|
|
}
|
|
|
|
public void SetJoystick(int playerId, Joystick joystick)
|
|
{
|
|
if (!base.initialized)
|
|
{
|
|
return;
|
|
}
|
|
this.playerId = playerId;
|
|
this.joystick = joystick;
|
|
if (joystick == null)
|
|
{
|
|
Debug.LogError("Rewired Control Mapper: Joystick cannot be null!");
|
|
return;
|
|
}
|
|
float num = 0f;
|
|
for (int i = 0; i < joystick.axisCount; i++)
|
|
{
|
|
int index = i;
|
|
GameObject gameObject = UITools.InstantiateGUIObject<Button>(axisButtonPrefab, axisScrollAreaContent, "Axis" + i);
|
|
Button button = gameObject.GetComponent<Button>();
|
|
button.onClick.AddListener(delegate
|
|
{
|
|
OnAxisSelected(index, button);
|
|
});
|
|
Text componentInSelfOrChildren = UnityTools.GetComponentInSelfOrChildren<Text>(gameObject);
|
|
if (componentInSelfOrChildren != null)
|
|
{
|
|
componentInSelfOrChildren.text = ControlMapper.GetLanguage().GetElementIdentifierName(joystick, joystick.AxisElementIdentifiers[i].id, AxisRange.Full);
|
|
}
|
|
if (num == 0f)
|
|
{
|
|
num = UnityTools.GetComponentInSelfOrChildren<LayoutElement>(gameObject).minHeight;
|
|
}
|
|
axisButtons.Add(button);
|
|
}
|
|
float spacing = axisScrollAreaContent.GetComponent<VerticalLayoutGroup>().spacing;
|
|
axisScrollAreaContent.sizeDelta = new Vector2(axisScrollAreaContent.sizeDelta.x, Mathf.Max((float)joystick.axisCount * (num + spacing) - spacing, axisScrollAreaContent.sizeDelta.y));
|
|
origCalibrationData = joystick.calibrationMap.ToXmlString();
|
|
displayAreaWidth = rightContentContainer.sizeDelta.x;
|
|
rewiredStandaloneInputModule = base.gameObject.transform.root.GetComponentInChildren<RewiredStandaloneInputModule>();
|
|
if (rewiredStandaloneInputModule != null)
|
|
{
|
|
menuHorizActionId = ReInput.mapping.GetActionId(rewiredStandaloneInputModule.horizontalAxis);
|
|
menuVertActionId = ReInput.mapping.GetActionId(rewiredStandaloneInputModule.verticalAxis);
|
|
}
|
|
if (joystick.axisCount > 0)
|
|
{
|
|
SelectAxis(0);
|
|
}
|
|
base.defaultUIElement = doneButton.gameObject;
|
|
RefreshControls();
|
|
Redraw();
|
|
}
|
|
|
|
public void SetButtonCallback(ButtonIdentifier buttonIdentifier, Action<int> callback)
|
|
{
|
|
if (base.initialized && callback != null)
|
|
{
|
|
if (buttonCallbacks.ContainsKey((int)buttonIdentifier))
|
|
{
|
|
buttonCallbacks[(int)buttonIdentifier] = callback;
|
|
}
|
|
else
|
|
{
|
|
buttonCallbacks.Add((int)buttonIdentifier, callback);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void Cancel()
|
|
{
|
|
if (!base.initialized)
|
|
{
|
|
return;
|
|
}
|
|
if (joystick != null)
|
|
{
|
|
joystick.ImportCalibrationMapFromXmlString(origCalibrationData);
|
|
}
|
|
if (!buttonCallbacks.TryGetValue(1, out var value))
|
|
{
|
|
if (cancelCallback != null)
|
|
{
|
|
cancelCallback();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
value(base.id);
|
|
}
|
|
}
|
|
|
|
protected override void Update()
|
|
{
|
|
if (base.initialized)
|
|
{
|
|
base.Update();
|
|
UpdateDisplay();
|
|
}
|
|
}
|
|
|
|
public void OnDone()
|
|
{
|
|
if (base.initialized && buttonCallbacks.TryGetValue(0, out var value))
|
|
{
|
|
value(base.id);
|
|
}
|
|
}
|
|
|
|
public void OnCancel()
|
|
{
|
|
Cancel();
|
|
}
|
|
|
|
public void OnRestoreDefault()
|
|
{
|
|
if (base.initialized && joystick != null)
|
|
{
|
|
joystick.calibrationMap.Reset();
|
|
RefreshControls();
|
|
Redraw();
|
|
}
|
|
}
|
|
|
|
public void OnCalibrate()
|
|
{
|
|
if (base.initialized && buttonCallbacks.TryGetValue(3, out var value))
|
|
{
|
|
value(selectedAxis);
|
|
}
|
|
}
|
|
|
|
public void OnInvert(bool state)
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.invert = state;
|
|
}
|
|
}
|
|
|
|
public void OnZeroValueChange(float value)
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.calibratedZero = value;
|
|
RedrawCalibratedZero();
|
|
}
|
|
}
|
|
|
|
public void OnZeroCancel()
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.calibratedZero = origSelectedAxisCalibrationData.zero;
|
|
RedrawCalibratedZero();
|
|
RefreshControls();
|
|
}
|
|
}
|
|
|
|
public void OnDeadzoneValueChange(float value)
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.deadZone = Mathf.Clamp(value, 0f, 0.8f);
|
|
if (value > 0.8f)
|
|
{
|
|
deadzoneSlider.value = 0.8f;
|
|
}
|
|
RedrawDeadzone();
|
|
}
|
|
}
|
|
|
|
public void OnDeadzoneCancel()
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.deadZone = origSelectedAxisCalibrationData.deadZone;
|
|
RedrawDeadzone();
|
|
RefreshControls();
|
|
}
|
|
}
|
|
|
|
public void OnSensitivityValueChange(float value)
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
SetSensitivity(axisCalibration, value);
|
|
}
|
|
}
|
|
|
|
public void OnSensitivityCancel(float value)
|
|
{
|
|
if (base.initialized && axisSelected)
|
|
{
|
|
axisCalibration.sensitivity = origSelectedAxisCalibrationData.sensitivity;
|
|
RefreshControls();
|
|
}
|
|
}
|
|
|
|
public void OnAxisScrollRectScroll(Vector2 pos)
|
|
{
|
|
_ = base.initialized;
|
|
}
|
|
|
|
private void OnAxisSelected(int axisIndex, Button button)
|
|
{
|
|
if (base.initialized && joystick != null)
|
|
{
|
|
SelectAxis(axisIndex);
|
|
RefreshControls();
|
|
Redraw();
|
|
}
|
|
}
|
|
|
|
private void UpdateDisplay()
|
|
{
|
|
RedrawValueMarkers();
|
|
}
|
|
|
|
private void Redraw()
|
|
{
|
|
RedrawCalibratedZero();
|
|
RedrawValueMarkers();
|
|
}
|
|
|
|
private void RefreshControls()
|
|
{
|
|
if (!axisSelected)
|
|
{
|
|
deadzoneSlider.value = 0f;
|
|
zeroSlider.value = 0f;
|
|
sensitivitySlider.value = 0f;
|
|
invertToggle.isOn = false;
|
|
}
|
|
else
|
|
{
|
|
deadzoneSlider.value = axisCalibration.deadZone;
|
|
zeroSlider.value = axisCalibration.calibratedZero;
|
|
sensitivitySlider.value = GetSliderSensitivity(axisCalibration);
|
|
invertToggle.isOn = axisCalibration.invert;
|
|
}
|
|
}
|
|
|
|
private void RedrawDeadzone()
|
|
{
|
|
if (axisSelected)
|
|
{
|
|
float x = displayAreaWidth * axisCalibration.deadZone;
|
|
deadzoneArea.sizeDelta = new Vector2(x, deadzoneArea.sizeDelta.y);
|
|
deadzoneArea.anchoredPosition = new Vector2(axisCalibration.calibratedZero * (0f - deadzoneArea.parent.localPosition.x), deadzoneArea.anchoredPosition.y);
|
|
}
|
|
}
|
|
|
|
private void RedrawCalibratedZero()
|
|
{
|
|
if (axisSelected)
|
|
{
|
|
calibratedZeroMarker.anchoredPosition = new Vector2(axisCalibration.calibratedZero * (0f - deadzoneArea.parent.localPosition.x), calibratedZeroMarker.anchoredPosition.y);
|
|
RedrawDeadzone();
|
|
}
|
|
}
|
|
|
|
private void RedrawValueMarkers()
|
|
{
|
|
if (!axisSelected)
|
|
{
|
|
calibratedValueMarker.anchoredPosition = new Vector2(0f, calibratedValueMarker.anchoredPosition.y);
|
|
rawValueMarker.anchoredPosition = new Vector2(0f, rawValueMarker.anchoredPosition.y);
|
|
return;
|
|
}
|
|
float axis = joystick.GetAxis(selectedAxis);
|
|
float num = Mathf.Clamp(joystick.GetAxisRaw(selectedAxis), -1f, 1f);
|
|
calibratedValueMarker.anchoredPosition = new Vector2(displayAreaWidth * 0.5f * axis, calibratedValueMarker.anchoredPosition.y);
|
|
rawValueMarker.anchoredPosition = new Vector2(displayAreaWidth * 0.5f * num, rawValueMarker.anchoredPosition.y);
|
|
}
|
|
|
|
private void SelectAxis(int index)
|
|
{
|
|
if (index < 0 || index >= axisButtons.Count || axisButtons[index] == null)
|
|
{
|
|
return;
|
|
}
|
|
axisButtons[index].interactable = false;
|
|
axisButtons[index].Select();
|
|
for (int i = 0; i < axisButtons.Count; i++)
|
|
{
|
|
if (i != index)
|
|
{
|
|
axisButtons[i].interactable = true;
|
|
}
|
|
}
|
|
selectedAxis = index;
|
|
origSelectedAxisCalibrationData = axisCalibration.GetData();
|
|
SetMinSensitivity();
|
|
}
|
|
|
|
public override void TakeInputFocus()
|
|
{
|
|
base.TakeInputFocus();
|
|
if (selectedAxis >= 0)
|
|
{
|
|
SelectAxis(selectedAxis);
|
|
}
|
|
RefreshControls();
|
|
Redraw();
|
|
}
|
|
|
|
private void SetMinSensitivity()
|
|
{
|
|
if (!axisSelected)
|
|
{
|
|
return;
|
|
}
|
|
minSensitivity = 0.1f;
|
|
if (rewiredStandaloneInputModule != null)
|
|
{
|
|
if (IsMenuAxis(menuHorizActionId, selectedAxis))
|
|
{
|
|
GetAxisButtonDeadZone(playerId, menuHorizActionId, ref minSensitivity);
|
|
}
|
|
else if (IsMenuAxis(menuVertActionId, selectedAxis))
|
|
{
|
|
GetAxisButtonDeadZone(playerId, menuVertActionId, ref minSensitivity);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsMenuAxis(int actionId, int axisIndex)
|
|
{
|
|
if (rewiredStandaloneInputModule == null)
|
|
{
|
|
return false;
|
|
}
|
|
IList<Player> allPlayers = ReInput.players.AllPlayers;
|
|
int count = allPlayers.Count;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
IList<JoystickMap> maps = allPlayers[i].controllers.maps.GetMaps<JoystickMap>(joystick.id);
|
|
if (maps == null)
|
|
{
|
|
continue;
|
|
}
|
|
int count2 = maps.Count;
|
|
for (int j = 0; j < count2; j++)
|
|
{
|
|
IList<ActionElementMap> axisMaps = maps[j].AxisMaps;
|
|
if (axisMaps == null)
|
|
{
|
|
continue;
|
|
}
|
|
int count3 = axisMaps.Count;
|
|
for (int k = 0; k < count3; k++)
|
|
{
|
|
ActionElementMap actionElementMap = axisMaps[k];
|
|
if (actionElementMap.actionId == actionId && actionElementMap.elementIndex == axisIndex)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void GetAxisButtonDeadZone(int playerId, int actionId, ref float value)
|
|
{
|
|
InputAction action = ReInput.mapping.GetAction(actionId);
|
|
if (action != null)
|
|
{
|
|
int behaviorId = action.behaviorId;
|
|
InputBehavior inputBehavior = ReInput.mapping.GetInputBehavior(playerId, behaviorId);
|
|
if (inputBehavior != null)
|
|
{
|
|
value = inputBehavior.buttonDeadZone + 0.1f;
|
|
}
|
|
}
|
|
}
|
|
|
|
private float GetSliderSensitivity(AxisCalibration axisCalibration)
|
|
{
|
|
if (axisCalibration.sensitivityType == AxisSensitivityType.Multiplier)
|
|
{
|
|
return axisCalibration.sensitivity;
|
|
}
|
|
if (axisCalibration.sensitivityType == AxisSensitivityType.Power)
|
|
{
|
|
return ProcessPowerValue(axisCalibration.sensitivity, 0f, sensitivitySlider.maxValue);
|
|
}
|
|
return axisCalibration.sensitivity;
|
|
}
|
|
|
|
public void SetSensitivity(AxisCalibration axisCalibration, float sliderValue)
|
|
{
|
|
if (axisCalibration.sensitivityType == AxisSensitivityType.Multiplier)
|
|
{
|
|
axisCalibration.sensitivity = Mathf.Clamp(sliderValue, minSensitivity, float.PositiveInfinity);
|
|
if (sliderValue < minSensitivity)
|
|
{
|
|
sensitivitySlider.value = minSensitivity;
|
|
}
|
|
}
|
|
else if (axisCalibration.sensitivityType == AxisSensitivityType.Power)
|
|
{
|
|
axisCalibration.sensitivity = ProcessPowerValue(sliderValue, 0f, sensitivitySlider.maxValue);
|
|
}
|
|
else
|
|
{
|
|
axisCalibration.sensitivity = sliderValue;
|
|
}
|
|
}
|
|
|
|
private static float ProcessPowerValue(float value, float minValue, float maxValue)
|
|
{
|
|
value = Mathf.Clamp(value, minValue, maxValue);
|
|
if (value > 1f)
|
|
{
|
|
value = MathTools.ValueInNewRange(value, 1f, maxValue, 1f, 0f);
|
|
}
|
|
else if (value < 1f)
|
|
{
|
|
value = MathTools.ValueInNewRange(value, 0f, 1f, maxValue, 1f);
|
|
}
|
|
return value;
|
|
}
|
|
}
|
|
}
|