Dispozitivele dezvoltate de către Meta (în trecut, cunoscute ca și Oculus) sunt soluții `all-in-one` ce permit dezvoltarea aplicațiilor de realitate virtuală și oferă suport pentru cele mai recente funcționalități din acest domeniu, precum hand tracking, realitate mixtă (MR), audio spațializat, eye și body tracking.

În mod curent, în seria Quest, regăsim 4 astfel de dispozitive ce oferă suport activ pentru dezvoltarea aplicațiilor VR, anume:

• Meta Quest 2 reprezintă încă o alegere bună pentru dezvoltarea (și consumul de content) VR
• Meta Quest 3 vine cu o serie de îmbunătățiri față de Meta Quest 2 precum o rezoluție mai bună, o nouă generație de chipset (SD XR2 Gen1 vs Gen2) și suport sporit pentru realitate mixtă
• Meta Quest 3S este o variantă mai puțin performantă decât Meta Quest 3, având o rezoluție mai mică și alt tip de lentile
• Meta Quest Pro are un display panel mai bun, un upgrade de memorie RAM, dar avantajele principale sunt reprezentate de suport pentru face și eye tracking, precum și un design mai ergonomic. În plus, Meta Quest 3 și Meta Quest Pro vin cu controller-e ce au suport pentru feedback haptic mai avansat

Pentru dezvoltarea aplicațiilor de VR, există suport pentru OpenXR (aplicații native), sau SDK-uri ce oferă integrare cu game engine-urile standard, precum Unity și Unreal Engine.

Integrarea SDK-ului vine cu suport pentru diverse feature-uri pe care le putem utiliza, în funcție de necesitățile aplicației pe care dorim s-o dezvoltăm:

• Meta XR Core SDK: Funcționalități esențiale precum headset tracking, hand tracking, passthrough, ancore spațiale, etc.
• Meta XR Interaction SDK: Funcționalități de interacțiune cu controller-ele sau mâinile, precum ray, poke, grab, etc. Pe acestea le vom studia în acest laborator!
• Meta XR Audio SDK: Suport pentru sunet spațializat
• Meta XR Haptics SDK: Suport pentru redare haptică avansată
• Meta XR Voice SDK
• Meta XR Platform SDK: Aspecte sociale / networking: Matchmaking, In-App Purchasing (IAP), Cloud Storage, etc.
• Meta XR Simulator

În imaginea de mai jos puteți studia un flow generalizat al dezvoltării aplicațiilor de VR folosind dispozitivele celor de la Meta.

• Dispozitiv Meta Quest 2, 3, 3S, sau Pro
• Meta Quest App
• Configurare Quest Link wired sau wireless

• Meta Quest Developer Hub (opțional, download)
• SideQuest (opțional, download page)

Aplicația vă oferă setări adiționale pentru un dispozitiv Quest conectat la calculator. Folosind MQDH puteți să:

• Vizualizați log-uri ale dispozitivului pentru a face debugging
• Screen cast, screen recording
• Instalare/deploy aplicații pe cască

• Dispozitivele Meta rulează pe Android, așadar setați această platformă ca fiind cea activă din build settings

• Din meniul XR Loader Settings selectați activă opțiunea Set Meta XR Loader

Începând cu versiunea 59, pachetul de integrare se folosește de UPM (Unity Package Manager), oferind astfel o modalitate mai ușoară de integrare, realizarea rapidă a upgrade-urilor, iar probabil cel mai important, un management ușor în alegerea pachetelor esențiale de folosit (Core, Integration, Audio, etc.). Versiunea up-to-date la momentul redactării acestui text este 81.0.0.

• Descărcați și importați în proiectul de Unity:
  • Meta XR Interaction ​SDK. Acesta va instala ca dependințe:
    • Meta XR Core SDK
    • Meta XR Interaction SDK Essentials
  • Importați Example Scenes din sample-urile pachetului Meta XR Interaction ​SDK
  • Aveți linked pașii oficiali pentru importul pachetelor și modalități de update a acestora
• Acceptați prompt-urile care vă apar, restart la editor dacă este necesar

Din File → Build Profiles vă recomandăm să vă creați un nou profil de build derivat din platforma Meta Quest.

O să primiți un prompt pentru instalarea backend-ului OpenXR, acceptați-l.

În Unity Editor ar trebui să vă apară un nou buton Meta VR Tools (în stânga-sus, sub toolbar).

