コード例 #1
0
        public static string Generate(ActionManifest actionManifest, INamingConventionConverter conv)
        {
            var sb     = new StringBuilder();
            var indent = 0;

            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            appendLine("#pragma once"); // TODO: Use C style

            appendLine("");

            foreach (var actionSet in actionManifest.ActionSets)
            {
                WriteActionSetStruct(sb, actionSet, indent, conv);
                WriteActionSetStateStruct(sb, actionSet, indent, conv);
                WriteSuggestedBindingsStruct(sb, actionSet, indent, conv);
            }

            return(sb.ToString());
        }
コード例 #2
0
 public Handler(
     IFileWriter fileWriter,
     INamingConventionConverter namingConventionConverter,
     ITemplateLocator templateLocator,
     ITemplateProcessor templateProcessor
     )
 {
     _fileWriter = fileWriter;
     _namingConventionConverter = namingConventionConverter;
     _templateProcessor         = templateProcessor;
     _templateLocator           = templateLocator;
 }
コード例 #3
0
 public Handler(
     IFileSystem fileWriter,
     ITemplateProcessor templateProcessor,
     INamingConventionConverter namingConventionConverter,
     ISettingsProvider settingsProvider
     )
 {
     _fileWriter                = fileWriter;
     _templateProcessor         = templateProcessor;
     _namingConventionConverter = namingConventionConverter;
     _settingsProvider          = settingsProvider;
 }
コード例 #4
0
 private static string GetActionStateMemberName(Action action, TopLevelPath subactionPath, INamingConventionConverter conv) => conv.Rename(GetNameWithSubaction(action.Name, subactionPath), "ActionState");
コード例 #5
0
 public static string GetBindingVariableName(string bindingPath, INamingConventionConverter conv) => conv.Rename(bindingPath.Replace('/', '_'));
コード例 #6
0
 public static string GetInteractionProfileMemberName(string interactionProfilePath, INamingConventionConverter conv) => conv.Rename(interactionProfilePath.Replace("/interaction_profiles/", "").Replace('/', '_'));
コード例 #7
0
 public static string GetSuggestedBindingsMemberName(string interactionProfilePath, INamingConventionConverter conv) => conv.Rename(interactionProfilePath.Replace("/interaction_profiles/", "").Replace('/', '_'), "Bindings");
コード例 #8
0
        private static void WriteActionSetInitializeMethod(StringBuilder sb, ActionSet actionSet, int indent, INamingConventionConverter conv)
        {
            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            appendLine("XrResult Initialize(XrInstance instance)");
            appendLine("{");
            indent++;

            // TODO: Add condition to return error if already inintialized.

            appendLine($"XrActionSetCreateInfo actionSetInfo{{XR_TYPE_ACTION_SET_CREATE_INFO}};");
            appendLine($"strcpy_s(actionSetInfo.actionSetName, \"{actionSet.Name}\");");
            appendLine($"strcpy_s(actionSetInfo.localizedActionSetName, \"{actionSet.LocalizedName}\");");
            appendLine($"actionSetInfo.priority = {actionSet.Priority};");
            appendLine($"XrResult result = xrCreateActionSet(instance, &actionSetInfo, &ActionSet);");

            var allSubactionPathInActionSet = actionSet.Actions.SelectMany(a => GetActionSubactionPaths(actionSet, a)).ToHashSet();

            foreach (var subactionPath in allSubactionPathInActionSet)
            {
                if (subactionPath == TopLevelPath.Null)
                {
                    continue;
                }

                appendLine("");
                appendLine("if (XR_SUCCEEDED(result))");
                appendLine("{");
                indent++;
                appendLine($"result = xrStringToPath(instance, \"{GetSubactionPath(subactionPath)}\", &{GetSubactionMemberName(subactionPath, conv)});");
                indent--;
                appendLine("}");
            }

            foreach (Action action in actionSet.Actions)
            {
                appendLine("");
                appendLine("if (XR_SUCCEEDED(result))");
                appendLine("{");
                indent++;

                var subactionPaths = GetActionSubactionPaths(actionSet, action);
                if (subactionPaths.Any())
                {
                    appendLine($"const XrPath subactionPaths[] = {{ {string.Join(", ", subactionPaths.Select(s => GetSubactionMemberName(s, conv)))} }};");
                }

                appendLine($"XrActionCreateInfo actionCreateInfo{{XR_TYPE_ACTION_CREATE_INFO}};");
                appendLine($"actionCreateInfo.actionType = {GetActionType(action.Type)};");
                appendLine($"strcpy_s(actionCreateInfo.actionName, \"{action.Name}\");");
                appendLine($"strcpy_s(actionCreateInfo.localizedActionName, \"{action.LocalizedName}\");");

                if (subactionPaths.Any())
                {
                    appendLine($"actionCreateInfo.countSubactionPaths = {subactionPaths.Count()};");
                    appendLine($"actionCreateInfo.subactionPaths = subactionPaths;");
                }
                appendLine($"result = xrCreateAction(ActionSet, &actionCreateInfo, &{GetActionHandleMemberName(action.Name, conv)});");
                indent--;
                appendLine("}");
            }

            appendLine("");
            appendLine("return result;");
            indent--;
            appendLine("}");
        }
