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

1. Î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:

2. În cazul în care nu au fost probleme, faceți switch la scena de laborator (L6_Scene) ș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.

3. 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 > L6_ManoMotion). Implementarea va trebui realizată în script-ul CursorPositionController. Rezultat corect: Obiectul cursor urmărește poziția mâinii și poate tăia fructele instanțiate în scenă. Urmăriți todo-urile din script.

4. Va trebui să implementați diverse gesturi pentru a altera logica jocului. De exemplu, în frame-urile în care este detectat podul palmei, opriți spawning de fructe. Pentru detalii, urmăriți todo-urile din script-ul HandGestureController

5. Pentru fiecare frame în care se detectează gestul de tip continuu CLOSED_HAND_GESTURE, creșteți spawn rate-ul de 20 de ori. Pentru detalii, urmăriți todo-urile din script-ul HandGestureController

6. Când este detectat gestul de trigger de tip PICK, realizați o implementare prin care să “tăiați” (distrugeți) toate fructele instanțiate în acel moment în scena. Nu folosiți direct Destroy() pe ele, există o funcție deja implementată în controller-ul de fructe (use that!). Pentru detalii, urmăriți todo-urile din script-ul HandGestureController