De aici puteți deschide Project Setup Tool, care vă permite să vă configurați proiectul de Unity pentru a fi compatibil cu cerințele SDK-ului.

• Treceți prin fiecare platformă și rezolvați problemele descrise

• Intrați în modul Link pe headset
• În proiectul suport, deschideți și testați scenele sample (prin Play în editor):
  • Assets → Samples → Meta XR Interaction ​SDK → <versiune> → Example Scenes → HandGrabExamples
  • Assets → Samples → Meta XR Interaction ​SDK → <versiune> → Example Scenes → ComprehensiveRigExample

Puteți realiza build-uri în cel mai simplu mod folosiți opțiunea de Build And Run din meniul profilului de build selectat (Meta Quest). La finalul build-ului, aplicația este instalată pe headset și pornită în mod automat. Aplicația se poate apoi regăsi în submeniul Unknown Sources.

Pentru alte variante de build, în urma creării APK-ului din Unity (așadar Build simplu, nu Build And Run), se pot folosi Meta Quest Developer Hub sau SideQuest pentru instalarea acestor aplicații pe headset (proces cunsocut ca și sideloading).

• Task-ul vostru implică să realizați și să testați un build pentru oricare din scenele demo prezentate anterior

#if UNITY_STANDALONE 
 
// ... script GravityGunController ...
 
#endif

• Importați ultima versiune a pachetului IRVA_L4_VR_MetaXR_Skeleton care se găsește în folder-ul UnityPackages din folder-ul root al proiectului
• Deschideți scena din schelet - veți lucra pentru următoarele task-uri în aceasta

Veți învăța în continuare cum se pot integra diverse componente ale SDK-ului aplicația voastră: headset-ul virtual, controller-ele, hand tracking-ul, funcționalitatea de passthrough, etc.

SDK-ul a introdus recent o nouă modalitate de setup a acestor elemente printr-un meniu de Building Blocks.

• Acest nou meniu prezintă funcționalități care se pot adăga prin drag-and-drop în oricare scenă din Unity
• Pentru a-l deschide aveți două variante
  • Din Meta XR Tools (pe care l-ați folosit pentru a accesa Project Setup Tool)
  • Din toolbar, Meta → Tools → Building Blocks

• Înainte de introducerea acestor Building Blocks, elementele necesare ale unei scene trebuiau incluse manual - în esență, acest meniu abstractizează procesul de căutare de prefab-uri, adăugare și parentare corectă a acestora în scenă
• Totuși, rețineți că acest meniu nu este comprehensiv, întrucât abtractizează includerea elementelor pe care Meta le consideră cele mai utile; unele funcționalități tot vor necesita setup manual
• Pentru acest laborator ne este suficient acest meniu

În primele iterații ale sistemului de building blocks componentele player-ului trebuiau alcătuite din building block-uri separate. De exemplu, dacă doream un player care să poată folosi atât controllerele cât și mâinile pentru a interacționa cu un obiect trebuiau inserate:

• Building block | Camera Rig
• Building block | Controller Tracking
• Building block | Hand Tracking
• Building block | Virtual Hands (deprecated)
• Building block | Grab Interaction

Fiecare dintre acestea adăuga câte o componentă și făcea setup în mod automat în ierarhie. Spre exemplu:

• Camera Rig include în scenă toată logica necesară camerei virtuale și head tracking-ului
• Controller Tracking include în scenă elementele necesare activării funcționalității de tracking a controller-elor
• Hand Tracking include în scenă elementele necesare activării funcționalității de tracking a mâinilor
• Grab Interaction include în scenă un nou obiect interactibil (cub) precum și intractorii necesari pentru a interacționa cu acest tip de obiect

În noile versiuni ale SDK-ului a fost introdus un building block numit Interactions Rig care este util întrucât unifică toate componentele menționate mai sus, nefiind necesar setup-ul individual. Introduceți-l pe acesta în scenă via drag-and-drop.

Selectați obiectul [BuildingBlock] Camera Rig. În cadrul acestui laborator nu va trebui să-l modificați dar rețineți că acesta conține configurări esențiale atunci când o să lucrați la proiectele voastre.

Nagivagați în inspector la script-ul OVRManager. Acesta conține numeroase setări ce țin de sesiunea VR, precum:

