Zelfstudie: Stapsgewijze instructies voor het maken van een nieuwe HoloLens Unity-app met behulp van Azure Spatial Anchors
In deze zelfstudie wordt beschreven hoe u een nieuwe HoloLens Unity-app maakt met behulp van Azure Spatial Anchors.
Vereisten
Het volgende moet zijn geïnstalleerd om deze zelfstudie te voltooien:
- Pc - een pc met Windows
- Visual Studio Visual Studio - 2019 geïnstalleerd met de Universeel Windows-platform ontwikkelworkload en het onderdeel Windows 10 SDK (10.0.18362.0 of hoger). De C++/WinRT Visual Studio Extension (VSIX) voor Visual Studio moet worden geïnstalleerd vanuit de Visual Studio Marketplace.
- HoloLens : een HoloLens-apparaat waarvoor de ontwikkelaarsmodus is ingeschakeld. Voor dit artikel is een HoloLens-apparaat met de Update voor Windows van 10 mei 2020 nodig. Als u wilt bijwerken naar de nieuwste release op HoloLens, opent u de app Instellingen, gaat u naar Bijwerken en beveiliging en selecteert u vervolgens de knop Controleren op updates.
- Unity - Unity 2020.3.25 met modules Universeel Windows-platform Build Support en Windows Build Support (IL2CPP)
Unity Project maken en instellen
Nieuw project maken
- Selecteer nieuw project in Unity Hub
- 3D selecteren
- Voer uw projectnaam in en voer een opslaglocatie in
- Selecteer Project maken en wacht tot Unity uw project heeft gemaakt
Buildplatform wijzigen
- Selecteer in uw Unity-editor de optie File>Build Instellingen
- Selecteer Universeel Windows-platform en schakel platform over. Wacht tot unity alle bestanden heeft verwerkt.
ASA en OpenXR importeren
- Hulpprogramma voor mixed reality-functies starten
- Selecteer uw projectpad - de map met mappen zoals Assets, Pakketten, Project Instellingen, enzovoort - en selecteer Functies ontdekken
- Selecteer onder Azure Mixed Reality Services beide
- Azure Spatial Anchors SDK Core
- Azure Spatial Anchors SDK voor Windows
- Selecteer onder Platformondersteuning de optie
- Mixed Reality OpenXR-invoegtoepassing
Notitie
Zorg ervoor dat u de catalogus hebt vernieuwd en dat de nieuwste versie voor elke versie is geselecteerd
- Druk op Functies ophalen -->Importeren -->Goedkeuren -->Afsluiten
- Wanneer u uw Unity-venster opnieuw focust, begint Unity met het importeren van de modules
- Als u een bericht krijgt over het gebruik van het nieuwe invoersysteem, selecteert u Ja om Unity opnieuw op te starten en de back-ends in te schakelen.
De projectinstellingen instellen
We gaan nu enkele Unity-projectinstellingen instellen die ons helpen de Windows Holographic SDK te richten op ontwikkeling.
OpenXR-Instellingen wijzigen
- Selecteer Bestandsbuild>Instellingen (deze is mogelijk nog steeds geopend in de vorige stap)
- Selecteer Player Instellingen...
- XR-invoegtoepassingsbeheer selecteren
- Zorg ervoor dat het tabblad Universeel Windows-platform Instellingen is ingeschakeld en schakel het selectievakje naast OpenXR en naast de Microsoft HoloLens-functiegroep in
- Selecteer het gele waarschuwingsteken naast OpenXR om alle OpenXR-problemen weer te geven.
- Alles herstellen selecteren
- Als u het probleem 'Ten minste één interactieprofiel moet worden toegevoegd' wilt oplossen, selecteert u Bewerken om de OpenXR Project-instellingen te openen. Selecteer vervolgens onder Interactieprofielen het + symbool en selecteer Microsoft HandInteractieprofiel
Kwaliteit Instellingen wijzigen
- Selecteer Edit>Project Settings>Quality
- Selecteer in de kolom onder het Universeel Windows-platform logo de pijl in de standaardrij en selecteer Zeer laag. U weet dat de instelling correct wordt toegepast wanneer het vak in de kolom Universeel Windows-platform en zeer laag groen is.
Mogelijkheden instellen
- Ga naar Project bewerken>Instellingen> Player (mogelijk hebt u het nog geopend in de vorige stap).
- Zorg ervoor dat het tabblad Universeel Windows-platform Instellingen is geselecteerd
- Schakel in de sectie Publicatie Instellingen Configuratie het volgende in
- InternetClient
- InternetClientServer
- PrivateNetworkClientServer
- SpatialPerception (mogelijk al ingeschakeld)
De hoofdcamera instellen
- Selecteer in het Hierarchy Panel de optie Main Camera.
- Stel in de Inspector de transformatiepositie in op 0,0,0.
- Zoek de eigenschap Clear Flags op en wijzig de vervolgkeuzelijst van Skybox in Solid Color.
- Selecteer het veld Achtergrond om een kleurkiezer te openen.
- Stel R, G, B en A in op 0.
- Selecteer Component toevoegen onderaan en voeg het onderdeel Tracked Pose Driver toe aan de camera
Probeer het uit #1
U moet nu een lege scène hebben die klaar is om te worden geïmplementeerd op uw HoloLens-apparaat. Als u wilt testen of alles werkt, bouwt u uw app in Unity en implementeert u deze vanuit Visual Studio. Volg Visual Studio gebruiken om dit te implementeren en fouten op te sporen. U moet nu het startscherm van Unity zien en vervolgens een duidelijke weergave.
Een Spatial Anchors-resource maken
Ga naar de Azure-portal.
Selecteer Een resource maken in het linkerdeelvenster.
Gebruik het zoekvak om te zoeken naar Spatial Anchors.
Selecteer Spatial Anchors en vervolgens Maken.
Doe in het deelvenster Spatial Anchors-account het volgende:
Voer een unieke resourcenaam in met gewone alfanumerieke tekens.
Selecteer het abonnement waaraan u de resource wilt koppelen.
Maak een resourcegroep door Nieuwe maken te selecteren. Noem deze myResourceGroup en selecteer OK.
Een resourcegroep is een logische container waarin Azure-resources, zoals web-apps, databases en opslagaccounts, worden geïmplementeerd en beheerd. U kunt bijvoorbeeld later de hele resourcegroep in één stap verwijderen.
Selecteer de locatie (regio) waarin u de resource wilt plaatsen.
Selecteer Maken om de resource te maken.
Nadat de resource is gemaakt, ziet u in de Azure-portal dat uw implementatie is voltooid.
Selecteer Naar resource. Nu kunt u de resource-eigenschappen bekijken.
Kopieer de waarde bij Account-id van de resource naar een teksteditor om later te gebruiken.
Kopieer ook de waarde bij Accountdomein van de resource naar een teksteditor om later te gebruiken.
Selecteer Toegangssleutel onder Instellingen. Kopieer de waarde bij Primaire sleutel, Accountsleutel, naar een teksteditor om later te gebruiken.
Scripts maken en toevoegen
- Maak in Unity in het deelvenster Project een nieuwe map met de naam Scripts in de map Assets.
- Klik in de map met de rechtermuisknop op ->Create ->C#Script. Titel van AzureSpatialAnchorsScript
- Ga naar GameObject ->Create Empty.
- Selecteer deze en wijzig de naam van GameObject in AzureSpatialAnchors in Inspector.
- Nog steeds op de
GameObject- Stel de positie in op 0,0,0
- Selecteer Component toevoegen en zoek en voeg het AzureSpatialAnchorsScript toe
- Selecteer Component toevoegen opnieuw en zoek en voeg AR Anchor Manager toe. Hiermee wordt ook automatisch AR Session Origin toegevoegd.
- Selecteer Component toevoegen opnieuw en zoek en voeg het SpatialAnchorManager-script toe
- Vul in het toegevoegde onderdeel SpatialAnchorManager het account-id, de accountsleutel en het accountdomein in die u in de vorige stap hebt gekopieerd uit de resource spatial anchors in Azure Portal.
App-overzicht
Onze app biedt ondersteuning voor de volgende interacties:
| Gebaar | Actie |
|---|---|
| Tik ergens op | Start/Continue sessie + Anker maken bij handpositie |
| Tikken op een anker | Delete GameObject + Delete Anchor in ASA Cloud Service |
| Tik op + Wachtstand voor 2 sec (+ sessie wordt uitgevoerd) | Stop de sessie en verwijder alle GameObjects. Ankers behouden in ASA Cloud Service |
| Tik op + Wachtstand voor 2 sec (+ sessie wordt niet uitgevoerd) | Start de sessie en zoek naar alle ankers. |
Tikherkenning toevoegen
Laten we code toevoegen aan ons script om de tikbeweging van een gebruiker te herkennen.
- Open
AzureSpatialAnchorsScript.csin Visual Studio door te dubbelklikken op het script in het deelvenster Unity Project. - Voeg de volgende matrix toe aan uw klasse
public class AzureSpatialAnchorsScript : MonoBehaviour
{
/// <summary>
/// Used to distinguish short taps and long taps
/// </summary>
private float[] _tappingTimer = { 0, 0 };
- Voeg de volgende twee methoden toe onder de methode Update(). We voegen in een later stadium implementatie toe
// Update is called once per frame
void Update()
{
}
/// <summary>
/// Called when a user is air tapping for a short time
/// </summary>
/// <param name="handPosition">Location where tap was registered</param>
private async void ShortTap(Vector3 handPosition)
{
}
/// <summary>
/// Called when a user is air tapping for a long time (>=2 sec)
/// </summary>
private async void LongTap()
{
}
- Voeg de volgende import toe
using UnityEngine.XR;
- Voeg de volgende code toe bovenaan de
Update()methode. Hierdoor kan de app korte en lange bewegingen (2 sec) herkennen
// Update is called once per frame
void Update()
{
//Check for any air taps from either hand
for (int i = 0; i < 2; i++)
{
InputDevice device = InputDevices.GetDeviceAtXRNode((i == 0) ? XRNode.RightHand : XRNode.LeftHand);
if (device.TryGetFeatureValue(CommonUsages.primaryButton, out bool isTapping))
{
if (!isTapping)
{
//Stopped Tapping or wasn't tapping
if (0f < _tappingTimer[i] && _tappingTimer[i] < 1f)
{
//User has been tapping for less than 1 sec. Get hand position and call ShortTap
if (device.TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 handPosition))
{
ShortTap(handPosition);
}
}
_tappingTimer[i] = 0;
}
else
{
_tappingTimer[i] += Time.deltaTime;
if (_tappingTimer[i] >= 2f)
{
//User has been air tapping for at least 2sec. Get hand position and call LongTap
if (device.TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 handPosition))
{
LongTap();
}
_tappingTimer[i] = -float.MaxValue; // reset the timer, to avoid retriggering if user is still holding tap
}
}
}
}
}
SpatialAnchorManager toevoegen en configureren
De ASA SDK biedt een eenvoudige interface die wordt aangeroepen SpatialAnchorManager om de ASA-service aan te roepen. Laten we het toevoegen als een variabele aan onze AzureSpatialAnchorsScript.cs
Voeg eerst de import toe
using Microsoft.Azure.SpatialAnchors.Unity;
Declareer vervolgens de variabele
public class AzureSpatialAnchorsScript : MonoBehaviour
{
/// <summary>
/// Used to distinguish short taps and long taps
/// </summary>
private float[] _tappingTimer = { 0, 0 };
/// <summary>
/// Main interface to anything Spatial Anchors related
/// </summary>
private SpatialAnchorManager _spatialAnchorManager = null;
Wijs in de Start() methode de variabele toe aan het onderdeel dat we in een vorige stap hebben toegevoegd
// Start is called before the first frame update
void Start()
{
_spatialAnchorManager = GetComponent<SpatialAnchorManager>();
}
Als u foutopsporings- en foutenlogboeken wilt ontvangen, moeten we ons abonneren op de verschillende callbacks
// Start is called before the first frame update
void Start()
{
_spatialAnchorManager = GetComponent<SpatialAnchorManager>();
_spatialAnchorManager.LogDebug += (sender, args) => Debug.Log($"ASA - Debug: {args.Message}");
_spatialAnchorManager.Error += (sender, args) => Debug.LogError($"ASA - Error: {args.ErrorMessage}");
}
Notitie
Als u de logboeken wilt weergeven, zorgt u ervoor dat nadat u het project hebt gemaakt vanuit Unity en u de visual studio-oplossing hebt geopend .sln, selecteert u Debug-> Voer de foutopsporing uit en laat u uw HoloLens verbonden met uw computer terwijl de app wordt uitgevoerd.
Sessie starten
Om ankers te maken en te vinden, moeten we eerst een sessie starten. Wanneer u belt StartSessionAsync(), SpatialAnchorManager maakt u indien nodig een sessie en start u deze. Laten we dit toevoegen aan onze ShortTap() methode.
/// <summary>
/// Called when a user is air tapping for a short time
/// </summary>
/// <param name="handPosition">Location where tap was registered</param>
private async void ShortTap(Vector3 handPosition)
{
await _spatialAnchorManager.StartSessionAsync();
}
Anker maken
Nu we een sessie hebben die wordt uitgevoerd, kunnen we ankers maken. In deze toepassing willen we het gemaakte anker GameObjects en de gemaakte anker-id's (anker-id's) bijhouden. Laten we twee lijsten toevoegen aan onze code.
using Microsoft.Azure.SpatialAnchors.Unity;
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.XR;
/// <summary>
/// Main interface to anything Spatial Anchors related
/// </summary>
private SpatialAnchorManager _spatialAnchorManager = null;
/// <summary>
/// Used to keep track of all GameObjects that represent a found or created anchor
/// </summary>
private List<GameObject> _foundOrCreatedAnchorGameObjects = new List<GameObject>();
/// <summary>
/// Used to keep track of all the created Anchor IDs
/// </summary>
private List<String> _createdAnchorIDs = new List<String>();
We gaan een methode CreateAnchor maken waarmee een anker wordt gemaakt op een positie die is gedefinieerd door de parameter.
using System.Threading.Tasks;
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
}
Omdat ruimtelijke ankers niet alleen een positie hebben, maar ook een draaiing, gaan we de draaiing zo instellen dat ze altijd gericht zijn op de HoloLens bij het maken.
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
}
Nu we de positie en draaiing van het gewenste anker hebben, gaan we een zichtbaar GameObjectanker maken. Houd er rekening mee dat Spatial Anchors niet vereist dat het anker GameObject zichtbaar is voor de eindgebruiker, omdat het belangrijkste doel van Spatial Anchors is om een gemeenschappelijk en permanent referentiekader te bieden. Voor deze zelfstudie visualiseren we de ankers als kubussen. Elk anker wordt geïnitialiseerd als een witte kubus, die wordt omgezet in een groene kubus zodra het aanmaakproces is voltooid.
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.transform.position = position;
anchorGameObject.transform.rotation = orientationTowardsHead;
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
}
Notitie
We gebruiken een verouderde shader, omdat deze is opgenomen in een standaard Unity-build. Andere shaders, zoals de standaard-shader, worden alleen opgenomen als ze handmatig zijn opgegeven of rechtstreeks deel uitmaken van de scène. Als een shader niet is opgenomen en de toepassing deze probeert weer te geven, resulteert dit in een roze materiaal.
Nu gaan we de Spatial Anchor-onderdelen toevoegen en configureren. We stellen de vervaldatum van het anker in op 3 dagen na het maken van het anker. Daarna worden ze automatisch uit de cloud verwijderd. Vergeet niet om de import toe te voegen
using Microsoft.Azure.SpatialAnchors;
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.transform.position = position;
anchorGameObject.transform.rotation = orientationTowardsHead;
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
//Add and configure ASA components
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.AddComponent<CloudNativeAnchor>();
await cloudNativeAnchor.NativeToCloud();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
cloudSpatialAnchor.Expiration = DateTimeOffset.Now.AddDays(3);
}
Om een anker op te slaan, moet de gebruiker omgevingsgegevens verzamelen.
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.transform.position = position;
anchorGameObject.transform.rotation = orientationTowardsHead;
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
//Add and configure ASA components
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.AddComponent<CloudNativeAnchor>();
await cloudNativeAnchor.NativeToCloud();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
cloudSpatialAnchor.Expiration = DateTimeOffset.Now.AddDays(3);
//Collect Environment Data
while (!_spatialAnchorManager.IsReadyForCreate)
{
float createProgress = _spatialAnchorManager.SessionStatus.RecommendedForCreateProgress;
Debug.Log($"ASA - Move your device to capture more environment data: {createProgress:0%}");
}
}
Notitie
Een HoloLens kan mogelijk al vastgelegde omgevingsgegevens rondom het anker hergebruiken, wat resulteert in IsReadyForCreate waar al wanneer deze voor de eerste keer wordt aangeroepen.
Nu het ruimtelijke anker in de cloud is voorbereid, kunnen we de werkelijke opslag hier proberen.
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.transform.position = position;
anchorGameObject.transform.rotation = orientationTowardsHead;
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
//Add and configure ASA components
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.AddComponent<CloudNativeAnchor>();
await cloudNativeAnchor.NativeToCloud();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
cloudSpatialAnchor.Expiration = DateTimeOffset.Now.AddDays(3);
//Collect Environment Data
while (!_spatialAnchorManager.IsReadyForCreate)
{
float createProgress = _spatialAnchorManager.SessionStatus.RecommendedForCreateProgress;
Debug.Log($"ASA - Move your device to capture more environment data: {createProgress:0%}");
}
Debug.Log($"ASA - Saving cloud anchor... ");
try
{
// Now that the cloud spatial anchor has been prepared, we can try the actual save here.
await _spatialAnchorManager.CreateAnchorAsync(cloudSpatialAnchor);
bool saveSucceeded = cloudSpatialAnchor != null;
if (!saveSucceeded)
{
Debug.LogError("ASA - Failed to save, but no exception was thrown.");
return;
}
Debug.Log($"ASA - Saved cloud anchor with ID: {cloudSpatialAnchor.Identifier}");
_foundOrCreatedAnchorGameObjects.Add(anchorGameObject);
_createdAnchorIDs.Add(cloudSpatialAnchor.Identifier);
anchorGameObject.GetComponent<MeshRenderer>().material.color = Color.green;
}
catch (Exception exception)
{
Debug.Log("ASA - Failed to save anchor: " + exception.ToString());
Debug.LogException(exception);
}
}
Ten slotte gaan we de functie-aanroep toevoegen aan onze ShortTap methode
/// <summary>
/// Called when a user is air tapping for a short time
/// </summary>
/// <param name="handPosition">Location where tap was registered</param>
private async void ShortTap(Vector3 handPosition)
{
await _spatialAnchorManager.StartSessionAsync();
await CreateAnchor(handPosition);
}
Onze app kan nu meerdere ankers maken. Elk apparaat kan nu de gemaakte ankers vinden (indien nog niet verlopen) zolang ze de anker-id's kennen en toegang hebben tot dezelfde Spatial Anchors-resource in Azure.
Sessie stoppen en GameObjects vernietigen
Als u een tweede apparaat wilt emuleren om alle ankers te vinden, stoppen we de sessie en verwijderen we alle anchor GameObjects (we behouden de anker-id's). Daarna starten we een nieuwe sessie en voeren we een query uit op de ankers met behulp van de opgeslagen anker-id's.
SpatialAnchorManager kan ervoor zorgen dat de sessie wordt gestopt door simpelweg de methode aan DestroySession() te roepen. Laten we dit toevoegen aan onze LongTap() methode
/// <summary>
/// Called when a user is air tapping for a long time (>=2 sec)
/// </summary>
private async void LongTap()
{
_spatialAnchorManager.DestroySession();
}
Laten we een methode maken om alle ankers te verwijderen GameObjects
/// <summary>
/// Destroys all Anchor GameObjects
/// </summary>
private void RemoveAllAnchorGameObjects()
{
foreach (var anchorGameObject in _foundOrCreatedAnchorGameObjects)
{
Destroy(anchorGameObject);
}
_foundOrCreatedAnchorGameObjects.Clear();
}
En noem het na het vernietigen van de sessie in LongTap()
/// <summary>
/// Called when a user is air tapping for a long time (>=2 sec)
/// </summary>
private async void LongTap()
{
// Stop Session and remove all GameObjects. This does not delete the Anchors in the cloud
_spatialAnchorManager.DestroySession();
RemoveAllAnchorGameObjects();
Debug.Log("ASA - Stopped Session and removed all Anchor Objects");
}
Anker zoeken
We proberen nu de ankers opnieuw te vinden met de juiste positie en draaiing waarin we ze hebben gemaakt. Hiervoor moeten we een sessie starten en een Watcher sessie maken die zoekt naar ankers die voldoen aan de opgegeven criteria. Als criterium voeren we de id's van de ankers die we eerder hebben gemaakt. Laten we een methode LocateAnchor() maken en gebruiken SpatialAnchorManager om een Watcher. Zie De ankerzoekstrategie voor andere strategieën dan het gebruik van anker-id's
/// <summary>
/// Looking for anchors with ID in _createdAnchorIDs
/// </summary>
private void LocateAnchor()
{
if (_createdAnchorIDs.Count > 0)
{
//Create watcher to look for all stored anchor IDs
Debug.Log($"ASA - Creating watcher to look for {_createdAnchorIDs.Count} spatial anchors");
AnchorLocateCriteria anchorLocateCriteria = new AnchorLocateCriteria();
anchorLocateCriteria.Identifiers = _createdAnchorIDs.ToArray();
_spatialAnchorManager.Session.CreateWatcher(anchorLocateCriteria);
Debug.Log($"ASA - Watcher created!");
}
}
Zodra een watcher is gestart, wordt er een callback geactiveerd wanneer er een anker is gevonden dat voldoet aan de opgegeven criteria. Laten we eerst onze ankermethode maken die wordt aangeroepen SpatialAnchorManager_AnchorLocated() om te worden aangeroepen wanneer de watcher een anker heeft gevonden. Met deze methode maakt u een visual GameObject en koppelt u het systeemeigen ankeronderdeel eraan. Het systeemeigen ankeronderdeel zorgt ervoor dat de juiste positie en draaiing van de GameObject component is ingesteld.
Net als bij het aanmaakproces wordt het anker gekoppeld aan een GameObject. Dit GameObject hoeft niet zichtbaar te zijn in uw scène om ruimtelijke ankers te laten werken. Voor deze zelfstudie visualiseren we elk anker als een blauwe kubus zodra ze zich hebben gevonden. Als u alleen het anker gebruikt om een gedeeld coördinaatsysteem tot stand te brengen, hoeft u het gemaakte GameObject niet te visualiseren.
/// <summary>
/// Callback when an anchor is located
/// </summary>
/// <param name="sender">Callback sender</param>
/// <param name="args">Callback AnchorLocatedEventArgs</param>
private void SpatialAnchorManager_AnchorLocated(object sender, AnchorLocatedEventArgs args)
{
Debug.Log($"ASA - Anchor recognized as a possible anchor {args.Identifier} {args.Status}");
if (args.Status == LocateAnchorStatus.Located)
{
//Creating and adjusting GameObjects have to run on the main thread. We are using the UnityDispatcher to make sure this happens.
UnityDispatcher.InvokeOnAppThread(() =>
{
// Read out Cloud Anchor values
CloudSpatialAnchor cloudSpatialAnchor = args.Anchor;
//Create GameObject
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.GetComponent<MeshRenderer>().material.color = Color.blue;
// Link to Cloud Anchor
anchorGameObject.AddComponent<CloudNativeAnchor>().CloudToNative(cloudSpatialAnchor);
_foundOrCreatedAnchorGameObjects.Add(anchorGameObject);
});
}
}
Laten we ons nu abonneren op de callback AnchorLocated van SpatialAnchorManager waaruit we ervoor zorgen dat onze SpatialAnchorManager_AnchorLocated() methode wordt aangeroepen zodra de watcher een anker heeft gevonden.
// Start is called before the first frame update
void Start()
{
_spatialAnchorManager = GetComponent<SpatialAnchorManager>();
_spatialAnchorManager.LogDebug += (sender, args) => Debug.Log($"ASA - Debug: {args.Message}");
_spatialAnchorManager.Error += (sender, args) => Debug.LogError($"ASA - Error: {args.ErrorMessage}");
_spatialAnchorManager.AnchorLocated += SpatialAnchorManager_AnchorLocated;
}
Ten slotte gaan we onze LongTap() methode uitbreiden om het anker te vinden. We gebruiken de IsSessionStarted Booleaanse waarde om te bepalen of we op zoek zijn naar alle ankers of alle ankers vernietigen, zoals beschreven in het app-overzicht
/// <summary>
/// Called when a user is air tapping for a long time (>=2 sec)
/// </summary>
private async void LongTap()
{
if (_spatialAnchorManager.IsSessionStarted)
{
// Stop Session and remove all GameObjects. This does not delete the Anchors in the cloud
_spatialAnchorManager.DestroySession();
RemoveAllAnchorGameObjects();
Debug.Log("ASA - Stopped Session and removed all Anchor Objects");
}
else
{
//Start session and search for all Anchors previously created
await _spatialAnchorManager.StartSessionAsync();
LocateAnchor();
}
}
Probeer het uit #2
Uw app ondersteunt nu het maken van ankers en het vinden ervan. Bouw uw app in Unity en implementeer deze vanuit Visual Studio door Visual Studio te volgen om visual studio te implementeren en fouten op te sporen.
Controleer of uw HoloLens verbinding heeft met internet. Zodra de app is gestart en het gemaakte bericht met Unity verdwijnt, tikt u kort op uw omgeving. Er moet een witte kubus verschijnen om de positie en draaiing van het te maken anker weer te geven. Het proces voor het maken van ankers wordt automatisch aangeroepen. Terwijl u langzaam rond uw omgeving kijkt, legt u omgevingsgegevens vast. Zodra er voldoende omgevingsgegevens zijn verzameld, probeert onze app een anker te maken op de opgegeven locatie. Zodra het proces voor het maken van het anker is voltooid, wordt de kubus groen. Controleer uw logboeken voor foutopsporing in Visual Studio om te zien of alles werkt zoals bedoeld.
Lang tikken om alles GameObjects uit uw scène te verwijderen en de sessie voor ruimtelijk anker te stoppen.
Zodra uw scène is gewist, kunt u lang nogmaals tikken, waardoor een sessie wordt gestart en wordt gezocht naar de ankers die u eerder hebt gemaakt. Zodra ze zijn gevonden, worden ze gevisualiseerd door blauwe kubussen op de verankerde positie en rotatie. Deze ankers (zolang ze niet verlopen zijn) kunnen worden gevonden door elk ondersteund apparaat zolang ze de juiste anker-id's hebben en toegang hebben tot uw ruimtelijke ankerresource.
Anker verwijderen
Op dit moment kan onze app ankers maken en vinden. Terwijl het GameObjectswordt verwijderd, wordt het anker niet in de cloud verwijderd. Laten we de functionaliteit toevoegen om deze ook in de cloud te verwijderen als u op een bestaand anker tikt.
Laten we een methode DeleteAnchor toevoegen die een GameObject. Vervolgens gebruiken we het SpatialAnchorManager onderdeel van het object CloudNativeAnchor om het anker in de cloud te verwijderen.
/// <summary>
/// Deleting Cloud Anchor attached to the given GameObject and deleting the GameObject
/// </summary>
/// <param name="anchorGameObject">Anchor GameObject that is to be deleted</param>
private async void DeleteAnchor(GameObject anchorGameObject)
{
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.GetComponent<CloudNativeAnchor>();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
Debug.Log($"ASA - Deleting cloud anchor: {cloudSpatialAnchor.Identifier}");
//Request Deletion of Cloud Anchor
await _spatialAnchorManager.DeleteAnchorAsync(cloudSpatialAnchor);
//Remove local references
_createdAnchorIDs.Remove(cloudSpatialAnchor.Identifier);
_foundOrCreatedAnchorGameObjects.Remove(anchorGameObject);
Destroy(anchorGameObject);
Debug.Log($"ASA - Cloud anchor deleted!");
}
Als u deze methode ShortTapwilt aanroepen, moeten we kunnen bepalen of een tik in de buurt van een bestaand zichtbaar anker is geweest. Laten we een helpermethode maken die hiervoor zorgt
using System.Linq;
/// <summary>
/// Returns true if an Anchor GameObject is within 15cm of the received reference position
/// </summary>
/// <param name="position">Reference position</param>
/// <param name="anchorGameObject">Anchor GameObject within 15cm of received position. Not necessarily the nearest to this position. If no AnchorObject is within 15cm, this value will be null</param>
/// <returns>True if a Anchor GameObject is within 15cm</returns>
private bool IsAnchorNearby(Vector3 position, out GameObject anchorGameObject)
{
anchorGameObject = null;
if (_foundOrCreatedAnchorGameObjects.Count <= 0)
{
return false;
}
//Iterate over existing anchor gameobjects to find the nearest
var (distance, closestObject) = _foundOrCreatedAnchorGameObjects.Aggregate(
new Tuple<float, GameObject>(Mathf.Infinity, null),
(minPair, gameobject) =>
{
Vector3 gameObjectPosition = gameobject.transform.position;
float distance = (position - gameObjectPosition).magnitude;
return distance < minPair.Item1 ? new Tuple<float, GameObject>(distance, gameobject) : minPair;
});
if (distance <= 0.15f)
{
//Found an anchor within 15cm
anchorGameObject = closestObject;
return true;
}
else
{
return false;
}
}
We kunnen nu onze ShortTap methode uitbreiden om de DeleteAnchor aanroep op te nemen
/// <summary>
/// Called when a user is air tapping for a short time
/// </summary>
/// <param name="handPosition">Location where tap was registered</param>
private async void ShortTap(Vector3 handPosition)
{
await _spatialAnchorManager.StartSessionAsync();
if (!IsAnchorNearby(handPosition, out GameObject anchorGameObject))
{
//No Anchor Nearby, start session and create an anchor
await CreateAnchor(handPosition);
}
else
{
//Delete nearby Anchor
DeleteAnchor(anchorGameObject);
}
}
Probeer het #3
Bouw uw app in Unity en implementeer deze vanuit Visual Studio door Visual Studio te volgen om visual studio te implementeren en fouten op te sporen.
Houd er rekening mee dat de locatie van uw handtikkenbeweging het midden van uw hand in deze app is en niet de punt van uw vingers.
Wanneer u op een anker tikt, wordt er (groen) of (blauw) een aanvraag verzonden naar de service voor ruimtelijk anker om dit anker uit het account te verwijderen. Stop de sessie (lange tik) en start de sessie opnieuw (lange tik) om te zoeken naar alle ankers. De verwijderde ankers bevinden zich niet meer.
Alles bij elkaar
Hier ziet u hoe het volledige klassebestand AzureSpatialAnchorsScript eruit moet zien, nadat alle verschillende elementen bij elkaar zijn geplaatst. U kunt deze gebruiken ter referentie om te vergelijken met uw eigen bestand, en om te controleren of er verschillen zijn opgetreden.
Notitie
U zult merken dat we het script hebben opgenomen [RequireComponent(typeof(SpatialAnchorManager))] . Met dit zorgt Unity ervoor dat het GameObject waaraan we koppelen AzureSpatialAnchorsScript ook de SpatialAnchorManager gekoppelde gameobject heeft.
using Microsoft.Azure.SpatialAnchors;
using Microsoft.Azure.SpatialAnchors.Unity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using UnityEngine;
using UnityEngine.XR;
[RequireComponent(typeof(SpatialAnchorManager))]
public class AzureSpatialAnchorsScript : MonoBehaviour
{
/// <summary>
/// Used to distinguish short taps and long taps
/// </summary>
private float[] _tappingTimer = { 0, 0 };
/// <summary>
/// Main interface to anything Spatial Anchors related
/// </summary>
private SpatialAnchorManager _spatialAnchorManager = null;
/// <summary>
/// Used to keep track of all GameObjects that represent a found or created anchor
/// </summary>
private List<GameObject> _foundOrCreatedAnchorGameObjects = new List<GameObject>();
/// <summary>
/// Used to keep track of all the created Anchor IDs
/// </summary>
private List<String> _createdAnchorIDs = new List<String>();
// <Start>
// Start is called before the first frame update
void Start()
{
_spatialAnchorManager = GetComponent<SpatialAnchorManager>();
_spatialAnchorManager.LogDebug += (sender, args) => Debug.Log($"ASA - Debug: {args.Message}");
_spatialAnchorManager.Error += (sender, args) => Debug.LogError($"ASA - Error: {args.ErrorMessage}");
_spatialAnchorManager.AnchorLocated += SpatialAnchorManager_AnchorLocated;
}
// </Start>
// <Update>
// Update is called once per frame
void Update()
{
//Check for any air taps from either hand
for (int i = 0; i < 2; i++)
{
InputDevice device = InputDevices.GetDeviceAtXRNode((i == 0) ? XRNode.RightHand : XRNode.LeftHand);
if (device.TryGetFeatureValue(CommonUsages.primaryButton, out bool isTapping))
{
if (!isTapping)
{
//Stopped Tapping or wasn't tapping
if (0f < _tappingTimer[i] && _tappingTimer[i] < 1f)
{
//User has been tapping for less than 1 sec. Get hand position and call ShortTap
if (device.TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 handPosition))
{
ShortTap(handPosition);
}
}
_tappingTimer[i] = 0;
}
else
{
_tappingTimer[i] += Time.deltaTime;
if (_tappingTimer[i] >= 2f)
{
//User has been air tapping for at least 2sec. Get hand position and call LongTap
if (device.TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 handPosition))
{
LongTap();
}
_tappingTimer[i] = -float.MaxValue; // reset the timer, to avoid retriggering if user is still holding tap
}
}
}
}
}
// </Update>
// <ShortTap>
/// <summary>
/// Called when a user is air tapping for a short time
/// </summary>
/// <param name="handPosition">Location where tap was registered</param>
private async void ShortTap(Vector3 handPosition)
{
await _spatialAnchorManager.StartSessionAsync();
if (!IsAnchorNearby(handPosition, out GameObject anchorGameObject))
{
//No Anchor Nearby, start session and create an anchor
await CreateAnchor(handPosition);
}
else
{
//Delete nearby Anchor
DeleteAnchor(anchorGameObject);
}
}
// </ShortTap>
// <LongTap>
/// <summary>
/// Called when a user is air tapping for a long time (>=2 sec)
/// </summary>
private async void LongTap()
{
if (_spatialAnchorManager.IsSessionStarted)
{
// Stop Session and remove all GameObjects. This does not delete the Anchors in the cloud
_spatialAnchorManager.DestroySession();
RemoveAllAnchorGameObjects();
Debug.Log("ASA - Stopped Session and removed all Anchor Objects");
}
else
{
//Start session and search for all Anchors previously created
await _spatialAnchorManager.StartSessionAsync();
LocateAnchor();
}
}
// </LongTap>
// <RemoveAllAnchorGameObjects>
/// <summary>
/// Destroys all Anchor GameObjects
/// </summary>
private void RemoveAllAnchorGameObjects()
{
foreach (var anchorGameObject in _foundOrCreatedAnchorGameObjects)
{
Destroy(anchorGameObject);
}
_foundOrCreatedAnchorGameObjects.Clear();
}
// </RemoveAllAnchorGameObjects>
// <IsAnchorNearby>
/// <summary>
/// Returns true if an Anchor GameObject is within 15cm of the received reference position
/// </summary>
/// <param name="position">Reference position</param>
/// <param name="anchorGameObject">Anchor GameObject within 15cm of received position. Not necessarily the nearest to this position. If no AnchorObject is within 15cm, this value will be null</param>
/// <returns>True if a Anchor GameObject is within 15cm</returns>
private bool IsAnchorNearby(Vector3 position, out GameObject anchorGameObject)
{
anchorGameObject = null;
if (_foundOrCreatedAnchorGameObjects.Count <= 0)
{
return false;
}
//Iterate over existing anchor gameobjects to find the nearest
var (distance, closestObject) = _foundOrCreatedAnchorGameObjects.Aggregate(
new Tuple<float, GameObject>(Mathf.Infinity, null),
(minPair, gameobject) =>
{
Vector3 gameObjectPosition = gameobject.transform.position;
float distance = (position - gameObjectPosition).magnitude;
return distance < minPair.Item1 ? new Tuple<float, GameObject>(distance, gameobject) : minPair;
});
if (distance <= 0.15f)
{
//Found an anchor within 15cm
anchorGameObject = closestObject;
return true;
}
else
{
return false;
}
}
// </IsAnchorNearby>
// <CreateAnchor>
/// <summary>
/// Creates an Azure Spatial Anchor at the given position rotated towards the user
/// </summary>
/// <param name="position">Position where Azure Spatial Anchor will be created</param>
/// <returns>Async Task</returns>
private async Task CreateAnchor(Vector3 position)
{
//Create Anchor GameObject. We will use ASA to save the position and the rotation of this GameObject.
if (!InputDevices.GetDeviceAtXRNode(XRNode.Head).TryGetFeatureValue(CommonUsages.devicePosition, out Vector3 headPosition))
{
headPosition = Vector3.zero;
}
Quaternion orientationTowardsHead = Quaternion.LookRotation(position - headPosition, Vector3.up);
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.transform.position = position;
anchorGameObject.transform.rotation = orientationTowardsHead;
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
//Add and configure ASA components
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.AddComponent<CloudNativeAnchor>();
await cloudNativeAnchor.NativeToCloud();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
cloudSpatialAnchor.Expiration = DateTimeOffset.Now.AddDays(3);
//Collect Environment Data
while (!_spatialAnchorManager.IsReadyForCreate)
{
float createProgress = _spatialAnchorManager.SessionStatus.RecommendedForCreateProgress;
Debug.Log($"ASA - Move your device to capture more environment data: {createProgress:0%}");
}
Debug.Log($"ASA - Saving cloud anchor... ");
try
{
// Now that the cloud spatial anchor has been prepared, we can try the actual save here.
await _spatialAnchorManager.CreateAnchorAsync(cloudSpatialAnchor);
bool saveSucceeded = cloudSpatialAnchor != null;
if (!saveSucceeded)
{
Debug.LogError("ASA - Failed to save, but no exception was thrown.");
return;
}
Debug.Log($"ASA - Saved cloud anchor with ID: {cloudSpatialAnchor.Identifier}");
_foundOrCreatedAnchorGameObjects.Add(anchorGameObject);
_createdAnchorIDs.Add(cloudSpatialAnchor.Identifier);
anchorGameObject.GetComponent<MeshRenderer>().material.color = Color.green;
}
catch (Exception exception)
{
Debug.Log("ASA - Failed to save anchor: " + exception.ToString());
Debug.LogException(exception);
}
}
// </CreateAnchor>
// <LocateAnchor>
/// <summary>
/// Looking for anchors with ID in _createdAnchorIDs
/// </summary>
private void LocateAnchor()
{
if (_createdAnchorIDs.Count > 0)
{
//Create watcher to look for all stored anchor IDs
Debug.Log($"ASA - Creating watcher to look for {_createdAnchorIDs.Count} spatial anchors");
AnchorLocateCriteria anchorLocateCriteria = new AnchorLocateCriteria();
anchorLocateCriteria.Identifiers = _createdAnchorIDs.ToArray();
_spatialAnchorManager.Session.CreateWatcher(anchorLocateCriteria);
Debug.Log($"ASA - Watcher created!");
}
}
// </LocateAnchor>
// <SpatialAnchorManagerAnchorLocated>
/// <summary>
/// Callback when an anchor is located
/// </summary>
/// <param name="sender">Callback sender</param>
/// <param name="args">Callback AnchorLocatedEventArgs</param>
private void SpatialAnchorManager_AnchorLocated(object sender, AnchorLocatedEventArgs args)
{
Debug.Log($"ASA - Anchor recognized as a possible anchor {args.Identifier} {args.Status}");
if (args.Status == LocateAnchorStatus.Located)
{
//Creating and adjusting GameObjects have to run on the main thread. We are using the UnityDispatcher to make sure this happens.
UnityDispatcher.InvokeOnAppThread(() =>
{
// Read out Cloud Anchor values
CloudSpatialAnchor cloudSpatialAnchor = args.Anchor;
//Create GameObject
GameObject anchorGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube);
anchorGameObject.transform.localScale = Vector3.one * 0.1f;
anchorGameObject.GetComponent<MeshRenderer>().material.shader = Shader.Find("Legacy Shaders/Diffuse");
anchorGameObject.GetComponent<MeshRenderer>().material.color = Color.blue;
// Link to Cloud Anchor
anchorGameObject.AddComponent<CloudNativeAnchor>().CloudToNative(cloudSpatialAnchor);
_foundOrCreatedAnchorGameObjects.Add(anchorGameObject);
});
}
}
// </SpatialAnchorManagerAnchorLocated>
// <DeleteAnchor>
/// <summary>
/// Deleting Cloud Anchor attached to the given GameObject and deleting the GameObject
/// </summary>
/// <param name="anchorGameObject">Anchor GameObject that is to be deleted</param>
private async void DeleteAnchor(GameObject anchorGameObject)
{
CloudNativeAnchor cloudNativeAnchor = anchorGameObject.GetComponent<CloudNativeAnchor>();
CloudSpatialAnchor cloudSpatialAnchor = cloudNativeAnchor.CloudAnchor;
Debug.Log($"ASA - Deleting cloud anchor: {cloudSpatialAnchor.Identifier}");
//Request Deletion of Cloud Anchor
await _spatialAnchorManager.DeleteAnchorAsync(cloudSpatialAnchor);
//Remove local references
_createdAnchorIDs.Remove(cloudSpatialAnchor.Identifier);
_foundOrCreatedAnchorGameObjects.Remove(anchorGameObject);
Destroy(anchorGameObject);
Debug.Log($"ASA - Cloud anchor deleted!");
}
// </DeleteAnchor>
}
Volgende stappen
In deze zelfstudie hebt u geleerd hoe u een eenvoudige Spatial Anchors-toepassing voor HoloLens implementeert met behulp van Unity. Ga verder met de volgende zelfstudie voor meer informatie over het gebruik van Azure Spatial Anchors in een nieuwe Android-app.