Beispiel #1
0
        protected static SteamVR_Input_BindingFile GetBindingFileObject(string path)
        {
            if (File.Exists(path) == false)
            {
                Debug.LogError("<b>[SteamVR]</b> Could not access file at path: " + path);
                return(null);
            }

            string jsonText = File.ReadAllText(path);

            SteamVR_Input_BindingFile importingBindingFile = JsonConvert.DeserializeObject <SteamVR_Input_BindingFile>(jsonText);

            return(importingBindingFile);
        }
Beispiel #2
0
        protected static void WriteBindingFileObject(SteamVR_Input_BindingFile currentBindingFile, string currentBindingPath)
        {
            if (File.Exists(currentBindingPath))
            {
                FileInfo fileInfo = new FileInfo(currentBindingPath);
                fileInfo.IsReadOnly = false;
            }

            string newJSON = JsonConvert.SerializeObject(currentBindingFile, Formatting.Indented, new JsonSerializerSettings {
                NullValueHandling = NullValueHandling.Ignore
            });

            File.WriteAllText(currentBindingPath, newJSON);

            Debug.Log("<b>[SteamVR]</b> Added action bindings to: " + currentBindingPath);
        }
Beispiel #3
0
        protected static void RemoveOldActionsAndSetsFromBindings(List <SteamVR_Input_ActionFile_ActionSet> setsToRemove,
                                                                  List <SteamVR_Input_ActionFile_Action> actionsToRemove)
        {
            foreach (var defaultBindingItem in SteamVR_Input.actionFile.default_bindings)
            {
                string currentBindingPath = defaultBindingItem.binding_url;

                SteamVR_Input_BindingFile currentBindingFile = GetBindingFileObject(currentBindingPath);
                if (currentBindingFile == null)
                {
                    Debug.LogError("<b>[SteamVR]</b> There was an error deserializing the binding at path: " +
                                   currentBindingPath);
                    continue;
                }

                bool changed = false;

                List <string> bindingListsToRemove = new List <string>();
                foreach (var actionList in currentBindingFile.bindings)
                {
                    if (setsToRemove.Any(set => set.name == actionList.Key))
                    {
                        bindingListsToRemove.Add(actionList.Key);
                        changed = true;
                        continue;
                    }

                    for (int chordIndex = 0; chordIndex < actionList.Value.chords.Count; chordIndex++)
                    {
                        var existingChord = actionList.Value.chords[chordIndex];
                        if (actionsToRemove.Any(action => action.name == existingChord.output))
                        {
                            actionList.Value.chords.Remove(existingChord);
                            chordIndex--;
                            changed = true;
                        }
                    }

                    for (int hapticIndex = 0; hapticIndex < actionList.Value.haptics.Count; hapticIndex++)
                    {
                        var existingHaptic = actionList.Value.haptics[hapticIndex];
                        if (actionsToRemove.Any(action => action.name == existingHaptic.output))
                        {
                            actionList.Value.haptics.Remove(existingHaptic);
                            hapticIndex--;
                            changed = true;
                        }
                    }

                    for (int poseIndex = 0; poseIndex < actionList.Value.poses.Count; poseIndex++)
                    {
                        var existingPose = actionList.Value.poses[poseIndex];
                        if (actionsToRemove.Any(action => action.name == existingPose.output))
                        {
                            actionList.Value.poses.Remove(existingPose);
                            poseIndex--;
                            changed = true;
                        }
                    }

                    for (int skeletonIndex = 0; skeletonIndex < actionList.Value.skeleton.Count; skeletonIndex++)
                    {
                        var existingSkeleton = actionList.Value.skeleton[skeletonIndex];
                        if (actionsToRemove.Any(action => action.name == existingSkeleton.output))
                        {
                            actionList.Value.skeleton.Remove(existingSkeleton);
                            skeletonIndex--;
                            changed = true;
                        }
                    }

                    for (int sourceIndex = 0; sourceIndex < actionList.Value.sources.Count; sourceIndex++)
                    {
                        var existingSource = actionList.Value.sources[sourceIndex];
                        if (actionsToRemove.Any(action => action.name == existingSource.GetOutput()))
                        {
                            actionList.Value.sources.Remove(existingSource);
                            sourceIndex--;
                            changed = true;
                        }
                    }
                }

                for (int bindingListToRemoveIndex = 0;
                     bindingListToRemoveIndex < bindingListsToRemove.Count;
                     bindingListToRemoveIndex++)
                {
                    currentBindingFile.bindings.Remove(bindingListsToRemove[bindingListToRemoveIndex]);
                }

                if (changed)
                {
                    WriteBindingFileObject(currentBindingFile, currentBindingPath);
                }
            }
        }
