Zhrnutie
Ak chcete vyvíjať pre VITURE BEAST, otvorte stránku Developer spoločnosti VITURE a vyberte VITURE XR Glasses SDK. Ide o multiplatformové SDK v jazyku C na prepojenie softvéru s okuliarmi VITURE. Jeho dokumentácia uvádza Android, Linux, Windows a macOS. Samostatné VITURE XR SDK for Unity je opísané pre aplikácie bežiace na VITURE Neckband, takže nie je východiskovým bodom pre aplikáciu na ovládanie okuliarov BEAST.
SDK pre okuliare poskytuje aplikácii prístup ku komunikácii so zariadením, údajom o sledovaní hlavy, streamovaniu z kamery a vybraným ovládacím prvkom okuliarov. Konkrétne pre BEAST VITURE dokumentuje natívne sledovanie 3DoF, passthrough kameru a natívne ovládanie displeja. Z okuliarov však nerobí univerzálny počítač ani automaticky nevytvorí hotovú XR aplikáciu. Vy vytvoríte hostiteľskú aplikáciu, pripojíte BEAST cez USB a z tejto aplikácie voláte SDK.
Postup vývoja: Vyberte hostiteľskú platformu -> stiahnite jej balík SDK -> zostavte prvú ukážku pripojenia od výrobcu -> načítajte údaje o sledovaní -> pridajte ovládanie BEAST alebo funkciu kamery -> otestujte aplikáciu s okuliarmi.
Ak chcete pred plánovaním softvérovej integrácie získať kontext o produkte, pozrite si recenziu VITURE BEAST na VRX. Pri hardvérových detailoch sa oplatí pozrieť aj oficiálnu produktovú stránku VITURE.
ÚVOD:
(ak už poznáte SDK a podporu platforiem, prejdite k hlavnému návodu)
Čo je VITURE BEAST?
VITURE BEAST je XR displej s rozhraním USB-C so zabudovanými senzormi a kamerou. V natívnom režime sa o sledovanie 3DoF a podporované efekty displeja stará jeho vlastné spracovanie; v režime bypass posiela videosignál hostiteľ a okuliare ho len prepúšťajú. Tento rozdiel medzi natívnym režimom a režimom bypass je dôležitý, keď softvér mení režim displeja alebo správanie sledovania.
Vývojárske SDK je softvér, ktorý sa linkuje k vášmu programu, aby mohol komunikovať s okuliarmi. Je oddelené od bežných aplikácií VITURE, ako je SpaceWalker, ktorá slúži na používanie podporovaných funkcií displeja a priestorovej obrazovky, nie na písanie kódu.
Dve SDK od VITURE slúžia na rôzne účely
VITURE XR Glasses SDK:
- Na čo slúži: Natívne C API na prístup k okuliarom, sledovanie, streamovanie z kamery a ovládanie zariadenia na podporovaných hostiteľských platformách.
- Použiť ho na vývoj pre BEAST?: Áno. Toto je SDK pre BEAST, ktorým sa zaoberá tento návod.
VITURE XR SDK for Unity:
- Na čo slúži: Balík Unity XR zdokumentovaný na tvorbu imerzívnych zážitkov na VITURE Neckband s integráciami pre Unity, ako je sledovanie rúk.
- Použiť ho na vývoj pre BEAST?: Nie ako predvolené SDK pre okuliare BEAST. Nezamieňajte si ho s natívnym SDK pre okuliare.
SpaceWalker:
- Na čo slúži: Sprievodný softvér VITURE pre podporované režimy displeja a funkcie priestorovej obrazovky.
- Použiť ho na vývoj pre BEAST?: Nie. Je to aplikácia pre koncových používateľov, nie vývojové prostredie.
Čo XR Glasses SDK ovláda
Pripojenie zariadenia:
- Čo aplikácia dokáže: Rozpoznať pripojené zariadenie, vytvoriť jeho handle, inicializovať ho, spustiť a korektne ho zatvoriť.
- Na čo pamätať pri BEAST: SDK komunikuje s okuliarmi cez pripojenie k hostiteľovi.
Sledovanie hlavy:
- Čo aplikácia dokáže: Čítať údaje o orientácii/z IMU a používať rozhranie sledovania špecifické pre daný model.
- Na čo pamätať pri BEAST: BEAST je zdokumentovaný pre natívne 3DoF; položka 6DoF VIO v tabuľke zariadení sa týka modelu Luma Ultra.
Displej a ovládanie okuliarov:
- Čo aplikácia dokáže: Čítať alebo nastavovať podporovaný jas, hlasitosť, režim displeja, režim 2D/3D, stmavenie a možnosti natívneho režimu.
- Na čo pamätať pri BEAST: V natívnom režime používajte natívne konštanty displeja špecifické pre BEAST. Niektoré kombinácie režimu a frekvencie nie sú podporované.
Stream z kamery:
- Čo aplikácia dokáže: Pristupovať k podporovaným snímkam z passthrough kamery cez kamerové API SDK.
- Na čo pamätať pri BEAST: BEAST je uvedený s passthrough kamerou UVC. Prístup ku kamere je oddelený od sledovania 6DoF.
SDK samo osebe neposkytuje: pracovný postup vašej aplikácie, biznis logiku, ponuky, ukladanie údajov, používateľské účty ani kompletnú scénu v Unity. Tieto časti vytvára váš aplikačný tím okolo funkcií zariadenia, ktoré SDK sprístupňuje. Hlavná vývojárska stránka zdôrazňuje tieto štyri platformy. Od verzie SDK 2.4.0 (6. augusta 2026) dokumentácia uvádza piaty cieľ: Browser, zostavenie WebAssembly s API v TypeScripte, ktoré sa k okuliarom pripája cez WebHID, iba v prehliadačoch Chrome a Chromium, pričom BEAST je podporovaný a Luma Ultra nie. Pred výberom produkčného zariadenia alebo OS si overte aktuálny balík a poznámky k vydaniu.
Multiplatformová podpora: Android, Linux, Windows a macOS
„Multiplatformové“ znamená, že VITURE poskytuje pre to isté SDK okuliarov zostavenia a pokyny na nastavenie špecifické pre jednotlivé platformy. Neznamená to, že jeden binárny súbor beží všade bez zmien. Vyberte hostiteľa, na ktorom musí vaša aplikácia bežať, a potom použite jeho zodpovedajúcu knižnicu a integračnú príručku. Aktuálna dokumentácia API uvádza tieto architektúry:
Windows:
- Zdokumentovaná architektúra: x86_64
- Typický postup nastavenia: Desktopová aplikácia v C/C++ s knižnicou a hlavičkovými súbormi SDK pre Windows; postupujte podľa Quick Start: Desktop (C++).
Linux:
- Zdokumentovaná architektúra: x86_64 a aarch64
- Typický postup nastavenia: Desktopová aplikácia v C/C++. Pridajte pravidlo udev od VITURE, aby aplikácia mohla pristupovať k rozhraniu USB/HID bez spúšťania pod rootom.
macOS:
- Zdokumentovaná architektúra: aarch64 (Apple silicon)
- Typický postup nastavenia: Desktopová aplikácia v C/C++ s knižnicou a hlavičkovými súbormi pre macOS; postupujte podľa Quick Start: Desktop (C++).
Android:
- Zdokumentovaná architektúra: armeabi-v7a a arm64-v8a
- Typický postup nastavenia: Aplikácia pre Android využívajúca natívnu knižnicu C cez JNI; oprávnenie USB a pripojenie spracujte v aplikácii pre Android.
Hlavná vývojárska stránka zdôrazňuje tieto štyri platformy. Podrobná stránka API môže časom pridať ďalšie ciele alebo zmeniť podporované architektúry, preto si pred výberom produkčného zariadenia alebo OS overte aktuálny balík a poznámky k vydaniu.
Čo potrebujete pred začatím vývoja
· Okuliare VITURE BEAST a dátové pripojenie USB-C k počítaču alebo hostiteľovi s Androidom, ktorý chcete podporovať.
· Vývojový počítač s kompilátorom/nástrojmi na zostavenie pre váš cieľ: sadu nástrojov C/C++ a CMake pre desktop alebo Android Studio s komponentmi NDK a CMake pre Android.
· Balík VITURE XR Glasses SDK pre cieľovú platformu stiahnutý zo stránky Developer spoločnosti VITURE.
· Zodpovedajúcu dokumentáciu SDK, najmä Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming a Native-DOF Devices.
· Základné znalosti jazyka, ktorý používa váš aplikačný tím: C/C++ pre desktopové príklady a pri typickej integrácii pre Android aj Kotlin alebo Java a JNI.
Ako zostaviť prvý test SDK pre VITURE BEAST
Začnite malou hostiteľskou aplikáciou, ktorá nájde BEAST a načíta údaje o sledovaní. Keď to funguje, pridajte jedno ovládanie alebo funkciu kamery.
Krok 1: Vyberte, kde bude vaša aplikácia bežať
Vyberte počítač alebo telefón, na ktorom bude aplikácia bežať; podľa toho sa určí balík SDK a príručka na nastavenie.
1. Vyberte hostiteľa. Pre počítač použite Windows, Linux alebo macOS, pre telefón pripojený k BEAST Android.
2. Poznačte si jeho OS a procesor. Zaznamenajte napríklad Windows x86_64 alebo macOS Apple silicon a potom skontrolujte tabuľku platforiem vyššie.
3. Vetvu pre Android sledujte iba pri aplikácii pre Android. Používa natívnu knižnicu, most JNI a oprávnenie USB.
Krok 2: Stiahnite VITURE XR Glasses SDK
Stiahnite oficiálne SDK pre okuliare a otvorte príručku pre svojho hostiteľa. Balík Unity pre Neckband je určený pre iné nastavenie.
1. Otvorte stránku Developer. V prehliadači prejdite na https://www.viture.com/developer a posuňte sa k časti „VITURE XR Glasses SDK“.
2. Stiahnite balík pre svoju platformu. Na karte SDK kliknite na „Download“ a ak sa zobrazí výzva, vyberte svojho hostiteľa.
3. Otvorte príručku na nastavenie. Na tej istej karte kliknite na „Documents“, potom na „Core Concepts“ a následne na „Quick Start: Desktop (C++)“ alebo „Android Integration Guide“.
4. Overte kompatibilitu. Vráťte sa na stránku Developer, otvorte „Release Notes“ a skontrolujte svoj OS, procesor a firmvér BEAST.
Ku kroku 3 prejdite, keď: máte zodpovedajúcu knižnicu, hlavičkové súbory a príručku na nastavenie.
Krok 3: Nastavte SDK na hostiteľskej platforme
Použite iba vetvu nastavenia pre hostiteľa, ktorého ste vybrali v kroku 1.
Pre Windows, Linux alebo macOS
1. Otvorte príručku pre desktop. V SDK Documents vyberte „Quick Start: Desktop (C++)“ a majte ju otvorenú vedľa editora kódu.
2. Prilinkujte SDK. Otvorte ukážku alebo svoj projekt a potom pomocou príkladu CMake z príručky pridajte hlavičkové súbory SDK a knižnicu okuliarov.
V súbore `CMakeLists.txt` vášho projektu pridajte cesty k hlavičkovým súborom a knižniciam SDK. `VITURE_SDK_ROOT` nahraďte priečinkom, do ktorého ste SDK rozbalili:
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. Len Linux: povoľte prístup k USB. V termináli postupujte podľa „Linux udev Rule“ a vytvorte `/etc/udev/rules.d/70-viture.rules`; znova načítajte pravidlá a znova pripojte BEAST. Vo Windows a macOS tento krok preskočte.
4. Zostavte ukážku. Otvorte súbor `main.cpp` z príkladu SDK a pred pridávaním funkcií sa uistite, že sa dá zostaviť.
Pre Android
1. Vytvorte projekt pre Android. V Android Studiu založte projekt s podporou CMake/NDK a na paneli projektu otvorte `app/src/main`.
2. Skopírujte súbory SDK. Postupujte podľa „Android Integration Guide“: hlavičkové súbory vložte do `app/src/main/include/` a zodpovedajúci súbor `.so` do `app/src/main/jniLibs/<ABI>/`.
3. Prilinkujte knižnicu. V Android Studiu otvorte `app/src/main/cpp/CMakeLists.txt` a `app/build.gradle.kts` a použite nastavenia CMake, NDK a ABI z príručky.
V súbore `CMakeLists.txt` importujte knižnicu SDK a prilinkujte ju k svojmu mostu JNI. Tento príklad predpokladá, že súbory SDK sú v priečinkoch uvedených v 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. Pridajte most medzi aplikáciou a C++. V priečinku so zdrojovým kódom aplikácie vytvorte triedu `GlassesBridge` z príručky; jej funkcie `external` volajú váš kód JNI.
5. Vyžiadajte oprávnenie USB. Pomocou `UsbManager` v Androide nájdite BEAST; keď používateľ ťukne na „Povoliť“, otvorte USB a odovzdajte jeho deskriptor súboru mostu.
Keď používateľ ťukne na „Povoliť“, otvorte vo svojej aktivite v Kotline pripojenie USB a odovzdajte jeho deskriptor súboru natívnemu mostu. `GlassesBridge` nahraďte názvom triedy mosta vo svojom projekte:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
V súbore `glasses_bridge.cpp` natívna funkcia create odovzdá tento deskriptor súboru z Androidu do SDK od 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; }
Ku kroku 4 prejdite, keď: sa aplikácia zostaví a načíta SDK bez chyby chýbajúceho súboru alebo linkera.
Krok 4: Pripojte BEAST a spustite prvú ukážku
Teraz otestujte pripojenie okuliarov. Vo Windows, Linuxe alebo macOS použite desktopovú ukážku. V Androide ponechajte nastavenie USB a JNI z kroku 3; nepoužívajte desktopový kód na vyhľadávanie HID.
1. Pripojte BEAST. Použite dátový kábel USB-C; v Androide potvrďte výzvu USB v telefóne.
2. Nájdite BEAST a vytvorte jeho handle. Na desktope nájdite ID produktu BEAST pomocou vyhľadávania HID a potom vytvorte provider pomocou xr_device_provider_create(product_id). V Androide odovzdajte ID produktu aj deskriptor súboru z pripojenia USB.
3. Spustite sledovanie. Sledovanie spustíte registráciou callbacku. Callback je funkcia, ktorú SDK zavolá, keď prídu údaje o sledovaní. BEAST poskytuje roll, pitch a yaw v data[0] až data[2] a kvaternión v data[3] až data[6], ale iba so SDK 2.4.0 alebo novším a s aktualizovaným firmvérom okuliarov. So starším firmvérom sa callback pozície na BEAST nikdy nespustí (VITURE to uvádza v poznámkach k vydaniu v časti „Known Limitations on Beast“): vtedy buď zaregistrujte xr_device_provider_register_imu_raw_callback a surové údaje z IMU integrujte sami, alebo prepnite okuliare do natívneho režimu a nechajte sledovanie na nich.
Pridajte túto funkciu nad 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]
);
}
Callback zaregistrujte pred inicializáciou a spustením SDK:
</> 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;
Na desktope použite handle. V kóde JNI pre Android použite g_handle.
4. Otvorte stream sledovania. Pridajte toto volanie do desktopového `main.cpp`; v Androide ho sprístupnite cez JNI a zavolajte po `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Pri ukončení aplikácie zatvorte IMU a potom provider zastavte, vypnite a zničte. V Androide zavolajte rovnaké čistiace funkcie pred zatvorením 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. Skontrolujte výstup. Spustite aplikáciu a v desktopovej konzole alebo v Logcate v Android Studiu sledujte aktualizácie pripojenia a sledovania.
Ku kroku 5 prejdite, keď: sa BEAST pripojí a aktualizácie sledovania prichádzajú bez chýb.
Krok 5: Pridajte jedno ovládanie BEAST
Keď sledovanie funguje, pridajte jedno ovládanie okuliarov do kódu aplikácie na ovládanie zariadenia, a to po spustení handle SDK.
1. Vyberte ovládanie. V SDK Documents otvorte „Device Control“ a skontrolujte, aké možnosti jasu, hlasitosti alebo displeja BEAST podporuje.
2. Načítajte a nastavte jeho hodnotu. Pridajte volania C/C++ do kódu ovládania; v Androide ich vložte do `glasses_bridge.cpp` a sprístupnite cez JNI.
Po spustení providera načítajte jas BEAST a vyskúšajte podporovanú hodnotu. Zdokumentovaný rozsah je 0 až 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. Prispôsobte API displeja režimu. Môžete nakonfigurovať aj režim displeja BEAST. Natívny režim využíva zabudované spracovanie displeja v okuliaroch a podporuje natívne 3DoF. Režim bypass prepúšťa videosignál z hostiteľa cez okuliare. Vyberte vetvu, ktorá zodpovedá režimu zvolenému vo vašej aplikácii. Nespúšťajte obe vetvy po sebe.
V tomto príklade je use_native_mode booleovské nastavenie vo vašej aplikácii a rc je existujúca premenná s výsledkom.
</> 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;
}
Vyberte rozlíšenie a obnovovaciu frekvenciu, ktoré BEAST podporuje.
4. Otestujte jednu zmenu. Spustite aplikáciu, skontrolujte výsledok na BEAST a potom obnovte pôvodné nastavenie.
Dôležité: BEAST podporuje natívne 3DoF, ale aktuálny firmvér akceptuje iba tri režimy displeja: 1920 x 1200 pri 60 Hz a 3D side-by-side 3840 x 1200 pri 60 Hz v natívnom režime a 3840 x 1200 pri 90 Hz v režime bypass (poznámky k vydaniu VITURE XR Glasses SDK, 2.3.0 a 2.3.1). Iné konštanty prejdú kontrolou SDK, ale okuliare ich odmietnu alebo ignorujú, preto po nastavení režim spätne načítajte a za zoznam podporovaných hodnôt považujte poznámky k vydaniu.
Krok 6: Prístup ku kamere pridajte, len ak ho aplikácia potrebuje
Passthrough kameru pridajte, iba ak vaša aplikácia potrebuje obrazové snímky. Streamovanie z kamery je oddelené od sledovania hlavy a neposkytuje 6DoF.
1. Otvorte príručku ku kamere. V SDK Documents vyberte „Camera Streaming“ a postupujte podľa časti o nastavení pre svojho hostiteľa.
2. Pridajte obsluhu snímok. Vo svojej aplikácii vytvorte funkciu, ktorá prijíma snímky z kamery a posiela ich funkcii, ktorá ich potrebuje, napríklad náhľadu.
Vo svojom kamerovom module v C++ vytvorte provider kamery BEAST a spustite ho so svojím callbackom snímok `on_frame`. Toto volanie s dvoma argumentmi je určené pre 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);
// When finished xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
V Androide odovzdajte ako tretí argument deskriptor súboru USB kamery s využitím nastavenia oprávnení z kroku 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Najprv získajte oprávnenie. Android potrebuje oprávnenia na kameru a USB; na desktope postupujte podľa príručky pre platformu.
4. Chráňte súkromie. Vysvetlite, na čo sa kamera používa, zaznamenávajte iba to, čo funkcia potrebuje, a v EÚ dodržiavajte postup vašej organizácie podľa GDPR.
Tento krok preskočte, ak vaša aplikácia potrebuje iba sledovanie alebo ovládanie displeja.
Krok 7: Testovanie a príprava malého pilotu
1. Otestujte opätovné pripojenie. Reštartujte aplikáciu, odpojte a znova pripojte BEAST a skontrolujte, či aplikácia zostáva stabilná.
2. Testujte na BEAST. Pri každej funkcii overte režim displeja, rozlíšenie, sledovanie a oprávnenia kamery voči firmvéru.
3. Uložte podrobnosti testov. Zaznamenajte verzie SDK, OS, procesora, kompilátora/NDK a firmvéru, podrobnosti o pripojení a chyby.
4. Naplánujte nasadenie. Rozhodnite, ako budete inštalovať a aktualizovať hostiteľskú aplikáciu, spravovať prístup ku kamere a údaje a zabezpečovať podporu.
Podmienka pilotu: rozširujte až po otestovaní hostiteľa, funkcií, oprávnení a procesu aktualizácie.
Čo SDK nerobí
VITURE XR Glasses SDK je sada nástrojov na integráciu zariadenia, nie hotové prostredie na tvorbu XR obsahu. Sprístupňuje funkcie, ktoré môže váš softvér volať. Váš tím si stále musí vybrať aplikačný framework, napísať používateľské rozhranie a logiku úloh, zostaviť aplikáciu pre hostiteľskú platformu a rozhodnúť, ako ju firma nasadí a bude podporovať.
Takisto nesprístupňuje všetky schopnosti na každom modeli VITURE. V aktuálnej tabuľke hardvéru je BEAST uvedený s natívnym 3DoF a prístupom k passthrough kamere, zatiaľ čo Luma Ultra je model uvedený s 3/6DoF a stereo VIO. Pri každom API, ktoré plánujete použiť, si overte tabuľku podporovaného hardvéru a nepovažujte všeobecný popis „3DoF/6DoF“ na portáli za prísľub, že BEAST podporuje každý režim sledovania.
Časté chyby pri vývoji so SDK pre VITURE BEAST
- Sťahovanie Unity XR SDK pre aplikáciu na ovládanie okuliarov BEAST.: Použite kartu VITURE XR Glasses SDK; príručka pre Unity je zdokumentovaná pre VITURE Neckband.
- Predpoklad, že multiplatformové znamená všade rovnaký binárny súbor alebo nastavenie.: Stiahnite správnu knižnicu a postupujte podľa príručky k architektúre a pripojeniu pre cieľovú platformu.
- Považovanie BEAST za zariadenie so 6DoF VIO, pretože portál spomína 6DoF.: Overte podporu na úrovni modelu: aktuálna tabuľka SDK uvádza pre BEAST natívne 3DoF a 6DoF VIO uvádza pre Luma Ultra.
- Volanie štandardných funkcií režimu displeja, keď je BEAST v natívnom režime.: Skontrolujte aktívny režim a použite zodpovedajúcu sadu štandardných funkcií alebo funkcií `native_*`.
- Otváranie kamery pred udelením oprávnení alebo bez prípadu použitia kamery.: Najprv si vyžiadajte oprávnenia platformy a streamovanie z kamery pridajte, iba ak aplikácia potrebuje obrazové údaje.
- Používanie SpaceWalkera ako editora kódu alebo aplikácie na nastavenie SDK.: Použite stránku Developer, balík SDK, dokumentáciu a editor kódu alebo Android Studio.
Záver
Vývoj pre VITURE BEAST začína s VITURE XR Glasses SDK, nie s balíkom Unity pre zážitky na Neckband ani so spotrebiteľskou aplikáciou SpaceWalker. Ako hostiteľa vyberte Android, Linux, Windows alebo macOS, stiahnite zodpovedajúce SDK zo stránky Developer spoločnosti VITURE, postupujte podľa príručky pre danú platformu a najprv zostavte malý program, ktorý sa pripojí cez USB a načíta údaje o sledovaní. Potom pridajte podporované ovládanie BEAST alebo funkciu kamery a otestujte ich na skutočnom hardvéri. Pre firmy to oddeľuje pracovný postup a údaje aplikácie od funkcií zariadenia okuliarov, podporuje vývoj na hostiteľskej platforme, ktorá zodpovedá nasadeniu, a dáva tímom možnosť overiť konkrétny priemyselný prípad použitia predtým, ako investujú do širšieho nasadenia.
Vytvárate XR pracovný postup pre VITURE BEAST? Prezrite si produktovú stránku VITURE BEAST a vývojársku dokumentáciu VITURE ešte predtým, ako definujete požiadavky na pilot.
