コード例 #9
0
        private static void WriteSuggestedBindingsStruct(StringBuilder sb, ActionSet actionSet, int indent, INamingConventionConverter conv)
        {
            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            appendLine("");
            appendLine($"struct SuggestedBindings"); // TODO: Add a manifest name and use it here to ensure no namespace conflicts.
            appendLine("{");
            indent++;

            //  Initialize() method
            appendLine($"XrResult Initialize(XrInstance instance, {GetActionSetStructName(actionSet, conv)} const& actionSet)");
            appendLine("{");
            indent++;
            appendLine("XrResult result = XR_SUCCESS;");
            appendLine("");
            foreach (var suggestedBindings in actionSet.SuggestedBindings)
            {
                appendLine("if (XR_SUCCEEDED(result))");
                appendLine("{");
                indent++;
                appendLine($"result = xrStringToPath(instance, \"{suggestedBindings.InteractionProfile}\", &{GetInteractionProfileMemberName(suggestedBindings.InteractionProfile, conv)});");
                indent--;
                appendLine("}");
            }

            appendLine("");
            var allBindingPaths = actionSet.SuggestedBindings.SelectMany(s => s.Bindings).SelectMany(s => s.Value);

            foreach (var suggestedBinding in allBindingPaths.Distinct().OrderBy(p => p))
            {
                appendLine($"XrPath {GetBindingVariableName(suggestedBinding, conv)} = XR_NULL_PATH;");
            }

            foreach (var suggestedBinding in allBindingPaths.Distinct().OrderBy(p => p))
            {
                appendLine("if (XR_SUCCEEDED(result))");
                appendLine("{");
                indent++;
                appendLine($"result = xrStringToPath(instance, \"{suggestedBinding}\", &{GetBindingVariableName(suggestedBinding, conv)});");
                indent--;
                appendLine("}");
            }

            appendLine("");
            appendLine("if (XR_SUCCEEDED(result))");
            appendLine("{");
            indent++;
            foreach (var suggestedBindings in actionSet.SuggestedBindings)
            {
                int index = 0;
                foreach (var suggestedBinding in suggestedBindings.Bindings)
                {
                    foreach (var bindingPath in suggestedBinding.Value)
                    {
                        appendLine($"{GetSuggestedBindingsMemberName(suggestedBindings.InteractionProfile, conv)}[{index}] = {{actionSet.{GetActionHandleMemberName(suggestedBinding.Key, conv)}, {GetBindingVariableName(bindingPath, conv)}}};");
                        index++;
                    }
                }
            }
            indent--;
            appendLine("}");

            appendLine("");
            appendLine("return result;");
            indent--;
            appendLine("}");


            // SuggestInteractionProfileBindings() method
            appendLine("");
            appendLine($"XrResult SuggestInteractionProfileBindings(XrInstance instance)");
            appendLine("{");
            indent++;
            appendLine("XrResult result = XR_SUCCESS;");

            foreach (var suggestedBindings in actionSet.SuggestedBindings)
            {
                appendLine("");
                appendLine("if (XR_SUCCEEDED(result))");
                appendLine("{");
                indent++;
                appendLine($"XrInteractionProfileSuggestedBinding interactionSuggestedBindings{{XR_TYPE_INTERACTION_PROFILE_SUGGESTED_BINDING}};");
                appendLine($"interactionSuggestedBindings.interactionProfile = {GetInteractionProfileMemberName(suggestedBindings.InteractionProfile, conv)};");
                appendLine($"interactionSuggestedBindings.suggestedBindings = {GetSuggestedBindingsMemberName(suggestedBindings.InteractionProfile, conv)};");
                appendLine($"interactionSuggestedBindings.countSuggestedBindings = {suggestedBindings.Bindings.Sum(b => b.Value.Count())};");
                appendLine($"result = xrSuggestInteractionProfileBindings(instance, &interactionSuggestedBindings);");
                indent--;
                appendLine("}");
            }

            appendLine("");
            appendLine("return result;");
            indent--;
            appendLine("}");

            appendLine("");
            foreach (var suggestedBindings in actionSet.SuggestedBindings)
            {
                appendLine($"XrPath {GetInteractionProfileMemberName(suggestedBindings.InteractionProfile, conv)};");
            }

            appendLine("");
            foreach (var suggestedBindings in actionSet.SuggestedBindings)
            {
                appendLine($"XrActionSuggestedBinding {GetSuggestedBindingsMemberName(suggestedBindings.InteractionProfile, conv)}[{suggestedBindings.Bindings.Sum(b => b.Value.Count())}];");
            }

            indent--;
            appendLine("};");
        }
