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();
}
private void CleanUpDefaultProgressIndicator()
{
if (progressIndicatorObject != null)
{
GameObjectExtensions.DestroyGameObject(progressIndicatorObject);
}
}
private void DestroyCursorInstance()
{
if (cursorInstance != null)
{
// Destroy correctly depending on if in play mode or edit mode
GameObjectExtensions.DestroyGameObject(cursorInstance);
}
}
private static void DestroyFacades()
{
foreach (var facade in ServiceFacade.ActiveFacadeObjects)
{
if (facade != null)
{
GameObjectExtensions.DestroyGameObject(facade.gameObject);
}
}
ServiceFacade.ActiveFacadeObjects.Clear();
}
private void DestroyQuads()
{
foreach (Quad quad in quads.Values)
{
if (quad.Renderer != null)
{
GameObjectExtensions.DestroyGameObject(quad.Renderer.gameObject);
}
}
quads.Clear();
}
private static void DestroyFacades()
{
for (int i = ServiceFacade.ActiveFacadeObjects.Count - 1; i >= 0; i--)
{
var facade = ServiceFacade.ActiveFacadeObjects[i];
if (facade != null)
{
GameObjectExtensions.DestroyGameObject(facade.gameObject);
}
}
ServiceFacade.ActiveFacadeObjects.Clear();
}
/// <inheritdoc />
public virtual void OnSourceLost(SourceStateEventData eventData)
{
if (eventData.SourceId == Controller?.InputSource.SourceId &&
eventData.Controller?.ControllerHandedness == Handedness)
{
TrackingState = TrackingState.NotTracked;
if (destroyOnSourceLost)
{
GameObjectExtensions.DestroyGameObject(gameObject);
}
}
}
public IEnumerator TestLinePointers()
{
BaseEventSystem.enableDanglingHandlerDiagnostics = false;
var linePointer = CreatePointerPrefab <LinePointer>(LinePointerPrefab,
out IMixedRealityInputSource lineInputSource, out IMixedRealityController lineController);
var curvePointer = CreatePointerPrefab <TeleportPointer>(CurvePointerPrefab,
out IMixedRealityInputSource curveInputSource, out IMixedRealityController curveController);
Assert.IsNotNull(linePointer);
Assert.IsNotNull(curvePointer);
// Simulate pushing "up" on joystick axis to activate teleport pointer lines
CoreServices.InputSystem?.RaisePositionInputChanged(curveInputSource,
curveController.ControllerHandedness,
curvePointer.TeleportInputAction,
new Vector2(0.0f, 1.0f));
var hitObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
hitObject.transform.position = Vector3.forward * 3.0f;
hitObject.transform.localScale = Vector3.one * 0.1f;
yield return(PlayModeTestUtilities.WaitForInputSystemUpdate());
// Confirm the line pointer is colliding with the cube which is straight in front
Assert.IsTrue(hitObject == linePointer.Result.CurrentPointerTarget);
Assert.IsNull(curvePointer.Result.CurrentPointerTarget);
hitObject.transform.position = new Vector3(0.0f, -0.8f, 2.0f);
yield return(PlayModeTestUtilities.WaitForInputSystemUpdate());
// Confirm the teleport pointer is colliding with the cube which is in front but down
Assert.IsTrue(hitObject == curvePointer.Result.CurrentPointerTarget);
Assert.IsNull(linePointer.Result.CurrentPointerTarget);
// Clean up our dummy controllers and objects from the input & teleport system
CoreServices.InputSystem.RaiseSourceLost(lineInputSource, lineController);
CoreServices.InputSystem.RaiseSourceLost(curveInputSource, curveController);
CoreServices.TeleportSystem.RaiseTeleportCanceled(curvePointer, null);
GameObjectExtensions.DestroyGameObject(linePointer.gameObject);
GameObjectExtensions.DestroyGameObject(curvePointer.gameObject);
yield return(PlayModeTestUtilities.WaitForInputSystemUpdate());
BaseEventSystem.enableDanglingHandlerDiagnostics = true;
}
private IEnumerator TestTheme <C>(
GameObject host,
ThemeDefinition themeDefinition,
params Action <InteractableThemeBase>[] stateTests)
where C : UnityEngine.Component
{
host.AddComponent <C>();
var theme = InteractableThemeBase.CreateAndInitTheme(themeDefinition, host);
for (int i = 0; i < stateTests.Length; i++)
{
theme.OnUpdate(i);
yield return(null);
stateTests[i](theme);
}
GameObjectExtensions.DestroyGameObject(host);
}
protected override async void Start()
{
base.Start();
await EnsureInputSystemValid();
// We've been destroyed during the await.
if (this == null)
{
return;
}
// The pointer's input source was lost during the await.
if (Controller == null)
{
GameObjectExtensions.DestroyGameObject(gameObject);
return;
}
}
/// <inheritdoc />
public void OnSourceLost(SourceStateEventData eventData)
{
if (eventData.SourceId == InputSourceParent.SourceId)
{
BaseCursor c = gazeProvider.GazePointer.BaseCursor as BaseCursor;
if (c != null)
{
c.SourceDownIds.Remove(eventData.SourceId);
}
if (isSelectPressed)
{
// Raise OnInputUp if pointer is lost while select is pressed
CoreServices.InputSystem.RaisePointerUp(this, selectAction, lastControllerHandedness);
// For GGV, the gaze pointer does not set this value itself.
// See comment in OnInputDown for more details.
gazeProvider.GazePointer.IsFocusLocked = false;
}
// Destroy the pointer since nobody else is destroying us
GameObjectExtensions.DestroyGameObject(gameObject);
}
}
private static void UpdateServiceFacades()
{
// If compiling, don't modify service facades
if (EditorApplication.isCompiling)
{
return;
}
// If MRTK has no active instance
// or there is no active profile for the active instance
// or we are instructed to not use service inspectors
// Return early and clean up any facade instances
if (!MixedRealityToolkit.IsInitialized ||
!MixedRealityToolkit.Instance.HasActiveProfile ||
!MixedRealityToolkit.Instance.ActiveProfile.UseServiceInspectors)
{
DestroyFacades();
return;
}
var mrtkTransform = MixedRealityToolkit.Instance.transform;
bool newMRTKActiveInstance = previousActiveInstance != null && MixedRealityToolkit.Instance != previousActiveInstance;
var serviceSet = GetAllServices();
// Update existing service facade GameObjects
for (int i = ServiceFacade.ActiveFacadeObjects.Count - 1; i >= 0; i--)
{
var facade = ServiceFacade.ActiveFacadeObjects[i];
// if this facade is no longer valid, remove item
if (facade == null)
{
ServiceFacade.ActiveFacadeObjects.Remove(facade);
}
// If service facade is not part of the current service list,
// Remove from the list so that the facade is not-duply-created in the following serviceSet enumeration loop
else if (!serviceSet.Contains(facade.Service))
{
ServiceFacade.ActiveFacadeObjects.Remove(facade);
GameObjectExtensions.DestroyGameObject(facade.gameObject);
}
else
{
// Else item is valid and exists in our list. Remove from list
serviceSet.Remove(facade.Service);
//Ensure valid facades are parented under the current MRTK active instance
if (facade.transform.parent != mrtkTransform)
{
facade.transform.parent = mrtkTransform;
}
}
}
// Remaining services need to be created and added into scene
foreach (var service in serviceSet)
{
// Find where we need to place service based on name ordering
int idx = 0;
for (; idx < mrtkTransform.childCount; idx++)
{
if (mrtkTransform.GetChild(idx).name.CompareTo(service.GetType().Name) >= 0)
{
break;
}
}
CreateFacade(mrtkTransform, service, idx);
}
previousActiveInstance = MixedRealityToolkit.Instance;
}
public void BuildMatrix()
{
List <Transform> children = transform.Cast <Transform>().ToList();
for (int i = 0; i < children.Count; ++i)
{
Transform child = children[i];
GameObjectExtensions.DestroyGameObject(child.gameObject);
}
if (material == null)
{
Debug.LogError("Failed to build material matrix due to missing material.");
return;
}
float center = (dimension - 1) * positionOffset * -0.5f;
Vector3 position = new Vector3(center, 0.0f, center);
int firstPropertyId = Shader.PropertyToID(firstPropertyName);
int secondPropertyId = Shader.PropertyToID(secondPropertyName);
float firstProperty = 0.0f;
float secondProperty = 0.0f;
for (int i = 0; i < dimension; ++i)
{
for (int j = 0; j < dimension; ++j)
{
GameObject element = GameObject.CreatePrimitive(PrimitiveType.Sphere);
element.name = "Element" + (i * dimension + j);
element.transform.parent = transform;
element.transform.localPosition = position;
element.transform.localRotation = Quaternion.Euler(localRotation);
position.x += positionOffset;
Material newMaterial = new Material(material);
newMaterial.SetFloat(firstPropertyId, firstProperty);
newMaterial.SetFloat(secondPropertyId, secondProperty);
Renderer _renderer = element.GetComponent <Renderer>();
MeshFilter meshFilter = element.GetComponent <MeshFilter>();
if (Application.isPlaying == true)
{
_renderer.material = newMaterial;
if (mesh != null)
{
meshFilter.mesh = mesh;
Destroy(element.GetComponent <SphereCollider>());
element.AddComponent <MeshCollider>();
}
}
else
{
_renderer.sharedMaterial = newMaterial;
if (mesh != null)
{
meshFilter.mesh = mesh;
DestroyImmediate(element.GetComponent <SphereCollider>());
element.AddComponent <MeshCollider>();
}
}
firstProperty += 1.0f / (dimension - 1);
}
position.x = center;
position.z += positionOffset;
firstProperty = 0.0f;
secondProperty += 1.0f / (dimension - 1);
}
}
public void TearDown()
{
GameObjectExtensions.DestroyGameObject(testCamera.gameObject);
}
