public void Test_07_02_DisableServicesByType() { TestUtilities.InitializeMixedRealityToolkitScene(); // Add test 1 services MixedRealityToolkit.RegisterService <ITestDataProvider1>(new TestDataProvider1("Test07-01-1.1")); MixedRealityToolkit.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test07-01-1.2")); // Add test 2 services MixedRealityToolkit.RegisterService <ITestDataProvider2>(new TestDataProvider2("Test07-01-2.1")); MixedRealityToolkit.RegisterService <ITestExtensionService2>(new TestExtensionService2("Test07-01-2.2")); // Enable all test services MixedRealityToolkit.EnableAllServicesOfType <ITestService>(); // Get all services var testServices = MixedRealityToolkit.GetActiveServices <ITestService>(); foreach (var service in testServices) { Assert.IsTrue(service is ITestService); Assert.IsTrue((service as ITestService).IsEnabled); } // Enable all test services MixedRealityToolkit.DisableAllServiceOfType <ITestService>(); foreach (var service in testServices) { Assert.IsTrue(service is ITestService); Assert.IsFalse((service as ITestService).IsEnabled); } }
public void Test_06_03_TryRegisterMixedRealityDataProviderByName() { TestUtilities.InitializeMixedRealityToolkitScene(); LogAssert.Expect(LogType.Error, "Unable to find Test Data Provider 2 service."); // Register MixedRealityToolkit.RegisterService <ITestDataProvider1>(new TestDataProvider1("Test Data Provider 1")); // Retrieve ITestDataProvider1 extensionService1 = null; ITestDataProvider1 extensionService2 = null; bool resultTrue = MixedRealityToolkit.TryGetService <ITestDataProvider1>("Test Data Provider 1", out extensionService1); bool resultFalse = MixedRealityToolkit.TryGetService <ITestDataProvider1>("Test Data Provider 2", out extensionService2); // Tests Assert.IsEmpty(MixedRealityToolkit.ActiveSystems); Assert.AreEqual(1, MixedRealityToolkit.RegisteredMixedRealityServices.Count); // Tests Assert.IsTrue(resultTrue, "Test Data Provider 1 found"); Assert.IsFalse(resultFalse, "Test Data Provider 2 not found"); Assert.IsNotNull(extensionService1, "Test Data Provider 1 service found"); Assert.IsNull(extensionService2, "Test Data Provider 2 service not found"); }
public void Test_07_02_DisableServicesByType() { TestUtilities.InitializeMixedRealityToolkitScene(); // Add test 1 services MixedRealityToolkit.Instance.RegisterService(typeof(ITestDataProvider1), new TestDataProvider1("Test07-01-1.1", 10)); MixedRealityToolkit.Instance.RegisterService(typeof(ITestExtensionService1), new TestExtensionService1("Test07-01-1.2", 10, null)); // Add test 2 services MixedRealityToolkit.Instance.RegisterService(typeof(ITestDataProvider2), new TestDataProvider2("Test07-01-2.1", 10)); MixedRealityToolkit.Instance.RegisterService(typeof(ITestExtensionService2), new TestExtensionService2("Test07-01-2.2", 10, null)); // Enable all test services MixedRealityToolkit.EnableAllServicesByType(typeof(ITestService)); // Get all services var testServices = MixedRealityToolkit.Instance.GetActiveServices(typeof(ITestService)); foreach (var service in testServices) { Assert.IsTrue(service is ITestService); Assert.IsTrue((service as ITestService).IsEnabled); } // Enable all test services MixedRealityToolkit.DisableAllServicesByType(typeof(ITestService)); foreach (var service in testServices) { Assert.IsTrue(service is ITestService); Assert.IsFalse((service as ITestService).IsEnabled); } }
public void Test_05_02_02_UnregisterMixedRealityExtensionServiceByTypeAndName() { TestUtilities.InitializeMixedRealityToolkitScene(); // Register ITestExtensionService1 MixedRealityToolkit.Instance.RegisterService(typeof(ITestExtensionService1), new TestExtensionService1("Test ExtensionService 1", 10, null)); // Retrieve ITestExtensionService1 var extensionService1 = MixedRealityToolkit.Instance.GetService(typeof(ITestExtensionService1)); // Tests Assert.IsNotNull(extensionService1); Assert.IsEmpty(MixedRealityToolkit.ActiveSystems); Assert.AreEqual(1, MixedRealityToolkit.RegisteredMixedRealityServices.Count); var success = MixedRealityToolkit.UnregisterService(typeof(ITestExtensionService1), extensionService1.Name); // Validate non-existent service var isServiceRegistered = MixedRealityToolkit.Instance.IsServiceRegistered <ITestExtensionService1>(); // Tests Assert.IsTrue(success); Assert.IsFalse(isServiceRegistered); Assert.IsEmpty(MixedRealityToolkit.ActiveSystems); Assert.IsEmpty(MixedRealityToolkit.RegisteredMixedRealityServices); LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestExtensionService1).Name} service."); }
public void Test_04_02_01_UnregisterMixedRealityDataProviderByType() { TestUtilities.InitializeMixedRealityToolkitScene(); // Register MixedRealityToolkit.RegisterService <ITestDataProvider1>(new TestDataProvider1("Test Data Provider 1")); // Retrieve var extensionService1 = MixedRealityToolkit.GetService <ITestDataProvider1>(); // Tests Assert.IsNotNull(extensionService1); Assert.IsEmpty(MixedRealityToolkit.ActiveSystems); Assert.AreEqual(1, MixedRealityToolkit.RegisteredMixedRealityServices.Count); var success = MixedRealityToolkit.UnregisterServicesOfType <ITestDataProvider1>(); // Validate non-existent service var isServiceRegistered = MixedRealityToolkit.IsServiceRegistered <ITestDataProvider1>(); // Tests Assert.IsTrue(success); Assert.IsFalse(isServiceRegistered); Assert.IsEmpty(MixedRealityToolkit.ActiveSystems); Assert.IsEmpty(MixedRealityToolkit.RegisteredMixedRealityServices); LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestDataProvider1).Name} service."); }
/// <summary> /// Get a list of Mixed Reality Input Actions from the input actions profile. /// </summary> public static bool TryGetInputActions(out string[] descriptionsArray) { if (!MixedRealityToolkit.ConfirmInitialized() || !MixedRealityToolkit.Instance.HasActiveProfile) { descriptionsArray = null; return(false); } MixedRealityInputSystemProfile inputSystemProfile = CoreServices.InputSystem?.InputSystemProfile; if (inputSystemProfile != null && inputSystemProfile.SpeechCommandsProfile != null) { MixedRealityInputAction[] actions = inputSystemProfile.InputActionsProfile.InputActions; descriptionsArray = new string[actions.Length]; for (int i = 0; i < actions.Length; i++) { descriptionsArray[i] = actions[i].Description; } } else { descriptionsArray = null; } if (descriptionsArray == null || descriptionsArray.Length < 1) { return(false); } return(true); }
/// <summary> /// If MRTK is not initialized in scene, adds and initializes instance to current scene /// </summary> public static void AddMixedRealityToolkitToScene(MixedRealityToolkitConfigurationProfile configProfile = null, bool inPlayMode = false) { if (!MixedRealityToolkit.IsInitialized) { MixedRealityToolkit newInstance = new GameObject("MixedRealityToolkit").AddComponent<MixedRealityToolkit>(); MixedRealityToolkit.SetActiveInstance(newInstance); Selection.activeObject = newInstance; MixedRealityToolkit.ConfirmInitialized(); if (configProfile == null) { // if we don't have a profile set we get the default profile newInstance.ActiveProfile = GetDefaultConfigProfile(); } else { newInstance.ActiveProfile = configProfile; } if(!newInstance.ActiveProfile.ExperienceSettingsProfile.IsNull()) { // Add a MixedRealitySceneContent object to a scene. Children of this object will scale appropriately dependent on MR platform MixedRealitySceneContent contentAdjuster = new GameObject("MixedRealitySceneContent").AddComponent<MixedRealitySceneContent>(); } if (!inPlayMode) { EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene()); } } }
/// <summary> /// Try to get a list of speech commands from the MRTK/Input/SpeechCommands profile /// </summary> public static bool TryGetMixedRealitySpeechCommands(out SpeechCommands[] commands) { if (!MixedRealityToolkit.ConfirmInitialized() || !MixedRealityToolkit.Instance.HasActiveProfile) { commands = null; return(false); } MixedRealityInputSystemProfile inputSystemProfile = CoreServices.InputSystem?.InputSystemProfile; if (inputSystemProfile != null && inputSystemProfile.SpeechCommandsProfile != null) { commands = inputSystemProfile.SpeechCommandsProfile.SpeechCommands; } else { commands = null; } if (commands == null || commands.Length < 1) { return(false); } return(true); }
public void TestCreateMultipleInstancesInMultipleScenes() { TestUtilities.EditorCreateScenes(3); for (int i = 0; i < SceneManager.sceneCount; i++) { Scene scene = SceneManager.GetSceneAt(i); SceneManager.SetActiveScene(scene); MixedRealityToolkit newInstance = new GameObject("MixedRealityToolkit").AddComponent <MixedRealityToolkit>(); } MixedRealityToolkit[] instances = GameObject.FindObjectsOfType <MixedRealityToolkit>(); for (int i = 0; i < instances.Length; i++) { MixedRealityToolkit.SetActiveInstance(instances[i]); Assert.AreEqual(instances[i], MixedRealityToolkit.Instance); Assert.IsTrue(instances[i].IsActiveInstance); for (int j = 0; j < instances.Length; j++) { if (i == j) { continue; } Assert.IsFalse(instances[j].IsActiveInstance); } } }
private static void DestroyAllChildren(MixedRealityToolkit instance) { Transform instanceTransform = instance.transform; childrenToDelete.Clear(); foreach (Transform child in instanceTransform.transform) { childrenToDelete.Add(child); } foreach (ServiceFacade facade in ServiceFacade.ActiveFacadeObjects) { if (!childrenToDelete.Contains(facade.transform)) { childrenToDelete.Add(facade.transform); } } foreach (Transform child in childrenToDelete) { GameObjectExtensions.DestroyGameObject(child.gameObject); } childrenToDelete.Clear(); }
public static void InitializeMixedRealityToolkit(bool useDefaultProfile = false) { if (!MixedRealityToolkit.IsInitialized) { MixedRealityToolkit mixedRealityToolkit = new GameObject("MixedRealityToolkit").AddComponent <MixedRealityToolkit>(); MixedRealityToolkit.SetActiveInstance(mixedRealityToolkit); MixedRealityToolkit.ConfirmInitialized(); } // Todo: this condition shouldn't be here. // It's here due to some edit mode tests initializing Mrtk instance in Edit mode, causing some of // event handler registration to live over tests and cause next tests to fail. // Exact reason requires investigation. if (Application.isPlaying) { BaseEventSystem.enableDanglingHandlerDiagnostics = true; } // Tests Assert.IsTrue(MixedRealityToolkit.IsInitialized); Assert.IsNotNull(MixedRealityToolkit.Instance); if (!MixedRealityToolkit.Instance.HasActiveProfile) { var configuration = useDefaultProfile ? GetDefaultMixedRealityProfile <MixedRealityToolkitConfigurationProfile>() : ScriptableObject.CreateInstance <MixedRealityToolkitConfigurationProfile>(); Assert.IsTrue(configuration != null, "Failed to find the Default Mixed Reality Configuration Profile"); MixedRealityToolkit.Instance.ActiveProfile = configuration; Assert.IsTrue(MixedRealityToolkit.Instance.ActiveProfile != null); } }
public void Test_04_01_RegisterMixedRealityServiceAndDataProvider() { TestUtilities.InitializeMixedRealityToolkitScene(false); var activeSystemCount = MixedRealityToolkit.ActiveSystems.Count; var activeServiceCount = MixedRealityToolkit.RegisteredMixedRealityServices.Count; // Register MixedRealityToolkit.TryRegisterService <ITestService>(new TestService1()); // Retrieve var testService1 = MixedRealityToolkit.GetService <ITestService>(); // Register MixedRealityToolkit.TryRegisterService <ITestDataProvider1>(new TestDataProvider1(testService1)); // Retrieve var dataProvider1 = MixedRealityToolkit.GetService <ITestDataProvider1>(); // Tests Assert.IsNotNull(testService1); Assert.IsNotNull(dataProvider1); Assert.IsTrue(activeSystemCount == MixedRealityToolkit.ActiveSystems.Count); Assert.IsTrue(activeServiceCount + 2 == MixedRealityToolkit.RegisteredMixedRealityServices.Count); // Tests Assert.IsNotNull(dataProvider1); }
private void Start() { if (!MixedRealityToolkit.TryGetSystem(out locomotionSystem)) { Debug.LogError($"Locomotion system not found. The locomotion demo requires the locomotion system to be enabled."); } }
public void Test_06_03_TryRegisterMixedRealityDataProviderByName() { TestUtilities.InitializeMixedRealityToolkitScene(false); var activeSystemCount = MixedRealityToolkit.ActiveSystems.Count; var activeServiceCount = MixedRealityToolkit.RegisteredMixedRealityServices.Count; MixedRealityToolkit.TryRegisterService <ITestService>(new TestService1()); var testService1 = MixedRealityToolkit.GetService <ITestService>(); // Register MixedRealityToolkit.TryRegisterService <ITestDataProvider1>(new TestDataProvider1(testService1)); // Retrieve var resultTrue = MixedRealityToolkit.TryGetService <ITestDataProvider1>("Test Data Provider 1", out var extensionService1); var resultFalse = MixedRealityToolkit.TryGetService <ITestDataProvider1>("Test Data Provider 2", out var extensionService2); // Tests LogAssert.Expect(LogType.Error, "Unable to find Test Data Provider 2 service."); Assert.IsTrue(activeSystemCount == MixedRealityToolkit.ActiveSystems.Count); Assert.IsTrue(activeServiceCount + 2 == MixedRealityToolkit.RegisteredMixedRealityServices.Count); Assert.IsTrue(resultTrue, "Test Data Provider 1 found"); Assert.IsFalse(resultFalse, "Test Data Provider 2 not found"); Assert.IsNotNull(extensionService1, "Test Data Provider 1 service found"); Assert.IsNull(extensionService2, "Test Data Provider 2 service not found"); }
public void Test_07_01_EnableServicesByType() { TestUtilities.InitializeMixedRealityToolkitScene(false); MixedRealityToolkit.TryRegisterService <ITestService>(new TestService1()); var testService1 = MixedRealityToolkit.GetService <ITestService>(); // Add test 1 services MixedRealityToolkit.TryRegisterService <ITestDataProvider1>(new TestDataProvider1(testService1)); MixedRealityToolkit.TryRegisterService <ITestExtensionService1>(new TestExtensionService1()); // Add test 2 services MixedRealityToolkit.TryRegisterService <ITestDataProvider2>(new TestDataProvider2(testService1)); MixedRealityToolkit.TryRegisterService <ITestExtensionService2>(new TestExtensionService2()); // Enable all test services MixedRealityToolkit.EnableAllServicesOfType <ITestService>(); // Tests var testServices = MixedRealityToolkit.GetActiveServices <ITestService>(); foreach (var service in testServices) { Assert.IsTrue(service != null); Assert.IsTrue(service.IsEnabled); } }
public void Test_05_02_02_UnregisterMixedRealityExtensionServiceByTypeAndName() { TestUtilities.InitializeMixedRealityToolkitScene(false); var activeSystemCount = MixedRealityToolkit.ActiveSystems.Count; var activeServiceCount = MixedRealityToolkit.RegisteredMixedRealityServices.Count; // Register ITestExtensionService1 MixedRealityToolkit.TryRegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1")); // Retrieve ITestExtensionService1 var extensionService1 = MixedRealityToolkit.GetService <ITestExtensionService1>(); // Tests Assert.IsNotNull(extensionService1); Assert.IsTrue(activeSystemCount == MixedRealityToolkit.ActiveSystems.Count); Assert.IsTrue(activeServiceCount + 1 == MixedRealityToolkit.RegisteredMixedRealityServices.Count); var success = MixedRealityToolkit.TryUnregisterService <ITestExtensionService1>(extensionService1.Name); // Validate non-existent service var isServiceRegistered = MixedRealityToolkit.IsServiceRegistered <ITestExtensionService1>(); LogAssert.Expect(LogType.Error, $"Unable to find {nameof(ITestExtensionService1)} service."); // Tests Assert.IsTrue(success); Assert.IsFalse(isServiceRegistered); Assert.IsTrue(activeSystemCount == MixedRealityToolkit.ActiveSystems.Count); Assert.IsTrue(activeServiceCount == MixedRealityToolkit.RegisteredMixedRealityServices.Count); }
public void Test_04_03_RegisterMixedRealityDataProviders() { TestUtilities.InitializeMixedRealityToolkitScene(false); var activeSystemCount = MixedRealityToolkit.ActiveSystems.Count; var activeServiceCount = MixedRealityToolkit.RegisteredMixedRealityServices.Count; // Register MixedRealityToolkit.TryRegisterService <ITestService>(new TestService1()); // Retrieve var testService1 = MixedRealityToolkit.GetService <ITestService>(); // Register MixedRealityToolkit.TryRegisterService <ITestDataProvider1>(new TestDataProvider1(testService1)); MixedRealityToolkit.TryRegisterService <ITestDataProvider2>(new TestDataProvider2(testService1)); // Retrieve all registered IMixedRealityDataProviders var extensionServices = MixedRealityToolkit.GetActiveServices <IMixedRealityDataProvider>(); // Tests Assert.IsNotEmpty(extensionServices); Assert.IsTrue(activeSystemCount == MixedRealityToolkit.ActiveSystems.Count); Assert.IsTrue(activeServiceCount + 3 == MixedRealityToolkit.RegisteredMixedRealityServices.Count); }
public static void InitializeMixedRealityToolkit(MixedRealityToolkitConfigurationProfile configuration) { InitializeCamera(); if (!MixedRealityToolkit.IsInitialized) { MixedRealityToolkit mixedRealityToolkit = new GameObject("MixedRealityToolkit").AddComponent <MixedRealityToolkit>(); MixedRealityToolkit.SetActiveInstance(mixedRealityToolkit); MixedRealityToolkit.ConfirmInitialized(); } // Todo: this condition shouldn't be here. // It's here due to some edit mode tests initializing MRTK instance in Edit mode, causing some of // event handler registration to live over tests and cause next tests to fail. // Exact reason requires investigation. if (Application.isPlaying) { BaseEventSystem.enableDanglingHandlerDiagnostics = true; } Debug.Assert(MixedRealityToolkit.IsInitialized); Debug.Assert(MixedRealityToolkit.Instance != null); MixedRealityToolkit.Instance.ActiveProfile = configuration; Debug.Assert(MixedRealityToolkit.Instance.ActiveProfile != null); }
/// <summary> /// Check and make sure we have a Mixed Reality Toolkit and an active profile. /// </summary> /// <returns>True if the Mixed Reality Toolkit is properly initialized.</returns> public static bool CheckMixedRealityConfigured(bool showHelpBox = true) { if (!MixedRealityToolkit.IsInitialized) { // Search the scene for one, in case we've just hot reloaded the assembly. var managerSearch = Object.FindObjectsOfType <MixedRealityToolkit>(); if (managerSearch.Length == 0) { if (showHelpBox) { EditorGUILayout.HelpBox("No Mixed Reality Toolkit found in scene.", MessageType.Error); } return(false); } MixedRealityToolkit.ConfirmInitialized(); } if (!MixedRealityToolkit.Instance.HasActiveProfile) { if (showHelpBox) { EditorGUILayout.HelpBox("No Active Profile set on the Mixed Reality Toolkit.", MessageType.Error); } return(false); } return(true); }
private void Start() { providers = MixedRealityToolkit.GetActiveServices <IMixedRealityHandControllerDataProvider>(); physicsToggle.isOn = providers[0].HandPhysicsEnabled; handsModeEnabledImage.gameObject.SetActive(providers[0].BoundsMode == HandBoundsLOD.Low); fingersModeEnabledImage.gameObject.SetActive(providers[0].BoundsMode == HandBoundsLOD.High); }
private static void CleanupCurrentFacades() { foreach (MixedRealityToolkit toolkitInstance in GameObject.FindObjectsOfType <MixedRealityToolkit>()) { DestroyAllChildren(toolkitInstance); } previousActiveInstance = null; }
private static void OnPlayModeStateChanged(PlayModeStateChange state) { foreach (MixedRealityToolkit toolkitInstance in GameObject.FindObjectsOfType <MixedRealityToolkit>()) { DestroyAllChildren(toolkitInstance); } previousActiveInstance = null; }
public override void OnInspectorGUI() { MixedRealityToolkit instance = (MixedRealityToolkit)target; if (MixedRealityToolkit.Instance == null && instance.isActiveAndEnabled) { // See if an active instance exists at all. If it doesn't register this instance preemptively. MixedRealityToolkit.SetActiveInstance(instance); } if (!instance.IsActiveInstance) { EditorGUILayout.HelpBox("This instance of the toolkit is inactive. There can only be one active instance loaded at any time.", MessageType.Warning); using (new EditorGUILayout.HorizontalScope()) { if (GUILayout.Button("Select Active Instance")) { Selection.activeGameObject = MixedRealityToolkit.Instance.gameObject; } if (GUILayout.Button("Make this the Active Instance")) { MixedRealityToolkit.SetActiveInstance(instance); } } return; } serializedObject.Update(); // If no profile is assigned, then warn user if (activeProfile.objectReferenceValue == null) { EditorGUILayout.HelpBox("MixedRealityToolkit cannot initialize unless an Active Profile is assigned!", MessageType.Error); } bool changed = MixedRealityInspectorUtility.DrawProfileDropDownList(activeProfile, null, activeProfile.objectReferenceValue, typeof(MixedRealityToolkitConfigurationProfile), false, false) || cachedProfile != activeProfile.objectReferenceValue; serializedObject.ApplyModifiedProperties(); if (changed) { MixedRealityToolkit.Instance.ResetConfiguration((MixedRealityToolkitConfigurationProfile)activeProfile.objectReferenceValue); activeProfileEditor = null; cachedProfile = activeProfile.objectReferenceValue; } if (activeProfile.objectReferenceValue != null && activeProfileEditor == null) { // For the configuration profile, show the default inspector GUI activeProfileEditor = CreateEditor(activeProfile.objectReferenceValue); } if (activeProfileEditor != null) { activeProfileEditor.OnInspectorGUI(); } }
/// <remarks> /// <para>There is a check in here that verifies whether or not we can get InputActions, if we can't we show an error help box; otherwise we get them. /// This method is sealed, if you wish to override <see cref="OnInspectorGUI"/>, then override <see cref="RenderCustomInspector"/> method instead.</para> /// </remarks> public sealed override void OnInspectorGUI() { if (!MixedRealityToolkit.ConfirmInitialized() || (inputActionOptions == null && !TryGetInputActions(out inputActionOptions))) { EditorGUILayout.HelpBox("Mixed Reality Toolkit is missing, configure it by invoking the 'Mixed Reality Toolkit > Add to Scene and Configure...' menu", MessageType.Error); } RenderCustomInspector(); }
// Start is called before the first frame update void Start() { _rootAction = MixedRealityToolkit.GetService <OpenKitService>().EnsureRootAction("Test Root Action"); _startActionBtn.onClick.AddListener(OnActionButtonClicked); _startAction2Btn.onClick.AddListener(OnActionButton2Clicked); _startTaskBtn.onClick.AddListener(OnStartTaskButtonClicked); _destroyBtn.onClick.AddListener(OnDestroyClicked); _rootAction.ReportEvent("Added button listeners"); }
private static void OnScriptsReloaded() { // If scripts were reloaded, nuke everything and start over foreach (MixedRealityToolkit toolkitInstance in GameObject.FindObjectsOfType <MixedRealityToolkit>()) { DestroyAllChildren(toolkitInstance); } previousActiveInstance = null; }
public void SetMeshMode() { var providers = MixedRealityToolkit.GetActiveServices <IMixedRealityHandControllerDataProvider>(); for (int i = 0; i < providers.Count; i++) { providers[i].RenderingMode = XRTK.Definitions.Controllers.Hands.HandRenderingMode.Mesh; } }
public static void ShutdownMixedRealityToolkit() { MixedRealityToolkit.SetInstanceInactive(MixedRealityToolkit.Instance); if (Application.isPlaying) { MixedRealityPlayspace.Destroy(); } BaseEventSystem.enableDanglingHandlerDiagnostics = false; }
public void Test_01_InitializeMixedRealityToolkit() { TestUtilities.CleanupScene(); MixedRealityToolkit.ConfirmInitialized(); // Tests GameObject gameObject = GameObject.Find(nameof(MixedRealityToolkit)); Assert.AreEqual(nameof(MixedRealityToolkit), gameObject.name); }
protected override void Start() { base.Start(); dictationSystem = MixedRealityToolkit.GetService <IMixedRealityDictationDataProvider>(); Debug.Assert(dictationSystem != null, "No dictation system found. In order to use dictation, add a dictation system like 'Windows Dictation Input Provider' to the Data Providers in the Input System profile"); if (startRecordingOnStart) { StartRecording(); } }