ManoMotion este un SDK ce permite dezvoltarea de aplicații în AR, unde modalitatea de input este determinată de hand tracking.

SDK-ul este construit pe baza unor metode de computer vision și machine learning ce facilitează detecția mâinilor; este antrenat, de asemenea, să recunoască o serie de gesturi, de care vom vorbi în acest laborator.

Putem crea aplicații sau jocuri folosind ARFoundation + ManoMotion care să nu necesite interacțiunea cu touchscreen-ul sau cu UI-ul, modalitatea de input fiind dictată de către poziția mâinii detectate, precum și a gesturilor efectuate.

ManoMotion SDK (împreună cu ARFoundation) sunt deja incluse în laborator, iar setările aferente build-ului au fost realizate. De asemenea, în scena aferentă laboratorului acesta, există deja un manager script care are setat license key-ul pentru ManoMotion.

Următorii pași nu sunt necesari în cadrul acestui laborator, dar ilustrează modalitatea de adăugare a package-ului ManoMotion în proiect, generarea și inserarea license key-ului (în framework este deja făcut setup-ul și se folosește un license key).

1. Creați-vă un cont aici. Este necesar pentru descărcarea unity package-ului și accesarea documentației.
2. Descărcați unity package de aici. Note: În laborator s-a folosit “Pro & AR Foundation”.
3. De aici creați-vă un license key. Trebuie să vă introduceți Bundle ID-ul aplicației (se găsește în Project Settings → Player → Package Name), precum și target platform-ul (Android sau iOS).
4. Importați package-ul Unity (setările de proiect ar trebui să fie realizate automat – în caz contrar, folosiți quickstart guide-ul de aici).
5. Pe scena demo sau pe una creată de voi cu suport pentru ManoMotion, adăugați-vă pe scriptul ManoMotionManager license key-ul generat la pasul 3.
6. Pe site-ul ManoMotion citiți și realizați modificările necesare ale Quickstart Guide-ului din secțiunea de documentație, unde sunt prezentate setările din Unity pentru realizarea corectă a unui build.

Un proiect ce folosește ManoMotion se folosește de camera telefonului ca input; SDK-ul procesează fluxul de frame-uri primite de la cameră și detectează mâna și gesturile. Ne putem folosi destul de ușor de informația oferită de SDK – acesta setează valorile unor structuri de date pe care le putem interoga în fiecare frame. Informația oferită este de mai multe tipuri, împărțită pe o serie de clase:

Reprezintă clase “generale” de detecție, valori posibile:

ManoClass.NO_HAND
ManoClass.GRAB_GESTURE
ManoClass.POINTER_GESTURE
ManoClass.PINCH_GESTURE

Acestea sunt gesturi de tip trigger – de exemplu, momentul (sau frame-ul) în care s-a detectat un “grab”, adică SDK-ul a detectat gestul de tip închidere pumn. Alt exemplu este un gest de tip “release”, care este true în frame-ul în care s-a detectat gestul de deschidere a pumnului. Valori posibile:

ManoGestureTrigger.NO_GESTURE
ManoGestureTrigger.CLICK
ManoGestureTrigger.RELEASE_GESTURE
ManoGestureTrigger.GRAB_GESTURE
ManoGestureTrigger.PICK
ManoGestureTrigger.DROP

Acestea sunt gesturile continue, mai exact cele care persistă pe mai multe frame-uri – gestul de tip “closed hand” este detectat în toate frame-urile în care este detectată o mână cu pumnul strâns. Valori posible:

ManoGestureContinuous.NO_GESTURE
ManoGestureContinuous.HOLD_GESTURE
ManoGestureContinuous.OPEN_HAND_GESTURE
ManoGestureContinuous.OPEN_PINCH_GESTURE
ManoGestureContinuous.CLOSED_HAND_GESTURE
ManoGestureContinuous.POINTER_GESTURE

Specifică ce parte a mâinii este detectată – palma sau dosul palmei. Valori posibile:

HandSide.None
HandSide.Backside
HandSide.Palmside

// Detected hand information
HandInfo handInfo = ManomotionManager.Instance.Hand_infos[0].hand_info;
 
// Detected gesture information
GestureInfo gestInfo = handInfo.gesture_info;
 
