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();
}
}