Beispiel #4
0
        public static void CleanBindings(bool verbose = false)
        {
            SteamVR_Input.InitializeFile(true);
            SteamVR_Input_ActionFile currentActionsFile = SteamVR_Input.actionFile;

            for (int localizationIndex = 0;
                 localizationIndex < currentActionsFile.localization.Count;
                 localizationIndex++)
            {
                Dictionary <string, string> dictionary = currentActionsFile.localization[localizationIndex];
                bool removed;
                do
                {
                    removed = false;
                    string missingAction = null;
                    foreach (string key in dictionary.Keys)
                    {
                        if (key == SteamVR_Input_ActionFile_LocalizationItem.languageTagKeyName)
                        {
                            continue;
                        }

                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, key, StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            missingAction = key;
                        }
                    }

                    if (missingAction != null)
                    {
                        removed = true;
                        dictionary.Remove(missingAction);
                        if (verbose)
                        {
                            Debug.Log("<b>[SteamVR Input]</b> Removing localization entry for: " + missingAction);
                        }
                    }
                } while (removed);
            }

            for (int bindingIndex = 0; bindingIndex < currentActionsFile.default_bindings.Count; bindingIndex++)
            {
                SteamVR_Input_ActionFile_DefaultBinding currentBinding =
                    currentActionsFile.default_bindings[bindingIndex];

                if (File.Exists(currentBinding.binding_url) == false)
                {
                    if (verbose)
                    {
                        Debug.Log("<b>[SteamVR Input]</b> Removing binding entry for missing file: '" +
                                  currentBinding.controller_type + "' at: " + currentBinding.binding_url);
                    }

                    currentActionsFile.default_bindings.RemoveAt(bindingIndex);
                    bindingIndex--;
                    continue;
                }

                SteamVR_Input_BindingFile bindingFile = GetBindingFileObject(currentBinding.binding_url);
                if (bindingFile == null)
                {
                    Debug.LogError("<b>[SteamVR Input]</b> Error parsing binding file for: '" +
                                   currentBinding.controller_type + "' at: " + currentBinding.binding_url);
                    continue;
                }

                int changed = 0;

                foreach (var actionList in bindingFile.bindings)
                {
                    for (int itemIndex = 0; itemIndex < actionList.Value.chords.Count; itemIndex++)
                    {
                        string outputActionPath = actionList.Value.chords[itemIndex].output;
                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, outputActionPath,
                                                                         StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            if (verbose)
                            {
                                Debug.Log("<b>[SteamVR Input]</b> " + currentBinding.controller_type +
                                          ": Removing chord binding for action: " + outputActionPath);
                            }

                            actionList.Value.chords.RemoveAt(itemIndex);
                            itemIndex--;
                            changed++;
                        }
                    }

                    for (int itemIndex = 0; itemIndex < actionList.Value.haptics.Count; itemIndex++)
                    {
                        string outputActionPath = actionList.Value.haptics[itemIndex].output;
                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, outputActionPath,
                                                                         StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            if (verbose)
                            {
                                Debug.Log("<b>[SteamVR Input]</b> " + currentBinding.controller_type +
                                          ": Removing haptics binding for action: " + outputActionPath);
                            }

                            actionList.Value.haptics.RemoveAt(itemIndex);
                            itemIndex--;
                            changed++;
                        }
                    }

                    for (int itemIndex = 0; itemIndex < actionList.Value.poses.Count; itemIndex++)
                    {
                        string outputActionPath = actionList.Value.poses[itemIndex].output;
                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, outputActionPath,
                                                                         StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            if (verbose)
                            {
                                Debug.Log("<b>[SteamVR Input]</b> " + currentBinding.controller_type +
                                          ": Removing pose binding for action: " + outputActionPath);
                            }

                            actionList.Value.poses.RemoveAt(itemIndex);
                            itemIndex--;
                            changed++;
                        }
                    }

                    for (int itemIndex = 0; itemIndex < actionList.Value.skeleton.Count; itemIndex++)
                    {
                        string outputActionPath = actionList.Value.skeleton[itemIndex].output;
                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, outputActionPath,
                                                                         StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            if (verbose)
                            {
                                Debug.Log("<b>[SteamVR Input]</b> " + currentBinding.controller_type +
                                          ": Removing skeleton binding for action: " + outputActionPath);
                            }

                            actionList.Value.skeleton.RemoveAt(itemIndex);
                            itemIndex--;
                            changed++;
                        }
                    }

                    for (int itemIndex = 0; itemIndex < actionList.Value.sources.Count; itemIndex++)
                    {
                        string outputActionPath = actionList.Value.sources[itemIndex].GetOutput();
                        if (currentActionsFile.actions.Any(action =>
                                                           string.Equals(action.name, outputActionPath,
                                                                         StringComparison.CurrentCultureIgnoreCase)) == false)
                        {
                            if (verbose)
                            {
                                Debug.Log("<b>[SteamVR Input]</b> " + currentBinding.controller_type +
                                          ": Removing source binding for action: " + outputActionPath);
                            }

                            actionList.Value.sources.RemoveAt(itemIndex);
                            itemIndex--;
                            changed++;
                        }
                    }
                }

                if (changed > 0)
                {
                    WriteBindingFileObject(bindingFile, currentBinding.binding_url);
                }
            }

            if (SteamVR_Input.HasFileInMemoryBeenModified())
            {
                SteamVR_Input.actionFile.Save(SteamVR_Input.actionsFilePath);

                if (verbose)
                {
                    Debug.Log("<b>[SteamVR Input]</b> Saved new actions file: " + SteamVR_Input.actionsFilePath);
                }
            }
        }
