Självstudie: Gränssnitt och anpassade modeller

I den här guiden får du lära dig att:

Förutsättningar

• Den här självstudien bygger på Självstudie: Visa en fjärrre renderad modell.

Kom igång med Mixed Reality Toolkit (MRTK)

The Mixed Reality Toolkit (MRTK) är en plattformsoberoende verktygslåda för att skapa upplevelser med mixad verklighet. Vi använder MRTK 2.5.1 för dess interaktions- och visualiseringsfunktioner.

Om du vill lägga till MRTK följer du de nödvändiga stegen i installationsguiden för MRTK.

Dessa steg är:

• Hämta de senaste MRTK Unity-paketen
  • Även om det står "senaste" använder du version 2.5.1 från MRTK-versionssidan.
  • Vi använder bara Foundation-paketet i den här självstudien. Paketen Tillägg, Verktyg och Exempel krävs inte.
• Importera MRTK-paket till ditt Unity-projekt
• Växla ditt Unity-projekt till målplattformen
  • Du bör ha gjort det här steget redan i det första kapitlet, men nu är ett bra tillfälle att dubbelkolla!
• Lägga till MRTK i en ny scen eller ett nytt projekt
  • Du kan lägga till MRTK i en ny scen och lägga till koordinator- och modellobjekt/skript på nytt, eller så kan du lägga till MRTK till din befintliga scen med hjälp av menykommandot Mixed Reality Toolkit -> Add to Scene (Lägg till i scen) och Configure (Konfigurera).

Importera tillgångar som används i den här självstudien

Från och med det här kapitlet implementerar vi ett enkelt modellvisningskontrollmönster för en stor del av det material som omfattas. Modelldelen av mönstret är den Azure Remote Rendering koden och tillståndshanteringen som rör Azure Remote Rendering. Vyn och kontrollantdelarna i mönstret implementeras med HJÄLP av MRTK-tillgångar och vissa anpassade skript. Det är möjligt att använda modellen i den här självstudien utan att view-controller implementeras här. Med den här separationen kan du enkelt integrera koden som finns i den här självstudien i ditt eget program där den tar över visningskontrolldelen av designmönstret.

Med introduktionen av MRTK finns det ett antal skript, prefab-skript och tillgångar som nu kan läggas till i projektet för att stödja interaktioner och visuell feedback. Dessa tillgångar, som kallas självstudietillgångar, paketeras i ett Unity-tillgångspaket, som ingår i Azure Remote Rendering GitHub i "\Unity\TutorialAssets\TutorialAssets.unitypackage".

1. Klona eller ladda ned git-Azure Remote Rendering, om du laddar ned zip-filen till en känd plats.
2. I ditt Unity-projekt väljer du Assets -> Import Package -> Custom Package.
3. I Utforskaren navigerar du till katalogen där du klonade eller uppackade Azure Remote Rendering-lagringsplatsen och väljer sedan .unitypackage som finns i Unity -> TutorialAssets -> TutorialAssets.unitypackage
4. Välj knappen Importera för att importera innehållet i paketet till projektet.
5. I Unity-redigeraren väljer du Mixed Reality Toolkit -> Utilities -> Upgrade MRTK Standard Shader for Lightweight Render Pipeline (Uppgradera MRTK Standard Shader för Lightweight Render Pipeline) på den översta menyraden och följer anvisningarna för att uppgradera skuggaren.

När MRTK och självstudietillgångarna ingår i projektet växlar vi MRTK-profilen till en som är mer lämplig för självstudien.

1. Välj GameObject för MixedRealityToolkit i scenhierarkin.
2. Under komponenten MixedRealityToolkit i Inspector växlar du konfigurationsprofilen till ARRMixedRealityToolkitConfigurationProfile.
3. Tryck på Ctrl + S för att spara ändringarna.

Detta konfigurerar FRÄMST MRTK med holoLens 2-standardprofilerna. De tillhandahållna profilerna är förkonfigurerade på följande sätt:

• Stäng av profileraren (tryck på 9 för att aktivera/inaktivera den, eller säg "Visa/dölj Profiler" på enheten).
• Stäng av ögonmarkören.
• Aktivera Unity-musklickningar så att du kan klicka på MRTK UI-element med musen i stället för den simulerade handen.

Lägg till appmenyn

