Condividi tramite

Condivisione MR 250: HoloLens e visori VR immersivi

Nota

Le esercitazioni di Mixed Reality Academy sono state progettate in base a HoloLens (prima generazione) e ai visori VR immersive di realtà mista. Pertanto, riteniamo importante lasciarle a disposizione degli sviluppatori a cui serve ancora materiale sussidiario per lo sviluppo di questi dispositivi. Queste esercitazioni non verranno aggiornate con i set di strumenti o le interazioni più recenti usati per HoloLens 2. Rimarranno invariate per consentire di continuare a lavorare sui dispositivi supportati. Per HoloLens 2 è stata pubblicata una nuova serie di esercitazioni.

Con la flessibilità di piattaforma UWP (Universal Windows Platform) (UWP), è facile creare un'applicazione che si estende su più dispositivi. Grazie a questa flessibilità, è possibile creare esperienze che sfruttano i punti di forza di ogni dispositivo. Questa esercitazione illustra un'esperienza condivisa di base che viene eseguita sia in HoloLens che in Windows Mixed Reality visori visori immersivi. Questo contenuto è stato originariamente recapitato alla conferenza di Microsoft Build 2017 a Seattle, WA.

In questa esercitazione si apprenderà come:

  • Configurare una rete usando UNET.
  • Condividere ologrammi tra dispositivi di realtà mista.
  • Stabilire una visualizzazione diversa dell'applicazione a seconda del dispositivo di realtà mista in uso.
  • Creare un'esperienza condivisa in cui gli utenti di HoloLens guidano gli utenti di visori immersivi attraverso alcuni semplici puzzle.

Supporto di dispositivi

Corso HoloLens Visori VR immersive
Condivisione MR 250: HoloLens e visori VR immersivi ✔️ ✔️

Prima di iniziare

Prerequisiti

File di progetto

Nota

Se si vuole esaminare il codice sorgente prima di scaricare, è disponibile in GitHub.

Capitolo 1 - Holo World

Obiettivi

Assicurarsi che l'ambiente di sviluppo sia pronto per passare con un progetto semplice.

Che cosa creeremo

Applicazione che mostra un ologramma in HoloLens o un visore visore immersivo Windows Mixed Reality.

Passaggi

  • Aprire Unity.
    • Selezionare Open (Apri).
    • Passare a dove sono stati estratti i file di progetto.
    • Fare clic su Seleziona cartella.
    • Ci sarà un po' di tempo per Unity per elaborare il progetto la prima volta.
  • Verificare che Realtà mista sia abilitato in Unity.
    • Aprire la finestra di dialogo Impostazioni di compilazione (Control+MAIUSC+B o Impostazioni compilazione file > ...).
    • Selezionare piattaforma UWP (Universal Windows Platform) quindi fare clic su Cambia piattaforma.
    • Selezionare Modifica>impostazioni lettore.
    • Nel pannello Inspector (Controllo ) sul lato destro espandere Impostazioni XR.
    • Selezionare la casella Realtà virtuale supportata .
    • Windows Mixed Reality deve essere Virtual Reality SDK.
  • Creare una scena.
    • Nella gerarchia fare clic con il pulsante destro del mouse su Fotocamera principale selezionare Elimina.
    • Da HoloToolkit > Input > Prefabs trascinare MixedRealityCameraParent nella gerarchia.
  • Aggiungere hologrammi alla scena
    • Da AppPrefabs trascinare Skybox nella visualizzazione scena.
    • Da AppPrefabs trascinare Manager nella gerarchia.
    • Da AppPrefabs trascinare l'isola nella gerarchia.
  • Salva e compila
    • Salva (controllo+S o scena di salvataggio file>)
    • Poiché si tratta di una nuova scena, sarà necessario assegnarne il nome. Il nome non è importante, ma viene usato SharedMixedReality.
  • Esporta in Visual Studio
    • Aprire il menu di compilazione (Control+MAIUSC+B o Impostazioni compilazione file>)
    • Fare clic su Aggiungi scene aperte.
    • Controllare i progetti C# di Unity
    • Fare clic su Compila.
    • Nella finestra esplora file visualizzata creare una nuova cartella denominata App.
    • Fare clic sulla cartella App .
    • Premere Seleziona cartella.
    • Attendere il completamento della compilazione
    • Nella finestra esplora file visualizzata passare alla cartella App .
    • Fare doppio clic su SharedMixedReality.sln per avviare Visual Studio
  • Compilazione da Visual Studio
    • Usando la destinazione di modifica della barra degli strumenti superiore a Release e x86.
    • Fare clic sulla freccia accanto a Computer locale e selezionare Dispositivo da distribuire in HoloLens
    • Fare clic sulla freccia accanto a Dispositivo e selezionare Computer locale da distribuire per il visore di realtà mista.
    • Fare clic su Debug-Start> senza debug o Control+F5 per avviare l'applicazione.