Beispiel #5
0
        protected static void ImportBindings(SteamVR_Input_ActionFile currentActionsFile,
                                             SteamVR_Input_ActionFile newActionsFile, string directory)
        {
            foreach (var newDefaultPath in newActionsFile.default_bindings)
            {
                if (currentActionsFile.default_bindings.Any(currentDefaultPath =>
                                                            newDefaultPath.controller_type == currentDefaultPath.controller_type) == false)
                {
                    currentActionsFile.default_bindings.Add(newDefaultPath.GetCopy());

                    string bindingPath = Path.Combine(directory, newDefaultPath.binding_url);
                    File.Copy(bindingPath, newDefaultPath.binding_url);
                }
                else
                {
                    string currentBindingPath = currentActionsFile.default_bindings
                                                .First(binding => binding.controller_type == newDefaultPath.controller_type).binding_url;

                    SteamVR_Input_BindingFile currentBindingFile = GetBindingFileObject(currentBindingPath);
                    if (currentBindingFile == null)
                    {
                        Debug.LogError("<b>[SteamVR]</b> There was an error deserializing the binding at path: " +
                                       currentBindingPath);
                        continue;
                    }

                    SteamVR_Input_BindingFile importingBindingFile = GetBindingFileObject(newDefaultPath.binding_url);
                    if (importingBindingFile == null)
                    {
                        Debug.LogError("<b>[SteamVR]</b> There was an error deserializing the binding at path: " +
                                       newDefaultPath.binding_url);
                        continue;
                    }

                    bool changed = false;

                    foreach (var importingActionList in importingBindingFile.bindings)
                    {
                        if (currentBindingFile.bindings.Any(binding => binding.Key == importingActionList.Key))
                        {
                            var currentSetBinding =
                                currentBindingFile.bindings.FirstOrDefault(binding =>
                                                                           binding.Key == importingActionList.Key);

                            //todo: better merge? if we don't have an exact copy of the item then we add a new one

                            foreach (var importingChord in importingActionList.Value.chords)
                            {
                                if (currentSetBinding.Value.chords.Any(currentChord =>
                                                                       importingChord.Equals(currentChord)) == false)
                                {
                                    changed = true;
                                    currentSetBinding.Value.chords.Add(importingChord);
                                }
                            }

                            foreach (var importingHaptic in importingActionList.Value.haptics)
                            {
                                if (currentSetBinding.Value.haptics.Any(currentHaptic =>
                                                                        importingHaptic.Equals(currentHaptic)) == false)
                                {
                                    changed = true;
                                    currentSetBinding.Value.haptics.Add(importingHaptic);
                                }
                            }

                            foreach (var importingPose in importingActionList.Value.poses)
                            {
                                if (currentSetBinding.Value.poses.Any(currentPose =>
                                                                      importingPose.Equals(currentPose)) == false)
                                {
                                    changed = true;
                                    currentSetBinding.Value.poses.Add(importingPose);
                                }
                            }

                            foreach (var importingSkeleton in importingActionList.Value.skeleton)
                            {
                                if (currentSetBinding.Value.skeleton.Any(currentSkeleton =>
                                                                         importingSkeleton.Equals(currentSkeleton)) == false)
                                {
                                    changed = true;
                                    currentSetBinding.Value.skeleton.Add(importingSkeleton);
                                }
                            }

                            foreach (var importingSource in importingActionList.Value.sources)
                            {
                                if (currentSetBinding.Value.sources.Any(currentSource =>
                                                                        importingSource.Equals(currentSource)) == false)
                                {
                                    changed = true;
                                    currentSetBinding.Value.sources.Add(importingSource);
                                }
                            }
                        }
                        else
                        {
                            changed = true;
                            currentBindingFile.bindings.Add(importingActionList.Key, importingActionList.Value);
                        }
                    }

                    if (changed)
                    {
                        WriteBindingFileObject(currentBindingFile, currentBindingPath);
                    }
                }
            }
        }