Пример #1
0
 public KeyMap(int buttonID, XR_Enum.InputType inputType)
 {
     this.mainInput  = buttonID;
     this.mapedInput = buttonID;
     this.enumType   = 0;
     this.inputType  = inputType;
     this.KeyID      = "";
 }
Пример #2
0
 void CreateKeyMap(XR_Enum.InputType inputType, int totalInput)
 {
     int[] enumValues = XR_Utilities.GetDeviceControllerKeysValues((XR_Enum.DefaultController)deviceType, inputType);
     for (int i = 0; i < totalInput; i++)
     {
         KeyMap keyMap = GetKeyMap(enumValues[i], inputType);
     }
 }
Пример #3
0
        public List <KeyMap> GetKeyMapList(XR_Enum.InputType inputType)
        {
            List <KeyMap> mapList = new List <KeyMap>();

            foreach (var item in keyMappingList)
            {
                if (item.inputType == inputType)
                {
                    mapList.Add(item);
                }
            }

            return(mapList);
        }
Пример #4
0
        public KeyMap GetKeyMap(int buttonID, XR_Enum.InputType inputType)
        {
            if (keyMappingList == null)
            {
                keyMappingList = new List <KeyMap>();
            }

            KeyMap keyMap = keyMappingList.Find((obj) => (obj.inputType == inputType && obj.mainInput == buttonID));

            if (keyMap == null || keyMap.KeyID == null)
            {
                keyMap = new KeyMap(buttonID, inputType);
                keyMappingList.Add(keyMap);
            }

            return(keyMap);
        }