De flesta visningskontrollanter i den här självstudien fungerar mot abstrakta basklasser i stället för mot konkreta klasser. Det här mönstret ger mer flexibilitet och gör att vi kan tillhandahålla visningskontrollerna åt dig, samtidigt som vi hjälper dig att lära Azure Remote Rendering kod. För enkelhetens skull har klassen RemoteRenderingCoordinator ingen abstrakt klass och dess visningskontrollant fungerar direkt mot den konkreta klassen.

Nu kan du lägga till prefab AppMenu i scenen för visuell feedback om det aktuella sessionstillståndet. Den här visningsstyrenheten "låser upp" fler undermenyvisningsstyrenheter när vi implementerar och integrerar fler ARR-funktioner i scenen. För tillfället har AppMenu en visuell indikation på ARR-tillståndet och visar den modala panelen som användaren använder för att auktorisera programmet att ansluta till ARR.

1. Leta upp prefab-programmet AppMenu i Assets/RemoteRenderingTutorial/Prefabs/AppMenu

2. Dra Prefab-prefabet AppMenu till scenen.

3. Du ser förmodligen en dialogruta för TMP Importer eftersom det är första gången vi inkluderar Text Mesh Pro-tillgångar i scenen. Följ anvisningarna för att importera TMP Essentials. Stäng sedan importverktygets dialogruta. Exempel och tillägg behövs inte.

4. AppMenu är konfigurerad för att automatiskt ansluta och tillhandahålla modal för medgivande till anslutning till en session, så att vi kan ta bort förbikopplingen som placerats tidigare. På RemoteRenderingCoordinator GameObject tar du bort förbikopplingen för auktorisering som vi implementerade tidigare genom att trycka på knappen "-" på händelsen Begär auktorisering.

   .

5. Testa visningskontrollanten genom att trycka på Spela upp i Unity-redigeraren.

6. Nu när MRTK har konfigurerats i redigeraren kan du använda WASD-tangenterna för att ändra vyns position och hålla höger musknapp + flytta musen för att ändra visningsriktningen. Försök att "köra" runt scenen lite för att få en känsla för kontrollerna.

7. På enheten kan du höja din röst så att AppMenu höjs, i Unity-redigeraren använder du snabbtangenten "M".

8. Om du har tappat bort menyn trycker du på tangenten "M" för att trycka på menyn. Menyn placeras nära kameran för enkel interaktion.

9. Auktoriseringen visas nu som en begäran till höger om AppMenu. Från och med nu använder du den för att auktorisera appen att hantera fjärrrenderingssessioner.

   

10. Stoppa Unity från att spela upp för att fortsätta med självstudien.

Hantera modelltillstånd

Nu implementerar vi ett nytt skript, RemoteRenderedModel, som används för att spåra tillstånd, svara på händelser, köra händelser och konfigurera. I princip lagrar RemoteRenderedModel fjärrsökvägen för modelldata i modelPath . Den lyssnar efter tillståndsändringar i RemoteRenderingCoordinator för att se om den automatiskt ska läsa in eller ta bort den modell som den definierar. GameObject som har RemoteRenderedModel kopplat till sig blir det lokala överordnade objektet för fjärrinnehållet.

Observera att skriptet RemoteRenderedModel implementerar BaseRemoteRenderedModel, som ingår i Självstudietillgångar. Detta gör att fjärrmodellvisningsstyrenheten kan bindas med skriptet.