Inserimento nel codice

Nel pannello del progetto passare a Asset\HoloToolkit\Input\Script\Utilities e fare doppio clic su MixedRealityCameraManager.cs per aprirlo.

Panoramica: MixedRealityCameraManager.cs è uno script semplice che regola il livello di qualità e le impostazioni di sfondo in base al dispositivo. Chiave qui è HolographicSettings.IsDisplayOpaque, che consente a uno script di rilevare se il dispositivo è un HoloLens (IsDisplayOpaque restituisce false) o un visore visore immersivo (IsDisplayOpaque restituisce true).

Goditi il tuo progresso

A questo punto l'applicazione eseguirà il rendering di un ologramma. Verrà aggiunta l'interazione all'ologramma in un secondo momento. Entrambi i dispositivi eseguiranno il rendering dello stesso ologramma. Il visore visore immersivo eseguirà anche il rendering di un cielo blu e di sfondo delle nuvole.

Capitolo 2 - Interazione

Obiettivi

Mostra come gestire l'input per un'applicazione Windows Mixed Reality.

Che cosa creeremo

L'applicazione del capitolo 1 aggiungerà funzionalità per consentire all'utente di raccogliere l'ologramma e posizionarlo su una superficie reale di HoloLens o su una tabella virtuale in un visore vr immersivo.

Aggiornamento input: In HoloLens il movimento di selezione è il tocco aria. Nei visori vr immersivi si userà il pulsante A sul controller Xbox. Per altre informazioni, vedere panoramica del modello di interazione.

Passaggi

  • Aggiungere Gestione input
    • Dai prefab di input > di HoloToolkit > trascinare InputManager in Hierarchy come figlio di Manager.
    • Da HoloToolkit Input Prefabs Cursor (Prefab di input > HoloToolkit>) >trascinare Cursore in Hierarchy (Gerarchia).
  • Aggiungi mapping spaziale
    • Dai prefab SpatialMapping di HoloToolkit trascinare SpatialMapping in Hierarchy.From HoloToolkit > SpatialMapping > Prefabs drag SpatialMapping to Hierarchy.
  • Aggiungere spazio di riproduzione virtuale
    • In Gerarchia espandere MixedRealityCameraParent selezionare Limite
    • Nel pannello Inspector (Controllo ) selezionare la casella per abilitare Boundary
    • Da AppPrefabs trascinare VRRoom in Hierarchy(Gerarchia).
  • Aggiungere WorldAnchorManager
    • In Gerarchia selezionare Manager.
    • In Inspector (Controllo) fare clic su Add Component (Aggiungi componente).
    • Digitare World Anchor Manager.
    • Selezionare World Anchor Manager per aggiungerlo.
  • Aggiungere TapToPlace all'isola
    • In Gerarchia espandere Isola.
    • Selezionare MixedRealityLand.
    • In Inspector (Controllo) fare clic su Add Component (Aggiungi componente).
    • Digitare Tap To Place (Tocca posizione) e selezionarlo.
    • Selezionare Posiziona elemento padre al tocco.
    • Impostare Offset di posizionamento su (0, 0,1, 0).
  • Salvare e compilare come prima

Analisi del codice

Script 1 - GamepadInput.cs

Nel pannello del progetto passare ad Assets\HoloToolkit\Input\Scripts\InputSources e fare doppio clic su GamepadInput.cs per aprirlo. Nello stesso percorso nel pannello del progetto fare doppio clic su InteractionSourceInputSource.cs.

Si noti che entrambi gli script hanno una classe base comune, BaseInputSource.