Пример #5
0
        void KeyBinding()
        {
            EditorGUILayout.Space();

            if (m_keyBindingData.controllerList.Count > 0)
            {
                if (m_keyBindingData.controllerList.Count > 0)
                {
                    EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));

                    if (GUILayout.Button("<==", GUILayout.Width(50)))
                    {
                        if (m_keyBindingData.currentControllerIndex > 0)
                        {
                            m_keyBindingData.currentControllerIndex--;
                        }
                        else
                        {
                            m_keyBindingData.currentControllerIndex = m_keyBindingData.controllerList.Count - 1;
                        }
                    }

                    GUILayout.FlexibleSpace();

                    List <string> deviceName  = new List <string>();
                    List <int>    deviceIndex = new List <int>();
                    for (int i = 0; i < m_keyBindingData.controllerList.Count; i++)
                    {
                        deviceName.Add(m_keyBindingData.controllerList[i].Name + " " + m_keyBindingData.controllerList[i].hand);
                        deviceIndex.Add(i);
                    }

                    if (deviceName.Count > 0)
                    {
                        m_keyBindingData.currentControllerIndex =
                            EditorGUILayout.IntPopup(m_keyBindingData.currentControllerIndex, deviceName.ToArray(), deviceIndex.ToArray(), GUILayout.MinWidth(10));
                    }
                    GUILayout.FlexibleSpace();

                    if (GUILayout.Button("==>", GUILayout.Width(50)))
                    {
                        if (m_keyBindingData.currentControllerIndex < m_keyBindingData.controllerList.Count - 1)
                        {
                            m_keyBindingData.currentControllerIndex++;
                        }
                        else
                        {
                            m_keyBindingData.currentControllerIndex = 0;
                        }
                    }

                    EditorGUILayout.EndHorizontal();

                    ControllerStruct controller = m_keyBindingData.GetControllerByIndex(m_keyBindingData.currentControllerIndex);

                    EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                    EditorGUILayout.LabelField("Name: " + controller.Name.ToString(), EditorStyles.boldLabel, GUILayout.Width(200));
                    EditorGUILayout.LabelField("Hand: " + controller.hand.ToString(), EditorStyles.boldLabel, GUILayout.Width(200));
                    EditorGUILayout.EndHorizontal();

                    if (controller.TotalButton > 0)
                    {
                        //EditorGUILayout.LabelField("Button Press/Touch", EditorStyles.boldLabel, GUILayout.Width(250));
                        EditorGUILayout.Space();
                        EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                        EditorGUILayout.LabelField("Button Name", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.LabelField("Key Mapping", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.EndHorizontal();

                        XR_Enum.InputType inputType  = XR_Enum.InputType.Bool;
                        string[]          enumNames  = XR_Utilities.GetDeviceControllerKeysName((XR_Enum.DefaultController)controller.deviceType, inputType);
                        int[]             enumValues = XR_Utilities.GetDeviceControllerKeysValues((XR_Enum.DefaultController)controller.deviceType, inputType);
                        if (enumValues != null)
                        {
                            for (int i = 1; i <= controller.TotalButton; i++)
                            {
                                KeyMap keyMap = controller.GetKeyMap(enumValues[i], inputType);
                                EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                                string featureUsageName = ((XR_Enum.FeatureUsageButton)enumValues[i]).ToString();
                                EditorGUILayout.LabelField(featureUsageName, GUILayout.Width(150));
                                //keyMap.enumType = EditorGUILayout.Popup(keyMap.enumType, GetButtonsEnum, GUILayout.Width(100));
                                keyMap.mapedInput = EditorGUILayout.IntPopup(keyMap.mapedInput, enumNames, enumValues, GUILayout.Width(100));
                                controller.UpdateKeyMap(keyMap);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    }

                    if (controller.TotalAxis1DButton > 0)
                    {
                        EditorGUILayout.Space();
                        EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                        EditorGUILayout.LabelField("Axis1D Name", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.LabelField("Key Mapping", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.EndHorizontal();

                        XR_Enum.InputType inputType  = XR_Enum.InputType.Axis1D;
                        string[]          enumNames  = XR_Utilities.GetDeviceControllerKeysName((XR_Enum.DefaultController)controller.deviceType, inputType);
                        int[]             enumValues = XR_Utilities.GetDeviceControllerKeysValues((XR_Enum.DefaultController)controller.deviceType, inputType);
                        if (enumValues != null)
                        {
                            for (int i = 1; i <= controller.TotalAxis1DButton; i++)
                            {
                                KeyMap keyMap = controller.GetKeyMap(enumValues[i], inputType);
                                EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                                string featureUsageName = ((XR_Enum.FeatureUsageAxis)enumValues[i]).ToString();
                                EditorGUILayout.LabelField(featureUsageName, GUILayout.Width(150));
                                keyMap.mapedInput = EditorGUILayout.IntPopup(keyMap.mapedInput, enumNames, enumValues, GUILayout.Width(100));
                                controller.UpdateKeyMap(keyMap);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    }

                    if (controller.TotalAxis2DButton > 0)
                    {
                        EditorGUILayout.Space();
                        EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                        EditorGUILayout.LabelField("Axis2D Name", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.LabelField("Key Mapping", EditorStyles.boldLabel, GUILayout.Width(150));
                        EditorGUILayout.EndHorizontal();

                        XR_Enum.InputType inputType  = XR_Enum.InputType.Axis2D;
                        string[]          enumNames  = XR_Utilities.GetDeviceControllerKeysName((XR_Enum.DefaultController)controller.deviceType, inputType);
                        int[]             enumValues = XR_Utilities.GetDeviceControllerKeysValues((XR_Enum.DefaultController)controller.deviceType, inputType);
                        if (enumValues != null)
                        {
                            for (int i = 1; i <= controller.TotalAxis2DButton; i++)
                            {
                                KeyMap keyMap = controller.GetKeyMap(enumValues[i], inputType);
                                EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
                                string featureUsageName = ((XR_Enum.FeatureUsage2DAxis)enumValues[i]).ToString();
                                EditorGUILayout.LabelField(featureUsageName, GUILayout.Width(150));
                                keyMap.mapedInput = EditorGUILayout.IntPopup(keyMap.mapedInput, enumNames, enumValues, GUILayout.Width(100));
                                controller.UpdateKeyMap(keyMap);
                                EditorGUILayout.EndHorizontal();
                            }
                        }
                    }
                }
            }

            EditorGUILayout.BeginHorizontal(GUILayout.MaxWidth(350));
            EditorGUILayout.EndHorizontal();
        }
Пример #6
0
        public static string GetKeyName(int index, XR_Enum.DefaultController defaultController, XR_Enum.InputType inputType)
        {
            switch (defaultController)
            {
            case XR_Enum.DefaultController.Vive:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.HTC_Vive_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.HTC_Vive_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.HTC_Vive_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.GearVR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.GearVR_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.GearVR_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.GearVR_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.Oculus:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.Oculus_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.Oculus_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.Oculus_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.WMR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.WMR_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.WMR_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.WMR_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.OpenVR_Full:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.OpenVRFull_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.OpenVRFull_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.OpenVRFull_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.OpenVR_Oculus:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.OpenVR_Oculus_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.OpenVR_Oculus_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.OpenVR_Oculus_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.OpenVR_MWR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.OpenVR_WMR_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.OpenVR_WMR_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.OpenVR_WMR_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            case XR_Enum.DefaultController.Daydream:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(((XR_Enum.Daydream_Button)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(((XR_Enum.Daydream_Axis)index).ToString());
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(((XR_Enum.Daydream_2DAxis)index).ToString());
                }
                else
                {
                    return("None");
                }
            }

            default: return("None");
            }
        }
Пример #7
0
        public static int[] GetDeviceControllerKeysValues(XR_Enum.DefaultController defaultController, XR_Enum.InputType inputType)
        {
            switch (defaultController)
            {
            case XR_Enum.DefaultController.Vive:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.HTC_Vive_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.HTC_Vive_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.HTC_Vive_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.GearVR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.GearVR_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.GearVR_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.GearVR_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.Oculus:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Oculus_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Oculus_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Oculus_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.WMR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.WMR_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.WMR_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.WMR_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.OpenVR_Full:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVRFull_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVRFull_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVRFull_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.OpenVR_Oculus:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_Oculus_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_Oculus_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_Oculus_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.OpenVR_MWR:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_WMR_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_WMR_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.OpenVR_WMR_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            case XR_Enum.DefaultController.Daydream:
            {
                if (inputType == XR_Enum.InputType.Bool)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Daydream_Button)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis1D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Daydream_Axis)) as int[]);
                }
                else if (inputType == XR_Enum.InputType.Axis2D)
                {
                    return(System.Enum.GetValues(typeof(XR_Enum.Daydream_2DAxis)) as int[]);
                }
                else
                {
                    return(null);
                }
            }

            default: return(null);
            }
        }