1. Skapa ett nytt skript med namnet RemoteRenderedModel i samma mapp som RemoteRenderingCoordinator. Ersätt hela innehållet med följande kod:

   // Copyright (c) Microsoft Corporation. All rights reserved.
   // Licensed under the MIT License. See LICENSE in the project root for license information.
   
   using Microsoft.Azure.RemoteRendering;
   using Microsoft.Azure.RemoteRendering.Unity;
   using System;
   using UnityEngine;
   using UnityEngine.Events;
   
   public class RemoteRenderedModel : BaseRemoteRenderedModel
   {
       public bool AutomaticallyLoad = true;
   
       private ModelState currentModelState = ModelState.NotReady;
   
       [SerializeField]
       [Tooltip("The friendly name for this model")]
       private string modelDisplayName;
       public override string ModelDisplayName { get => modelDisplayName; set => modelDisplayName = value; }
   
       [SerializeField]
       [Tooltip("The URI for this model")]
       private string modelPath;
       public override string ModelPath
       {
           get => modelPath.Trim();
           set => modelPath = value;
       }
   
       public override ModelState CurrentModelState
       {
           get => currentModelState;
           protected set
           {
               if (currentModelState != value)
               {
                   currentModelState = value;
                   ModelStateChange?.Invoke(value);
               }
           }
       }
   
       public override event Action<ModelState> ModelStateChange;
       public override event Action<float> LoadProgress;
       public override Entity ModelEntity { get; protected set; }
   
       public UnityEvent OnModelNotReady = new UnityEvent();
       public UnityEvent OnModelReady = new UnityEvent();
       public UnityEvent OnStartLoading = new UnityEvent();
       public UnityEvent OnModelLoaded = new UnityEvent();
       public UnityEvent OnModelUnloading = new UnityEvent();
   
       public UnityFloatEvent OnLoadProgress = new UnityFloatEvent();
   
       public void Awake()
       {
           // Hook up the event to the Unity event
           LoadProgress += (progress) => OnLoadProgress?.Invoke(progress);
   
           ModelStateChange += HandleUnityStateEvents;
       }
   
       private void HandleUnityStateEvents(ModelState modelState)
       {
           switch (modelState)
           {
               case ModelState.NotReady:  OnModelNotReady?.Invoke();  break;
               case ModelState.Ready:     OnModelReady?.Invoke();     break;
               case ModelState.Loading:   OnStartLoading?.Invoke();   break;
               case ModelState.Loaded:    OnModelLoaded?.Invoke();    break;
               case ModelState.Unloading: OnModelUnloading?.Invoke(); break;
           }
       }
   
       private void Start()
       {
           //Attach to and initialize current state (in case we're attaching late)
           RemoteRenderingCoordinator.CoordinatorStateChange += Instance_CoordinatorStateChange;
           Instance_CoordinatorStateChange(RemoteRenderingCoordinator.instance.CurrentCoordinatorState);
       }
   
       /// <summary>
       /// Listen for state changes on the coordinator, clean up this model's remote objects if we're no longer connected.
       /// Automatically load if required
       /// </summary>
       private void Instance_CoordinatorStateChange(RemoteRenderingCoordinator.RemoteRenderingState state)
       {
           switch (state)
           {
               case RemoteRenderingCoordinator.RemoteRenderingState.RuntimeConnected:
                   CurrentModelState = ModelState.Ready;
                   if (AutomaticallyLoad)
                       LoadModel();
                   break;
               default:
                   UnloadModel();
                   break;
           }
       }
   
       private void OnDestroy()
       {
           RemoteRenderingCoordinator.CoordinatorStateChange -= Instance_CoordinatorStateChange;
           UnloadModel();
       }
   
       /// <summary>
       /// Asks the coordinator to create a model entity and listens for coordinator state changes
       /// </summary>
       [ContextMenu("Load Model")]
       public override async void LoadModel()
       {
           if (CurrentModelState != ModelState.Ready)
               return; //We're already loaded, currently loading, or not ready to load
   
           CurrentModelState = ModelState.Loading;
   
           ModelEntity = await RemoteRenderingCoordinator.instance?.LoadModel(ModelPath, this.transform, SetLoadingProgress);
   
           if (ModelEntity != null)
               CurrentModelState = ModelState.Loaded;
           else
               CurrentModelState = ModelState.Error;
       }
   
       /// <summary>
       /// Clean up the local model instances
       /// </summary>
       [ContextMenu("Unload Model")]
       public override void UnloadModel()
       {
           CurrentModelState = ModelState.Unloading;
   
           if (ModelEntity != null)
           {
               var modelGameObject = ModelEntity.GetOrCreateGameObject(UnityCreationMode.DoNotCreateUnityComponents);
               Destroy(modelGameObject);
               ModelEntity.Destroy();
               ModelEntity = null;
           }
   
           if (RemoteRenderingCoordinator.instance.CurrentCoordinatorState == RemoteRenderingCoordinator.RemoteRenderingState.RuntimeConnected)
               CurrentModelState = ModelState.Ready;
           else
               CurrentModelState = ModelState.NotReady;
       }
   
       /// <summary>
       /// Update the Unity progress event
       /// </summary>
       /// <param name="progressValue"></param>
       public override void SetLoadingProgress(float progressValue)
       {
           LoadProgress?.Invoke(progressValue);
       }
   }
   

