public string Draw(GUIContent labelContent, string curName, InputRig rig)
{
EditorGUILayout.BeginHorizontal();
if (labelContent.text.Length > 0)
{
EditorGUILayout.LabelField(labelContent); //, GUILayout.Width(40));
}
string s = EditorGUILayout.TextField(curName, GUILayout.MinWidth(20), GUILayout.ExpandWidth(true));
bool buttonPressed = false;
InputRig.AxisConfig axisConfig = (rig == null) ? null : rig.GetAxisConfig(s, ref this.cachedAxisId);
float buttonWidth = 16;
//float buttonHeight = 16;
GUIContent buttonContent;
if (rig == null)
{
buttonContent = new GUIContent(string.Empty, CFEditorStyles.Inst.texError, "No rig attached!");
}
else if (axisConfig == null)
{
buttonContent = new GUIContent(string.Empty, CFEditorStyles.Inst.texError, "Axis not found!"); //, CFEditorStyles.Inst.iconError);
}
else if (!axisConfig.DoesSupportInputSource(this.inputSource))
{
buttonContent = new GUIContent(string.Empty, CFEditorStyles.Inst.texWarning, "Target axis is incompatible!"); //, CFEditorStyles.Inst.iconOkWarning);
}
else
{
buttonContent = new GUIContent(string.Empty, CFEditorStyles.Inst.texOk, "Axis name is ok!"); //, CFEditorStyles.Inst.iconOk);
}
buttonPressed = GUILayout.Button(buttonContent, CFEditorStyles.Inst.iconButtonStyle, GUILayout.Width(buttonWidth)); //, GUILayout.Height(buttonHeight));
EditorGUILayout.EndHorizontal();
// Show context menu...
if (buttonPressed)
{
this.ShowContextMenu(s, rig);
}
// Apply the name selected via context menu..
if (this.menuSelectedName != null)
{
s = this.menuSelectedName;
this.menuSelectedName = null;
EditorGUI.FocusTextInControl("");
}
return(s);
}
// -----------------
public void ApplyToRig(InputRig rig, bool skipIfTargetIsMuted)
{
InputRig.AxisConfig a = rig.GetAxisConfig(this.axisName, ref this.cachedAxisId);
if (a == null)
{
return;
}
if (!skipIfTargetIsMuted || !a.IsMuted())
{
a.SetSignedDigital(this.axisPositiveSide);
}
//rig.SetAxisDigital(this.axisName, ref this.cachedAxisId, !this.axisPositiveSide);
}
void XXX()
{
InputRig rig = CF2Input.activeRig;
if (rig != null)
{
InputRig.AxisConfig config = rig.GetAxisConfig("YourAxisName");
if (config != null)
{
config.keyboardPositive = KeyCode.A;
config.keyboardPositiveAlt0 = KeyCode.B;
config.keyboardPositiveAlt1 = KeyCode.C;
config.keyboardPositiveAlt2 = KeyCode.D;
config.keyboardPositive = KeyCode.E;
config.keyboardPositiveAlt0 = KeyCode.F;
config.keyboardPositiveAlt1 = KeyCode.G;
config.keyboardPositiveAlt2 = KeyCode.H;
}
}
}
// ------------------
private void ShowContextMenu(string curName, InputRig rig)
{
if (rig == null)
{
return;
}
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Select rig"), false, this.OnMenuSelectRig, rig);
//menu.AddDisabledItem(new GUIContent("Available axes:"));
InputRig.AxisConfig axisConfig = rig.GetAxisConfig(curName, ref this.cachedAxisId);
if ((curName.Length > 0) && (axisConfig == null))
{
menu.AddSeparator("");
menu.AddItem(new GUIContent("Create \"" + curName + "\" Digital Axis"), false, this.OnMenuCreateAxis, new AxisCreationParams(rig, curName, InputRig.AxisType.Digital));
menu.AddItem(new GUIContent("Create \"" + curName + "\" Unsigned Analog Axis"), false, this.OnMenuCreateAxis, new AxisCreationParams(rig, curName, InputRig.AxisType.UnsignedAnalog));
menu.AddItem(new GUIContent("Create \"" + curName + "\" Signed Analog Axis"), false, this.OnMenuCreateAxis, new AxisCreationParams(rig, curName, InputRig.AxisType.SignedAnalog));
menu.AddItem(new GUIContent("Create \"" + curName + "\" Delta"), false, this.OnMenuCreateAxis, new AxisCreationParams(rig, curName, InputRig.AxisType.Delta));
menu.AddItem(new GUIContent("Create \"" + curName + "\" Scroll"), false, this.OnMenuCreateAxis, new AxisCreationParams(rig, curName, InputRig.AxisType.ScrollWheel));
}
menu.AddSeparator("");
for (int i = 0; i < rig.axes.list.Count; ++i)
{
InputRig.AxisConfig axis = rig.axes.list[i];
if (axis.DoesSupportInputSource(this.inputSource))
{
menu.AddItem(new GUIContent("Use \"" + axis.name + "\""), (axis.name == curName), this.OnMenuNameSelected, axis.name);
}
}
menu.ShowAsContext();
}
// ----------------
private void AddAxesToRig()
{
// Check for already present axes...
int enabledAxisNum = 0;
int alreadyPresentAxisNum = 0;
string presentAxisNames = "";
for (int i = 0; i < this.axisList.Count; ++i)
{
if (!this.axisList[i].enabled)
{
continue;
}
enabledAxisNum++;
int axisId = 0;
if (this.rig.IsAxisDefined(this.axisList[i].name, ref axisId))
{
++alreadyPresentAxisNum;
if (alreadyPresentAxisNum <= 10)
{
presentAxisNames += (((alreadyPresentAxisNum == 10) ? "..." : this.axisList[i].name) + "\n");
}
}
}
bool overwriteAll = false;
bool igonrePresentAxes = false;
if (alreadyPresentAxisNum > 0)
{
int overwriteMethod = EditorUtility.DisplayDialogComplex(DIALOG_TITLE, "" + alreadyPresentAxisNum + " out of " + enabledAxisNum +
" selected axes are already present in selected Input Rig.\n\n" +
presentAxisNames + "\n" + "What do you want to do with them?", "Overwrite All", "Ignore All", "Choose one by one");
if (overwriteMethod == 1)
{
igonrePresentAxes = true;
}
else if (overwriteMethod == 0)
{
overwriteAll = true;
}
}
// Apply...
CFGUI.CreateUndo("Transfer axes from Input Manager to Input Rig", this.rig);
for (int i = 0; i < this.axisList.Count; ++i)
{
AxisDescription axisDesc = this.axisList[i];
if (!axisDesc.enabled)
{
continue;
}
InputRig.AxisConfig axisConfig = this.rig.GetAxisConfig(axisDesc.name);
if (axisConfig != null)
{
if (igonrePresentAxes)
{
continue;
}
if (!overwriteAll && !EditorUtility.DisplayDialog(DIALOG_TITLE, "Transfer and overwrite [" + axisDesc.name + "] axis?", "Transfer", "Skip"))
{
continue;
}
axisConfig.axisType = axisDesc.targetAxisType;
}
else
{
axisConfig = this.rig.axes.Add(axisDesc.name, axisDesc.targetAxisType, false);
}
axisConfig.keyboardNegative = KeyCode.None;
axisConfig.keyboardNegativeAlt0 = KeyCode.None;
axisConfig.keyboardPositive = KeyCode.None;
axisConfig.keyboardPositiveAlt0 = KeyCode.None;
axisConfig.scale = 1;
axisConfig.digitalToAnalogDecelTime = 0;
axisConfig.digitalToAnalogAccelTime = 0;
axisConfig.smoothingTime = 0;
axisConfig.rawSmoothingTime = 0;
axisConfig.snap = false;
for (int ai = 0; ai < axisDesc.inputAxes.Count; ++ai)
{
UnityInputManagerUtils.InputAxis inputAxis = axisDesc.inputAxes[ai];
switch (inputAxis.type)
{
case UnityInputManagerUtils.AxisType.KeyOrMouseButton:
KeyCode
positiveCode = InputRig.NameToKeyCode(!inputAxis.invert ? inputAxis.positiveButton : inputAxis.negativeButton),
positiveAltCode = InputRig.NameToKeyCode(!inputAxis.invert ? inputAxis.altPositiveButton : inputAxis.altNegativeButton),
negativeCode = InputRig.NameToKeyCode(!inputAxis.invert ? inputAxis.negativeButton : inputAxis.positiveButton),
negativeAltCode = InputRig.NameToKeyCode(!inputAxis.invert ? inputAxis.altNegativeButton : inputAxis.altPositiveButton);
if ((positiveCode != KeyCode.None) && !UnityInputManagerUtils.IsJoystickKeyCode(positiveCode))
{
axisConfig.keyboardPositive = positiveCode;
axisConfig.affectedKeyPositive = positiveCode;
}
if ((positiveAltCode != KeyCode.None) && !UnityInputManagerUtils.IsJoystickKeyCode(positiveAltCode))
{
axisConfig.keyboardPositiveAlt0 = positiveAltCode;
}
if ((negativeCode != KeyCode.None) && !UnityInputManagerUtils.IsJoystickKeyCode(negativeCode))
{
axisConfig.keyboardNegative = negativeCode;
axisConfig.affectedKeyNegative = negativeCode;
}
if ((negativeAltCode != KeyCode.None) && !UnityInputManagerUtils.IsJoystickKeyCode(negativeAltCode))
{
axisConfig.keyboardNegativeAlt0 = negativeAltCode;
}
if (inputAxis.snap)
{
axisConfig.snap = true;
}
break;
case UnityInputManagerUtils.AxisType.JoystickAxis:
break;
case UnityInputManagerUtils.AxisType.MouseMovement:
{
// Mouse Delta...
if ((inputAxis.axis == UnityInputManagerUtils.MOUSE_X_AXIS_ID) ||
(inputAxis.axis == UnityInputManagerUtils.MOUSE_Y_AXIS_ID))
{
ControlFreak2.Internal.AxisBinding mouseDeltaBinding = (inputAxis.axis == UnityInputManagerUtils.MOUSE_X_AXIS_ID) ?
this.rig.mouseConfig.horzDeltaBinding : this.rig.mouseConfig.vertDeltaBinding;
mouseDeltaBinding.Clear();
mouseDeltaBinding.Enable(); //.enabled = true;
mouseDeltaBinding.AddTarget().SetSingleAxis(axisDesc.name, inputAxis.invert); //, axisDesc.inputAxis.invert);
//mouseDeltaBinding.separateAxes = false;
//mouseDeltaBinding.singleAxis = axisDesc.name;
axisConfig.scale = inputAxis.sensitivity;
}
// Scroll wheel...
else if ((inputAxis.axis == UnityInputManagerUtils.SCROLL_PRIMARY_AXIS_ID) ||
(inputAxis.axis == UnityInputManagerUtils.SCROLL_SECONDARY_AXIS_ID))
{
ControlFreak2.Internal.AxisBinding scrollBinding = (inputAxis.axis == UnityInputManagerUtils.SCROLL_PRIMARY_AXIS_ID) ?
this.rig.scrollWheel.vertScrollDeltaBinding.deltaBinding : this.rig.scrollWheel.horzScrollDeltaBinding.deltaBinding;
scrollBinding.Clear();
scrollBinding.AddTarget().SetSingleAxis(axisDesc.name, inputAxis.invert);
//scrollBinding.enabled = true;
//scrollBinding.separateAxes = false;
//scrollBinding.singleAxis = axisDesc.name;
}
}
break;
}
}
// Set mouse delta scaling...
if (axisDesc.targetAxisType == InputRig.AxisType.Delta)
{
axisConfig.deltaMode = InputRig.DeltaTransformMode.EmulateMouse;
axisConfig.scale = axisDesc.inputAxis.sensitivity;
}
// Convert gravity to smoothing time...
else if ((axisDesc.targetAxisType == InputRig.AxisType.SignedAnalog) || (axisDesc.targetAxisType == InputRig.AxisType.UnsignedAnalog))
{
float
gravity = 0,
sensitivity = 0;
// Find biggest gravity and sensitivity...
for (int di = 0; di < axisDesc.inputAxes.Count; ++di)
{
if (axisDesc.inputAxes[di].type != UnityInputManagerUtils.AxisType.KeyOrMouseButton)
{
continue;
}
gravity = Mathf.Max(gravity, axisDesc.inputAxes[di].gravity);
sensitivity = Mathf.Max(sensitivity, axisDesc.inputAxes[di].sensitivity);
}
// Convert graivty and sensitivity to digiAccel/Decel times...
axisConfig.digitalToAnalogDecelTime = ((gravity < 0.001f) ? 0.2f : (1.0f / gravity));
axisConfig.digitalToAnalogAccelTime = ((sensitivity < 0.001f) ? 0.2f : (1.0f / sensitivity));
axisConfig.smoothingTime = 0;
axisConfig.rawSmoothingTime = 0;
//if (axisDesc.inputAxis.gravity > 0.1f)
// axisConfig.smoothingTime = Mathf.Min(1.0f, (1.0f / axisDesc.inputAxis.gravity));
}
//if (axisDesc.inputAxis.invert)
// axisConfig.scale = -axisConfig.scale;
}
CFGUI.EndUndo(this.rig);
}
// -------------------
void OnGUI()
{
if (CF2Input.activeRig == null)
{
return;
}
GUI.skin = this.skin;
GUILayout.BeginVertical((GUI.skin != null) ? GUI.skin.box : GUIStyle.none);
GUILayout.Box("Active RIG: " + CF2Input.activeRig.name);
if (this.drawMouseStats)
{
GUILayout.Box("Scroll: cf:" + this.cfScroll + " un:" + this.unScroll + "\n" +
"Mouse Delta: cf: " + this.cfMouseDelta + " un:" + this.unMouseDelta);
}
List <InputRig.AxisConfig> axes = CF2Input.activeRig.axes.list;
for (int i = 0; i < axes.Count; ++i)
{
InputRig.AxisConfig axis = axes[i];
float
cfAxisVal = 0,
unityAxisVal = 0;
bool
unityAxisAvailable = false;
cfAxisVal = axis.GetAnalog();
try { unityAxisVal = Input.GetAxis(axis.name); unityAxisAvailable = true; } catch (System.Exception) {}
if ((cfAxisVal == 0) && (!this.drawUnityAxes || (unityAxisVal == 0)))
{
continue;
}
const float BAR_WIDTH = 100;
GUILayout.BeginVertical();
GUILayout.Label(axis.name);
GUI.color = ((cfAxisVal == 0) || (cfAxisVal == 1) || (cfAxisVal == -1)) ? Color.green : Color.gray;
GUILayout.Label("CF : " + cfAxisVal.ToString("0.00000"));
GUILayout.Box("", GUILayout.Width(Mathf.Abs(cfAxisVal) * BAR_WIDTH));
if (this.drawUnityAxes)
{
GUI.color = ((unityAxisVal == 0) || (unityAxisVal == 1) || (unityAxisVal == -1)) ? Color.green : Color.gray;
GUILayout.Label("UN : " + (unityAxisAvailable ? unityAxisVal.ToString("0.00000") : "UNAVAILABLE!"));
GUILayout.Box("", GUILayout.Width(Mathf.Abs(unityAxisVal) * BAR_WIDTH));
}
GUILayout.EndVertical();
GUI.color = Color.white;
if (axis.axisType == InputRig.AxisType.UnsignedAnalog)
{
}
}
GUILayout.EndVertical();
}
// ------------------------
static public void CreateContextMenuForAxisBinding(Object panelOrRig, string axisName, /*InputRig.InputSource sourceType, */ System.Action onRefreshCallback = null)
{
InputRig rig = (panelOrRig as InputRig);
TouchControlPanel panel = (panelOrRig as TouchControlPanel);
//bool displayPanelName = false;
if (panel != null)
{
rig = panel.rig;
}
else if (rig != null)
{
// Auto Select panel...
panel = TouchControlWizardUtils.GetRigPanel(rig);
//displayPanelName = true;
}
else
{
return;
}
List <TouchControl> controlList = rig.GetTouchControls();
GenericMenu menu = new GenericMenu();
string commandName = ("\"" + axisName + "\" axis ");
menu.AddDisabledItem(new GUIContent("Actions for : " + commandName));
menu.AddSeparator("");
InputRig.AxisConfig axisConfig = rig.GetAxisConfig(axisName);
if (axisConfig == null)
{
AxisCreationMenuItem.AddAllMenuItems(menu, axisName, "", rig, onRefreshCallback);
}
else
{
int
axisSourceTypeMask = axisConfig.GetSupportedInputSourceMask();
BindingDescription.BindingType
bindingTypeMask = BindingDescription.BindingType.Axis | BindingDescription.BindingType.Digital;
UniversalBindingAssignment.AddBindingContainerToMenu(menu, rig, onRefreshCallback, bindingTypeMask, commandName,
"Bind to Input Rig/", rig, KeyCode.None, axisName, axisSourceTypeMask); //, true); //, null);
menu.AddSeparator("");
if (panel == null)
{
menu.AddDisabledItem(new GUIContent("Add a Touch Control Panel to this rig to create and bind commands to Touch Controls!"));
}
else
{
UniversalBindingAssignment.AddControlListBindingsToMenu(menu, controlList, onRefreshCallback,
bindingTypeMask, commandName, "Bind to Touch Controls/", KeyCode.None, axisName); //, true); //, null);
menu.AddSeparator("");
AddTouchControlCreationItemsToMenuForAxisOrKey(menu, panel, axisName, KeyCode.None, onRefreshCallback);
}
}
menu.ShowAsContext();
}