コード例 #10
0
 public EvaluateOperators(INamingConventionConverter namingConventionConverter)
 {
     registry = new Dictionary <string, Func <IProcessJsonLogic, JToken[], object, object> >();
     AddDefaultOperations();
     this.namingConventionConverter = namingConventionConverter;
 }
コード例 #11
0
        private static void WriteActionSetStruct(StringBuilder sb, ActionSet actionSet, int indent, INamingConventionConverter conv)
        {
            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            appendLine("");
            appendLine($"struct {GetActionSetStructName(actionSet, conv)}");
            appendLine("{");
            indent++;

            appendLine($"~{GetActionSetStructName(actionSet, conv)}()");
            appendLine("{");
            indent++;
            appendLine("if (ActionSet != XR_NULL_HANDLE)");
            appendLine("{");
            indent++;
            appendLine("(void)xrDestroyActionSet(ActionSet);");
            indent--;
            appendLine("}");
            indent--;
            appendLine("}");

            appendLine("");
            WriteActionSetInitializeMethod(sb, actionSet, indent, conv);

            foreach (var action in actionSet.Actions)
            {
                if (action.Type != ActionType.Pose)
                {
                    continue;
                }

                WriteCreateActionSpaceHelpers(sb, actionSet, action, indent, conv);
            }

            appendLine("");
            appendLine($"XrActionSet {conv.Rename("ActionSet")}{{XR_NULL_HANDLE}};");

            appendLine("");
            foreach (var action in actionSet.Actions)
            {
                appendLine($"XrAction {GetActionHandleMemberName(action.Name, conv)}{{XR_NULL_HANDLE}};");
            }

            // Write out the used subaction paths.
            var usedTopLevelPathsWithoutNull = actionSet.Actions.SelectMany(a => GetActionSubactionPaths(actionSet, a)).ToHashSet();

            addLineIfTrue(usedTopLevelPathsWithoutNull.Any());
            foreach (var subactionPath in usedTopLevelPathsWithoutNull)
            {
                appendLine($"XrPath {GetSubactionMemberName(subactionPath, conv)}{{XR_NULL_PATH}};");
            }

            indent--;
            appendLine("};");
        }