BaseInputSource mantiene un riferimento a un InputManager, che consente a uno script di attivare eventi. In questo caso, l'evento InputClicked è rilevante. Questo aspetto sarà importante da ricordare quando si arriva allo script 2, TapToPlace. Nel caso di GamePadInput, viene eseguito il polling del pulsante A sul controller da premere, quindi viene generato l'evento InputClicked. Nel caso di InteractionSourceInputSource, viene generato l'evento InputClicked in risposta all'evento TappedEvent.

Script 2 - TapToPlace.cs

Nel pannello del progetto passare ad Assets\HoloToolkit\SpatialMapping\Scripts e fare doppio clic su TapToPlace.cs per aprirlo.

La prima cosa che molti sviluppatori vogliono implementare quando si crea un'applicazione Holographic è lo spostamento degli ologrammi con l'input del movimento. Di conseguenza, abbiamo cercato di commentare accuratamente questo script. Per questa esercitazione vale la pena evidenziare alcuni aspetti.

In primo luogo, si noti che TapToPlace implementa IInputClickHandler. IInputClickHandler espone le funzioni che gestiscono l'evento InputClicked generato da GamePadInput.cs o InteractionSourceInputSource.cs. OnInputClicked viene chiamato quando baseInputSource rileva un clic mentre l'oggetto con TapToPlace è attivo. L'invio in modalità airtapping in HoloLens o la pressione del pulsante A nel controller Xbox attiverà l'evento.

In secondo luogo, il codice viene eseguito nell'aggiornamento per verificare se viene esaminata una superficie in modo da poter posizionare l'oggetto gioco su una superficie, ad esempio una tabella. Il visore VR immersive non ha un concetto di superfici reali, quindi l'oggetto che rappresenta la parte superiore della tabella (Vroom > TableThingy > Cube) è stato contrassegnato con il livello di fisica SpatialMapping, quindi il ray cast in Update sarà in conflitto con la parte superiore della tabella virtuale.

Goditi i tuoi progressi

Questa volta è possibile selezionare l'isola per spostarla. In HoloLens è possibile spostare l'isola in una superficie reale. Nel visore VR immersive è possibile spostare l'isola nella tabella virtuale aggiunta.

Capitolo 3 - Condivisione

Obiettivi

Assicurarsi che la rete sia configurata correttamente e in dettaglio la modalità di condivisione degli ancoraggi nello spazio tra i dispositivi.

Cosa creeremo

Convertiremo il progetto in un progetto multiplayer. Aggiungeremo l'interfaccia utente e la logica per ospitare o partecipare a sessioni. Gli utenti di HoloLens si vedranno tra loro nella sessione con cloud sulla testa e gli utenti con visore VR immersive hanno cloud vicino a dove si trova l'ancoraggio. Gli utenti nei visori VR immersive vedranno gli utenti di HoloLens in relazione all'origine della scena. Gli utenti di HoloLens vedranno tutti l'ologramma dell'isola nello stesso posto. È fondamentale notare che gli utenti nei visori VR immersive non saranno sull'isola durante questo capitolo, ma si comportano in modo molto simile a HoloLens, con una visualizzazione degli occhi degli uccelli dell'isola.

Passaggi

  • Rimuovi isola e VRRoom
    • In Gerarchia fare clic con il pulsante destro del mouse su Isola selezionare Elimina
    • In Gerarchia fare clic con il pulsante destro del mouse su VRRoom selezionare Elimina
  • Aggiungi Usland
    • Da AppPrefabs trascinare Usland in Hierarchy( Gerarchia).
  • Da AppPrefabs trascinare ognuna delle opzioni seguenti in Hierarchy (Gerarchia):
    • UNETSharingStage
    • UNetAnchorRoot
    • UIContainer
    • DebugPanelButton
  • Salvare e compilare come prima

Analisi del codice

Nel pannello del progetto passare ad Assets\AppPrefabs\Support\SharingWithUnet\Scripts e fare doppio clic su UnetAnchorManager.cs. La possibilità di condividere informazioni di rilevamento con un altro Dispositivo HoloLens in modo che entrambi i dispositivi possano condividere lo stesso spazio è quasi magico. La potenza della realtà mista diventa attiva quando due o più persone possono collaborare usando gli stessi dati digitali.