• Device-uri target (Quest 2, Quest 3, etc.)
• Cum se realizază tracking-ul
• Feature-urile pe care le puteți folosi
  • Suport hand tracking
  • Suport ancore spațiale
  • Suport face/eye/body tracking

Este locul central în care se poate configura sesiunea VR în cadrul acestui SDK.

Obiectele OVRHands și OVRControllers conțin atașate script-uri ce implementază structurile de date ce reprezintă în esență controllerele sau mâinile virtuale și pot fi utilizate pentru a citi date legate de input.

Obiectele OVRLeftHandVisual, OVRRightHandVisual, OVRLeftControllerVisual și OVRRightControllerVisual oferă logica și asset-urile pentru reprezentarea vizuală a mâinilor, respectiv controllerelor.

• Un interactibil (ex. obiect care poate fi grabbed) răspunde evenimentelor unui interactor (controller, mâini)
• Interacțiunea reprezintă comunicarea interactor ↔ interactibil
• Există diverse tipuri de interacțiuni
  • Grab
  • Ray
  • Touch
  • Poke

Adăugați în scenă building block-ul Grab Interaction.

Uitați vă în inspector la obiectul [BuildingBlock] Cube → [BuildingBlock] HandGrabInstallationRoutine. Observați că există preconfigurate script-urile necesare de tip interactibil:

• HandGrabInteractable
• GrabInteratable

Rețineți existența acestora în cazul în care aveți nevoie de interacțiuni de tip grab pe obiecte custom.

În cadrul task-urilor din laborator veți avea de completat implementarea unei arme pe care o veți folosi pentru a trage în niște obiecte (sticle) regăsite în scena suport.

• Interacțiunea cu arma se va face exclusiv prin hand tracking
• Veți învăța să creați un pose custom pentru mână atunci când o țineți în mână
• Veți citi inpul-ul de la hand tracking pentru a controla logica de tragere
• Veți completa logica de raycasting pentru armă

Funcționarea armei este descrisă în mod modular printr-o serie de script-uri, unele dintre acestea le veți avea de completat:

• GunHandGrabController controlează logica de tip grab și release a obiectului
• GunFingerCurlController controlează logica de citire și mapare a input-ului degetului arătător (folosit pe trăgaciul armei)
• GunTriggerCurlController controlează rotația trăgaciului armei
• GunFireController controlează logica de tragere a armei
• GunRaycastController controlează logica de tip raycast
• GunFireEffectsController controlează efectele afișate la momentul tragerii (sunet, efecte de particule)

Dacă ați testat scena sample ComprehensiveRigExample poate ați observat faptul modelul mâinii se conformează unor pose-uri prestabilite atunci obiectele din scenă (torța și cana).

De asemenea, SDK-ul oferă suport pentru diferite dimenisuni ale mâinii (în funcție de utilizator).

Acest feature oferă un grad sporit de imersivitate, întrucât dezvoltatorii se pot asigura de faptul că interacțiunea mână-obiect virtual este desenată fără probleme cum ar fi clipping-ul.

Meta SDK oferă un utilitar pentru a crea pose-uri custom pentru obiecte/modele artbitrare printr-un proces de înregistrare a unui snapshot al pose-ului.

În acest laborator, obiectul [Gun] are atașat doar un script Grabbable, dar momentan nu are un HandGrabInteractable. În loc să atașăm manual această componentă (care nu definește un pose al mâinii), vom crea cu acest utilitar un nou pose, care va crea la rândul său componenta HandGrabInteractable necesară.

Deschideți utilitarul din toolbar, Meta → Interaction → Hand Grab Pose Recorder.

Completați câmpurile de la secțiunea 1.

• LeftInteractions sau RightInteractions (copil al obiectului [BuildingBlock] OVRInteractionComprehensive), în funcție de ce mână doriți să folosiți
• Rigidbody-ul obiectului [Gun]

Pentru a înregistra un pose custom, urmați următorii pași (aveți și un GIF de ajutor după lista de mai jos)

• Rulați scena (Play mode)
• Asigurați-vă că aveți fereastra utilitarului selectată
• Puneți-vă casca
• Așezați-vă mâna pe grip-ul armei într-un pose ca și cum ați ține-o în mână
• Când sunteți mulțumiți de pose, apăsați pe butonul Space de pe tastatură - ar trebui să vă apară un ghost ce indică capturarea pose-ului
• Nu ieșiți înca din Play mode! Dați-vă casca jos și apăsați pe butonul de la secțiunea 3, Save To Collection
• Puteți închide acum Play mode și ultimul pas este apăsarea butonului de la secțiunea 4, Load From Collection
• Verificați în inspector dacă s-a creat un nou obiect HandGrabInteractable, copil al obiectului [Gun]