ManoClass manoClass = gestInfo.mano_class;                          // Gesture class
ManoGestureTrigger gestTrigger = gestInfo.mano_gesture_trigger;     // Trigger gesture 
ManoGestureContinuous gestCont = gestInfo.mano_gesture_continuous;  // Continuous gesture
HandSide handSide = gestInfo.hand_side;                             // Hand side
int gestureState = gestInfo.state;                                  // Gesture state
Vector3 palmPosNorm = handInfo.tracking_info.palm_center;           // Normalised screen coords [0...1]
 
/* To get screen coords in pixels, multiply 'palmPosNorm' x/y with Screen.width, Screen.height */

În principal, aceste informații înlocuiesc inputul clasic, așadar am putea testa pe Update(), de exemplu:

void Update()
{
    // Grab hand info from ManoMotion's SDK
    HandInfo handInfo = ManomotionManager.Instance.Hand_infos[0].hand_info;
 
    if(handInfo.gesture_info.mano_gesture_trigger == ManoGestureTrigger.GRAB_GESTURE)
    {
        // Do something only on the frame this is true
    }
 
    if(handInfo.gesture_info.mano_gesture_continuous == ManoGestureContinuous.OPEN_HAND_GESTURE)
    {
        // Do something every frame this is true
    }
}

Proiectul are deja partea de AR configurată precum și baza unui joc (o versiune simplificată a Fruit Ninja), la care va trebui să implementați câteva feature-uri.

Aplicația de laborator este configurată într-o serie de etape, care ajută la configurarea spațiului AR de joc. Acestea sunt:

• Etapa 1, cea de plane detection
• Etapa 2, cea de instanțiere game scene AR. Acest pas se realizează prin efectuarea unui gest de tip Grab peste un plan detectat – se realizează un raycast și se instanțiază scena de joc
• Etapa 3, cea de ajustări – se poate modifica rotația si scalarea scenei
• Etapa 4, cea de joc – în varianta nerezolvată, ar trebui să înceapă să fie instanțiate la intervale random de timp obiecte 3D (fructe) - nu se poate realiza interacțiunea cu acestea

Scripturi relevante:

• SetupScripts
  • ARGameInitCanvasController
  • ARInitController – Coordonează întreg procesul de setup AR și implementează funcțiile apelate de către butoanele de pe UI
  • ARSetupPhasesController – Coordonează tranzițiile între etapele de inițializare
  • Globals
• GameScripts
  • [TODO] CursorPositionController – Setează poziția unui cursor (obiect 3D care va urmări poziția mâinii pe ecran)
  • FruitController
  • [TODO] FruitSpawner – Coordonează procesul de spawning al fructelor
  • [TODO] HandGestureController – Detectează o serie de gesturi diferite și modifică logica jocului pe baza acestora

Înainte de a lucra la joculețul propus, vă recomandăm mai întâi să testați scena demo oferită de către cei de la ManoMotion. Aceasta se găsește în Assets → ManoMotion ARFoundation → Scenes → ManoMotionSDKProFeatures.

În cazul în care activați toate feature-urile din scena demo, ar trebui sa obțineți o scenă similară cu cea prezentată mai jos:

1. În cazul în care nu au fost probleme, faceți switch la scena de laborator (Fruit Ninja) și realizați un build. Citiți cu atenție etapele de inițializare – pasul acesta este încheiat dacă instațiați scena de joc, iar fructele încep să se spawneze.
2. Pentru a tăia fructele, vă este oferit un obiect care ar trebui să urmărească poziția mâinii (mai exact, acest obiect de tip cursor este numit Spikeball_Cursor și se găsește în prefab-ul GameScene din Assets → Prefabs → ManoMotion). Implementarea va trebui realizată în scriptul CursorPositionController. Rezultat corect: Obiectul cursor urmărește poziția mâinii și poate tăia fructele instanțiate în scenă.
3. Implementați diverse gesturi pentru a altera logica jocului. De exemplu, în frame-urile în care este detectat podul palmei, opriți generarea de fructe. Hint! Folosiți-vă de scriptul HandGestureController.
4. Pentru fiecare frame în care se detectează gestul de tip continuu CLOSED_HAND_GESTURE, creșteți spawn rate-ul de 20 de ori. Folosiți-vă de scriptul HandGestureController.
5. Când este detectat gestul trigger de tip PICK, realizați tăierea (distrugerea) tuturor fructelor instanțiate în acel moment în scenă. Nu folosiți direct funcția Destroy(). Pentru un efect mai spectaculos, folosiți funcția deja implementată în controllerul de fructe. Folosiți-vă de scriptul HandGestureController.
6. Bonus. Adăugați un scor pe ecran. De fiecare dată când tăiați un fruct, scorul va crește cu 1.