Alcuni aspetti da sottolineare in questo script:

Nella funzione start notare il controllo isDisplayOpaque. In questo caso, si fa finta che sia stato stabilito l'ancoraggio. Ciò è dovuto al fatto che i visori VR immersive non espongono un modo per importare o esportare ancoraggi. Se invece è in esecuzione in holoLens, questo script implementa la condivisione degli ancoraggi tra i dispositivi. Il dispositivo che avvia la sessione creerà un ancoraggio per l'esportazione. Il dispositivo che partecipa a una sessione richiederà l'ancoraggio dal dispositivo che ha avviato la sessione.

Esportazione:

Quando un utente crea una sessione, NetworkDiscoveryWithAnchors chiamerà la funzione UNETAnchorManagers CreateAnchor. Seguire il flusso CreateAnchor.

Iniziamo eseguendo alcune operazioni di pulizia, cancellando tutti i dati raccolti per gli ancoraggi precedenti. Controllare quindi se è presente un ancoraggio memorizzato nella cache da caricare. I dati di ancoraggio tendono a essere compresi tra 5 e 20 MB, quindi il riutilizzo degli ancoraggi memorizzati nella cache può risparmiare sulla quantità di dati da trasferire in rete. Vedremo come funziona più avanti. Anche se si riutilizza l'ancoraggio, è necessario preparare i dati di ancoraggio nel caso in cui un nuovo client join non disponga dell'ancoraggio.

In termini di preparazione dei dati di ancoraggio, la classe WorldAnchorTransferBatch espone la funzionalità per preparare i dati di ancoraggio per l'invio a un altro dispositivo o applicazione e la funzionalità per importare i dati di ancoraggio. Poiché si è nel percorso di esportazione, si aggiungerà l'ancoraggio a WorldAnchorTransferBatch e si chiamerà la funzione ExportAsync. ExportAsync chiamerà quindi il callback WriteBuffer in quanto genera i dati per l'esportazione. Quando tutti i dati sono stati esportati ExportComplete verranno chiamati. In WriteBuffer aggiungiamo il blocco di dati a un elenco che viene mantenuto per l'esportazione. In ExportComplete l'elenco viene convertito in una matrice. Viene impostata anche la variabile AnchorName, che attiverà altri dispositivi per richiedere l'ancoraggio se non lo hanno.

In alcuni casi l'ancoraggio non verrà esportato o creerà dati così piccoli che verranno riprovati. Qui chiamiamo di nuovo CreateAnchor.

Una funzione finale nel percorso di esportazione è AnchorFoundRemotely. Quando un altro dispositivo trova l'ancoraggio, il dispositivo indicherà all'host e l'host lo userà come segnale che l'ancoraggio è un "buon ancoraggio" e può essere memorizzato nella cache.

Importazione:

Quando un holoLens partecipa a una sessione, deve importare un ancoraggio. Nella funzione Update di UNETAnchorManager viene eseguito il polling di AnchorName. Quando il nome dell'ancoraggio viene modificato, inizia il processo di importazione. In primo luogo, si tenta di caricare l'ancoraggio con il nome specificato dall'archivio di ancoraggi locale. Se è già disponibile, è possibile usarlo senza scaricare nuovamente i dati. Se non è disponibile, chiamiamo WaitForAnchor che avvierà il download.

Al termine del download, viene chiamato NetworkTransmitter_dataReadyEvent. Verrà segnalato il ciclo update per chiamare ImportAsync con i dati scaricati. ImportAsync chiamerà ImportComplete al termine del processo di importazione. Se l'importazione ha esito positivo, l'ancoraggio verrà salvato nell'archivio del lettore locale. PlayerController.cs effettua effettivamente la chiamata a AnchorFoundRemotely per informare l'host che è stato stabilito un buon ancoraggio.

Goditi i tuoi progressi

Questa volta un utente con HoloLens ospiterà una sessione usando il pulsante avvia sessione nell'interfaccia utente. Altri utenti, sia in HoloLens che in un visore VR immersive, selezioneranno la sessione e quindi selezioneranno il pulsante partecipa alla sessione nell'interfaccia utente. Se si dispone di più persone con dispositivi HoloLens, avranno nuvole rosse sulla testa. Ci sarà anche una nuvola blu per ogni visore VR immersive, ma le nuvole blu non saranno al di sopra delle cuffie, perché i visori VR non stanno cercando di trovare lo stesso spazio di coordinate del mondo dei dispositivi HoloLens.