În continuare, puteți rafina pose-ul prin manipularea încheieturilor de pe obiectul HandGrabInteractable → HandGrabPose. Ajustați poziția degetelor după caz.

Va trebui să modificați pose-ul astfel încât acesta indică apăsarea completă a trăgaciului armei. Workflow recomandat (aveți GIF mai jos):

• Rămâneți în Edit mode
• De pe GunTriggerPivot selectați Testing | Set full curl pentru a simula poziția trăgaciului complet apăsat
• Selectați HandGrabPose
• Asigurați-vă că aveți gizmo-urile active în Scene View
• Rotiți incheieturile pentru a ajusta pose-ul

Ultimele ajustări pe care trebuie să le faceți țin de regulile care determină grab-ul obiectului, precum și specificarea constrângerilor degetelor în momentul în care arma este ținută în mână.

Pentru a realiza aceste setări, modicați de pe HandGrabInteractable atât Pinch Grab Rules cât și Palm Grab Rules astfel:

În final, ajustați pose-ul degetelor astfel (de pe HandGrabPose, Fingers Freedom):

Pentru a valida setup-ul pentru pose-ul custom al mâinii:

• Rulați scena
• Faceți grab pe armă
• Observați dacă mâna virtuală se conformază pose-ului creat (face snap) precum și dacă aveți liberate de mișcare pentru degetul arătător

Pentru a realiza acest feature, va trebui în esență să detectați schimarea de stare a interactibilului atașat de armă. Rețineți că HandGrabInteractable a fost adăugat atunci când ați creat pose-ul custom.

Adăugați pentru script-ul GunHandGrabController elementele lipsă din inspector.

În script-ul GunHandGrabController va trebui să interogați starea variabilei handGrabInteractable - Pentru a realiza acest lucru, abonați-vă evenimentului numit WhenStateChanged de pe handGrabInteractable.

În event handler-ul creat, va trebui să vă folosiți de proprietățile NewState și PreviousState ale argumentului InteractableStateChangeArgs pentru a testa starea de grab / release.

// Object has been grabbed.
if (state.NewState == InteractableState.Select) { ... }

// Object has been released.
if (state.PreviousState == InteractableState.Select && 
    state.NewState      != InteractableState.Select) { ... }

Pentru a accesa interactorul care a declanșat interacțiunea și în esență obiectul tip IHand aferent, puteți interoga structura SelectingInteractors - aceasta descrie intractorii care interacționează în mod curent cu interactibilul (arma) astfel:

var handInteractor = handGrabInteractable.SelectingInteractors.FirstOrDefault();

Pentru a extrage componenta tip IHand:

if (handInteractor != null)
{
    var hand = handInteractor.Hand;
}

Urmăriți comentariile din script pentru a finaliza acest task.

În continuare va trebui să citiți nivelul de curl (sau gradul de îndoire a degetului) arătător, valoare cu ajutorul căreia vom determina atât rotația trăgaciului armei cât și momentul în care aceasta declașează un eveniment de tragere.

SDK-ul ne permite să citim varii proprietați ale mâinilor și degetelor, precum:

• Curl
• Flexion
• Abduction
• Opposition

Accesați script-ul GunFingerCurlController.

Pentru a citi aceste informații ne vom folosi de datele furnizate de FingerFeatureStateProvider (deja atașate pe GunHandGrabController) – în metoda Update a script-ului curent observați că este deja implementată extragerea provider-ului curent în variabila provider.

Pentru a citi gradul de îndoire (curl) a degetului arătăror (index) putem face astfel:

var curlValue = provider.GetFeatureValue(HandFinger.Index, FingerFeature.Curl);
var curlFloat = curlValue ?? 0f;

Afișați în consolă valoarea pe care o obțineți. În continuare va trebui să setați valorile min și max (din inspector) pentru usableFingerCurlRange folosind valoarea afișată în consolă:

• Rulați scena, luați arma în mână
• Îndoiți degetul arătător suficient cât doar să atingă trăgaciul armei - notați valoarea de curl din consolă - aceasta va fi valoarea de maxim pentru slider
• Îndoiți (aproape) complet degetul arătător, până în momentul în care pose-ul degetului nu se mai schimbă - notați valoarea de curl din consolă - aceasta va fi valoarea de minim pentru slider

