/// <summary>
/// Raises the GU event.
/// </summary>
private void OnGUI()
{
GUI.skin = guiSkin;
GUI.Window(1, windowRect, CreateWindow, new GUIContent());
//GUI.Window(1, new Rect(0, 0, Screen.width, Screen.height), CreateWindow,new GUIContent());
//if event is of key or mouse
if (Event.current.isKey)
{
if (Event.current.keyCode == KeyCode.Return)
{
_selectedStateHash = 0;
_previousStateInput = null;
//this.Repaint ();
}
else if (Event.current.keyCode == KeyCode.Escape)
{
if (_selectedStateHash != 0)
{
_stateInputCombinations [_selectedStateHash].combinations [_isPrimary] = _previousStateInput;
_previousStateInput = null;
_selectedStateHash = 0;
}
}
}
//Approach dependent of GUI so not applicable if you have 3D GUI
//if (_selectedStateHash != 0)
// InputEx.processGUIEvent (Event.current);//process input from keyboard & mouses
}
private static void DrawBindings(InputCombination comb, SerializedProperty combProp, string labelName, string propertyName)
{
GUILayout.BeginHorizontal();
EditorGUILayout.LabelField(labelName);
SerializedProperty defaultCombProp = combProp.FindPropertyRelative(propertyName);
GUIContent addButtonContent = new GUIContent("+");
float addButtonWidth = EditorStyles.miniButton.CalcSize(addButtonContent).x;
if (GUILayout.Button(addButtonContent, GUILayout.Width(addButtonWidth)))
{
comb.AddCode();
}
GUILayout.EndHorizontal();
EditorGUI.indentLevel++;
int indentLevel2 = EditorGUI.indentLevel;
List <InputCode> inputs = comb.inputs;
SerializedProperty codesProp = defaultCombProp.FindPropertyRelative("inputs");
for (int j = 0; j < codesProp.arraySize && j < inputs.Count; j++)
{
GUILayout.BeginHorizontal();
InputCode code = inputs[j];
SerializedProperty codeProp = codesProp.GetArrayElementAtIndex(j);
EditorGUILayout.PropertyField(codeProp, GUIContent.none);
GUIContent removeButtonContent = new GUIContent("-");
float removeButtonWidth = EditorStyles.miniButton.CalcSize(removeButtonContent).x;
if (GUILayout.Button(removeButtonContent, GUILayout.Width(removeButtonWidth)))
{
comb.RemoveAtIndex(j);
codesProp = defaultCombProp.FindPropertyRelative("inputs");
}
GUILayout.EndHorizontal();
}
}
/// <summary>
/// Tos the input combination.
/// </summary>
/// <param name="combos">Combos.</param>
/// <param name="input">Input.</param>
void toInputCombination(InputCombination combos, InputAction input)
{
if (combos.numActions + 1 > maxCombosNum || (combos.numActions == 1 && combos.GetActionAt(0).getCode(_playerSelected.Device) == 0))
{
combos.Clear();
}
combos.Add(input);
}
private void testInput()
{
var combination = new InputCombination <MouseButton>(MouseButton.leftButton, KeyState.wasPressedThisFrame);
InputMgr.Instance.RegistMouseCallBack(combination, () => { print("单击"); });
var combination2 = new InputCombination <MouseButton>(MouseButton.leftButton, KeyState.wasDoublePressedThisFrame);
InputMgr.Instance.RegistMouseCallBack(combination2, () => { print("双击"); });
}
/// <summary>
/// Resolves empty or None input or restricts input to max num of combinaition(maxCombosNum)
/// </summary>
/// <param name="combos">Combos. ex. w+Mouse1(x2)+Joystick1Button3(-)</param>
/// <param name="input">Input.</param>
void toInputCombination(InputCombination combos, InputAction input)
{
if (combos.numActions + 1 > maxCombosNum || (combos.numActions == 1 && combos.GetActionAt(0).getCode(_deviceByProfile) == 0))
{
combos.Clear();
}
combos.Add(input);
//Debug.Log(input);
}
IEnumerator BindMouseEvent()
{
var result = ResourceMgr.Instance.LoadAssetAsync("cursor_effect_1");
yield return(new WaitUntil(() => { return result.IsDone; }));
PoolMgr.Instance.TryGetPool("cursor_effect_1", out UnityPool pool);
pool.onGetObjectInPool += (obj) => obj.SetActive(true);
pool.onPutObject += (obj) => obj.SetActive(false);
var param = new InputCombination <MouseButton>(MouseButton.leftButton, KeyState.wasPressedThisFrame);
m_MainPageMouseCBID = InputMgr.Instance.RegistMouseCallBack(param, () => ClickCB(pool));
}
public void ToStringFromStringTest()
{
var combination = new InputCombination(new Keys[] { Keys.Control, Keys.Left, Keys.F2 },
new MouseButtons[] { MouseButtons.Left, MouseButtons.Middle });
var combinationString = combination.ToString();
Assert.AreEqual(combinationString, "Keyboard.Control + Keyboard.Left + Keyboard.F2 + Mouse.Left + Mouse.Middle");
var newCombination = new InputCombination(combinationString);
Assert.AreEqual(combination, newCombination);
}
void Start()
{
LevelManager.Instance.CurrentTimeline.GetComponent<TimeLine>().TimePeriodStarted += OnTimePeriodStart;
LevelManager.Instance.CurrentTimeline.GetComponent<TimeLine>().TimePeriodEnded += OnTimePeriodEnd;
LevelManager.Instance.CurrentTimeline.GetComponent<TimeLine>().TimerEnded += OnTimerEnd;
GameObject gao = new GameObject();
gao.AddComponent<InputCombination>();
gao.GetComponent<InputCombination>().Populate(EGamePadButton.None);
_expectedCombination = gao.GetComponent<InputCombination>();
if (!_mesh.GetComponent<Renderer>())
_mesh.AddComponent<Renderer>();
if (UnityEngine.Random.Range(0, 1) == 0)
_mesh.GetComponent<Renderer>().material.mainTexture = Resources.Load<Texture>("D_Chara_01");
else
_mesh.GetComponent<Renderer>().material.mainTexture = Resources.Load<Texture>("D_Chara_02");
}
/// <summary>
/// Replaces the designator.
/// </summary>
/// <param name="oldValue">Old value.</param>
/// <param name="newValue">New value.</param>
void replaceDesignator(string oldValue, string newValue)
{
foreach (var KeyCombinationStringPair in InputMapper._stateInputCombinations)
{
InputCombination combos = KeyCombinationStringPair.Value.combinations [0];
if (combos != null)
{
combos.combinationString = combos.combinationString.Replace(oldValue, newValue);
}
combos = KeyCombinationStringPair.Value.combinations [1];
if (combos != null)
{
combos.combinationString = combos.combinationString.Replace(oldValue, newValue);
}
}
}
public void YOLOTranscendSQUAD(float detectionRadius, int gatesToLive)
{
/*
_inputCombinationGao = Instantiate(new GameObject());
_inputCombinationGao.transform.SetParent(this.gameObject.transform);
_inputCombinationGao.AddComponent<InputCombination>();
_inputCombinationGao.GetComponent<InputCombination>().Populate(dissidentCombination.ToArray());
_dissidentCombination = _inputCombinationGao.GetComponent<InputCombination>();
*/
DeactivatePose();
_detectionRadius = detectionRadius;
_isRebel = true;
_gatesToLive = gatesToLive;
_expectedCombination = _expectedCombination.Randomize();
ActivatePose();
}
/// <summary>
/// Fill StringBuilde with StateName=Hash,...values
/// </summary>
/// <returns></returns>
StringBuilder HashStateInputsToStringBuilder()
{
Dictionary <int, InputState> stateInputsCurrent;
List <int> inputStatesToBeRemoved;
List <string> profilesToBeRemoved;
StringBuilder statesStringBuilder;
statesStringBuilder = new StringBuilder();
Dictionary <int, bool> stateInputsCombined = new Dictionary <int, bool> ();
int numPlayers = settings.Players.Length;
for (int i = 0; i < numPlayers; i++)
{
profilesToBeRemoved = new List <string> ();
foreach (var DeviceProfileHashStateInput in settings.Players[i].DeviceProfileStateInputs)
{
stateInputsCurrent = DeviceProfileHashStateInput.Value;
if (stateInputsCurrent.Count == 0)
{
profilesToBeRemoved.Add(DeviceProfileHashStateInput.Key);
continue;
}
inputStatesToBeRemoved = new List <int> ();
//Filter
foreach (var HashStateInput in stateInputsCurrent)
{
//fill String Builder with unique StateInputs
if (!stateInputsCombined.ContainsKey(HashStateInput.Key))
{
stateInputsCombined [HashStateInput.Key] = true;
statesStringBuilder.Append("\t" + HashStateInput.Value.name.Replace(" ", "_") + "=" + HashStateInput.Key + ",\n\r");
}
InputCombination combos = HashStateInput.Value.combinations [0];
if (combos != null && combos.GetActionAt(0).codeString == "None")
{
combos.Clear();
inputStatesToBeRemoved.Add(HashStateInput.Key);
}
combos = HashStateInput.Value.combinations [1];
if (combos != null && combos.GetActionAt(0).codeString == "None")
{
combos.Clear();
HashStateInput.Value.combinations [1] = null;
}
}
//remove those with "None" as Primary combination
foreach (var key in inputStatesToBeRemoved)
{
stateInputsCurrent.Remove(key);
}
}
//remove empty profiles
foreach (var key in profilesToBeRemoved)
{
settings.Players [i].DeviceProfileStateInputs.Remove(key);
}
} //end for Players
return(statesStringBuilder);
}
////////////////////// CREATE STATE GUI ///////////////////////
/// <summary>
/// Creates the state GUI.
/// </summary>
/// <param name="name">State Name.</param>
/// <param name="hash">State Hash.</param>
void createInputStateGUI(string name, int hash)
{
InputCombination[] combinations;
string currentCombinationString;
GUILayout.BeginHorizontal();
GUILayout.Label(name, _stateNameLabelStyle);
if (_selectedStateHash != hash)
{
if (InputMapper._stateInputCombinations.ContainsKey(hash))
{
combinations = InputMapper._stateInputCombinations [hash].combinations;
if (combinations [0] == null)
{
combinations [0] = new InputCombination("None");
}
if (GUILayout.Button(combinations [0].combinationString))
{
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 0;
EditorGUIUtility.keyboardControl = 0;
}
if (combinations [1] == null)
{
combinations [1] = new InputCombination("None");
}
if (GUILayout.Button(combinations [1].combinationString))
{
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 1;
EditorGUIUtility.keyboardControl = 0;
}
//DELETE
if (GUILayout.Button("-", _addRemoveButtonStyle))
{
//delete
_deleteStateWithHash = hash;
//this.Repaint();
}
}
else
{
if (GUILayout.Button("None"))
{
InputState state = _stateInputCombinations [hash] = new InputState(name, hash);
state.Add(new InputCombination((int)KeyCode.None), 0);
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 0;
EditorGUIUtility.keyboardControl = 0;
}
if (GUILayout.Button("None"))
{
InputState state = _stateInputCombinations [hash] = new InputState(name, hash);
state.Add(new InputCombination((int)KeyCode.None), 1);
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 1;
EditorGUIUtility.keyboardControl = 0;
}
}
}
else
{
if (InputMapper._stateInputCombinations.ContainsKey(hash))
{
combinations = InputMapper._stateInputCombinations [hash].combinations;
currentCombinationString = combinations [_isPrimary].combinationString;
if (_previousStateInput == null)
{
_previousStateInput = combinations [_isPrimary].Clone();
}
}
else
{
currentCombinationString = "None";
}
GUILayout.Label(currentCombinationString); //, _inputLabelStyle);
this.Repaint();
}
//
GUILayout.EndHorizontal();
EditorGUILayout.Separator();
}
private void OnStart(InputCombination button, float timePeriod, EventArgs e)
{
Debug.Log("Time period started");
}
protected virtual void OnTimePeriodStart(InputCombination button, float timePeriod, EventArgs e)
{
_inTimePeriod = true;
if (!_isRebel) _expectedCombination = button;
_timePeriod = UnityEngine.Random.Range(0f, timePeriod);
}
protected virtual void OnPeriodStart(InputCombination button, float timePeriod, EventArgs e)
{
TimerStartHandler handler = TimePeriodStarted;
if (handler != null)
handler(button, timePeriod, e);
}
protected override void OnTimePeriodStart(InputCombination button, float timePeriod, EventArgs e)
{
_inTimePeriod = true;
_expectedCombination = button;
_timePeriod = 0f;
}
private void OnTimerEnd(EventArgs e)
{
// release their state of animations
DeactivatePose();
if (_isRebel)
{
_gatesToLive--;
if (_expectedCombination)
_expectedCombination = _expectedCombination.Randomize();
if (_gatesToLive <= 0)
YOLOBringMeBackToLifeSQUAD();
}
}
/////////////////////////// OnGUI ////////////////////////
/// <summary>
/// Raises the GU event.
/// </summary>
void OnGUI()
{
int numLayers;
int numStates;
int i = 0;
int j = 0;
UnityEditor.Animations.AnimatorStateMachine stateMachine;
UnityEditor.Animations.AnimatorState state;
UnityEditor.Animations.AnimatorControllerLayer layer;
UnityEditor.Animations.AnimatorController ac;
if (_deleteStateWithHash != 0)
{
_stateInputCombinations.Remove(_deleteStateWithHash);
_deleteStateWithHash = 0;
}
if (_spaceDesignator != null)
{
EditorGUILayout.LabelField("Settings");
EditorGUILayout.Separator();
////// MAX NUM COMBOS /////
maxCombosNum = EditorGUILayout.IntField("Combos per input:", maxCombosNum, _settingsStyle);
EditorGUILayout.Separator();
////// DESIGNATORS /////
EditorGUILayout.LabelField("Click Designators");
///////// DOUBLE ////////////
_doubleClickDesignator = EditorGUILayout.TextField("Double click designator", _doubleClickDesignator, _settingsStyle);
InputManager.Settings.doubleDesignator = _doubleClickDesignator.Length > 0 ? _doubleClickDesignator : _prevlongClickDesignator;
if (_prevdoubleClickDesignator != null && _doubleClickDesignator.Length > 0 && _prevdoubleClickDesignator != _doubleClickDesignator)
{
replaceDesignator(_prevdoubleClickDesignator, _doubleClickDesignator);
}
_prevdoubleClickDesignator = _doubleClickDesignator;
////////////// LONG //////////
_longClickDesignator = EditorGUILayout.TextField("Long click designator", _longClickDesignator, _settingsStyle);
InputManager.Settings.longDesignator = _longClickDesignator.Length > 0 ? _longClickDesignator : _prevlongClickDesignator;
if (_prevlongClickDesignator != null && _longClickDesignator.Length > 0 && _prevlongClickDesignator != _longClickDesignator)
{
replaceDesignator(_prevlongClickDesignator, _longClickDesignator);
}
_prevlongClickDesignator = _longClickDesignator;
///////////// SPACE /////////////
_spaceDesignator = EditorGUILayout.TextField("Combination separator", _spaceDesignator, _settingsStyle);
if (_spaceDesignator.Length > 1)
{
_spaceDesignator = _spaceDesignator [0].ToString(); //restrict to 1 char
}
InputManager.Settings.spaceDesignator = _spaceDesignator.Length > 0 ? _spaceDesignator : _prevSpaceDesinator.ToString();
if (_spaceDesignator.Length > 0 && _prevSpaceDesinator != _spaceDesignator [0])
{
replaceDesignator(_prevSpaceDesinator.ToString(), _spaceDesignator [0].ToString());
}
_prevSpaceDesinator = _spaceDesignator [0];
EditorGUILayout.Separator();
///// SENSITIVITY ////
EditorGUILayout.LabelField("Sensitivity");
InputManager.Settings.singleClickSensitivity = _singleClickSensitivity = EditorGUILayout.FloatField("Single click sensitivity", _singleClickSensitivity, _settingsStyle);
InputManager.Settings.doubleClickSensitivity = _doubleClickSensitivity = EditorGUILayout.FloatField("Double click sensitivity", _doubleClickSensitivity, _settingsStyle);
InputManager.Settings.longClickSensitivity = _longClickSensitivity = EditorGUILayout.FloatField("Long click sensitivity", _longClickSensitivity, _settingsStyle);
InputManager.Settings.combinationsClickSensitivity = _combosClickSensitivity = EditorGUILayout.FloatField("Combos click sensitivity", _combosClickSensitivity, _settingsStyle);
EditorGUILayout.Separator();
//////////// PLAYERS //////////////
EditorGUILayout.BeginHorizontal();
InputPlayer player = null;
_playerNumber = EditorGUILayout.IntField("Number of Players", _playerNumber);
if (_playerNumber < 1)
{
_playerNumber = 1;
}
//create Players
if (settings.Players == null || _playerNumber != settings.Players.Length)
{
InputPlayer[] players = new InputPlayer[_playerNumber];
for (i = 0; i < _playerNumber; i++)
{
//don't delete previous players just add new
if (settings.Players != null && settings.Players.Length > i)
{
players [i] = settings.Players [i];
}
else
{
players [i] = new InputPlayer();
}
}
settings.Players = players;
//set last player as current
_playerIndexSelected = _playerNumber - 1;
//reset profile to default
_profileSelectedIndex = 0;
}
//create player display options
if (_playerDisplayOptions == null || _playerNumber != _playerDisplayOptions.Length)
{
_playerDisplayOptions = new string [_playerNumber];
for (i = 0; i < _playerNumber; i++)
{
_playerDisplayOptions [i] = "Player" + i;
}
}
_playerIndexSelected = EditorGUILayout.Popup(_playerIndexSelected, _playerDisplayOptions);
if (_playerNumber > 1 && GUILayout.Button("Clone To All"))
{
if (EditorUtility.DisplayDialog("Clone to All!",
"Are you sure to clone selected player overwriting other player's settings?", "Yes", "Cancel"))
{
InputPlayer sample = settings.Players [_playerIndexSelected];
for (i = 0; i < _playerNumber; i++)
{
if (i != _playerIndexSelected)
{
settings.Players [i] = sample.Clone();
}
}
}
}
EditorGUILayout.EndHorizontal();
//////////// Profiles /////////////
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("Profiles");
List <IDevice> devices = InputManager.GetDevices <IDevice> ();
if (devices.Count > 0)
{
List <string> pList = devices.Where(item => item.profile != null).Select(item => item.profile.Name).Distinct().ToList();
pList.Insert(0, "default");
_profilesDevicesDisplayOptions = pList.ToArray();
}
else
{
_profileSelectedIndex = 0;
_profilesDevicesDisplayOptions = new string[] { "default" };
}
_profileSelectedIndex = EditorGUILayout.Popup(_profileSelectedIndex, _profilesDevicesDisplayOptions);
//by selecting profile we are setting Device type expectation
_deviceByProfile = devices.Where(item => item.profile != null).FirstOrDefault(item => item.profile.Name == _profilesDevicesDisplayOptions [_profileSelectedIndex]);
player = settings.Players [_playerIndexSelected];
Dictionary <int, InputState> stateInputsCurrent = null;
//init stateInput Dictionary if player numbers is increased
if (_profilesDevicesDisplayOptions.Length > _profileSelectedIndex)
{
if (!player.DeviceProfileStateInputs.ContainsKey(_profilesDevicesDisplayOptions [_profileSelectedIndex]))
{
player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]] = new Dictionary <int, InputState> ();
}
stateInputsCurrent = player.DeviceProfileStateInputs [_profilesDevicesDisplayOptions [_profileSelectedIndex]];
}
else
{
_profileSelectedIndex = 0;
stateInputsCurrent = player.DeviceProfileStateInputs ["default"];
}
if (_profileSelectedIndex > 0)
{
if (GUILayout.Button("Clone default") &&
EditorUtility.DisplayDialog("Clone Default!",
"Are you sure to clone Default input settings to " + _profilesDevicesDisplayOptions [_profileSelectedIndex] + " device specific settings?", "Yes", "Cancel")
)
{
Dictionary <int, InputState> stateInputsDefault = player.DeviceProfileStateInputs ["default"];
foreach (var HashInputStatePair in stateInputsDefault)
{
if (!stateInputsCurrent.ContainsKey(HashInputStatePair.Key))
{
stateInputsCurrent.Add(HashInputStatePair.Key, HashInputStatePair.Value.Clone());
}
}
}
}
_stateInputCombinations = stateInputsCurrent;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
////////// ANY/Complex Action Types(doubles,long...) /FULL AXIS Checkers ///////
EditorGUILayout.BeginHorizontal();
// _isDeviceAny = GUILayout.Toggle (_isDeviceAny, "Any(Uncheck 4Testing Only");
_isComplexActionTypesAllowed = GUILayout.Toggle(_isComplexActionTypesAllowed, "Allow DOUBLE/LONG(HOLD)");
_isDeviceAxisPositionFull = GUILayout.Toggle(_isDeviceAxisPositionFull, "Full Axis");
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
}
/////////////// GENERATING ENUM SETTINGS ///////////
_enumSettingsFoldout = EditorGUILayout.Foldout(_enumSettingsFoldout, "States Enum Properties");
if (_enumSettingsFoldout)
{
EditorGUILayout.BeginVertical();
//settingsXML = EditorGUILayout.ObjectField (settingsXML, typeof(TextAsset), true) as TextAsset;
_namespace = EditorGUILayout.TextField("Namespace:", _namespace);
_enumName = EditorGUILayout.TextField("Enum:", _enumName);
_enumFileName = EditorGUILayout.TextField("File name:", _enumFileName);
EditorGUILayout.EndVertical();
}
EditorGUILayout.Separator();
///////////////// XML ////////////////////
EditorGUILayout.LabelField("Input XML/BIN");
EditorGUILayout.BeginHorizontal();
settingsFile = EditorGUILayout.ObjectField(settingsFile, typeof(UnityEngine.Object), true);
//reload if xml changed
if (_lastSettingsFile != settingsFile)
{
_settingsLoaded = false;
}
_lastSettingsFile = settingsFile;
if (_selectedStateHash == 0 && GUILayout.Button("Open"))
{
string path;
if (_isBinary)
{
path = EditorUtility.OpenFilePanel("Open XML Input Settings file", "", "bin");
}
else
{
path = EditorUtility.OpenFilePanel("Open XML Input Settings file", "", "xml");
}
if (path.Length > 0)
{
loadAsset(path);
}
return;
}
/////////////// SAVE ////////////////////
if (_selectedStateHash == 0 && GUILayout.Button("Save"))
{
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (!Directory.Exists(Application.streamingAssetsPath))
{
Directory.CreateDirectory(Application.streamingAssetsPath);
}
if (settingsFile != null)
{
string path = AssetDatabase.GetAssetPath(settingsFile);
if (Path.GetExtension(path) == ".xml")
{
saveInputSettings(Path.Combine(Application.streamingAssetsPath, settingsFile.name + ".xml"));
}
else
{
saveInputSettings(Path.Combine(Application.streamingAssetsPath, settingsFile.name + ".bin"));
}
}
else
{
if (_isBinary)
{
saveInputSettings(EditorUtility.SaveFilePanel("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "bin"));
}
else
{
saveInputSettings(EditorUtility.SaveFilePanel("Save Input Settings", Application.streamingAssetsPath, "InputSettings", "xml"));
}
return;
}
}
if (settingsFile == null)
{
_isBinary = GUILayout.Toggle(_isBinary, "Binary");
}
/////////// RELOAD ////////////////
if (GUILayout.Button("Reload"))
{
_settingsLoaded = false;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
//loadingSettings selected thru ObjectField browser or drag and drop
if ((!_settingsLoaded && settingsFile != null))
{
_settingsLoaded = loadInputSettings(settingsFile);
}
///////// ANIMATOR CONTROLER //////////
_lastController = controller;
EditorGUILayout.LabelField("Animator Controller States");
EditorGUILayout.BeginHorizontal();
controller = EditorGUILayout.ObjectField(controller, typeof(UnityEditor.Animations.AnimatorController), true) as UnityEditor.Animations.AnimatorController;
EditorGUILayout.EndHorizontal();
EditorGUILayout.Separator();
///////// Create AnimaitonController states GUI //////////
if (controller != null)
{
ac = controller as UnityEditor.Animations.AnimatorController;
numLayers = ac.layers.Length;
if (_showLayer == null || _showLayer.Length != numLayers)
{
_showLayer = new bool[controller.layers.Length];
}
for (i = 0; i < numLayers; i++)
{
layer = ac.layers [i];
_showLayer [i] = EditorGUILayout.Foldout(_showLayer [i], layer.name);
if (_showLayer [i])
{
stateMachine = layer.stateMachine;
numStates = stateMachine.states.Length;
scrollPosition = GUILayout.BeginScrollView(scrollPosition, false, false);
for (j = 0; j < numStates; j++)
{
state = stateMachine.states [j].state;
createInputStateGUI(state.name, Animator.StringToHash(state.name));
//createInputStateGUI (state.name, state.uniqueNameHash);
}
GUILayout.EndScrollView();
}
}
EditorGUILayout.Separator();
}
///////////////////// NEW CUSTOM STATE STATE //////////////////////
EditorGUILayout.LabelField("Custom States");
EditorGUILayout.BeginHorizontal();
EditorGUILayout.LabelField("New state name:", _stateNameLabelStyle);
_newCustomStateName = EditorGUILayout.TextField(_newCustomStateName, _stateNameLabelStyle);
if (_newCustomStateName != _prevNewCustomStateName)
{
_warrningAddStateLabel = "";
}
_prevNewCustomStateName = _newCustomStateName;
if (GUILayout.Button("+", _addRemoveButtonStyle))
{
EditorGUIUtility.keyboardControl = 0;
_selectedStateHash = 0;
if (_newCustomStateName != null && _newCustomStateName.Length > 0)
{
int hash = Animator.StringToHash(_newCustomStateName);
if (!_stateInputCombinations.ContainsKey(hash)) //not already there
{
_stateInputCombinations [hash] = new InputState(_newCustomStateName, hash); // string[]{"None","None"};
_stateInputCombinations [hash].Add(new InputCombination("None"));
_stateInputCombinations [hash].Add(new InputCombination("None"));
_newCustomStateName = ""; //reset
}
else
{
_warrningAddStateLabel = "Already exist!";
}
}
else
{
_warrningAddStateLabel = "Empty state name!";
}
}
GUI.color = Color.red;
EditorGUILayout.LabelField(_warrningAddStateLabel);
EditorGUILayout.EndHorizontal();
GUI.color = Color.white;
EditorGUILayout.BeginHorizontal();
scrollPosition2 = EditorGUILayout.BeginScrollView(scrollPosition2, false, false);
//Debug.Log ("Loop..." + _stateInputCombinations.Count+" inputmngr "+InputManager.Settings.stateInputs.Count);
if (_stateInputCombinations != null)
{
foreach (var KeyValuePair in _stateInputCombinations)
{
if (!existInController(KeyValuePair.Key))
{
createInputStateGUI(KeyValuePair.Value.name, KeyValuePair.Key);
}
}
}
GUILayout.EndScrollView();
EditorGUILayout.EndHorizontal();
//}
//if event is of key or mouse
if (Event.current.isKey)
{
if (Event.current.keyCode == KeyCode.Return)
{
_selectedStateHash = 0;
_previousStateInput = null;
this.Repaint();
}
else if (Event.current.keyCode == KeyCode.Escape)
{
if (_selectedStateHash != 0)
{
_stateInputCombinations [_selectedStateHash].combinations [_isPrimary] = _previousStateInput;
_previousStateInput = null;
_selectedStateHash = 0;
}
}
}
if (_selectedStateHash != 0)
{
InputManager.processGUIEvent(Event.current); //process input from keyboard & mouses
}
}
private void OnTimePeriodStart(InputCombination button, float timePeriod, EventArgs e)
{
}
/// <summary>
/// Creates the Input State GUI.
/// </summary>
/// <param name="hash">State Hash.</param>
/// <param name="stateName">State name.</param>
/// <param name="combinations">State Combinations.</param>
void createInputStateGUI(int hash, string stateName, InputCombination[] combinations)
{
string currentCombinationString;
GUILayout.BeginHorizontal();
//string stateName=((CharacterInputControllerClass.States)hash).ToString();
//(AnimatorEnum)hash
//GUILayout.Label(stateName.Remove(0,stateName.IndexOf("Layer")+6).Replace("_"," "),_stateNameLabelStyle);
GUILayout.Label(stateName, _stateNameLabelStyle);
if (_selectedStateHash != hash)
{
//!!! USE HERE YOUR CUSTOM METHOD TO SHOW DISPLAY
if (GUILayout.Button(InputCode.beautify(combinations [0].combinationString), _inputButtonStyle))
{
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 0;
}
if (combinations.Length > 1 && combinations [1] != null)
{
//!!! USE HERE YOUR CUSTOM METHOD TO SHOW DISPLAY
if (GUILayout.Button(InputCode.beautify(combinations [1].combinationString), _inputButtonStyle))
{
_selectedStateHash = hash;
_previousStateInput = null;
_isPrimary = 1;
}
}
}
else
{
currentCombinationString = combinations [_isPrimary].combinationString;
if (_previousStateInput == null)
{
_previousStateInput = combinations [_isPrimary].Clone();
}
//!!! USE HERE YOUR CUSTOM METHOD TO SHOW DISPLAY
currentCombinationString = InputCode.beautify(currentCombinationString);
GUILayout.Label(currentCombinationString);
#if UNITY_ANDROID || UNITY_IPHONE
if (GUILayout.Button("Submit", _submitButtonStyle))
{
_selectedStateHash = 0;
_previousStateInput = null;
return;
}
#endif
//this.Repaint ();
}
//Debug.Log ("_selectedStateHash after" + _selectedStateHash);
GUILayout.EndHorizontal();
GUILayout.Space(20);
}