コード例 #12
0
        private static void WriteCreateActionSpaceHelpers(StringBuilder sb, ActionSet actionSet, Action action, int indent, INamingConventionConverter conv)
        {
            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            Action <TopLevelPath> writeActionSpaceFunction = (TopLevelPath subactionPath) =>
            {
                appendLine("");
                appendLine($"XrResult {conv.Rename("Create", GetNameWithSubaction(action.Name, subactionPath), "ActionSpace")}(XrSession session, XrSpace* space) const");
                appendLine("{");
                indent++;

                appendLine($"XrActionSpaceCreateInfo actionSpaceInfo{{XR_TYPE_ACTION_SPACE_CREATE_INFO}};");
                appendLine($"actionSpaceInfo.action = {GetActionHandleMemberName(action.Name, conv)};");
                appendLine($"actionSpaceInfo.poseInActionSpace.orientation.w = 1.0f;");

                if (subactionPath != TopLevelPath.Null)
                {
                    appendLine($"actionSpaceInfo.subactionPath = {GetSubactionMemberName(subactionPath, conv)};");
                }

                appendLine($"return xrCreateActionSpace(session, &actionSpaceInfo, space);");

                indent--;
                appendLine("}");
            };

            foreach (var subaction in GetActionSubactionPaths(actionSet, action, includeNull: true))
            {
                writeActionSpaceFunction(subaction);
            }
        }
コード例 #13
0
 public NamespaceProvider(INamingConventionConverter namingConventionConverter)
 => _namingConventionConverter = namingConventionConverter;
コード例 #14
0
 public TemplateProcessor(INamingConventionConverter namingConventionConverter)
 {
     _namingConventionConverter = namingConventionConverter;
 }
コード例 #15
0
 private static string GetActionSetStructName(ActionSet actionSet, INamingConventionConverter conv) => conv.Rename(actionSet.Name, "ActionSet");
