Vezetői összefoglaló
A VITURE BEAST-re való fejlesztéshez nyissa meg a VITURE Developer oldalát, és válassza a VITURE XR Glasses SDK-t. Ez egy platformfüggetlen C SDK, amellyel szoftvereket csatlakoztathat a VITURE szemüvegekhez. Dokumentációja az Android, Linux, Windows és macOS rendszert sorolja fel. A különálló VITURE XR SDK for Unity leírása szerint a VITURE Neckbanden futó élményekhez készült, ezért nem ez a kiindulópont egy BEAST-szemüvegvezérlő alkalmazáshoz.
A szemüveg-SDK hozzáférést ad az alkalmazásnak az eszközkommunikációhoz, a fejkövetési adatokhoz, a kamerastreameléshez és a szemüveg egyes vezérlőihez. Kifejezetten a BEAST esetében a VITURE natív 3DoF-követést, kamerás passthrough-t és natív kijelzővezérlőket dokumentál. Az SDK nem alakítja a szemüveget általános célú számítógéppé, és nem hoz létre automatikusan kész XR-alkalmazást. Ön egy gazdaalkalmazást épít, USB-n keresztül csatlakoztatja a BEAST-et, és ebből az alkalmazásból hívja meg az SDK-t.
Fejlesztési folyamat: Válassza ki a gazdaplatformot -> töltse le a hozzá tartozó SDK-csomagot -> építse meg a gyártó első csatlakozási mintapéldáját -> olvassa ki a követési adatokat -> adjon hozzá egy BEAST-vezérlőt vagy kamerafunkciót -> tesztelje az alkalmazást a szemüveggel.
A szoftverintegráció megtervezése előtti termékháttérhez olvassa el a VRX-en megjelent VITURE BEAST-értékelést. A VITURE hivatalos termékoldala is hasznos a hardveres részletekhez.
BEVEZETÉS:
(ha már ismeri az SDK-t és a platformtámogatást, ugorjon a fő útmutatóra)
Mi az a VITURE BEAST?
A VITURE BEAST egy USB-C-s XR-kijelző beépített érzékelőkkel és kamerával. Natív módban a saját feldolgozóegysége kezeli a 3DoF-követést és a támogatott kijelzőeffektusokat; bypass módban a gazdaeszköz videojelet küld, amelyet a szemüveg változtatás nélkül továbbít. A natív és a bypass mód közötti különbség akkor számít, amikor a szoftver módosítja a kijelzőmódot vagy a követés működését.
A fejlesztői SDK olyan szoftver, amelyet a programja linkel, hogy kommunikálni tudjon a szemüveggel. Elkülönül az olyan hétköznapi VITURE-alkalmazásoktól, mint a SpaceWalker, amely a támogatott kijelző- és térbeli képernyő-funkciók használatára szolgál, nem kódírásra.
A két VITURE SDK különböző feladatokra való
VITURE XR Glasses SDK:
- Mire való: Natív C API a szemüveg eszközszintű eléréséhez, a követéshez, a kamerastreameléshez és az eszközvezérlőkhöz a támogatott gazdaplatformokon.
- Ezt használja a BEAST-fejlesztéshez?: Igen. Ez az útmutatóban tárgyalt BEAST SDK.
VITURE XR SDK for Unity:
- Mire való: Unity XR-csomag, amelyet a dokumentáció a VITURE Neckbanden futó immerzív élmények készítéséhez ír le, olyan Unity-integrációkkal, mint a kézkövetés.
- Ezt használja a BEAST-fejlesztéshez?: Alapértelmezett BEAST-szemüveg-SDK-ként nem. Ne keverje össze a natív szemüveg-SDK-val.
SpaceWalker:
- Mire való: VITURE kísérőszoftver a támogatott kijelzőmódokhoz és térbeli képernyő-funkciókhoz.
- Ezt használja a BEAST-fejlesztéshez?: Nem. Ez végfelhasználói alkalmazás, nem fejlesztői környezet.
Mit vezérel az XR Glasses SDK
Eszközkapcsolat:
- Mire képes az alkalmazás: Felderíti a csatlakoztatott eszközt, létrehoz egy eszközleírót (handle), inicializálja, elindítja, majd szabályosan lezárja.
- A BEAST-tel kapcsolatban ne feledje: Az SDK a gazdaeszközzel létesített kapcsolaton keresztül kommunikál a szemüveggel.
Fejkövetés:
- Mire képes az alkalmazás: Kiolvassa az orientációs/IMU-adatokat, és használja a modellspecifikus követési interfészt.
- A BEAST-tel kapcsolatban ne feledje: A BEAST dokumentáltan natív 3DoF-et támogat; az eszköztáblázat 6DoF VIO bejegyzése a Luma Ultrára vonatkozik.
Kijelző- és szemüvegvezérlők:
- Mire képes az alkalmazás: Kiolvassa vagy beállítja a támogatott fényerőt, hangerőt, kijelzőmódot, 2D/3D módot, sötétítést (tint) és natív módú beállításokat.
- A BEAST-tel kapcsolatban ne feledje: Natív módban a BEAST-specifikus natív kijelzőkonstansokat használja. Egyes mód–frissítési frekvencia kombinációk nem támogatottak.
Kamerastream:
- Mire képes az alkalmazás: Hozzáfér a támogatott passthrough kamera képkockáihoz az SDK kamera-API-ján keresztül.
- A BEAST-tel kapcsolatban ne feledje: A BEAST passthrough UVC kamerával szerepel a listában. A kamera-hozzáférés független a 6DoF-követéstől.
Amit az SDK önmagában nem biztosít: az alkalmazás munkafolyamata, üzleti logikája, menüi, adattárolása, felhasználói fiókjai vagy egy kész Unity-jelenet. Ezeket a részeket az alkalmazásfejlesztő csapat építi fel az SDK által elérhetővé tett eszközfunkciók köré. A fő fejlesztői oldal ezt a négy platformot emeli ki. Az SDK 2.4.0 (2026. augusztus 6.) óta a dokumentáció egy ötödik célplatformot is felsorol: a Browsert, egy TypeScript API-val rendelkező WebAssembly-buildet, amely WebHID-on keresztül éri el a szemüveget, kizárólag Chrome-ban és Chromiumban, a BEAST támogatásával és a Luma Ultra kizárásával. Éles használatra szánt eszköz vagy operációs rendszer kiválasztása előtt ellenőrizze az aktuális csomagot és a kiadási megjegyzéseket.
Platformfüggetlen támogatás: Android, Linux, Windows és macOS
A „platformfüggetlen” azt jelenti, hogy a VITURE ugyanahhoz a szemüveg-SDK-hoz platformspecifikus SDK-buildeket és beállítási útmutatókat biztosít. Nem azt jelenti, hogy egyetlen bináris változtatás nélkül mindenhol fut. Válassza ki azt a gazdagépet, amelyen az alkalmazásnak futnia kell, majd használja a hozzá tartozó könyvtárat és integrációs útmutatót. Az aktuális API-dokumentáció a következő architektúrákat sorolja fel:
Windows:
- Dokumentált architektúra: x86_64
- Szokásos beállítási út: C/C++ asztali alkalmazás a Windows SDK-könyvtárral és fejlécfájlokkal; kövesse a Quick Start: Desktop (C++) útmutatót.
Linux:
- Dokumentált architektúra: x86_64 és aarch64
- Szokásos beállítási út: C/C++ asztali alkalmazás. Adja hozzá a VITURE udev-szabályát, hogy az alkalmazás root jogosultság nélkül is hozzáférjen az USB/HID interfészhez.
macOS:
- Dokumentált architektúra: aarch64 (Apple silicon)
- Szokásos beállítási út: C/C++ asztali alkalmazás a macOS-könyvtárral és fejlécfájlokkal; kövesse a Quick Start: Desktop (C++) útmutatót.
Android:
- Dokumentált architektúra: armeabi-v7a és arm64-v8a
- Szokásos beállítási út: Android-alkalmazás, amely JNI-n keresztül használja a natív C-könyvtárat; az USB-engedélyt és a kapcsolatot az Android-alkalmazásban kell kezelni.
A fő fejlesztői oldal ezt a négy platformot emeli ki. A részletes API-oldal idővel új célplatformokkal bővülhet, vagy módosulhatnak a támogatott architektúrák, ezért éles használatra szánt eszköz vagy operációs rendszer kiválasztása előtt ellenőrizze az aktuális csomagot és a kiadási megjegyzéseket.
Amire a fejlesztés előtt szüksége lesz
· VITURE BEAST szemüveg és USB-C adatkapcsolat a támogatni kívánt számítógéphez vagy androidos gazdaeszközhöz.
· Fejlesztői számítógép a célplatformhoz szükséges fordító- és buildeszközökkel: asztali környezethez C/C++ eszközlánc és CMake, Androidhoz pedig Android Studio az NDK és CMake komponensekkel.
· A célplatformhoz tartozó VITURE XR Glasses SDK-csomag, a VITURE Developer oldaláról letöltve.
· A hozzá tartozó SDK-dokumentáció, különösen a Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming és Native-DOF Devices fejezet.
· Alapszintű ismeretek az alkalmazásfejlesztő csapat által használt nyelvből: C/C++ az asztali példákhoz, valamint Kotlin vagy Java és JNI egy tipikus Android-integrációhoz.
Az első VITURE BEAST SDK-teszt elkészítése
Kezdje egy kis gazdaalkalmazással, amely megtalálja a BEAST-et, és kiolvassa a követési adatokat. Ha ez működik, adjon hozzá egy vezérlőt vagy kamerafunkciót.
1. lépés: Válassza ki, hol fog futni az alkalmazás
Válassza ki azt a számítógépet vagy telefont, amelyen az alkalmazás futni fog; ez határozza meg az SDK-csomagot és a beállítási útmutatót.
1. Válassza ki a gazdaeszközt. Számítógéphez Windowst, Linuxot vagy macOS-t, a BEAST-hez csatlakoztatott telefonhoz Androidot használjon.
2. Jegyezze fel az operációs rendszert és a processzort. Jegyezze fel például, hogy Windows x86_64 vagy macOS Apple silicon, majd ellenőrizze a fenti platformtáblázatot.
3. Az androidos ágat csak Android-alkalmazás esetén kövesse. Ez natív könyvtárat, JNI-hidat és USB-engedélyt használ.
2. lépés: Töltse le a VITURE XR Glasses SDK-t
Töltse le a hivatalos szemüveg-SDK-t, és nyissa meg a gazdaeszközének megfelelő útmutatót. A Unity Neckband-csomag egy másik konfigurációhoz készült.
1. Nyissa meg a Developer oldalt. Egy böngészőben lépjen a https://www.viture.com/developer címre, és görgessen a „VITURE XR Glasses SDK” részhez.
2. Töltse le a platformjához tartozó csomagot. Az SDK-kártyán kattintson a „Download” gombra, és ha a rendszer kéri, válassza ki a gazdaeszközét.
3. Nyissa meg a beállítási útmutatót. Ugyanazon a kártyán kattintson a „Documents”, majd a „Core Concepts”, végül a „Quick Start: Desktop (C++)” vagy az „Android Integration Guide” elemre.
4. Ellenőrizze a kompatibilitást. Térjen vissza a Developer oldalra, nyissa meg a „Release Notes” részt, és ellenőrizze az operációs rendszert, a processzort és a BEAST firmware-ét.
Akkor lépjen tovább a 3. lépésre, ha: megvan a megfelelő könyvtár, a fejlécfájlok és a beállítási útmutató.
3. lépés: Az SDK beállítása a gazdaplatformon
Csak az 1. lépésben kiválasztott gazdaeszköznek megfelelő beállítási ágat használja.
Windows, Linux vagy macOS esetén
1. Nyissa meg az asztali útmutatót. Az SDK Documents részben válassza a „Quick Start: Desktop (C++)” útmutatót, és tartsa nyitva a kódszerkesztő mellett.
2. Linkelje az SDK-t. Nyissa meg a mintapéldát vagy a saját projektjét, majd az útmutató CMake-példája alapján adja hozzá az SDK fejlécfájljait és a glasses könyvtárat.
A projekt `CMakeLists.txt` fájljában adja hozzá az SDK include- és könyvtárútvonalait. A `VITURE_SDK_ROOT` helyére azt a mappát írja, ahová az SDK-t kicsomagolta:
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. Csak Linuxon: engedélyezze az USB-hozzáférést. A Terminalban kövesse a „Linux udev Rule” részt, és hozza létre a `/etc/udev/rules.d/70-viture.rules` fájlt; töltse újra a szabályokat, és csatlakoztassa újra a BEAST-et. Windowson és macOS-en hagyja ki.
4. Építse meg a mintapéldát. Nyissa meg az SDK-példa `main.cpp` fájlját, és győződjön meg róla, hogy lefordul, mielőtt funkciókat adna hozzá.
Android esetén
1. Hozzon létre egy Android-projektet. Az Android Studióban indítson egy CMake/NDK-támogatással rendelkező projektet, és nyissa meg az `app/src/main` mappát a projektpanelen.
2. Másolja be az SDK-fájlokat. Kövesse az „Android Integration Guide” útmutatót: a fejlécfájlokat tegye az `app/src/main/include/` mappába, a megfelelő `.so` fájlt pedig az `app/src/main/jniLibs/<ABI>/` mappába.
3. Linkelje a könyvtárat. Az Android Studióban nyissa meg az `app/src/main/cpp/CMakeLists.txt` és az `app/build.gradle.kts` fájlt; alkalmazza az útmutató CMake-, NDK- és ABI-beállításait.
A `CMakeLists.txt` fájlban importálja az SDK-könyvtárat, és linkelje a JNI-hídhoz. Ez a példa feltételezi, hogy az SDK-fájlok az Android Integration Guide-ban bemutatott mappákban vannak:
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. Adja hozzá az alkalmazás és a C++ közötti hidat. Az alkalmazás forrásmappájában hozza létre az útmutatóban szereplő `GlassesBridge` osztályt; ennek `external` függvényei hívják meg a JNI-kódot.
5. Kérjen USB-engedélyt. Az Android `UsbManager` osztályával keresse meg a BEAST-et; miután a felhasználó az Engedélyezés gombra koppintott, nyissa meg az USB-kapcsolatot, és adja át a fájlleíróját a hídnak.
Miután a felhasználó az Engedélyezés gombra koppintott, nyissa meg az USB-kapcsolatot a Kotlin-activityben, és adja át a fájlleíróját a natív hídnak. A `GlassesBridge` helyére a projekt hídosztályának nevét írja:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
A `glasses_bridge.cpp` fájlban a natív create függvény átadja ezt az androidos fájlleírót a VITURE SDK-jának:
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; }
Akkor lépjen tovább a 4. lépésre, ha: az alkalmazás lefordul, és hiányzó fájlra vagy linkelésre vonatkozó hiba nélkül betölti az SDK-t.
4. lépés: Csatlakoztassa a BEAST-et, és futtassa az első mintapéldát
Most tesztelje a szemüveg kapcsolatát. Windowson, Linuxon vagy macOS-en használja az asztali mintapéldát. Androidon tartsa meg a 3. lépésben beállított USB- és JNI-konfigurációt; ne használjon asztali HID-felderítő kódot.
1. Csatlakoztassa a BEAST-et. Használjon USB-C adatkábelt; Androidon fogadja el a telefon USB-kérését.
2. Keresse meg a BEAST-et, és hozza létre a leíróját. Asztali gépen HID-felderítéssel keresse meg a BEAST termékazonosítóját, majd hozza létre a providert az xr_device_provider_create(product_id) hívással. Androidon a termékazonosítót és az USB-kapcsolat fájlleíróját is adja át.
3. Indítsa el a követést. A követést egy callback regisztrálásával indíthatja el. A callback olyan függvény, amelyet az SDK meghív, amikor követési adat érkezik. A BEAST a roll, pitch és yaw értékeket a data[0]–data[2], a kvaterniót pedig a data[3]–data[6] elemekben adja át, de csak SDK 2.4.0 vagy újabb verzióval és frissített szemüveg-firmware-rel. Régebbi firmware esetén a pose callback a BEAST-en soha nem hívódik meg (a VITURE ezt a kiadási megjegyzéseiben a „Known Limitations on Beast” részben tünteti fel): ilyenkor vagy regisztrálja az xr_device_provider_register_imu_raw_callback függvényt, és saját maga integrálja a nyers IMU-adatokat, vagy kapcsolja a szemüveget natív módba, és hagyja, hogy az végezze a követést.
Adja hozzá ezt a függvényt a main() fölé:
</> 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]
);
}
Regisztrálja a callbacket az SDK inicializálása és elindítása előtt:
</> 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;
Asztali gépen a handle, Android JNI-kódban a g_handle változót használja.
4. Nyissa meg a követési streamet. Adja hozzá ezt a hívást az asztali `main.cpp` fájlhoz; Androidon tegye elérhetővé JNI-n keresztül, és a `start` után hívja meg.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Amikor az alkalmazás kilép, zárja be az IMU-t, majd állítsa le, kapcsolja ki és semmisítse meg a providert. Androidon ugyanezeket a takarító függvényeket hívja meg az USB lezárása előtt:
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. Ellenőrizze a kimenetet. Futtassa az alkalmazást, és az asztali konzolon vagy az Android Studio Logcatben figyelje a kapcsolódási és követési frissítéseket.
Akkor lépjen tovább az 5. lépésre, ha: a BEAST csatlakozik, és a követési frissítések hibák nélkül érkeznek.
5. lépés: Adjon hozzá egy BEAST-vezérlőt
Miután a követés működik, adjon hozzá egy szemüvegvezérlőt az alkalmazás eszközvezérlő kódjához, az SDK-leíró elindítása után.
1. Válasszon egy vezérlőt. Az SDK Documents részben nyissa meg a „Device Control” fejezetet, és nézze meg, milyen fényerő-, hangerő- vagy kijelzőbeállításokat támogat a BEAST.
2. Olvassa ki és állítsa be az értékét. Adja hozzá a C/C++ hívásokat a vezérlőkódhoz; Androidon tegye őket a `glasses_bridge.cpp` fájlba, és tegye elérhetővé JNI-n keresztül.
A provider elindítása után olvassa ki a BEAST fényerejét, és próbáljon ki egy támogatott értéket. A dokumentált tartomány 0 és 8 között van:
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. Igazítsa a kijelző-API-t a módhoz. A BEAST kijelzőmódját is konfigurálhatja. A natív mód a szemüveg beépített kijelzőfeldolgozását használja, és támogatja a natív 3DoF-et. A bypass mód a gazdaeszköz videojelét változtatás nélkül továbbítja a szemüvegen keresztül. Azt az ágat válassza, amely megfelel az alkalmazásban kiválasztott módnak. Ne futtassa a két ágat egymás után.
Ebben a példában a use_native_mode egy logikai (Boolean) beállítás az alkalmazásban, az rc pedig a már meglévő eredményváltozó.
</> 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;
}
Olyan felbontást és frissítési frekvenciát válasszon, amelyet a BEAST támogat.
4. Teszteljen egyetlen változtatást. Futtassa az alkalmazást, ellenőrizze az eredményt a BEAST-en, majd állítsa vissza az eredeti beállítást.
Fontos: A BEAST támogatja a natív 3DoF-et, de a jelenlegi firmware csak három kijelzőmódot fogad el: natív módban 1920 x 1200-at 60 Hz-en és 3D side-by-side 3840 x 1200-at 60 Hz-en, bypass módban pedig 3840 x 1200-at 90 Hz-en (VITURE XR Glasses SDK kiadási megjegyzések, 2.3.0 és 2.3.1). Más konstansok átmennek az SDK ellenőrzésén, de a szemüveg elutasítja vagy figyelmen kívül hagyja őket, ezért beállítás után olvassa vissza a módot, és a támogatott értékek listájaként a kiadási megjegyzéseket tekintse irányadónak.
6. lépés: Kamera-hozzáférést csak akkor adjon hozzá, ha az alkalmazásnak szüksége van rá
A passthrough kamerát csak akkor adja hozzá, ha az alkalmazásnak képkockákra van szüksége. A kamerastreamelés független a fejkövetéstől, és nem biztosít 6DoF-et.
1. Nyissa meg a kamera-útmutatót. Az SDK Documents részben válassza a „Camera Streaming” fejezetet, és kövesse a gazdaeszközének megfelelő beállítási szakaszt.
2. Adjon hozzá egy képkocka-kezelőt. Az alkalmazásban hozzon létre egy függvényt, amely fogadja a kamera képkockáit, és továbbítja őket az azokat igénylő funkciónak, például egy előnézetnek.
A C++ kameramodulban hozza létre a BEAST kamera-providerét, és indítsa el az `on_frame` képkocka-callbackkel. Ez a kétargumentumos hívás asztali környezethez való:
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);
Androidon harmadik argumentumként adja át a kamera USB-fájlleíróját, a 3. lépésben beállított engedélykezelést használva:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Először kérjen engedélyt. Androidon kamera- és USB-engedély szükséges; asztali gépen kövesse a platform útmutatóját.
4. Védje a magánszférát. Ismertesse a kamera használatát, csak azt rögzítse, amire a funkciónak szüksége van, és az EU-ban kövesse a szervezete GDPR-folyamatát.
Hagyja ki ezt a lépést, ha az alkalmazásnak csak követésre vagy kijelzővezérlőkre van szüksége.
7. lépés: Tesztelés és egy kisebb pilot előkészítése
1. Tesztelje az újracsatlakozást. Indítsa újra az alkalmazást, húzza ki és csatlakoztassa újra a BEAST-et, és ellenőrizze, hogy az alkalmazás stabil marad-e.
2. Teszteljen a BEAST-en. Ellenőrizze minden funkció kijelzőmódját, felbontását, követését és kameraengedélyeit a firmware-rel összevetve.
3. Mentse a teszt részleteit. Jegyezze fel az SDK, az operációs rendszer, a processzor, a fordító/NDK és a firmware verzióját, a kapcsolat részleteit és a hibákat.
4. Tervezze meg a bevezetést. Döntse el, hogyan telepíti és frissíti a gazdaalkalmazást, hogyan kezeli a kamera-hozzáférést és az adatokat, és hogyan biztosítja a támogatást.
Pilotkapu: csak azután bővítsen, hogy tesztelte a gazdaeszközt, a funkciókat, az engedélyeket és a frissítési folyamatot.
Amire az SDK nem képes
A VITURE XR Glasses SDK eszközintegrációs eszközkészlet, nem kész XR-tartalomkészítő környezet. Olyan függvényeket tesz elérhetővé, amelyeket a szoftvere meghívhat. A csapatnak továbbra is magának kell kiválasztania az alkalmazás-keretrendszert, megírnia a felhasználói felületet és a feladatlogikát, megépítenie az alkalmazást a gazdaplatformra, és eldöntenie, hogyan telepíti és támogatja azt a vállalat.
Azt sem teszi lehetővé, hogy minden képesség minden VITURE-modellen elérhető legyen. A jelenlegi hardvertáblázatban a BEAST natív 3DoF-fel és passthrough kamera-hozzáféréssel szerepel, míg a Luma Ultra az a modell, amelynél 3/6DoF és sztereó VIO van feltüntetve. Minden használni kívánt API-nál ellenőrizze a támogatott hardverek táblázatát, ahelyett hogy a portál általános „3DoF/6DoF” leírását annak ígéreteként értelmezné, hogy a BEAST minden követési módot támogat.
Gyakori hibák a VITURE BEAST SDK-fejlesztés során
- A Unity XR SDK letöltése egy BEAST-szemüvegvezérlő alkalmazáshoz.: Használja a VITURE XR Glasses SDK kártyát; a Unity-útmutató a dokumentáció szerint a VITURE Neckbandhez készült.
- Annak feltételezése, hogy a platformfüggetlenség mindenhol ugyanazt a binárist vagy beállítást jelenti.: Töltse le a megfelelő könyvtárat, és kövesse a célplatform architektúrájára és kapcsolódására vonatkozó útmutatót.
- A BEAST 6DoF VIO-eszközként kezelése, mert a portál említi a 6DoF-et.: Ellenőrizze a modellszintű támogatást: a jelenlegi SDK-táblázat a BEAST-nél natív 3DoF-et, a Luma Ultránál 6DoF VIO-t tüntet fel.
- Szabványos kijelzőmód-függvények hívása, miközben a BEAST natív módban van.: Ellenőrizze az aktív módot, és a hozzá illő szabványos vagy `native_*` függvénykészletet használja.
- A kamera megnyitása az engedélyek megszerzése előtt vagy kamerás felhasználási eset nélkül.: Először kérje le a platform engedélyeit, és csak akkor adjon hozzá kamerastreamelést, ha az alkalmazásnak képadatokra van szüksége.
- A SpaceWalker használata kódszerkesztőként vagy SDK-beállító alkalmazásként.: Használja a Developer oldalt, az SDK-csomagot, a dokumentációt, valamint egy kódszerkesztőt vagy az Android Studiót.
Összegzés
A VITURE BEAST-fejlesztés a VITURE XR Glasses SDK-val kezdődik, nem pedig a Neckband-élményekhez készült Unity-csomaggal vagy a SpaceWalker fogyasztói alkalmazással. Válassza ki gazdaeszközként az Androidot, a Linuxot, a Windowst vagy a macOS-t, töltse le a megfelelő SDK-t a VITURE Developer oldaláról, kövesse a platform útmutatóját, és először készítsen egy kis programot, amely USB-n keresztül csatlakozik és kiolvassa a követési adatokat. Ezután adjon hozzá egy támogatott BEAST-vezérlőt vagy kamerafunkciót, és tesztelje a valódi hardveren. A vállalatok számára ez elválasztja az alkalmazás munkafolyamatát és adatait a szemüveg eszközfunkcióitól, lehetővé teszi a fejlesztést a telepítéshez illő gazdaplatformon, és módot ad a csapatoknak arra, hogy egy jól körülhatárolt ipari felhasználási esetet validáljanak, mielőtt szélesebb körű bevezetésbe fektetnének.
VITURE BEAST-re épülő XR-munkafolyamatot fejleszt? A pilot követelményeinek meghatározása előtt tekintse meg a VITURE BEAST termékoldalát és a VITURE fejlesztői dokumentációját.

