Questo punto nel progetto è un'applicazione di condivisione contenuta; non esegue molto, e può fungere da baseline. Nei capitoli successivi, inizieremo a costruire un'esperienza per i piaceri delle persone. Per altre indicazioni sulla progettazione dell'esperienza condivisa, vedere qui.

Capitolo 4 - Immersione e teletrasporto

Obiettivi

Soddisfare l'esperienza per ogni tipo di dispositivo di realtà mista.

Cosa creeremo

L'applicazione verrà aggiornata per mettere gli utenti del visore VR immersive sull'isola con una visualizzazione immersiva. Gli utenti di HoloLens avranno ancora la visualizzazione degli occhi degli uccelli dell'isola. Gli utenti di ogni tipo di dispositivo possono visualizzare gli altri utenti come appaiono nel mondo. Ad esempio, gli utenti del visore VR immersive possono vedere gli altri avatar su altri percorsi sull'isola e vedono gli utenti di HoloLens come nuvole giganti sopra l'isola. Gli utenti del visore VR immersive vedranno anche il cursore del raggio dello sguardo fisso dell'utente holoLens se l'utente HoloLens sta guardando l'isola. Gli utenti di HoloLens vedranno un avatar sull'isola per rappresentare ogni utente vr immersive.

Input aggiornato per il dispositivo immersive:

  • I pulsanti del paraurti sinistro e destro sul controller Xbox ruotano il lettore
  • Tenendo premuto il pulsante Y sul controller Xbox, verrà abilitato un cursore di teletrasporto . Se il cursore ha un indicatore freccia rotante quando si rilascia il pulsante Y, si verrà teletrasportati nella posizione del cursore.

Passaggi

  • Aggiungere MixedRealityTeleport a MixedRealityCameraParent
    • In Gerarchia selezionare Usland.
    • In Inspector (Controllo) abilitare Level Control (Controllo livello).
    • In Gerarchia selezionare MixedRealityCameraParent.
    • In Inspector (Controllo) fare clic su Add Component (Aggiungi componente).
    • Digitare Realtà mista Teleport e selezionarlo.

Analisi del codice

Gli utenti di visori VR immersive saranno tethered ai loro PC con un cavo, ma la nostra isola è più grande del cavo è lunga. Per compensare, è necessaria la possibilità di spostare la fotocamera indipendentemente dal movimento dell'utente. Per altre informazioni sulla progettazione dell'applicazione di realtà mista (in particolare auto motion e locomozione), vedere la pagina del comfort .

Per descrivere questo processo, sarà utile definire due termini. In primo luogo, dolly sarà l'oggetto che sposta la fotocamera indipendentemente dall'utente. Un oggetto gioco figlio del dolly sarà la fotocamera principale. La fotocamera principale è collegata alla testa dell'utente.

Nel pannello del progetto passare a Assets\AppPrefabs\Support\Scripts\GameLogic e fare doppio clic su MixedRealityTeleport.cs.

MixedRealityTeleport ha due processi. Prima di tutto, gestisce la rotazione usando i paraurti. Nella funzione di aggiornamento viene eseguito il polling di 'ButtonUp' su LeftBumper e RightBumper. GetButtonUp restituisce true solo nel primo fotogramma in cui un pulsante è attivo dopo essere stato inattivo. Se uno dei due pulsanti era stato generato, si sa che l'utente deve ruotare.

Quando si ruota si esegue una dissolvenza in uscita e si dissolve usando uno script semplice denominato "controllo dissolvenza". Lo facciamo per impedire all'utente di vedere un movimento innaturale che potrebbe causare disagio. L'effetto dissolvenza in entrata e in uscita è abbastanza semplice. Abbiamo un quad nero appeso davanti alla fotocamera principale. Quando si dissolve il valore alfa viene passato da 0 a 1. Questo causa gradualmente il rendering dei pixel neri del quad e nasconde qualsiasi cosa dietro di loro. Quando si fading indietro in viene eseguito il passaggio del valore alfa a zero.