I de mest grundläggande termerna innehåller RemoteRenderedModel de data som behövs för att läsa in en modell (i det här fallet SAS eller builtin:// URI) och spårar fjärrmodelltillståndet. När det är dags att läsa in anropas metoden på LoadModel RemoteRenderingCoordinator och entiteten som innehåller modellen returneras för referens och avlastning.

Läsa in testmodellen

Nu ska vi testa det nya skriptet genom att läsa in testmodellen igen. Vi lägger till ett spelobjekt som ska innehålla skriptet och vara överordnat till testmodellen. Vi skapar också en virtuell fas som innehåller modellen. Fasen förblir fast i förhållande till den verkliga världen med hjälp av en WorldAnchor. Vi använder en fast fas så att själva modellen fortfarande kan flyttas senare.

1. Skapa ett nytt tomt spelobjekt i scenen och ge det namnet ModelStage.

2. Lägga till en World Anchor-komponent i ModelStage

   

3. Skapa ett nytt tomt spelobjekt som underobjekt i ModelStage och ge det namnet TestModel.

4. Lägg till skriptet RemoteRenderedModel i TestModel.

   

5. Fyll i Model Display Name och med " Model Path TestModel" och "builtin://Engine" respektive .

   

6. Placera TestModel-objektet framför kameran, vid position x = 0, y = 0, z = 3.

   

7. Se till att AutomaticallyLoad är aktiverat.

8. Tryck på Spela upp i Unity-redigeraren för att testa programmet.

9. Bevilja auktorisering genom att klicka på knappen Anslut för att tillåta att appen skapar en session och den ansluter till en session och läser in modellen automatiskt.

Titta på konsolen när programmet går igenom dess tillstånd. Tänk på att vissa tillstånd kan ta lite tid att slutföra och visar inte förloppet. Så småningom ser du loggarna från modellläsningen och sedan renderas testmodellen i scenen.

Försök att flytta och rotera TestModel GameObject via transformeringen i kontrollvyn eller i scenvyn. Du ser hur modellen flyttas och roteras i spelvyn.

Etablera Blob Storage i Azure och anpassad modellinmatning

Nu kan vi prova att läsa in din egen modell. För att göra det måste du konfigurera Blob Storage och på Azure, ladda upp och konvertera en modell. Sedan läser vi in modellen med hjälp av skriptet RemoteRenderedModel. Inläsningsstegen för den anpassade modellen kan hoppas över på ett säkert sätt om du inte har en egen modell att läsa in just nu.

Följ stegen som anges i Snabbstart: Konvertera en modell för rendering av. Hoppa över avsnittet Infoga ny modell i snabbstartsexempelappen i den här självstudien. När du har den inkommande modellens SAS-URI (signatur för delad åtkomst) fortsätter du till nästa steg nedan.

Läsa in och återge en anpassad modell

1. Skapa ett nytt tomt GameObject i scenen och ge det ett namn som liknar din anpassade modell.

2. Lägg till skriptet RemoteRenderedModel i det nyligen skapade GameObject.

   

3. Fyll i Model Display Name med ett lämpligt namn för din modell.

4. Fyll i med Model Path modellens SAS-URI (signatur för delad åtkomst) som du skapade i inmatningsstegen ovan.

5. Placera GameObject framför kameran, vid position x = 0, y = 0, z = 3.

6. Se till att AutomaticallyLoad är aktiverat.

7. Tryck på Spela upp i Unity Editor för att testa programmet.

   Konsolen börjar fyllas i med det aktuella tillståndet och så småningom modellen läser in förloppsmeddelanden. Din anpassade modell läses sedan in i scenen.

8. Ta bort ditt anpassade modellobjekt från scenen. Den bästa upplevelsen för den här självstudien är att använda testmodellen. Även om flera modeller verkligen stöds i ARR skrevs den här självstudien för att ge bästa möjliga stöd för en enda fjärrmodell i taget.

Nästa steg

Nu kan du läsa in dina egna modeller Azure Remote Rendering och visa dem i ditt program! Härnäst vägleder vi dig genom att manipulera dina modeller.