private void OnAddCallback(ReorderableList list)
{
if (selectedActionSet == -1)
{
return;
}
SteamVR_Input_ActionFile_Action newAction = new SteamVR_Input_ActionFile_Action();
list.list.Add(newAction);
string direction = "";
if (inList == list)
{
direction = "in";
outList.index = -1;
inList.index = inList.list.Count - 1;
}
else if (outList == list)
{
direction = "out";
inList.index = -1;
outList.index = outList.list.Count - 1;
}
newAction.name = SteamVR_Input_ActionFile_Action.CreateNewName(SteamVR_Input.actionFile.action_sets[selectedActionSet].shortName, direction);
OnSelectCallback(list);
}
protected static int ImportActions(SteamVR_Input_ActionFile currentActionsFile,
SteamVR_Input_ActionFile newActionsFile)
{
int count = 0;
foreach (var newAction in newActionsFile.actions)
{
if (currentActionsFile.actions.Any(actionInCurrent => newAction.name == actionInCurrent.name) == false)
{
currentActionsFile.actions.Add(newAction.GetCopy());
count++;
}
else
{
SteamVR_Input_ActionFile_Action existingAction =
currentActionsFile.actions.First(actionInCurrent => newAction.name == actionInCurrent.name);
//todo: better merge? should we overwrite?
existingAction.type = newAction.type;
existingAction.scope = newAction.scope;
existingAction.skeleton = newAction.skeleton;
existingAction.requirement = newAction.requirement;
}
}
return(count);
}
protected override void CreateUninitialized(string newActionSet, SteamVR_ActionDirections direction, string newAction, bool caseSensitive)
{
actionPath = SteamVR_Input_ActionFile_Action.CreateNewName(newActionSet, direction, newAction);
sourceMap = new SourceMap();
sourceMap.PreInitialize(this, actionPath, false);
needsReinit = true;
initialized = false;
}
public SteamVR_Input_ActionFile_Action GetCopy()
{
SteamVR_Input_ActionFile_Action newAction = new SteamVR_Input_ActionFile_Action();
newAction.name = this.name;
newAction.type = this.type;
newAction.scope = this.scope;
newAction.skeleton = this.skeleton;
newAction.requirement = this.requirement;
return(newAction);
}
private void OnSelectCallback(ReorderableList list)
{
selectedActionIndex = list.index;
if (selectedActionIndex != -1)
{
selectedAction = (SteamVR_Input_ActionFile_Action)list.list[selectedActionIndex];
}
if (inList == list)
{
outList.index = -1;
}
else if (outList == list)
{
inList.index = -1;
}
}
public override bool Equals(object obj)
{
if (obj is SteamVR_Input_ActionFile_Action)
{
SteamVR_Input_ActionFile_Action action = (SteamVR_Input_ActionFile_Action)obj;
if (this == obj)
{
return(true);
}
if (this.name == action.name && this.type == action.type && this.skeleton == action.skeleton && this.requirement == action.requirement)
{
return(true);
}
return(false);
}
return(base.Equals(obj));
}
private static Type GetTypeForAction(SteamVR_Input_ActionFile_Action action)
{
string actionType = action.type.ToLower();
if (SteamVR_Input_ActionFile_ActionTypes.boolean == actionType)
{
return(typeof(SteamVR_Action_Boolean));
}
if (SteamVR_Input_ActionFile_ActionTypes.vector1 == actionType)
{
return(typeof(SteamVR_Action_Single));
}
if (SteamVR_Input_ActionFile_ActionTypes.vector2 == actionType)
{
return(typeof(SteamVR_Action_Vector2));
}
if (SteamVR_Input_ActionFile_ActionTypes.vector3 == actionType)
{
return(typeof(SteamVR_Action_Vector3));
}
if (SteamVR_Input_ActionFile_ActionTypes.pose == actionType)
{
return(typeof(SteamVR_Action_Pose));
}
if (SteamVR_Input_ActionFile_ActionTypes.skeleton == actionType)
{
return(typeof(SteamVR_Action_Skeleton));
}
if (SteamVR_Input_ActionFile_ActionTypes.vibration == actionType)
{
return(typeof(SteamVR_Action_Vibration));
}
throw new Exception("unknown type (" + action.type + ") in actions file for action: " + action.name);
}
private static CodeMemberProperty CreateActionPropertyWrapper(CodeTypeDeclaration addToClass,
string actionClass, string propertyName, string actionClassFieldName,
SteamVR_Input_ActionFile_Action action)
{
string propertyType = GetTypeStringForAction(action);
CodeMemberProperty property = new CodeMemberProperty();
property.Name = propertyName;
property.Type = new CodeTypeReference(propertyType);
property.Attributes = MemberAttributes.Public;
CodeFieldReferenceExpression fieldReference =
new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(actionClass), actionClassFieldName);
CodeMethodReturnStatement returnStatement = new CodeMethodReturnStatement(fieldReference);
property.GetStatements.Add(returnStatement);
addToClass.Members.Add(property);
return(property);
}
private static void GenerateActionHelpers(string actionsClassFileName)
{
CodeCompileUnit compileUnit = new CodeCompileUnit();
CodeTypeDeclaration inputClass = CreatePartialInputClass(compileUnit);
CodeArrayCreateExpression actionsArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action)));
CodeArrayCreateExpression actionsInArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_In)));
CodeArrayCreateExpression actionsOutArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_Out)));
CodeArrayCreateExpression actionsVibrationArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vibration)));
CodeArrayCreateExpression actionsPoseArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Pose)));
CodeArrayCreateExpression actionsSkeletonArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Skeleton)));
CodeArrayCreateExpression actionsBooleanArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Boolean)));
CodeArrayCreateExpression actionsSingleArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Single)));
CodeArrayCreateExpression actionsVector2Array = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vector2)));
CodeArrayCreateExpression actionsVector3Array = new CodeArrayCreateExpression(new CodeTypeReference(typeof(SteamVR_Action_Vector3)));
CodeArrayCreateExpression actionsNonPoseNonSkeletonArray = new CodeArrayCreateExpression(new CodeTypeReference(typeof(ISteamVR_Action_In)));
//add the getaction method to
CodeMemberMethod actionsArraysInitMethod = CreateStaticMethod(inputClass, initializeActionsArraysMethodName, false);
CodeMemberMethod actionsPreInitMethod = CreateStaticMethod(inputClass, preInitActionsMethodName, false);
for (int actionSetIndex = 0; actionSetIndex < SteamVR_Input.actionFile.action_sets.Count; actionSetIndex++)
{
SteamVR_Input_ActionFile_ActionSet actionSet = SteamVR_Input.actionFile.action_sets[actionSetIndex];
string actionSetShortName = actionSet.shortName;
actionSetShortName = actionSetShortName.Substring(0, 1).ToLower() + actionSetShortName.Substring(1);
for (int actionIndex = 0; actionIndex < actionSet.actionsList.Count; actionIndex++)
{
SteamVR_Input_ActionFile_Action action = actionSet.actionsList[actionIndex];
string actionShortName = action.shortName;
string typeName = GetTypeStringForAction(action);
string codeFriendlyInstanceName;
if (actionSet.actionsList.Count(findAction => findAction.shortName == actionShortName) >= 2)
{
codeFriendlyInstanceName = string.Format("{0}_{1}_{2}", actionSetShortName, action.direction.ToString().ToLower(), actionShortName);
}
else
{
codeFriendlyInstanceName = string.Format("{0}_{1}", actionSetShortName, actionShortName);
}
CodeMemberField actionField = CreateFieldAndPropertyWrapper(inputClass, codeFriendlyInstanceName, typeName);
AddAssignActionStatement(actionsPreInitMethod, inputClass.Name, actionField.Name, action.name, typeName);
actionsArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
if (action.direction == SteamVR_ActionDirections.In)
{
actionsInArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
if (typeName == typeof(SteamVR_Action_Pose).Name)
{
actionsPoseArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
else if (typeName == typeof(SteamVR_Action_Skeleton).Name)
{
actionsSkeletonArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
else if (typeName == typeof(SteamVR_Action_Boolean).Name)
{
actionsBooleanArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
else if (typeName == typeof(SteamVR_Action_Single).Name)
{
actionsSingleArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
else if (typeName == typeof(SteamVR_Action_Vector2).Name)
{
actionsVector2Array.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
else if (typeName == typeof(SteamVR_Action_Vector3).Name)
{
actionsVector3Array.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
if ((typeName == typeof(SteamVR_Action_Skeleton).Name) == false && (typeName == typeof(SteamVR_Action_Pose).Name) == false)
{
actionsNonPoseNonSkeletonArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
}
else
{
actionsVibrationArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
actionsOutArray.Initializers.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(inputClass.Name), codeFriendlyInstanceName));
}
}
}
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsFieldName, actionsArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsInFieldName, actionsInArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsOutFieldName, actionsOutArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVibrationFieldName, actionsVibrationArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsPoseFieldName, actionsPoseArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsBooleanFieldName, actionsBooleanArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsSingleFieldName, actionsSingleArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVector2FieldName, actionsVector2Array);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsVector3FieldName, actionsVector3Array);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsSkeletonFieldName, actionsSkeletonArray);
AddAssignStatement(actionsArraysInitMethod, SteamVR_Input_Generator_Names.actionsNonPoseNonSkeletonIn, actionsNonPoseNonSkeletonArray);
// Build the output file name.
string fullSourceFilePath = GetSourceFilePath(actionsClassFileName);
CreateFile(fullSourceFilePath, compileUnit);
}
private static string GetTypeStringForAction(SteamVR_Input_ActionFile_Action action)
{
return(GetTypeForAction(action).Name);
}
private void DrawSets()
{
EditorGUILayout.LabelField("Action Sets", headerLabelStyle);
EditorGUILayout.BeginHorizontal();
GUILayout.FlexibleSpace();
for (int actionSetIndex = 0; actionSetIndex < SteamVR_Input.actionFile.action_sets.Count; actionSetIndex++)
{
if (selectedActionSet == actionSetIndex)
{
EditorGUILayout.BeginVertical();
string newName = GUILayout.TextField(SteamVR_Input.actionFile.action_sets[actionSetIndex].shortName);
if (newName != SteamVR_Input.actionFile.action_sets[actionSetIndex].shortName)
{
string oldName = SteamVR_Input.actionFile.action_sets[actionSetIndex].name;
foreach (var action in SteamVR_Input.actionFile.actions)
{
if (action.actionSet == oldName)
{
action.SetNewActionSet(newName);
}
}
SteamVR_Input.actionFile.action_sets[actionSetIndex].SetNewShortName(newName);
}
EditorGUILayout.BeginHorizontal();
int selectedUsage = -1;
for (int valueIndex = 0; valueIndex < SteamVR_Input_ActionFile_ActionSet_Usages.listValues.Length; valueIndex++)
{
if (SteamVR_Input_ActionFile_ActionSet_Usages.listValues[valueIndex] == SteamVR_Input.actionFile.action_sets[actionSetIndex].usage)
{
selectedUsage = valueIndex;
break;
}
}
int wasUsage = selectedUsage;
if (selectedUsage == -1)
{
selectedUsage = 1;
}
selectedUsage = EditorGUILayout.Popup(selectedUsage, SteamVR_Input_ActionFile_ActionSet_Usages.listDescriptions);
if (wasUsage != selectedUsage)
{
SteamVR_Input.actionFile.action_sets[actionSetIndex].usage = SteamVR_Input_ActionFile_ActionSet_Usages.listValues[selectedUsage];
}
EditorGUILayout.Space();
bool removeSet = GUILayout.Button("-");
if (removeSet)
{
bool confirm = EditorUtility.DisplayDialog("Confirmation", "Are you sure you want to delete this action set and all of its actions?.", "Delete", "Cancel");
if (confirm)
{
//todo: this doesn't work
SteamVR_Input.actionFile.action_sets.RemoveAt(selectedActionSet);
selectedActionSet = -1;
selectedAction = null;
InitializeLists();
break;
}
}
EditorGUILayout.Space();
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
else
{
bool pressedSet = GUILayout.Button(SteamVR_Input.actionFile.action_sets[actionSetIndex].shortName);
if (pressedSet)
{
selectedActionSet = actionSetIndex;
selectedActionIndex = -1;
selectedAction = null;
InitializeLists();
}
}
if (actionSetIndex < SteamVR_Input.actionFile.action_sets.Count - 1)
{
GUILayout.FlexibleSpace();
}
}
EditorGUILayout.Space();
bool addSet = GUILayout.Button("+");
if (addSet)
{
SteamVR_Input_ActionFile_ActionSet newActionSet = new SteamVR_Input_ActionFile_ActionSet();
newActionSet.name = SteamVR_Input_ActionFile_ActionSet.CreateNewName();
SteamVR_Input.actionFile.action_sets.Add(newActionSet);
selectedActionSet = SteamVR_Input.actionFile.action_sets.Count - 1;
selectedActionIndex = -1;
selectedAction = null;
InitializeLists();
}
GUILayout.FlexibleSpace();
EditorGUILayout.EndHorizontal();
}
