Fejlesztés VITURE BEAST-re: az XR Glasses SDK bemutatása

Fejlesztés VITURE BEAST-re: az XR Glasses SDK bemutatása

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.

João Noronha

Írta

João Noronha

XR és immerzív tartalom specialista a VR Expertnél

João Noronha XR és immerzív tartalom specialista a VR Expertnél, akit erősen érdekelnek az új technológiák és azok valós alkalmazásai. Arra összpontosít, hogy a VR, AR, AI szemüvegek és immerzív technológiák összetett fejlesztéseit érthető, gyakorlatias tartalommá alakítsa a vállalatok és az XR iparág iránt érdeklődő szakemberek számára.

Gyakori kérdések

Ez a cikk

Igen. A VITURE Developer oldalán megtalálható a VITURE XR Glasses SDK kártya Download, Release Notes és Documents hivatkozásokkal. A részletes API-dokumentáció a támogatott szemüvegek között sorolja fel a BEAST-et.

A szemüveg natív eléréséhez a VITURE XR Glasses SDK-t használja. A különálló VITURE XR SDK for Unity leírása szerint a VITURE Neckbanden futó immerzív élményekhez készült.

A fő Developer oldal az Android, Linux, Windows és macOS rendszert sorolja fel. A részletes API-dokumentáció megadja ezeknek a platformoknak az architektúráit, ezért a könyvtárat a célzott gazdaeszközhöz igazítsa.

A jelenlegi részletes eszköztáblázat a BEAST-et natív 3DoF-követéssel és passthrough kamerával tünteti fel. A Luma Ultránál 3/6DoF és sztereó VIO szerepel, ezért ne feltételezze, hogy a BEAST támogatja ezeket a Luma Ultra-követési funkciókat.

API-kat biztosít az USB-s eszközhozzáféréshez, a követési/IMU-adatokhoz, a támogatott kijelző- és eszközvezérlőkhöz, valamint a kamerastreameléshez. A felületet, az üzleti logikát és az adatkezelést továbbra is a saját alkalmazásának kell biztosítania.

Nem. A SpaceWalker a támogatott VITURE kijelző- és térbeli képernyő-funkciók használatára szolgáló alkalmazás. Az egyedi SDK-fejlesztéshez a Developer oldalra, az XR Glasses SDK-ra, annak dokumentációjára és a platform fejlesztőeszközeire van szükség.