private Input.MagicLeapHand GetOrAddHand(MLHandTracking.Hand mlHand, Handedness handedness) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } // Add new hand var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Magic Leap {handedness} Hand", pointers, inputSourceType); var controller = new Input.MagicLeapHand(TrackingState.Tracked, handedness, inputSource); controller.Initalize(new ManagedHand(mlHand)); for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedHands.Add(handedness, controller); return(controller); }
private SimpleWebXRController GetOrAddController(Handedness handedness) { if (trackedControllers.ContainsKey(handedness)) { return(trackedControllers[handedness]); } var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"WebXR {handedness} Controller", pointers, inputSourceType); if (!inactiveControllerCache.TryGetValue(handedness, out var controller)) { controller = new SimpleWebXRController(TrackingState.Tracked, handedness, inputSource); } for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedControllers.Add(handedness, controller); return(controller); }
private OculusHand GetOrAddHand(Handedness handedness, OVRHand ovrHand) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } // Add new hand var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType); OculusHand handDevice = new OculusHand(TrackingState.Tracked, handedness, inputSource); handDevice.InitializeHand(ovrHand, SettingsProfile); for (int i = 0; i < handDevice.InputSource?.Pointers?.Length; i++) { handDevice.InputSource.Pointers[i].Controller = handDevice; } inputSystem?.RaiseSourceDetected(handDevice.InputSource, handDevice); trackedHands.Add(handedness, handDevice); return(handDevice); }
private SimpleWebXRHand GetOrAddHand(Handedness handedness) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"WebXR {handedness} Hand", pointers, inputSourceType); var handController = new SimpleWebXRHand(TrackingState.Tracked, handedness, inputSource); for (int i = 0; i < handController.InputSource?.Pointers?.Length; i++) { handController.InputSource.Pointers[i].Controller = handController; } inputSystem?.RaiseSourceDetected(handController.InputSource, handController); trackedHands.Add(handedness, handController); return(handController); }
private OculusQuestHand GetOrAddHand(Handedness handedness) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } // Add new hand var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType); var controller = new OculusQuestHand(TrackingState.Tracked, handedness, inputSource); controller.SetupConfiguration(typeof(OculusQuestHand)); for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedHands.Add(handedness, controller); return(controller); }
private OculusQuestController GetOrAddController(Handedness handedness) { if (trackedControllers.ContainsKey(handedness)) { return(trackedControllers[handedness]); } var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Controller", pointers, inputSourceType); var controller = new OculusQuestController(TrackingState.Tracked, handedness, inputSource); // Code is obsolete later on, but older MRTK versions require it. #pragma warning disable 618 controller.SetupConfiguration(typeof(OculusQuestController)); #pragma warning restore 618 for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedControllers.Add(handedness, controller); return(controller); }
private void InitializeKeywordRecognizer() { IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; InputSource = inputSystem?.RequestNewGenericInputSource("Magic Leap Speech Input Source", sourceType: InputSourceType.Voice); InitializeMLSpeech(); }
/// <summary> /// Gets or adds a controller using the InputDevice name provided. /// </summary> /// <param name="inputDevice">The InputDevice from XR SDK.</param> /// <returns>The controller reference.</returns> protected virtual GenericXRSDKController GetOrAddController(InputDevice inputDevice) { // If a device is already registered with the ID provided, just return it. if (ActiveControllers.ContainsKey(inputDevice.name)) { var controller = ActiveControllers[inputDevice.name]; Debug.Assert(controller != null); return(controller); } Handedness controllingHand; if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Left)) { controllingHand = Handedness.Left; } else if (inputDevice.characteristics.HasFlag(InputDeviceCharacteristics.Right)) { controllingHand = Handedness.Right; } else { controllingHand = Handedness.None; } var currentControllerType = GetCurrentControllerType(inputDevice); Type controllerType = GetControllerType(currentControllerType); InputSourceType inputSourceType = GetInputSourceType(currentControllerType); IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; IMixedRealityPointer[] pointers = RequestPointers(currentControllerType, controllingHand); IMixedRealityInputSource inputSource = inputSystem?.RequestNewGenericInputSource($"{currentControllerType} Controller {controllingHand}", pointers, inputSourceType); if (!(Activator.CreateInstance(controllerType, TrackingState.NotTracked, controllingHand, inputSource, null) is GenericXRSDKController detectedController)) { Debug.LogError($"Failed to create {controllerType.Name} controller"); return(null); } if (!detectedController.SetupConfiguration(controllerType)) { // Controller failed to be set up correctly. Debug.LogError($"Failed to set up {controllerType.Name} controller"); // Return null so we don't raise the source detected. return(null); } for (int i = 0; i < detectedController.InputSource?.Pointers?.Length; i++) { detectedController.InputSource.Pointers[i].Controller = detectedController; } ActiveControllers.Add(inputDevice.name, detectedController); return(detectedController); }
/// <inheritdoc /> public override void Enable() { if (!UInput.mousePresent) { Disable(); return; } #if UNITY_EDITOR if (UnityEditor.EditorWindow.focusedWindow != null) { UnityEditor.EditorWindow.focusedWindow.ShowNotification(new GUIContent("Press \"ESC\" to regain mouse control")); } #endif Cursor.visible = false; Cursor.lockState = CursorLockMode.Locked; IMixedRealityInputSource mouseInputSource = null; MixedRealityRaycaster.DebugEnabled = true; const Handedness handedness = Handedness.Any; System.Type controllerType = typeof(MouseController); // Make sure that the handedness declared in the controller attribute matches what we expect { var controllerAttribute = MixedRealityControllerAttribute.Find(controllerType); if (controllerAttribute != null) { Handedness[] handednesses = controllerAttribute.SupportedHandedness; Debug.Assert(handednesses.Length == 1 && handednesses[0] == Handedness.Any, "Unexpected mouse handedness declared in MixedRealityControllerAttribute"); } } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (inputSystem != null) { var pointers = RequestPointers(SupportedControllerType.Mouse, handedness); mouseInputSource = inputSystem.RequestNewGenericInputSource("Mouse Input", pointers); } Controller = new MouseController(TrackingState.NotApplicable, handedness, mouseInputSource); if (mouseInputSource != null) { for (int i = 0; i < mouseInputSource.Pointers.Length; i++) { mouseInputSource.Pointers[i].Controller = Controller; } } Controller.SetupConfiguration(typeof(MouseController)); inputSystem?.RaiseSourceDetected(Controller.InputSource, Controller); }
void MLControllerConnected(byte controllerId) { #if PLATFORM_LUMIN MLInput.Controller mlController = MLInput.GetController(controllerId); if (mlController.Type == MLInput.Controller.ControlType.Control) { if (!ConnectedControllers.ContainsKey(controllerId)) { Handedness handedness = mlController.Hand == MLInput.Hand.Right ? Handedness.Right : Handedness.Left; switch (CurrentControllerSettings) { case HandSettings.None: return; case HandSettings.Left: if (handedness != Handedness.Left) { return; } break; case HandSettings.Right: if (handedness != Handedness.Right) { return; } break; case HandSettings.Both: break; } var pointers = RequestPointers(SupportedControllerType.GenericUnity, handedness); var inputSourceType = InputSourceType.Controller; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Magic Leap {handedness} Controller", pointers, inputSourceType); MagicLeapMRTKController controller = new MagicLeapMRTKController(mlController, TrackingState.Tracked, handedness, inputSource); for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); ConnectedControllers[controllerId] = new MLControllerContainer() { controllerId = controllerId, mrtkController = controller }; trackedControls.Add(controller); } } #endif }
/// <inheritdoc /> public override void Enable() { if (!UInput.mousePresent) { Disable(); return; } if (Controller != null) { // device manager has already been set up return; } IMixedRealityInputSource mouseInputSource = null; MixedRealityRaycaster.DebugEnabled = true; const Handedness handedness = Handedness.Any; System.Type controllerType = typeof(MouseController); // Make sure that the handedness declared in the controller attribute matches what we expect { var controllerAttribute = MixedRealityControllerAttribute.Find(controllerType); if (controllerAttribute != null) { Handedness[] handednesses = controllerAttribute.SupportedHandedness; Debug.Assert(handednesses.Length == 1 && handednesses[0] == Handedness.Any, "Unexpected mouse handedness declared in MixedRealityControllerAttribute"); } } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (inputSystem != null) { var pointers = RequestPointers(SupportedControllerType.Mouse, handedness); mouseInputSource = inputSystem.RequestNewGenericInputSource("Mouse Input", pointers); } Controller = new MouseController(TrackingState.NotApplicable, handedness, mouseInputSource); if (mouseInputSource != null) { for (int i = 0; i < mouseInputSource.Pointers.Length; i++) { mouseInputSource.Pointers[i].Controller = Controller; } } Controller.SetupConfiguration(typeof(MouseController)); inputSystem?.RaiseSourceDetected(Controller.InputSource, Controller); }
/// <summary> /// Gets or adds a controller using the joystick name provided. /// </summary> /// <param name="joystickName">The name of the joystick from Unity's <see href="https://docs.unity3d.com/ScriptReference/Input.GetJoystickNames.html">Input.GetJoystickNames</see></param> /// <returns>A new controller reference.</returns> protected virtual GenericJoystickController GetOrAddController(string joystickName) { Profiler.BeginSample("[MRTK] UnityJoystickManager.GetOrAddController"); IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (ActiveControllers.ContainsKey(joystickName)) { var controller = ActiveControllers[joystickName]; Debug.Assert(controller != null); Profiler.EndSample(); // GetOrAddController - already registered return(controller); } Type controllerType; switch (GetCurrentControllerType(joystickName)) { default: Profiler.EndSample(); // GetOrAddController - unknown type return(null); case SupportedControllerType.GenericUnity: controllerType = typeof(GenericJoystickController); break; case SupportedControllerType.Xbox: controllerType = typeof(XboxController); break; } var inputSource = inputSystem?.RequestNewGenericInputSource($"{controllerType.Name} Controller", sourceType: InputSourceType.Controller); var detectedController = Activator.CreateInstance(controllerType, TrackingState.NotTracked, Handedness.None, inputSource, null) as GenericJoystickController; if (detectedController == null || !detectedController.Enabled) { // Controller failed to be setup correctly. Debug.LogError($"Failed to create {controllerType.Name} controller"); Profiler.EndSample(); // GetOrAddController - failure // Return null so we don't raise the source detected. return(null); } ActiveControllers.Add(joystickName, detectedController); Profiler.EndSample(); // GetOrAddController return(detectedController); }
private OculusQuestHand GetOrAddHand(Handedness handedness, OVRHand ovrHand) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } Material handMaterial = null; if (handedness == Handedness.Right) { if (rightHandMaterial == null) { rightHandMaterial = new Material(MRTKOculusConfig.Instance.CustomHandMaterial); } handMaterial = rightHandMaterial; } else { if (leftHandMaterial == null) { leftHandMaterial = new Material(MRTKOculusConfig.Instance.CustomHandMaterial); } handMaterial = leftHandMaterial; } // Add new hand var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType); var controller = new OculusQuestHand(TrackingState.Tracked, handedness, ovrHand, handMaterial, inputSource); // Code is obsolete later on, but older MRTK versions require it. #pragma warning disable 618 controller.SetupConfiguration(typeof(OculusQuestHand)); #pragma warning restore 618 for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedHands.Add(handedness, controller); return(controller); }
/// <inheritdoc /> public override void Enable() { if (!Application.isPlaying || (Commands == null) || (Commands.Length == 0)) { return; } if (InputSystemProfile == null) { return; } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; InputSource = inputSystem?.RequestNewGenericInputSource("Windows Speech Input Source", sourceType: InputSourceType.Voice); var newKeywords = new string[Commands.Length]; for (int i = 0; i < Commands.Length; i++) { newKeywords[i] = Commands[i].LocalizedKeyword; } RecognitionConfidenceLevel = InputSystemProfile.SpeechCommandsProfile.SpeechRecognitionConfidenceLevel; if (keywordRecognizer == null) { try { keywordRecognizer = new KeywordRecognizer(newKeywords, (ConfidenceLevel)RecognitionConfidenceLevel); } catch (UnityException ex) { Debug.LogWarning($"Failed to start keyword recognizer. Are microphone permissions granted? Exception: {ex}"); keywordRecognizer = null; return; } keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized; } if (InputSystemProfile.SpeechCommandsProfile.SpeechRecognizerStartBehavior == AutoStartBehavior.AutoStart) { StartRecognition(); } }
private void HandleOnControllerConnected(byte controllerId) { MLInputController controller = MLInput.GetController(controllerId); if (mlInputControllers.Exists((device) => device.Id == controllerId)) { Debug.LogWarning(string.Format("Connected controller with id {0} already connected.", controllerId)); return; } mlInputControllers.Add(controller); // Generate MRTK Controller Handedness controllingHand; if (controller.Type == MLInputControllerType.Control && controller.Hand == MLInput.Hand.Left) { controllingHand = Handedness.Left; } else if (controller.Type == MLInputControllerType.Control && controller.Hand == MLInput.Hand.Right) { controllingHand = Handedness.Right; } else { controllingHand = Handedness.Other; } var currentControllerType = SupportedControllerType.GenericOpenVR; var controllerType = typeof(MagicLeapController); var pointers = RequestPointers(currentControllerType, controllingHand); IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"{currentControllerType} Controller {controllingHand}", pointers, InputSourceType.Controller); var detectedController = new MagicLeapController(TrackingState.Tracked, controllingHand, inputSource); detectedController.SetupConfiguration(controllerType); for (int i = 0; i < detectedController.InputSource?.Pointers?.Length; i++) { detectedController.InputSource.Pointers[i].Controller = detectedController; } ActiveControllers.Add(controllerId, detectedController); inputSystem?.RaiseSourceDetected(detectedController.InputSource, detectedController); }
/// <summary> /// Gets or adds a controller using the joystick name provided. /// </summary> /// <param name="joystickName">The name of the joystick from Unity's <see href="https://docs.unity3d.com/ScriptReference/Input.GetJoystickNames.html">Input.GetJoystickNames</see></param> /// <returns>A new controller reference.</returns> protected virtual GenericJoystickController GetOrAddController(string joystickName) { IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (ActiveControllers.ContainsKey(joystickName)) { var controller = ActiveControllers[joystickName]; Debug.Assert(controller != null); return(controller); } Type controllerType; switch (GetCurrentControllerType(joystickName)) { default: return(null); case SupportedControllerType.GenericUnity: controllerType = typeof(GenericJoystickController); break; case SupportedControllerType.Xbox: controllerType = typeof(XboxController); break; } var inputSource = inputSystem?.RequestNewGenericInputSource($"{controllerType.Name} Controller", sourceType: InputSourceType.Controller); var detectedController = Activator.CreateInstance(controllerType, TrackingState.NotTracked, Handedness.None, inputSource, null) as GenericJoystickController; if (detectedController == null) { Debug.LogError($"Failed to create {controllerType.Name} controller"); return(null); } if (!detectedController.SetupConfiguration(controllerType)) { // Controller failed to be setup correctly. // Return null so we don't raise the source detected. return(null); } ActiveControllers.Add(joystickName, detectedController); return(detectedController); }
private OculusQuestHand GetOrAddHand(Handedness handedness, OVRHand ovrHand) { if (trackedHands.ContainsKey(handedness)) { return(trackedHands[handedness]); } // Add new hand var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Hand", pointers, inputSourceType); if (!inactiveHandCache.TryGetValue(handedness, out var handController)) { handController = new OculusQuestHand(TrackingState.Tracked, handedness, inputSource); handController.InitializeHand(ovrHand, MRTKOculusConfig.Instance.CustomHandMaterial); } inactiveHandCache.Remove(handedness); for (int i = 0; i < handController.InputSource?.Pointers?.Length; i++) { handController.InputSource.Pointers[i].Controller = handController; } if (MRTKOculusConfig.Instance.ActiveTeleportPointerMode == MRTKOculusConfig.TeleportPointerMode.Custom && MixedRealityToolkit.IsTeleportSystemEnabled) { if (!teleportPointers.TryGetValue(handedness, out CustomTeleportPointer pointer)) { pointer = GameObject.Instantiate(MRTKOculusConfig.Instance.CustomTeleportPrefab).GetComponent <CustomTeleportPointer>(); pointer.gameObject.SetActive(false); teleportPointers.Add(handedness, pointer); } pointer.Controller = handController; handController.TeleportPointer = pointer; } inputSystem?.RaiseSourceDetected(handController.InputSource, handController); trackedHands.Add(handedness, handController); return(handController); }
private OculusQuestController GetOrAddController(Handedness handedness) { if (trackedControllers.ContainsKey(handedness)) { return(trackedControllers[handedness]); } var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var inputSource = inputSystem?.RequestNewGenericInputSource($"Oculus Quest {handedness} Controller", pointers, inputSourceType); if (!inactiveControllerCache.TryGetValue(handedness, out var controller)) { controller = new OculusQuestController(TrackingState.Tracked, handedness, inputSource); controller.UpdateAvatarMaterial(MRTKOculusConfig.Instance.CustomHandMaterial); } inactiveHandCache.Remove(handedness); controller.ApplyHandMaterial(); for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } if (MixedRealityToolkit.IsTeleportSystemEnabled) { if (!teleportPointers.TryGetValue(handedness, out CustomTeleportPointer pointer)) { pointer = GameObject.Instantiate(MRTKOculusConfig.Instance.CustomTeleportPrefab).GetComponent <CustomTeleportPointer>(); teleportPointers.Add(handedness, pointer); } pointer.Controller = controller; controller.TeleportPointer = pointer; } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); trackedControllers.Add(handedness, controller); return(controller); }
private LeapMotionHand GetOrAddHand(Hand hand) { var handId = hand.Id; var handedness = GetHandedness(hand); if (trackedHands.ContainsKey(handId)) { var existingHand = trackedHands[handId]; if (existingHand.ControllerHandedness == handedness) { return(existingHand); } else { RemoveHandDevice(handId); } } // Add new hand IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var pointers = RequestPointers(SupportedControllerType.ArticulatedHand, handedness); var inputSourceType = InputSourceType.Hand; var inputSource = inputSystem?.RequestNewGenericInputSource($"Leap Motion Hand {handId}", pointers, inputSourceType); var controller = new LeapMotionHand(TrackingState.Tracked, handedness, inputSource); controller.SetupConfiguration(typeof(LeapMotionHand), inputSourceType); for (int i = 0; i < controller.InputSource?.Pointers?.Length; i++) { controller.InputSource.Pointers[i].Controller = controller; } inputSystem?.RaiseSourceDetected(inputSource, controller); trackedHands.Add(handId, controller); UpdateActiveControllers(); return(controller); }
/// <inheritdoc /> public override void Enable() { if (!Application.isPlaying) { return; } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (inputSystem == null) { Debug.LogError($"Unable to start {Name}. An Input System is required for this feature."); return; } inputSource = inputSystem.RequestNewGenericInputSource(Name, sourceType: InputSourceType.Voice); dictationResult = string.Empty; if (dictationRecognizer == null && InputSystemProfile.SpeechCommandsProfile.SpeechRecognizerStartBehavior == AutoStartBehavior.AutoStart) { InitializeDictationRecognizer(); } }
/// <inheritdoc /> public override void Enable() { if (!Application.isPlaying) { return; } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (inputSystem == null) { Debug.LogError($"Unable to start {Name}. An Input System is required for this feature."); return; } inputSource = inputSystem.RequestNewGenericInputSource(Name, sourceType: InputSourceType.Voice); dictationResult = string.Empty; try { if (dictationRecognizer == null) { dictationRecognizer = new DictationRecognizer(); dictationRecognizer.DictationHypothesis += DictationRecognizer_DictationHypothesis; dictationRecognizer.DictationResult += DictationRecognizer_DictationResult; dictationRecognizer.DictationComplete += DictationRecognizer_DictationComplete; dictationRecognizer.DictationError += DictationRecognizer_DictationError; } } catch (System.Exception ex) { Debug.LogWarning($"Failed to start dictation recognizer. Are microphone permissions granted? Exception: {ex}"); Disable(); dictationRecognizer = null; } }
void PlugSimulatedMotionController(Handedness controllerHandedness) { MixedRealityRaycaster.DebugEnabled = true; System.Type controllerType = typeof(SimulatedMotionController); // Make sure that the handedness declared in the controller attribute matches what we expect { var controllerAttribute = MixedRealityControllerAttribute.Find(controllerType); if (controllerAttribute != null) { Handedness[] handednesses = controllerAttribute.SupportedHandedness; //Debug.Assert(handednesses.Length == 3 && handednesses[0] == Handedness.Any, "Unexpected mouse handedness declared in MixedRealityControllerAttribute"); } } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var pointers = RequestPointers(SupportedControllerType.GenericOpenVR, controllerHandedness); IMixedRealityInputSource inputSource = inputSystem.RequestNewGenericInputSource("Mouse Input", pointers, InputSourceType.Controller); SimulatedMotionController simulatedMotionController = new SimulatedMotionController(TrackingState.Tracked, controllerHandedness, inputSource); simulatedMotionController.SetupConfiguration(controllerType); if (inputSource != null) { for (int i = 0; i < inputSource.Pointers.Length; i++) { inputSource.Pointers[i].Controller = simulatedMotionController; } } SimulatedMotionControllerDictionary.Add(controllerHandedness, simulatedMotionController); inputSystem?.RaiseSourceDetected(simulatedMotionController.InputSource, simulatedMotionController); }
private void AddTouchController(Touch touch, Ray ray) { UnityTouchController controller; IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; if (!ActiveTouches.TryGetValue(touch.fingerId, out controller)) { IMixedRealityInputSource inputSource = null; if (inputSystem != null) { var pointers = RequestPointers(SupportedControllerType.TouchScreen, Handedness.Any); inputSource = inputSystem.RequestNewGenericInputSource($"Touch {touch.fingerId}", pointers); } controller = new UnityTouchController(TrackingState.NotApplicable, Handedness.Any, inputSource); if (inputSource != null) { for (int i = 0; i < inputSource.Pointers.Length; i++) { inputSource.Pointers[i].Controller = controller; var touchPointer = (IMixedRealityTouchPointer)inputSource.Pointers[i]; touchPointer.TouchRay = ray; touchPointer.FingerId = touch.fingerId; } } controller.SetupConfiguration(typeof(UnityTouchController)); ActiveTouches.Add(touch.fingerId, controller); } inputSystem?.RaiseSourceDetected(controller.InputSource, controller); controller.StartTouch(); UpdateTouchData(touch, ray); }
/// <inheritdoc /> public override void Enable() { if (!Application.isPlaying || Commands.Length == 0) { return; } if (InputSystemProfile == null) { return; } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; InputSource = inputSystem?.RequestNewGenericInputSource("Windows Speech Input Source", sourceType: InputSourceType.Voice); var newKeywords = new string[Commands.Length]; for (int i = 0; i < Commands.Length; i++) { newKeywords[i] = Commands[i].LocalizedKeyword; } RecognitionConfidenceLevel = InputSystemProfile.SpeechCommandsProfile.SpeechRecognitionConfidenceLevel; if (keywordRecognizer == null) { keywordRecognizer = new KeywordRecognizer(newKeywords, (ConfidenceLevel)RecognitionConfidenceLevel); keywordRecognizer.OnPhraseRecognized += KeywordRecognizer_OnPhraseRecognized; } if (InputSystemProfile.SpeechCommandsProfile.SpeechRecognizerStartBehavior == AutoStartBehavior.AutoStart) { StartRecognition(); } }
/// <inheritdoc /> protected override GenericJoystickController GetOrAddController(string joystickName) { // If a device is already registered with the ID provided, just return it. if (ActiveControllers.ContainsKey(joystickName)) { var controller = ActiveControllers[joystickName]; Debug.Assert(controller != null); return(controller); } Handedness controllingHand; if (joystickName.Contains("Left")) { controllingHand = Handedness.Left; } else if (joystickName.Contains("Right")) { controllingHand = Handedness.Right; } else { controllingHand = Handedness.None; } var currentControllerType = GetCurrentControllerType(joystickName); Type controllerType; switch (currentControllerType) { case SupportedControllerType.GenericOpenVR: controllerType = typeof(GenericOpenVRController); break; case SupportedControllerType.ViveWand: controllerType = typeof(ViveWandController); break; case SupportedControllerType.ViveKnuckles: controllerType = typeof(ViveKnucklesController); break; case SupportedControllerType.OculusTouch: controllerType = typeof(OculusTouchController); break; case SupportedControllerType.OculusRemote: controllerType = typeof(OculusRemoteController); break; case SupportedControllerType.WindowsMixedReality: controllerType = typeof(WindowsMixedRealityOpenVRMotionController); break; default: return(null); } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; var pointers = RequestPointers(currentControllerType, controllingHand); var inputSource = inputSystem?.RequestNewGenericInputSource($"{currentControllerType} Controller {controllingHand}", pointers, InputSourceType.Controller); var detectedController = Activator.CreateInstance(controllerType, TrackingState.NotTracked, controllingHand, inputSource, null) as GenericOpenVRController; if (detectedController == null) { Debug.LogError($"Failed to create {controllerType.Name} controller"); return(null); } if (!detectedController.SetupConfiguration(controllerType)) { // Controller failed to be set up correctly. Debug.LogError($"Failed to set up {controllerType.Name} controller"); // Return null so we don't raise the source detected. return(null); } for (int i = 0; i < detectedController.InputSource?.Pointers?.Length; i++) { detectedController.InputSource.Pointers[i].Controller = detectedController; } ActiveControllers.Add(joystickName, detectedController); return(detectedController); }
/// <summary> /// Retrieve the source controller from the Active Store, or create a new device and register it /// </summary> /// <param name="interactionSource">Source State provided by the SDK</param> /// <param name="addController">Should the Source be added as a controller if it isn't found?</param> /// <returns>New or Existing Controller Input Source</returns> private WindowsMixedRealityController GetController(InteractionSource interactionSource, bool addController = true) { //If a device is already registered with the ID provided, just return it. if (activeControllers.ContainsKey(interactionSource.id)) { var controller = activeControllers[interactionSource.id] as WindowsMixedRealityController; Debug.Assert(controller != null); return(controller); } if (!addController) { return(null); } Handedness controllingHand; switch (interactionSource.handedness) { default: controllingHand = Handedness.None; break; case InteractionSourceHandedness.Left: controllingHand = Handedness.Left; break; case InteractionSourceHandedness.Right: controllingHand = Handedness.Right; break; } IMixedRealityInputSystem inputSystem = Service as IMixedRealityInputSystem; IMixedRealityPointer[] pointers = null; InputSourceType inputSourceType = InputSourceType.Other; switch (interactionSource.kind) { case InteractionSourceKind.Controller: pointers = RequestPointers(SupportedControllerType.WindowsMixedReality, controllingHand); inputSourceType = InputSourceType.Controller; break; case InteractionSourceKind.Hand: if (interactionSource.supportsPointing) { pointers = RequestPointers(SupportedControllerType.ArticulatedHand, controllingHand); } else { pointers = RequestPointers(SupportedControllerType.GGVHand, controllingHand); } inputSourceType = InputSourceType.Hand; break; case InteractionSourceKind.Voice: // set to null: when pointers are null we use head gaze, which is what we want for voice break; default: Debug.LogError($"Unknown new type in WindowsMixedRealityDeviceManager {interactionSource.kind}, make sure to add a SupportedControllerType"); break; } string nameModifier = controllingHand == Handedness.None ? interactionSource.kind.ToString() : controllingHand.ToString(); var inputSource = inputSystem?.RequestNewGenericInputSource($"Mixed Reality Controller {nameModifier}", pointers, inputSourceType); WindowsMixedRealityController detectedController; if (interactionSource.kind == InteractionSourceKind.Hand) { if (interactionSource.supportsPointing) { detectedController = new WindowsMixedRealityArticulatedHand(TrackingState.NotTracked, controllingHand, inputSource); if (!detectedController.SetupConfiguration(typeof(WindowsMixedRealityArticulatedHand), inputSourceType)) { // Controller failed to be setup correctly. // Return null so we don't raise the source detected. return(null); } } else { detectedController = new WindowsMixedRealityGGVHand(TrackingState.NotTracked, controllingHand, inputSource); if (!detectedController.SetupConfiguration(typeof(WindowsMixedRealityGGVHand), inputSourceType)) { // Controller failed to be setup correctly. // Return null so we don't raise the source detected. return(null); } } } else { detectedController = new WindowsMixedRealityController(TrackingState.NotTracked, controllingHand, inputSource); if (!detectedController.SetupConfiguration(typeof(WindowsMixedRealityController), inputSourceType)) { // Controller failed to be setup correctly. // Return null so we don't raise the source detected. return(null); } } for (int i = 0; i < detectedController.InputSource?.Pointers?.Length; i++) { detectedController.InputSource.Pointers[i].Controller = detectedController; } activeControllers.Add(interactionSource.id, detectedController); return(detectedController); }