コード例 #16
0
        private static void WriteActionSetStateStruct(StringBuilder sb, ActionSet actionSet, int indent, INamingConventionConverter conv)
        {
            Action <string> appendLineTrim = (string text) => sb.AppendLine(text.TrimEnd());
            Action <string> appendLine     = (string text) => appendLineTrim($"{new string(' ', indent * 4)}{text}");
            Action <bool>   addLineIfTrue  = (bool condition) => { if (condition)
                                                                   {
                                                                       appendLineTrim("");
                                                                   }
            };

            var inputActions = actionSet.Actions.Where(a => a.Type != ActionType.Haptic);

            var usedTopLevelPathsWithoutNull = inputActions.SelectMany(a => GetActionSubactionPaths(actionSet, a)).Distinct().OrderBy(s => s);

            appendLine("");
            appendLine($"struct {conv.Rename("", actionSet.Name, "ActionStates")}");
            appendLine("{");
            indent++;

            // Write out a struct with all actions that have subactions enabled for per-subaction querying.
            bool hasSubactionPath = false;

            foreach (var action in inputActions.Where(a => a.UseSubactionPaths))
            {
                if (!hasSubactionPath)
                {
                    // Delay writing struct to here so it isn't written at all if there are no subaction paths.
                    appendLine("struct SubactionStates");
                    appendLine("{");
                    indent++;
                    hasSubactionPath = true;
                    appendLine("XrPath SubactionPath = XR_NULL_PATH;");
                }

                appendLine($"const {GetActionStateStructName(action.Type)}* {GetActionStateMemberName(action, TopLevelPath.Null, conv)} = nullptr;");
            }
            if (hasSubactionPath)
            {
                indent--;
                appendLine("};");
                appendLine("");
            }

            appendLine($"XrResult UpdateActionStates(XrSession session, {GetActionSetStructName(actionSet, conv)} const& actionSet)");
            appendLine("{");
            indent++;
            appendLine("XrActionStateGetInfo actionStateGetInfo{XR_TYPE_ACTION_STATE_GET_INFO};");
            appendLine("XrResult result = XR_SUCCESS;");
            foreach (var action in inputActions)
            {
                foreach (var subaction in GetActionSubactionPaths(actionSet, action, includeNull: true))
                {
                    appendLine("");

                    appendLine("if (XR_SUCCEEDED(result))");
                    appendLine("{");
                    indent++;
                    appendLine($"actionStateGetInfo.action = actionSet.{GetActionHandleMemberName(action.Name, conv)};");

                    if (action.UseSubactionPaths)
                    {
                        appendLine($"actionStateGetInfo.subactionPath = actionSet.{GetSubactionMemberName(subaction, conv)};");
                    }
                    else
                    {
                        appendLine($"actionStateGetInfo.subactionPath = XR_NULL_PATH;");
                    }

                    appendLine($"result = {GetActionStateUpdateFunction(action.Type)}(session, &actionStateGetInfo, &{GetActionStateMemberName(action, subaction, conv)});");

                    indent--;
                    appendLine("}");
                }
            }
            appendLine("return result;");
            indent--;
            appendLine("}");

            // Write function to get the action states for a specific subaction path.
            if (usedTopLevelPathsWithoutNull.Any())
            {
                appendLine("");
                appendLine($"SubactionStates GetSubactionStates({GetActionSetStructName(actionSet, conv)} const& actionSet, XrPath subactionPath) const");
                appendLine("{");
                indent++;
                bool firstCase = true;
                foreach (var subactionPath in usedTopLevelPathsWithoutNull)
                {
                    appendLine($"{(firstCase ? "" : "else ")}if (subactionPath == actionSet.{GetSubactionMemberName(subactionPath, conv)})");
                    appendLine("{");
                    indent++;
                    var subactionMemberVariables = inputActions
                                                   .Where(a => a.UseSubactionPaths)
                                                   .Select(a =>
                    {
                        bool hasThisSubactionBinding = GetActionSubactionPaths(actionSet, a).Any(s => s == subactionPath);
                        return(hasThisSubactionBinding ? ("&" + GetActionStateMemberName(a, subactionPath, conv)) : "nullptr");
                    });

                    appendLine($"return {{subactionPath, {string.Join(", ", subactionMemberVariables)}}};");
                    indent--;
                    appendLine("}");
                    firstCase = false;
                }

                appendLine("else");
                appendLine("{");
                indent++;
                appendLine("return {}; // Unknown subaction path.");
                indent--;
                appendLine("}");


                indent--;
                appendLine("}");
            }

            appendLine("");
            foreach (var action in inputActions)
            {
                foreach (var subaction in GetActionSubactionPaths(actionSet, action, includeNull: true))
                {
                    appendLine($"{GetActionStateStructName(action.Type)} {GetActionStateMemberName(action, subaction, conv)}{{{GetActionStateStructType(action.Type)}}};");
                }
            }

            // Write out per-subaction path member struct shortcuts.

            /*addLineIfTrue(usedTopLevelPathsWithoutNull.Any());
             * foreach (var subactionPath in usedTopLevelPathsWithoutNull)
             * {
             *  appendLine($"SubactionStates {GetSubactionMemberName(subactionPath, conv)};");
             * }*/

            indent--;
            appendLine("};");
        }
コード例 #17
0
 private static string GetActionHandleMemberName(string actionName, INamingConventionConverter conv) => conv.Rename(actionName);
コード例 #18
0
 public RazorTemplateProcessor(INamingConventionConverter namingConventionConverter)
     : base(namingConventionConverter)
 {
 }