public static void ResetInputAxes()
{
InputConfiguration inputConfig = _instance._currentConfiguration;
for (int i = 0; i < inputConfig.axes.Count; i++)
{
inputConfig.axes[i].Reset();
}
Input.ResetInputAxes();
}
public static InputConfiguration GetInputConfiguration(string name)
{
InputConfiguration inputConfig = null;
if (_instance._configurationTable.TryGetValue(name, out inputConfig))
{
return(inputConfig);
}
return(null);
}
private void WriteInputConfiguration(InputConfiguration inputConfig, XmlWriter writer)
{
writer.WriteStartElement("InputConfiguration");
writer.WriteAttributeString("name", inputConfig.name);
foreach (AxisConfiguration axisConfig in inputConfig.axes)
{
WriteAxisConfiguration(axisConfig, writer);
}
writer.WriteEndElement();
}
private static bool AnyInput(InputConfiguration inputConfig)
{
for (int i = 0; i < inputConfig.axes.Count; i++)
{
if (inputConfig.axes[i].AnyInput)
{
return(true);
}
}
return(false);
}
public static InputConfiguration Duplicate(InputConfiguration source)
{
InputConfiguration inputConfig = new InputConfiguration();
inputConfig.name = source.name;
inputConfig.axes = new List<AxisConfiguration>(source.axes.Count);
for(int i = 0; i < source.axes.Count; i++)
{
inputConfig.axes.Add(AxisConfiguration.Duplicate(source.axes[i]));
}
return inputConfig;
}
public static void ResetInputConfiguration(PlayerID playerID)
{
InputConfiguration inputConfig = _instance.GetInputConfigurationByPlayerID(playerID);
if (inputConfig != null)
{
int count = inputConfig.axes.Count;
for (int i = 0; i < count; i++)
{
inputConfig.axes[i].Reset();
}
}
}
private void Initialize()
{
_playerOneConfig = null;
_playerTwoConfig = null;
_playerThreeConfig = null;
_playerFourConfig = null;
if (inputConfigurations.Count == 0)
{
return;
}
PopulateLookupTables();
if (!string.IsNullOrEmpty(playerOneDefault) && _configurationTable.ContainsKey(playerOneDefault))
{
_playerOneConfig = _configurationTable[playerOneDefault];
}
else
{
if (inputConfigurations.Count > 0)
{
_playerOneConfig = inputConfigurations[0];
}
}
if (!string.IsNullOrEmpty(playerTwoDefault) && _configurationTable.ContainsKey(playerTwoDefault))
{
_playerTwoConfig = _configurationTable[playerTwoDefault];
}
if (!string.IsNullOrEmpty(playerThreeDefault) && _configurationTable.ContainsKey(playerThreeDefault))
{
_playerThreeConfig = _configurationTable[playerThreeDefault];
}
if (!string.IsNullOrEmpty(playerFourDefault) && _configurationTable.ContainsKey(playerFourDefault))
{
_playerFourConfig = _configurationTable[playerFourDefault];
}
foreach (InputConfiguration inputConfig in inputConfigurations)
{
foreach (AxisConfiguration axisConfig in inputConfig.axes)
{
axisConfig.Initialize();
}
}
Input.ResetInputAxes();
}
public static bool DeleteAxisConfiguration(string inputConfigName, string axisName)
{
InputConfiguration inputConfig = GetInputConfiguration(inputConfigName);
AxisConfiguration axisConfig = GetAxisConfiguration(inputConfigName, axisName);
if (inputConfig != null && axisConfig != null)
{
_instance._axesTable[inputConfig.name].Remove(axisConfig.name);
inputConfig.axes.Remove(axisConfig);
return(true);
}
return(false);
}
public static InputConfiguration Duplicate(InputConfiguration source)
{
InputConfiguration inputConfig = new InputConfiguration();
inputConfig.name = source.name;
inputConfig.axes = new List <AxisConfiguration>(source.axes.Count);
for (int i = 0; i < source.axes.Count; i++)
{
inputConfig.axes.Add(AxisConfiguration.Duplicate(source.axes[i]));
}
return(inputConfig);
}
private void UpdateInputConfiguration(InputConfiguration inputConfig, PlayerID playerID)
{
if (inputConfig != null)
{
for (int i = 0; i < inputConfig.axes.Count; i++)
{
inputConfig.axes[i].Update();
}
if (RemoteUpdate != null)
{
RemoteUpdate(playerID);
}
}
}
private InputConfiguration ReadInputConfiguration(XmlNode node)
{
InputConfiguration inputConfig = new InputConfiguration();
inputConfig.name = ReadAttribute(node, "name", "Unnamed Configuration");
var axisConfigNodes = node.SelectNodes("AxisConfiguration");
foreach (XmlNode child in axisConfigNodes)
{
inputConfig.axes.Add(ReadAxisConfiguration(child));
}
return(inputConfig);
}
public static InputConfiguration CreateInputConfiguration(string name)
{
if (_instance._configurationTable.ContainsKey(name))
{
throw new ArgumentException(string.Format("An input configuration with the name {0} already exists", name));
}
InputConfiguration inputConfig = new InputConfiguration(name);
_instance.inputConfigurations.Add(inputConfig);
_instance._configurationTable.Add(name, inputConfig);
_instance._axesTable.Add(name, new Dictionary <string, AxisConfiguration>());
return(inputConfig);
}
public static InputConfiguration CreateInputConfiguration(string name)
{
if (_instance._configurationTable.ContainsKey(name))
{
Debug.LogError(string.Format("An input configuration named \'{0}\' already exists", name));
return(null);
}
InputConfiguration inputConfig = new InputConfiguration(name);
_instance.inputConfigurations.Add(inputConfig);
_instance._configurationTable.Add(name, inputConfig);
_instance._axesTable.Add(name, new Dictionary <string, AxisConfiguration>());
return(inputConfig);
}
public InputConfiguration LoadSelective(string inputConfigName)
{
InputConfiguration inputConfig = null;
using (XmlReader reader = CreateXmlReader())
{
while (reader.Read())
{
if (reader.IsStartElement("InputConfiguration") && reader["name"] == inputConfigName)
{
inputConfig = ReadInputConfiguration(reader);
break;
}
}
}
return(inputConfig);
}
private InputConfiguration ReadInputConfiguration(XmlReader reader)
{
InputConfiguration inputConfig = new InputConfiguration();
inputConfig.name = reader["name"];
while (reader.Read())
{
if (!reader.IsStartElement("AxisConfiguration"))
{
break;
}
inputConfig.axes.Add(ReadAxisConfiguration(reader));
}
return(inputConfig);
}
/// <summary>
/// Returns true if any axis of the active input configuration is receiving input.
/// </summary>
public static bool AnyInput()
{
InputConfiguration inputConfig = _instance._currentConfiguration;
if (inputConfig != null)
{
int count = inputConfig.axes.Count;
for (int i = 0; i < count; i++)
{
if (inputConfig.axes[i].AnyInput)
{
return(true);
}
}
}
return(false);
}
public static AxisConfiguration CreateAnalogButton(string inputConfigName, string buttonName, int joystick, int axis)
{
InputConfiguration inputConfig = GetInputConfiguration(inputConfigName);
if (inputConfig == null)
{
Debug.LogError(string.Format("An input configuration named \'{0}\' does not exist", inputConfigName));
return(null);
}
if (_instance._axesTable[inputConfigName].ContainsKey(buttonName))
{
Debug.LogError(string.Format("The input configuration named {0} already contains an axis configuration named {1}", inputConfigName, buttonName));
return(null);
}
if (axis < 0 || axis >= AxisConfiguration.MaxJoystickAxes)
{
Debug.LogError("Joystick axis is out of range. Cannot create new analog button.");
return(null);
}
if (joystick < 0 || joystick >= AxisConfiguration.MaxJoysticks)
{
Debug.LogError("Joystick is out of range. Cannot create new analog button.");
return(null);
}
AxisConfiguration axisConfig = new AxisConfiguration(buttonName);
axisConfig.type = InputType.AnalogButton;
axisConfig.joystick = joystick;
axisConfig.axis = axis;
axisConfig.positive = KeyCode.None;
axisConfig.negative = KeyCode.None;
axisConfig.altPositive = KeyCode.None;
axisConfig.altNegative = KeyCode.None;
axisConfig.Initialize();
inputConfig.axes.Add(axisConfig);
var table = _instance._axesTable[inputConfigName];
table.Add(buttonName, axisConfig);
return(axisConfig);
}
private void SetInputConfigurationByPlayerID(PlayerID playerID, InputConfiguration inputConfig)
{
if (playerID == PlayerID.One)
{
_playerOneConfig = inputConfig;
}
else if (playerID == PlayerID.Two)
{
_playerTwoConfig = inputConfig;
}
else if (playerID == PlayerID.Three)
{
_playerThreeConfig = inputConfig;
}
else if (playerID == PlayerID.Four)
{
_playerFourConfig = inputConfig;
}
}
public static AxisConfiguration CreateAnalogAxis(string inputConfigName, string axisName, int joystick, int axis, float sensitivity, float deadZone)
{
InputConfiguration inputConfig = GetInputConfiguration(inputConfigName);
if (inputConfig == null)
{
Debug.LogError(string.Format("An input configuration named \'{0}\' does not exist", inputConfigName));
return(null);
}
if (_instance._axesTable[inputConfigName].ContainsKey(axisName))
{
Debug.LogError(string.Format("The input configuration named {0} already contains an axis configuration named {1}", inputConfigName, axisName));
return(null);
}
if (axis < 0 || axis >= AxisConfiguration.MaxJoystickAxes)
{
Debug.LogError("Joystick axis is out of range. Cannot create new analog axis.");
return(null);
}
if (joystick < 0 || joystick >= AxisConfiguration.MaxJoysticks)
{
Debug.LogError("Joystick is out of range. Cannot create new analog axis.");
return(null);
}
AxisConfiguration axisConfig = new AxisConfiguration(axisName);
axisConfig.type = InputType.AnalogAxis;
axisConfig.axis = axis;
axisConfig.joystick = joystick;
axisConfig.deadZone = deadZone;
axisConfig.sensitivity = sensitivity;
axisConfig.Initialize();
inputConfig.axes.Add(axisConfig);
var table = _instance._axesTable[inputConfigName];
table.Add(axisName, axisConfig);
return(axisConfig);
}
/// <summary>
/// Changes the active input configuration.
/// </summary>
public static void SetInputConfiguration(string name, PlayerID playerID)
{
if (_instance.IsInputConfigurationInUse(name))
{
Debug.LogErrorFormat("The input configuration named \'{0}\' is already being used by a player", name);
return;
}
InputConfiguration inputConfig = null;
if (_instance._configurationTable.TryGetValue(name, out inputConfig))
{
_instance.SetInputConfigurationByPlayerID(playerID, inputConfig);
ResetInputConfiguration(playerID);
_instance.RaiseInputConfigurationChangedEvent(playerID);
}
else
{
Debug.LogError(string.Format("An input configuration named \'{0}\' does not exist", name));
}
}
public static AxisConfiguration CreateAnalogButton(string inputConfigName, string buttonName, int joystick, int axis)
{
InputConfiguration inputConfig = GetInputConfiguration(inputConfigName);
if (inputConfig == null)
{
throw new ArgumentException(string.Format("An input configuration named \'{0}\' does not exist", inputConfigName));
}
if (_instance._axesTable[inputConfigName].ContainsKey(buttonName))
{
string error = string.Format("The input configuration named {0} already contains an axis configuration named {1}", inputConfigName, buttonName);
throw new ArgumentException(error);
}
if (axis < 0 || axis >= AxisConfiguration.MaxJoystickAxes)
{
throw new ArgumentOutOfRangeException("axis");
}
if (joystick < 0 || joystick >= AxisConfiguration.MaxJoysticks)
{
throw new ArgumentOutOfRangeException("joystick");
}
AxisConfiguration axisConfig = new AxisConfiguration(buttonName);
axisConfig.type = InputType.AnalogButton;
axisConfig.joystick = joystick;
axisConfig.axis = axis;
axisConfig.positive = KeyCode.None;
axisConfig.negative = KeyCode.None;
axisConfig.altPositive = KeyCode.None;
axisConfig.altNegative = KeyCode.None;
axisConfig.Initialize();
inputConfig.axes.Add(axisConfig);
var table = _instance._axesTable[inputConfigName];
table.Add(buttonName, axisConfig);
return(axisConfig);
}
public static AxisConfiguration CreateAnalogAxis(string configuration, string name, int joystick, int axis, float sensitivity, float deadZone)
{
InputConfiguration inputConfig = GetConfiguration(configuration);
if (inputConfig == null)
{
throw new ArgumentException("Unable to find any input configuration named " + configuration);
}
if (_instance._axesTable[configuration].ContainsKey(name))
{
string error = string.Format("The input configuration named {0} already contains an axis configuration named {1}", configuration, name);
throw new ArgumentException(error);
}
if (axis < 0 || axis > 9)
{
throw new ArgumentOutOfRangeException("axis");
}
if (joystick < 0 || joystick > 3)
{
throw new ArgumentOutOfRangeException("joystick");
}
AxisConfiguration axisConfig = new AxisConfiguration(name);
axisConfig.type = InputType.AnalogAxis;
axisConfig.axis = axis;
axisConfig.joystick = joystick;
axisConfig.deadZone = deadZone;
axisConfig.sensitivity = sensitivity;
axisConfig.Initialize();
inputConfig.axes.Add(axisConfig);
var table = _instance._axesTable[configuration];
table.Add(name, axisConfig);
return(axisConfig);
}
private void Initialize()
{
_playerOneConfig = null;
_playerTwoConfig = null;
_playerThreeConfig = null;
_playerFourConfig = null;
if (inputConfigurations.Count == 0)
return;
PopulateLookupTables();
if (!string.IsNullOrEmpty(playerOneDefault) && _configurationTable.ContainsKey(playerOneDefault))
{
_playerOneConfig = _configurationTable[playerOneDefault];
}
else
{
if(inputConfigurations.Count > 0)
_playerOneConfig = inputConfigurations[0];
}
if (!string.IsNullOrEmpty(playerTwoDefault) && _configurationTable.ContainsKey(playerTwoDefault))
{
_playerTwoConfig = _configurationTable[playerTwoDefault];
}
if (!string.IsNullOrEmpty(playerThreeDefault) && _configurationTable.ContainsKey(playerThreeDefault))
{
_playerThreeConfig = _configurationTable[playerThreeDefault];
}
if (!string.IsNullOrEmpty(playerFourDefault) && _configurationTable.ContainsKey(playerFourDefault))
{
_playerFourConfig = _configurationTable[playerFourDefault];
}
foreach (InputConfiguration inputConfig in inputConfigurations)
{
foreach(AxisConfiguration axisConfig in inputConfig.axes)
{
axisConfig.Initialize();
}
}
Input.ResetInputAxes();
}
private void WriteInputConfiguration(InputConfiguration inputConfig, XmlWriter writer)
{
writer.WriteStartElement("InputConfiguration");
writer.WriteAttributeString("name", inputConfig.name);
foreach(AxisConfiguration axisConfig in inputConfig.axes)
{
WriteAxisConfiguration(axisConfig, writer);
}
writer.WriteEndElement();
}
private void DisplayInputConfigurationFields(InputConfiguration inputConfig, Rect screenRect)
{
GUILayout.BeginArea(screenRect);
_mainPanelScrollPos = EditorGUILayout.BeginScrollView(_mainPanelScrollPos);
inputConfig.name = EditorGUILayout.TextField("Name", inputConfig.name);
EditorGUILayout.Space();
GUI.enabled = (!EditorApplication.isPlaying && _inputManager.playerOneDefault != inputConfig.name);
if(GUILayout.Button("Make Player One Default", GUILayout.Width(200.0f), GUILayout.Height(25.0f)))
{
_inputManager.playerOneDefault = inputConfig.name;
}
GUI.enabled = (!EditorApplication.isPlaying && _inputManager.playerTwoDefault != inputConfig.name);
if (GUILayout.Button("Make Player Two Default", GUILayout.Width(200.0f), GUILayout.Height(25.0f)))
{
_inputManager.playerTwoDefault = inputConfig.name;
}
GUI.enabled = (!EditorApplication.isPlaying && _inputManager.playerThreeDefault != inputConfig.name);
if (GUILayout.Button("Make Player Three Default", GUILayout.Width(200.0f), GUILayout.Height(25.0f)))
{
_inputManager.playerThreeDefault = inputConfig.name;
}
GUI.enabled = (!EditorApplication.isPlaying && _inputManager.playerFourDefault != inputConfig.name);
if (GUILayout.Button("Make Player Four Default", GUILayout.Width(200.0f), GUILayout.Height(25.0f)))
{
_inputManager.playerFourDefault = inputConfig.name;
}
//GUI.enabled = (EditorApplication.isPlaying && _InputManager.PlayerOneConfiguration.name != inputConfig.name);
//if(GUILayout.Button("Switch To", GUILayout.Width(135.0f), GUILayout.Height(20.0f)))
//{
// _InputManager.SetInputConfiguration(inputConfig.name, PlayerID.One);
//}
GUI.enabled = true;
EditorGUILayout.EndScrollView();
GUILayout.EndArea();
}
private void DisplayAxisConfigurationFields(InputConfiguration inputConfigx, AxisConfiguration axisConfig, Rect screenRect)
{
GUIContent gravityInfo = new GUIContent("Gravity", "The speed(in units/sec) at which a digital axis falls towards neutral.");
GUIContent sensitivityInfo = new GUIContent("Sensitivity", "The speed(in units/sec) at which an axis moves towards the target value.");
GUIContent snapInfo = new GUIContent("Snap", "If input switches direction, do we snap to neutral and continue from there? For digital axes only.");
GUIContent deadZoneInfo = new GUIContent("Dead Zone", "Size of analog dead zone. Values within this range map to neutral.");
GUILayout.BeginArea(screenRect);
_mainPanelScrollPos = GUILayout.BeginScrollView(_mainPanelScrollPos);
axisConfig.name = EditorGUILayout.TextField("Name", axisConfig.name);
axisConfig.description = EditorGUILayout.TextField("Description", axisConfig.description);
// Positive Key
EditorToolbox.KeyCodeField(ref _keyString, ref _editingPositiveKey, "Positive",
"editor_positive_key", axisConfig.positive);
ProcessKeyString(ref axisConfig.positive, ref _editingPositiveKey);
// Negative Key
EditorToolbox.KeyCodeField(ref _keyString, ref _editingNegativeKey, "Negative",
"editor_negative_key", axisConfig.negative);
ProcessKeyString(ref axisConfig.negative, ref _editingNegativeKey);
// Alt Positive Key
EditorToolbox.KeyCodeField(ref _keyString, ref _editingAltPositiveKey, "Alt Positive",
"editor_alt_positive_key", axisConfig.altPositive);
ProcessKeyString(ref axisConfig.altPositive, ref _editingAltPositiveKey);
// Alt Negative key
EditorToolbox.KeyCodeField(ref _keyString, ref _editingAltNegativeKey, "Alt Negative",
"editor_alt_negative_key", axisConfig.altNegative);
ProcessKeyString(ref axisConfig.altNegative, ref _editingAltNegativeKey);
axisConfig.gravity = EditorGUILayout.FloatField(gravityInfo, axisConfig.gravity);
axisConfig.deadZone = EditorGUILayout.FloatField(deadZoneInfo, axisConfig.deadZone);
axisConfig.sensitivity = EditorGUILayout.FloatField(sensitivityInfo, axisConfig.sensitivity);
axisConfig.snap = EditorGUILayout.Toggle(snapInfo, axisConfig.snap);
axisConfig.invert = EditorGUILayout.Toggle("Invert", axisConfig.invert);
axisConfig.type = (InputType)EditorGUILayout.EnumPopup("Type", axisConfig.type);
axisConfig.axis = EditorGUILayout.Popup("Axis", axisConfig.axis, _axisOptions);
axisConfig.joystick = EditorGUILayout.Popup("Joystick", axisConfig.joystick, _joystickOptions);
if(EditorApplication.isPlaying)
{
EditorGUILayout.Space();
GUI.enabled = false;
EditorGUILayout.FloatField("Raw Axis", axisConfig.GetAxisRaw());
EditorGUILayout.FloatField("Axis", axisConfig.GetAxis());
EditorGUILayout.Toggle("Button", axisConfig.GetButton());
GUI.enabled = true;
}
GUILayout.EndScrollView();
GUILayout.EndArea();
}
private void ImportSelectedMapping()
{
if(_configurator == null)
{
EditorUtility.DisplayDialog("Error", "Unable to import joystick mapping. Did you close the advanced input editor?", "Close");
return;
}
InputConfiguration inputConfig = new InputConfiguration(_mappings[_selection].Name.Replace(' ', '_'));
foreach(AxisMapping am in _mappings[_selection])
{
if(am.ScanType == MappingWizard.ScanType.Button)
{
AxisConfiguration axisConfig = new AxisConfiguration(am.Name);
axisConfig.type = InputType.Button;
axisConfig.positive = am.Key;
inputConfig.axes.Add(axisConfig);
}
else
{
if(am.JoystickAxis < 0 || am.JoystickAxis >= AxisConfiguration.MaxJoystickAxes)
{
Debug.LogError("Joystick axis is out of range. Cannot import axis configuration: " + am.Name);
continue;
}
AxisConfiguration axisConfig = new AxisConfiguration(am.Name);
axisConfig.type = InputType.AnalogAxis;
axisConfig.axis = am.JoystickAxis;
axisConfig.joystick = 0;
axisConfig.deadZone = 0.0f;
axisConfig.sensitivity = 1.0f;
inputConfig.axes.Add(axisConfig);
}
}
_configurator.AddInputConfiguration(inputConfig);
}
private void SetInputConfigurationByPlayerID(PlayerID playerID, InputConfiguration inputConfig)
{
if (playerID == PlayerID.One)
_playerOneConfig = inputConfig;
else if (playerID == PlayerID.Two)
_playerTwoConfig = inputConfig;
else if (playerID == PlayerID.Three)
_playerThreeConfig = inputConfig;
else if (playerID == PlayerID.Four)
_playerFourConfig = inputConfig;
}
private static bool AnyInput(InputConfiguration inputConfig)
{
if (inputConfig != null)
{
int count = inputConfig.axes.Count;
for (int i = 0; i < count; i++)
{
if (inputConfig.axes[i].AnyInput)
return true;
}
}
return false;
}
public static InputConfiguration CreateInputConfiguration(string name)
{
if(_instance._configurationTable.ContainsKey(name))
{
Debug.LogError(string.Format("An input configuration named \'{0}\' already exists", name));
return null;
}
InputConfiguration inputConfig = new InputConfiguration(name);
_instance.inputConfigurations.Add(inputConfig);
_instance._configurationTable.Add(name, inputConfig);
_instance._axesTable.Add(name, new Dictionary<string, AxisConfiguration>());
return inputConfig;
}
private InputConfiguration ReadInputConfiguration(XmlReader reader)
{
InputConfiguration inputConfig = new InputConfiguration();
inputConfig.name = reader["name"];
while(reader.Read())
{
if(!reader.IsStartElement("AxisConfiguration"))
break;
inputConfig.axes.Add(ReadAxisConfiguration(reader));
}
return inputConfig;
}
public static InputConfiguration CreateInputConfiguration(string name)
{
if (_instance._configurationTable.ContainsKey (name))
throw new ArgumentException (string.Format ("An input configuration named \'{0}\' already exists", name));
InputConfiguration inputConfig = new InputConfiguration (name);
_instance.inputConfigurations.Add (inputConfig);
_instance._configurationTable.Add (name, inputConfig);
_instance._axesTable.Add (name, new Dictionary<string, AxisConfiguration> ());
return inputConfig;
}
private void Initialize()
{
if (inputConfigurations.Count == 0)
return;
PopulateLookupTables ();
if (string.IsNullOrEmpty (defaultConfiguration) || !_configurationTable.ContainsKey (defaultConfiguration))
_currentConfiguration = inputConfigurations [0];
else
_currentConfiguration = _configurationTable [defaultConfiguration];
foreach (InputConfiguration inputConfig in inputConfigurations) {
foreach (AxisConfiguration axisConfig in inputConfig.axes) {
axisConfig.Initialize ();
}
}
ResetInputAxes ();
}
private void UpdateInputConfiguration(InputConfiguration inputConfig, PlayerID playerID)
{
if (inputConfig != null)
{
for (int i = 0; i < inputConfig.axes.Count; i++)
inputConfig.axes[i].Update();
if (RemoteUpdate != null)
RemoteUpdate(playerID);
}
}
public void AddInputConfiguration(InputConfiguration configuration)
{
_inputManager.inputConfigurations.Add(configuration);
_selectionPath.Clear();
_selectionPath.Add(_inputManager.inputConfigurations.Count - 1);
Repaint();
}
private void Initialize()
{
_playerOneConfig = null;
_playerTwoConfig = null;
_playerThreeConfig = null;
_playerFourConfig = null;
if (inputConfigurations.Count == 0)
return;
PopulateLookupTables();
if (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.WindowsPlayer || Application.platform == RuntimePlatform.WindowsWebPlayer)
{
_playerOneConfig = _configurationTable [Config_Name_Windows];
_playerTwoConfig = _configurationTable[Config_Name_Windows];
_playerThreeConfig = _configurationTable[Config_Name_Windows];
_playerFourConfig = _configurationTable[Config_Name_Windows];
}
else if (Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.OSXPlayer || Application.platform == RuntimePlatform.OSXWebPlayer)
{
_playerOneConfig = _configurationTable [Config_Name_OSX];
_playerTwoConfig = _configurationTable[Config_Name_OSX];
_playerThreeConfig = _configurationTable[Config_Name_OSX];
_playerFourConfig = _configurationTable[Config_Name_OSX];
}
else if (Application.platform == RuntimePlatform.LinuxPlayer)
{
_playerOneConfig = _configurationTable [Config_Name_Linux];
_playerTwoConfig = _configurationTable[Config_Name_Linux];
_playerThreeConfig = _configurationTable[Config_Name_Linux];
_playerFourConfig = _configurationTable[Config_Name_Linux];
}
/*
if (!string.IsNullOrEmpty(playerOneDefault) && _configurationTable.ContainsKey(playerOneDefault))
{
_playerOneConfig = _configurationTable[playerOneDefault];
}
else
{
if(inputConfigurations.Count > 0)
_playerOneConfig = inputConfigurations[0];
}
if (!string.IsNullOrEmpty(playerTwoDefault) && _configurationTable.ContainsKey(playerTwoDefault))
{
_playerTwoConfig = _configurationTable[playerTwoDefault];
}
if (!string.IsNullOrEmpty(playerThreeDefault) && _configurationTable.ContainsKey(playerThreeDefault))
{
_playerThreeConfig = _configurationTable[playerThreeDefault];
}
if (!string.IsNullOrEmpty(playerFourDefault) && _configurationTable.ContainsKey(playerFourDefault))
{
_playerFourConfig = _configurationTable[playerFourDefault];
}
*/
foreach (InputConfiguration inputConfig in inputConfigurations)
{
foreach(AxisConfiguration axisConfig in inputConfig.axes)
{
axisConfig.Initialize();
}
}
Input.ResetInputAxes();
}
private void DisplayInputConfigurationFields(InputConfiguration inputConfig, Rect screenRect)
{
GUILayout.BeginArea(screenRect);
_mainPanelScrollPos = EditorGUILayout.BeginScrollView(_mainPanelScrollPos);
inputConfig.name = EditorGUILayout.TextField("Name", inputConfig.name);
EditorGUILayout.Space();
EditorGUILayout.BeginHorizontal();
GUI.enabled = (!EditorApplication.isPlaying && _inputManager.defaultConfiguration != inputConfig.name);
if(GUILayout.Button("Make Default", GUILayout.Width(135.0f), GUILayout.Height(20.0f)))
{
_inputManager.defaultConfiguration = inputConfig.name;
}
GUI.enabled = (EditorApplication.isPlaying && InputManager.CurrentConfiguration.name != inputConfig.name);
if(GUILayout.Button("Switch To", GUILayout.Width(135.0f), GUILayout.Height(20.0f)))
{
InputManager.SetInputConfiguration(inputConfig.name);
}
GUI.enabled = true;
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndScrollView();
GUILayout.EndArea();
}
private void Start()
{
InputConfiguration inputConfig = InputManager.GetInputConfiguration(_inputConfiguration);
if (inputConfig == null)
{
Debug.LogWarning(string.Format("An input configuration named \'{0}\' does not exist", _inputConfiguration), this);
return;
}
int axisCount = inputConfig.axes.Count;
int joystickButtonCount = (int)KeyCode.Joystick1Button19 - (int)KeyCode.Joystick1Button0 + 1;
// All new axes will be added at the end of the list so it's safe to iterate normally to
// the initial number of axes
for (int i = 0; i < axisCount; i++)
{
AxisConfiguration orig = inputConfig.axes[i];
if (!orig.name.EndsWith("_P1"))
{
continue;
}
if (orig.joystick > 0)
{
Debug.LogError(string.Format("Cannot clone axis {0} of configuration {1} because joystick is {2} instead of 0", orig.name, _inputConfiguration, orig.joystick), this);
continue;
}
if ((orig.positive != KeyCode.None && ((int)orig.positive < (int)KeyCode.Joystick1Button0 || (int)orig.positive > (int)KeyCode.Joystick1Button19)) ||
(orig.altPositive != KeyCode.None && ((int)orig.altPositive < (int)KeyCode.Joystick1Button0 || (int)orig.altPositive > (int)KeyCode.Joystick1Button19)) ||
(orig.negative != KeyCode.None && ((int)orig.negative < (int)KeyCode.Joystick1Button0 || (int)orig.negative > (int)KeyCode.Joystick1Button19)) ||
(orig.altNegative != KeyCode.None && ((int)orig.altNegative < (int)KeyCode.Joystick1Button0 || (int)orig.altNegative > (int)KeyCode.Joystick1Button19)))
{
Debug.LogError(string.Format("Cannot clone axis {0} of configuration {1} because some key codes are invalid", orig.name, _inputConfiguration), this);
continue;
}
for (int c = 0; c < _numberOfClones; c++)
{
string axisName = orig.name.Substring(0, orig.name.Length - 3) + "_P" + (c + 2);
AxisConfiguration clone = InputManager.CreateEmptyAxis(_inputConfiguration, axisName);
clone.Copy(orig);
clone.name = axisName;
if (orig.positive != KeyCode.None)
{
clone.positive = (KeyCode)((int)orig.positive + (c + 1) * joystickButtonCount);
}
if (orig.altPositive != KeyCode.None)
{
clone.altPositive = (KeyCode)((int)orig.altPositive + (c + 1) * joystickButtonCount);
}
if (orig.negative != KeyCode.None)
{
clone.negative = (KeyCode)((int)orig.negative + (c + 1) * joystickButtonCount);
}
if (orig.altNegative != KeyCode.None)
{
clone.altNegative = (KeyCode)((int)orig.altNegative + (c + 1) * joystickButtonCount);
}
clone.joystick = c + 1;
clone.Initialize();
}
}
}