Normalizați valoarea curl-ului între valorile de minim și maxim obținute. De exemplu, dacă min/max slider sunt [200;250], remapați în range-ul [0;1]. În script-ul Utils aveți metoda ajutătoare Remap.

Pentru a roti trăgaciul armei, apelați metoda SetCurl de pe script-ul GunTriggerCurlController.

Restul de script se ocupă de detecția evenimentului de tragere pe baza unui prag, anume triggerThreshold. Logica deja dată apelează evenimentele de trăgaci apăsat (OnTriggerPressed) sau trăgaci lăsat liber (OnTriggerReleased).

Partea aceasta este în mare parte implementată [moment de pauză 🧘‍♂️!]. În scop informativ:

• Evenimentele OnTriggerPressed și OnTriggerRelease din GunFingerCurlController sunt legate în GunFireController, unde se determină evenimentul de tragere (arma funcționează în modul semi-automat, fiecare apăsare de trăgaci declanșează o tragere)
• Evenimentul OnGunFired este declanșat de aici și ascultat în:
  • GunFireEffectsController pentru a declanșa sunetul de tragere și efecte de particule
  • GunRaycastController pentru logica de tip raycast

Pentru a finaliza implementarea armei, va trebui să completați logica de raycast astfel încât să puteți, pe baza tragerii armei, să spargeți sticlele din scenă.

Accesați script-ul GunRaycastController.

În metoda PerformRaycast va trebui să implementați logica de raycast.

Definim un Ray din poziția raycastOrigin pe direcția forward a acestuia.

var ray = new Ray(raycastOrigin.position, raycastOrigin.forward);

Efectuăm testul tip raycast:

if (Physics.Raycast(ray, out var hitInfo, raycastDistance)) { ... }

Testați dacă hitInfo.collider are atașat un script de tip Bottle - dacă testul trece, apelați metoda Shatter de pe Bottle.

Pentru a reseta sticlele de pe cea de-a doua masă din scenă, ne vom folosi de un intractibil de tip Poke - pe scurt, această funcționează ca un buton virtal și primește input de la interactorul de tip HandPokeInteractor.

Îl aveți deja definit în scenă.

Legarea se poate realiza și în cod, dar pentru acest task, folosiți-vă de evenimentele expuse în inspector de pe script-ul InteractableUnityEventWrapper atașat obiectului BottleReset_PokeInteractable. Evenimentul de interes este Select.

Legați la acesta metoda SpawnBottles din script-ul BottlesManager - îl găsiți atașat de obiectul BottlesTable în scenă.

1. Urmăriți pașii descriși în laborator pentru a face setup SDK-ului Meta XR
2. Importați și testați în modul Quest Link scenele sample
3. Realizați și testați un build pe headset al uneia dintre aceste scene sample
4. Creați un nou pose custom pentru a ține arma în mână
   1. Folosiți utilitarul Hand Grab Pose Recorder
   2. Ajustați pose-ul după înregistrarea acestuia (poziția încheieturilor degetelor)
   3. Aplicați regulile pentru grabbing și pose de pe HandGrabInteractable și HandGrabPose
5. Completați script-ul GunHandGrabController pentru a detecta momentul în care arma este grabbed
   1. Nu uitați să asignați întâi în inspectorul acestui script componentele necesare de pe Interaction Rig!
6. Completați script-ul GunFingerCurlController pentru a citi și aplica inputul corespuzător valorii de curl a degetului arătător
7. Completați script-ul GunRaycastController pentru a realiza raycast-ul în urma evenimentului de tragere și adăugați logica de spargere a sticlelor în cazul în care raza se intersectează cu un obiect de tip Bottle
8. Legați poke interactable-ul “Reset Bottles” de script-ul BottlesManager pentru a reseta sticlele
9. [✨Bonus✨] Creați un nou poke interactor
   • Atașat de armă (de ex. în partea stângă / lângă grip)
   • Prin apăsarea acestuia se va face toggle între modul de tragere semi-automatic și automat al armei
   • La apăsare să schimbați textul (opțional și culoarea) interactorului astfel încât acesta să indice modul curent de tragere al armei
   • Extindeți logica GunFireController pentru logica de tragere tip automat (sau creați-vă propriile script-uri, după plac/necesitate)