Quando calcoliamo la rotazione, tieni presente che stiamo ruotando il nostro dolly , ma calcolando la rotazione intorno alla fotocamera principale. Questo è importante poiché la fotocamera principale è lontana da 0,0,0, la rotazione meno accurata intorno al dolly sarebbe diventata dal punto di vista dell'utente. Infatti, se non si ruota intorno alla posizione della fotocamera, l'utente si muoverà su un arco intorno al dolly anziché ruotare.

Il secondo processo per MixedRealityTeleport consiste nel gestire lo spostamento del dolly. Questa operazione viene eseguita in SetWorldPosition. SetWorldPosition assume la posizione del mondo desiderata, la posizione in cui l'utente vuole percievere che abita. Dobbiamo mettere il nostro dolly in quella posizione meno la posizione locale della fotocamera principale, in quanto tale offset verrà aggiunto ogni fotogramma.

Un secondo script chiama SetWorldPosition. Esaminiamo questo script. Nel pannello del progetto passare a Assets\AppPrefabs\Support\Scripts\GameLogic e fare doppio clic su TeleportScript.cs.

Questo script è un po' più coinvolto rispetto a MixedRealityTeleport. Lo script sta verificando che il pulsante Y nel controller Xbox venga mantenuto premuto. Durante il rendering del pulsante viene eseguito il rendering di un cursore di teletrasporto e lo script esegue il cast di un raggio dalla posizione dello sguardo fisso dell'utente. Se il raggio si scontra con una superficie che punta più o meno verso l'alto, la superficie verrà considerata una buona superficie per teletrasportarsi e l'animazione sul cursore di teletrasportazione verrà abilitata. Se il raggio non è in conflitto con una superficie più o meno puntata verso l'alto, l'animazione sul cursore verrà disabilitata. Quando il pulsante Y viene rilasciato e il punto calcolato del raggio è una posizione valida, lo script chiama SetWorldPosition con la posizione intersecata dal raggio.

Goditi i tuoi progressi

Questa volta dovrai trovare un amico.

Ancora una volta, un utente con HoloLens ospiterà una sessione. Altri utenti si uniranno alla sessione. L'applicazione metterà i primi tre utenti a partecipare da un visore VR immersive su uno dei tre percorsi dell'isola. È possibile esplorare l'isola in questa sezione.

Dettagli da notare:

  1. È possibile visualizzare i visi nelle nuvole, che aiuta un utente immerso a vedere quale direzione sta guardando un utente HoloLens.
  2. Gli avatar sull'isola hanno collo che ruotano. Non seguiranno ciò che l'utente sta facendo è la realtà reale (non abbiamo queste informazioni), ma rende un'esperienza piacevole.
  3. Se l'utente holoLens sta guardando l'isola, gli utenti immersi possono visualizzare il cursore.
  4. I cloud che rappresentano gli utenti di HoloLens hanno eseguito il cast di ombreggiature.

Capitolo 5 - Finale

Obiettivi

Creare un'esperienza interattiva collaborativa tra i due tipi di dispositivo.

Cosa creeremo

Basandosi sul capitolo 4, quando un utente con un visore VR immersive si avvicina a un puzzle sull'isola, gli utenti di HoloLens otterranno una descrizione comando con un indizio per il puzzle. Una volta che tutti gli utenti del visore VR immersive si mettono oltre i loro puzzle e sul "pad pronto" nella stanza dei razzi, il razzo verrà lanciato.

Passaggi

  • In Gerarchia selezionare Usland.
  • In Inspector ( Controllo livello) selezionare Enable Collaboration (Abilita collaborazione).

Analisi del codice

Ora esaminiamo LevelControl.cs. Questo script è il nucleo della logica del gioco e mantiene lo stato del gioco. Poiché si tratta di un gioco multiplayer che usa UNET, è necessario comprendere il modo in cui i flussi di dati, almeno abbastanza bene da modificare questa esercitazione. Per una panoramica più completa di UNET, vedere la documentazione di Unity.

Nel pannello del progetto passare a Assets\AppPrefabs\Support\Scripts\GameLogic e fare doppio clic su LevelControl.cs.

