Rezumat
Pentru a dezvolta pentru VITURE BEAST, deschideți pagina Developer a VITURE și alegeți VITURE XR Glasses SDK. Acesta este SDK-ul C multiplatformă pentru conectarea software-ului la ochelarii VITURE. Documentația sa enumeră Android, Linux, Windows și macOS. VITURE XR SDK for Unity, separat, este descris pentru experiențe care rulează pe VITURE Neckband, așa că nu este punctul de plecare pentru o aplicație de control al ochelarilor BEAST.
SDK-ul pentru ochelari oferă unei aplicații acces la comunicarea cu dispozitivul, la datele de urmărire a capului, la streamingul camerei și la anumite comenzi ale ochelarilor. Pentru BEAST în mod specific, VITURE documentează urmărirea nativă 3DoF, passthrough-ul camerei și comenzile native ale afișajului. SDK-ul nu transformă ochelarii într-un computer de uz general și nici nu creează automat o aplicație XR finalizată. Dumneavoastră construiți o aplicație gazdă, conectați BEAST prin USB și apelați SDK-ul din acea aplicație.
Fluxul de dezvoltare: Alegeți platforma gazdă -> descărcați pachetul SDK corespunzător -> compilați primul exemplu de conectare oferit de producător -> citiți datele de urmărire -> adăugați o comandă BEAST sau o funcție de cameră -> testați aplicația cu ochelarii.
Pentru context despre produs înainte de a planifica integrarea software, consultați recenzia VITURE BEAST pe VRX. Pagina oficială a produsului de la VITURE este de asemenea utilă pentru detalii hardware.
INTRODUCERE:
(dacă știți deja despre SDK și suportul pentru platforme, treceți la ghidul principal)
Ce este VITURE BEAST?
VITURE BEAST este un afișaj XR USB-C cu senzori integrați și o cameră. În modul nativ, propria sa unitate de procesare gestionează urmărirea 3DoF și efectele de afișare acceptate; în modul bypass, gazda trimite un semnal video pe care ochelarii îl transmit mai departe. Această distincție între modul nativ și cel bypass contează atunci când software-ul schimbă modul de afișare sau comportamentul urmăririi.
SDK-ul pentru dezvoltatori este un software la care programul dumneavoastră se leagă pentru a putea comunica cu ochelarii. Este separat de aplicațiile VITURE de zi cu zi, precum SpaceWalker, care servește la utilizarea funcțiilor de afișare și de ecran spațial acceptate, nu la scrierea de cod.
Cele două SDK-uri VITURE au roluri diferite
VITURE XR Glasses SDK:
- La ce servește: API C nativ pentru accesul la ochelari, urmărire, streamingul camerei și comenzile dispozitivului pe platformele gazdă acceptate.
- Îl folosiți pentru dezvoltarea BEAST?: Da. Acesta este SDK-ul BEAST tratat în acest ghid.
VITURE XR SDK for Unity:
- La ce servește: Pachet Unity XR documentat pentru crearea de experiențe imersive pe VITURE Neckband, cu integrări Unity precum urmărirea mâinilor.
- Îl folosiți pentru dezvoltarea BEAST?: Nu ca SDK implicit pentru ochelarii BEAST. Nu îl confundați cu SDK-ul nativ pentru ochelari.
SpaceWalker:
- La ce servește: Software însoțitor VITURE pentru modurile de afișare și funcțiile de ecran spațial acceptate.
- Îl folosiți pentru dezvoltarea BEAST?: Nu. Este o aplicație pentru utilizatorul final, nu un mediu de dezvoltare.
Ce controlează XR Glasses SDK
Conectarea dispozitivului:
- Ce poate face aplicația: Să descopere un dispozitiv conectat, să creeze un handle de dispozitiv, să îl inițializeze, să îl pornească și să îl închidă corect.
- Detaliu BEAST de reținut: SDK-ul comunică cu ochelarii prin conexiunea gazdei.
Urmărirea capului:
- Ce poate face aplicația: Să citească date de orientare/IMU și să folosească interfața de urmărire specifică modelului.
- Detaliu BEAST de reținut: BEAST este documentat pentru 3DoF nativ; intrarea 6DoF VIO din tabelul dispozitivelor se referă la Luma Ultra.
Afișajul și comenzile ochelarilor:
- Ce poate face aplicația: Să citească sau să seteze luminozitatea, volumul, modul de afișare, modul 2D/3D, nuanțarea și opțiunile modului nativ, acolo unde sunt acceptate.
- Detaliu BEAST de reținut: În modul nativ, folosiți constantele de afișare native specifice BEAST. Unele combinații mod/frecvență nu sunt acceptate.
Fluxul camerei:
- Ce poate face aplicația: Să acceseze cadrele acceptate ale camerei passthrough prin API-ul de cameră al SDK-ului.
- Detaliu BEAST de reținut: BEAST este listat cu o cameră UVC passthrough. Accesul la cameră este separat de urmărirea 6DoF.
SDK-ul nu oferă de unul singur: fluxul de lucru al aplicației, logica de business, meniurile, stocarea datelor, conturile de utilizator sau o scenă Unity completă. Echipa care dezvoltă aplicația construiește aceste părți în jurul funcțiilor de dispozitiv expuse de SDK. Pagina principală pentru dezvoltatori evidențiază aceste patru platforme. Începând cu SDK 2.4.0 (6 august 2026), documentația enumeră o a cincea țintă: Browser, o versiune WebAssembly cu un API TypeScript care comunică cu ochelarii prin WebHID, doar în Chrome și Chromium, cu BEAST acceptat și Luma Ultra exclus. Verificați pachetul curent și notele de lansare înainte de a alege un dispozitiv sau un sistem de operare pentru producție.
Suport multiplatformă: Android, Linux, Windows și macOS
„Multiplatformă” înseamnă că VITURE oferă versiuni ale SDK-ului și instrucțiuni de configurare specifice fiecărei platforme pentru același SDK de ochelari. Nu înseamnă că un singur binar rulează neschimbat peste tot. Alegeți gazda pe care trebuie să ruleze aplicația, apoi folosiți biblioteca și ghidul de integrare corespunzătoare. Documentația API actuală enumeră aceste arhitecturi:
Windows:
- Arhitectură documentată: x86_64
- Configurare tipică: Aplicație desktop C/C++ care folosește biblioteca și headerele SDK pentru Windows; urmați Quick Start: Desktop (C++).
Linux:
- Arhitectură documentată: x86_64 și aarch64
- Configurare tipică: Aplicație desktop C/C++. Adăugați regula udev de la VITURE pentru ca aplicația să poată accesa interfața USB/HID fără a rula ca root.
macOS:
- Arhitectură documentată: aarch64 (Apple silicon)
- Configurare tipică: Aplicație desktop C/C++ care folosește biblioteca și headerele pentru macOS; urmați Quick Start: Desktop (C++).
Android:
- Arhitectură documentată: armeabi-v7a și arm64-v8a
- Configurare tipică: Aplicație Android care folosește biblioteca C nativă prin JNI; gestionați permisiunea USB și conexiunea în aplicația Android.
Pagina principală pentru dezvoltatori evidențiază aceste patru platforme. Pagina API detaliată poate adăuga ținte sau modifica arhitecturile acceptate în timp, așa că verificați pachetul curent și notele de lansare înainte de a alege un dispozitiv sau un sistem de operare pentru producție.
De ce aveți nevoie înainte de dezvoltare
· Ochelari VITURE BEAST și o conexiune de date USB-C la computerul sau gazda Android pe care intenționați să le acceptați.
· Un computer de dezvoltare cu compilatorul/instrumentele de build pentru ținta dumneavoastră: un toolchain C/C++ și CMake pentru desktop sau Android Studio cu componentele NDK și CMake pentru Android.
· Pachetul VITURE XR Glasses SDK pentru platforma țintă, descărcat de pe pagina Developer a VITURE.
· Documentația SDK corespunzătoare, în special Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming și Native-DOF Devices.
· O înțelegere de bază a limbajului folosit de echipa care dezvoltă aplicația: C/C++ pentru exemplele desktop, plus Kotlin sau Java și JNI pentru o integrare Android tipică.
Cum construiți un prim test cu SDK-ul VITURE BEAST
Începeți cu o mică aplicație gazdă care găsește BEAST și citește datele de urmărire. După ce aceasta funcționează, adăugați o comandă sau o funcție de cameră.
Pasul 1: Alegeți unde va rula aplicația
Alegeți computerul sau telefonul care va rula aplicația; acesta determină pachetul SDK și ghidul de configurare.
1. Alegeți gazda. Folosiți Windows, Linux sau macOS pentru un computer ori Android pentru un telefon conectat la BEAST.
2. Notați sistemul de operare și procesorul. De exemplu, notați Windows x86_64 sau macOS Apple silicon, apoi verificați tabelul platformelor de mai sus.
3. Urmați ramura Android doar pentru o aplicație Android. Aceasta folosește o bibliotecă nativă, o punte JNI și permisiunea USB.
Pasul 2: Descărcați VITURE XR Glasses SDK
Descărcați SDK-ul oficial pentru ochelari și deschideți ghidul pentru gazda dumneavoastră. Pachetul Unity pentru Neckband este destinat unei alte configurații.
1. Deschideți pagina Developer. Într-un browser, accesați https://www.viture.com/developer și derulați până la „VITURE XR Glasses SDK”.
2. Descărcați pachetul pentru platforma dumneavoastră. Pe cardul SDK, faceți clic pe „Download” și alegeți gazda, dacă vi se cere.
3. Deschideți ghidul de configurare. Pe același card, faceți clic pe „Documents”, apoi pe „Core Concepts”, apoi pe „Quick Start: Desktop (C++)” sau pe „Android Integration Guide”.
4. Verificați compatibilitatea. Reveniți la pagina Developer, deschideți „Release Notes” și verificați sistemul de operare, procesorul și firmware-ul BEAST.
Treceți la Pasul 3 când: aveți biblioteca, headerele și ghidul de configurare corespunzătoare.
Pasul 3: Configurați SDK-ul pe platforma gazdă
Folosiți doar ramura de configurare pentru gazda aleasă la Pasul 1.
Pentru Windows, Linux sau macOS
1. Deschideți ghidul pentru desktop. În SDK Documents, alegeți „Quick Start: Desktop (C++)” și țineți-l deschis lângă editorul de cod.
2. Legați SDK-ul. Deschideți exemplul sau proiectul dumneavoastră, apoi folosiți exemplul CMake din ghid pentru a adăuga headerele SDK și biblioteca pentru ochelari.
În fișierul `CMakeLists.txt` al proiectului, adăugați căile de include și de bibliotecă ale SDK-ului. Înlocuiți `VITURE_SDK_ROOT` cu folderul în care ați dezarhivat SDK-ul:
target_include_directories(my_xr_app PRIVATE "${VITURE_SDK_ROOT}/include")
target_link_directories(my_xr_app PRIVATE "${VITURE_SDK_ROOT}/lib")
target_link_libraries(my_xr_app PRIVATE glasses)
3. Doar pentru Linux: permiteți accesul USB. În Terminal, urmați „Linux udev Rule” și creați `/etc/udev/rules.d/70-viture.rules`; reîncărcați regulile și reconectați BEAST. Omiteți acest pas pe Windows și macOS.
4. Compilați exemplul. Deschideți `main.cpp` din exemplul SDK și asigurați-vă că se compilează înainte de a adăuga funcții.
Pentru Android
1. Creați un proiect Android. În Android Studio, porniți un proiect cu suport CMake/NDK și deschideți `app/src/main` în panoul proiectului.
2. Copiați fișierele SDK. Urmați „Android Integration Guide”: puneți headerele în `app/src/main/include/` și fișierul `.so` corespunzător în `app/src/main/jniLibs/<ABI>/`.
3. Legați biblioteca. În Android Studio, deschideți `app/src/main/cpp/CMakeLists.txt` și `app/build.gradle.kts`; aplicați setările CMake, NDK și ABI din ghid.
În `CMakeLists.txt`, importați biblioteca SDK și legați-o la puntea JNI. Acest exemplu presupune că fișierele SDK se află în folderele indicate în Android Integration Guide:
add_library(glasses SHARED IMPORTED)
set_target_properties(glasses PROPERTIES IMPORTED_LOCATION
"${CMAKE_SOURCE_DIR}/../jniLibs/arm64-v8a/libglasses.so")
add_library(glasses_bridge SHARED glasses_bridge.cpp)
target_include_directories(glasses_bridge PRIVATE "${CMAKE_SOURCE_DIR}/../include")
target_link_libraries(glasses_bridge glasses android log)
4. Adăugați puntea dintre aplicație și C++. În folderul sursă al aplicației, creați clasa `GlassesBridge` din ghid; funcțiile sale `external` apelează codul JNI.
5. Solicitați permisiunea USB. Folosiți `UsbManager` din Android pentru a găsi BEAST; după ce utilizatorul atinge Allow, deschideți conexiunea USB și transmiteți descriptorul de fișier al acesteia către punte.
După ce utilizatorul atinge Allow, deschideți conexiunea USB în activitatea Kotlin și transmiteți descriptorul de fișier către puntea nativă. Înlocuiți `GlassesBridge` cu numele clasei punte din proiectul dumneavoastră:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
În `glasses_bridge.cpp`, funcția nativă create transmite acel descriptor de fișier Android către SDK-ul VITURE:
static XRDeviceProviderHandle g_handle = nullptr;
extern "C" JNIEXPORT jboolean JNICALL Java_com_example_GlassesBridge_create(JNIEnv*, jobject, jint pid, jint fd) { g_handle = xr_device_provider_create((int)pid, (int)fd); return g_handle != nullptr; }
Treceți la Pasul 4 când: aplicația se compilează și încarcă SDK-ul fără erori de fișier lipsă sau de linker.
Pasul 4: Conectați BEAST și rulați primul exemplu
Acum testați conexiunea cu ochelarii. Folosiți exemplul desktop pe Windows, Linux sau macOS. Pe Android, păstrați configurarea USB și JNI de la Pasul 3; nu folosiți codul de descoperire HID pentru desktop.
1. Conectați BEAST. Folosiți un cablu de date USB-C; pe Android, acceptați solicitarea USB afișată de telefon.
2. Găsiți BEAST și creați-i handle-ul. Pe desktop, găsiți ID-ul de produs BEAST prin descoperire HID, apoi creați providerul cu xr_device_provider_create(product_id). Pe Android, transmiteți atât ID-ul de produs, cât și descriptorul de fișier din conexiunea USB.
3. Porniți urmărirea. Porniți urmărirea înregistrând un callback. Un callback este o funcție pe care SDK-ul o apelează când sosesc datele de urmărire. BEAST furnizează roll, pitch și yaw de la data[0] la data[2] și cuaternionul de la data[3] la data[6], dar numai cu SDK 2.4.0 sau mai nou și cu firmware actualizat al ochelarilor. Pe firmware mai vechi, callbackul de poziție nu se declanșează niciodată pe BEAST (VITURE menționează acest lucru la „Known Limitations on Beast” în notele de lansare): în acest caz, fie înregistrați xr_device_provider_register_imu_raw_callback și integrați singuri datele IMU brute, fie comutați ochelarii în modul nativ și lăsați-i pe ei să facă urmărirea.
Adăugați această funcție deasupra lui main():
</> C++ static void on_pose(float* data, uint64_t timestamp) {
std::printf(
"Timestamp: %llu | Roll: %.2f | Pitch: %.2f | Yaw: %.2f\n",
static_cast<unsigned long long>(timestamp),
data[0], data[1], data[2]
);
}
Înregistrați callbackul înainte de a inițializa și de a porni SDK-ul:
</> C++ xr_device_provider_register_imu_pose_callback(handle, on_pose);
int rc = xr_device_provider_initialize(handle, nullptr, nullptr);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
rc = xr_device_provider_start(handle);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
Pe desktop, folosiți handle. În codul JNI pentru Android, folosiți g_handle.
4. Deschideți fluxul de urmărire. Adăugați acest apel în `main.cpp` pe desktop; pe Android, expuneți-l prin JNI și apelați-l după `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Când aplicația se închide, închideți IMU-ul, apoi opriți providerul, închideți-l complet (shutdown) și distrugeți-l. Pe Android, apelați aceleași funcții de curățare înainte de a închide conexiunea USB:
xr_device_provider_close_imu(handle, VITURE_IMU_MODE_POSE); xr_device_provider_stop(handle); xr_device_provider_shutdown(handle); xr_device_provider_destroy(handle);
5. Verificați rezultatul. Rulați aplicația și urmăriți în consola desktop sau în Logcat din Android Studio actualizările privind conexiunea și urmărirea.
Treceți la Pasul 5 când: BEAST se conectează și actualizările de urmărire sosesc fără erori.
Pasul 5: Adăugați o comandă BEAST
După ce urmărirea funcționează, adăugați o comandă pentru ochelari în codul de control al dispozitivului din aplicație, după ce handle-ul SDK a pornit.
1. Alegeți o comandă. În SDK Documents, deschideți „Device Control” și verificați opțiunile de luminozitate, volum sau afișare acceptate de BEAST.
2. Citiți și setați valoarea. Adăugați apelurile C/C++ în codul de control; pe Android, puneți-le în `glasses_bridge.cpp` și expuneți-le prin JNI.
După pornirea providerului, citiți luminozitatea BEAST și încercați o valoare acceptată. Intervalul documentat este de la 0 la 8:
int brightness = xr_device_provider_get_brightness_level(handle); int rc = xr_device_provider_set_brightness_level(handle, 5); if (rc != VITURE_GLASSES_SUCCESS) { std::fprintf(stderr, "Brightness update failed: %d\n", rc); }
3. Potriviți API-ul de afișare cu modul. Puteți configura și modul de afișare al BEAST. Modul nativ folosește procesarea de afișare integrată a ochelarilor și acceptă 3DoF nativ. Modul bypass transmite semnalul video al gazdei prin ochelari. Alegeți ramura care corespunde modului selectat în aplicație. Nu rulați ambele ramuri una după alta.
În acest exemplu, use_native_mode este o setare booleană din aplicație, iar rc este variabila de rezultat existentă.
</> C++ if (use_native_mode) {
rc = xr_device_provider_native_set_mode(handle, 1);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
rc = xr_device_provider_native_set_display_mode(
handle, VITURE_NATIVE_DISPLAY_MODE_1920_1200_60HZ);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
rc = xr_device_provider_native_set_dof(handle, VITURE_NATIVE_DOF_3);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
} else {
rc = xr_device_provider_native_set_mode(handle, 0);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
rc = xr_device_provider_set_display_mode(
handle, VITURE_DISPLAY_MODE_3840_1200_90HZ);
if (rc != VITURE_GLASSES_SUCCESS) return rc;
}
Alegeți o rezoluție și o rată de reîmprospătare acceptate de BEAST.
4. Testați o singură modificare. Rulați aplicația, verificați rezultatul pe BEAST, apoi restabiliți setarea inițială.
Important: BEAST acceptă 3DoF nativ, dar firmware-ul actual acceptă doar trei moduri de afișare: 1920 x 1200 la 60 Hz și 3D side-by-side 3840 x 1200 la 60 Hz în modul nativ, respectiv 3840 x 1200 la 90 Hz în modul bypass (notele de lansare VITURE XR Glasses SDK, 2.3.0 și 2.3.1). Alte constante trec de verificarea SDK-ului, dar ochelarii le resping sau le ignoră, așa că citiți modul înapoi după ce l-ați setat și considerați notele de lansare drept lista valorilor acceptate.
Pasul 6: Adăugați accesul la cameră doar dacă aplicația are nevoie de el
Adăugați camera passthrough doar dacă aplicația are nevoie de cadre de imagine. Streamingul camerei este separat de urmărirea capului și nu oferă 6DoF.
1. Deschideți ghidul pentru cameră. În SDK Documents, alegeți „Camera Streaming” și urmați secțiunea de configurare pentru gazda dumneavoastră.
2. Adăugați un handler de cadre. În aplicație, creați o funcție care primește cadrele camerei și le trimite către funcționalitatea care are nevoie de ele, cum ar fi o previzualizare.
În modulul C++ pentru cameră, creați providerul de cameră al BEAST și porniți-l cu callbackul de cadre, `on_frame`. Acest apel cu două argumente este pentru desktop:
int camera_vid = xr_camera_provider_get_camera_vid(pid); int camera_pid = xr_camera_provider_get_camera_pid(pid); XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid); int rc = xr_camera_provider_start(camera, on_frame, nullptr);
// La final xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
Pe Android, transmiteți descriptorul de fișier USB al camerei ca al treilea argument, folosind configurarea permisiunilor de la Pasul 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Obțineți mai întâi permisiunea. Android necesită permisiuni pentru cameră și USB; pe desktop, urmați ghidul platformei.
4. Protejați confidențialitatea. Explicați utilizarea camerei, capturați doar ce are nevoie funcționalitatea respectivă și urmați procesul GDPR al organizației dumneavoastră în UE.
Omiteți acest pas dacă aplicația are nevoie doar de urmărire sau de comenzile afișajului.
Pasul 7: Testați și pregătiți un pilot restrâns
1. Testați reconectarea. Reporniți aplicația, deconectați și reconectați BEAST și verificați că aplicația rămâne stabilă.
2. Testați pe BEAST. Verificați, pentru fiecare funcționalitate, modul de afișare, rezoluția, urmărirea și permisiunile camerei în raport cu firmware-ul.
3. Salvați detaliile testelor. Notați versiunile SDK, ale sistemului de operare, procesorului, compilatorului/NDK și firmware-ului, detaliile conexiunii și erorile.
4. Planificați implementarea. Stabiliți cum veți instala și actualiza aplicația gazdă, cum veți gestiona accesul la cameră și datele și cum veți asigura suportul.
Condiție pentru pilot: extindeți doar după ce ați testat gazda, funcționalitățile, permisiunile și procesul de actualizare.
Ce nu face SDK-ul
VITURE XR Glasses SDK este un set de instrumente pentru integrarea dispozitivului, nu un mediu complet de creare de conținut XR. Expune funcții pe care software-ul dumneavoastră le poate apela. Echipa dumneavoastră trebuie în continuare să aleagă un framework pentru aplicație, să scrie interfața cu utilizatorul și logica sarcinilor, să compileze aplicația pentru platforma gazdă și să decidă cum o va implementa și susține compania.
De asemenea, SDK-ul nu face ca fiecare capabilitate să fie disponibilă pe fiecare model VITURE. În tabelul hardware actual, BEAST este listat cu 3DoF nativ și acces la camera passthrough, în timp ce Luma Ultra este modelul listat cu 3/6DoF și VIO stereo. Verificați tabelul cu hardware-ul acceptat pentru fiecare API pe care intenționați să îl folosiți, în loc să interpretați descrierea generală „3DoF/6DoF” de pe portal drept o promisiune că BEAST acceptă toate modurile de urmărire.
Greșeli frecvente în dezvoltarea cu SDK-ul VITURE BEAST
- Descărcarea Unity XR SDK pentru o aplicație de control al ochelarilor BEAST.: Folosiți cardul VITURE XR Glasses SDK; ghidul Unity este documentat pentru VITURE Neckband.
- Presupunerea că „multiplatformă” înseamnă același binar sau aceeași configurare peste tot.: Descărcați biblioteca corectă și urmați ghidul de arhitectură și conectare al platformei țintă.
- Tratarea BEAST ca dispozitiv 6DoF VIO pentru că portalul menționează 6DoF.: Verificați suportul la nivel de model: tabelul SDK actual listează 3DoF nativ pentru BEAST și 6DoF VIO pentru Luma Ultra.
- Apelarea funcțiilor standard pentru modul de afișare în timp ce BEAST este în modul nativ.: Verificați modul activ și folosiți setul de funcții corespunzător: standard sau `native_*`.
- Deschiderea camerei înainte de obținerea permisiunilor sau fără un caz de utilizare pentru cameră.: Solicitați mai întâi permisiunile platformei și adăugați streamingul camerei doar când aplicația are nevoie de date de imagine.
- Folosirea SpaceWalker ca editor de cod sau ca aplicație de configurare a SDK-ului.: Folosiți pagina Developer, pachetul SDK, documentația și un editor de cod sau Android Studio.
Concluzie
Dezvoltarea pentru VITURE BEAST începe cu VITURE XR Glasses SDK, nu cu pachetul Unity pentru experiențe Neckband sau cu aplicația pentru consumatori SpaceWalker. Alegeți Android, Linux, Windows sau macOS ca gazdă, descărcați SDK-ul corespunzător de pe pagina Developer a VITURE, urmați ghidul pentru platforma respectivă și construiți mai întâi un program mic care se conectează prin USB și citește datele de urmărire. Pornind de aici, adăugați o comandă BEAST acceptată sau o funcție de cameră și testați-o pe hardware-ul real. Pentru companii, această abordare separă fluxul de lucru și datele aplicației de funcțiile de dispozitiv ale ochelarilor, permite dezvoltarea pe platforma gazdă potrivită implementării și oferă echipelor o modalitate de a valida un caz de utilizare industrial bine definit înainte de a investi într-o implementare mai amplă.
Construiți un flux de lucru XR pentru VITURE BEAST? Explorați pagina produsului VITURE BEAST și documentația pentru dezvoltatori VITURE înainte de a defini cerințele pilotului.
