Vediamo come un visore VR immersive indica che sono pronti per il lancio del razzo. La preparazione del lancio di razzi viene comunicata impostando uno dei tre bool in un elenco di bool che corrispondono ai tre percorsi dell'isola. Il valore bool di un percorso verrà impostato quando l'utente assegnato al percorso si trova sopra il riquadro marrone all'interno della stanza del razzo. Ok, ora ai dettagli.

Verrà avviata la funzione Update(). Si noterà che esiste una funzione "imbrogliata". È stato usato in fase di sviluppo per testare la sequenza di lancio e reimpostazione del razzo. Non funzionerà nell'esperienza multiutente. Speriamo che nel momento in cui si internalizzi il codice seguente, è possibile farlo funzionare. Dopo aver verificato se dovremmo imbrogliare, controlliamo se il giocatore locale è immerso. Vogliamo concentrarci su come troviamo che siamo all'obiettivo. All'interno del controllo if (Immersed) c'è una chiamata a CheckGoal nascondersi dietro il bool EnableCollaboration . Corrisponde alla casella di controllo selezionata durante il completamento dei passaggi per questo capitolo. All'interno di EnableCollaboration viene visualizzata una chiamata a CheckGoal().

CheckGoal esegue alcune operazioni matematiche per vedere se siamo più o meno in piedi sul pad. Quando siamo, debug.log "Arrivato all'obiettivo" e quindi chiamiamo 'SendAtGoalMessage()'. In SendAtGoalMessage chiamiamo playerController.SendAtGoal. Per risparmiare tempo, ecco il codice:

private void CmdSendAtGoal(int GoalIndex)
{
    levelState.SetGoalIndex(GoalIndex);
}

public void SendAtGoal(int GoalIndex)
{
    if (isLocalPlayer)
    {
        Debug.Log("sending at goal " + GoalIndex);
        CmdSendAtGoal(GoalIndex);
    }
}

Si noti che SendAtGoalMessage chiama CmdSendAtGoal, che chiama levelState.SetGoalIndex, che torna a LevelControl.cs. A prima vista questo sembra strano. Perché non chiamare solo SetGoalIndex anziché questo strano routing attraverso il controller del lettore? Il motivo è che siamo conformi al modello di dati usato da UNET per mantenere i dati sincronizzati. Per evitare l'inganno e il thrashing, UNET richiede che ogni oggetto abbia un utente autorizzato a modificare le variabili sincronizzate. Inoltre, solo l'host (l'utente che ha avviato la sessione) può modificare direttamente i dati. Gli utenti che non sono l'host, ma hanno l'autorità, devono inviare un 'comando' all'host che modificherà la variabile. Per impostazione predefinita, l'host dispone dell'autorità su tutti gli oggetti, ad eccezione dell'oggetto generato per rappresentare l'utente. In questo caso questo oggetto ha lo script playercontroller. C'è un modo per richiedere l'autorità per un oggetto e quindi apportare modifiche, ma scegliamo di sfruttare il fatto che il controller del giocatore abbia auto authority e instradare i comandi attraverso il controller del giocatore.

Detto un altro modo, quando ci siamo trovati al nostro obiettivo, il giocatore deve dire all'host e l'host dirà a tutti gli altri.

Tornare a LevelControl.cs esaminare SetGoalIndex. Di seguito viene impostato il valore di un valore in un elenco di sincronizzazione (AtGoal). Tenere presente che si è nel contesto dell'host mentre si esegue questa operazione. Analogamente a un comando, una rpc è un problema che l'host può causare l'esecuzione di codice da parte di tutti i client. Qui chiamiamo "RpcCheckAllGoals". Ogni client verificherà singolarmente se tutti e tre gli AtGoal sono impostati e, in tal caso, lanciare il razzo.

Goditi i tuoi progressi

Basandosi sul capitolo precedente, la sessione verrà avviata come prima. Questa volta quando gli utenti nel visore VR immersive arrivano alla "porta" nel percorso, viene visualizzata una descrizione comando che solo gli utenti di HoloLens possono visualizzare. Gli utenti di HoloLens sono responsabili della comunicazione di questo indizio agli utenti nel visore VR immersive. Il razzo verrà lanciato nello spazio una volta che ogni avatar è salito sul suo corrispondente pad marrone all'interno del vulcano. La scena verrà reimpostata dopo 60 secondi in modo da poterla eseguire di nuovo.

Vedi anche