Vývoj pro VITURE BEAST: vysvětlení XR Glasses SDK

Shrnutí

Chcete-li vyvíjet pro VITURE BEAST, otevřete stránku Developer společnosti VITURE a zvolte VITURE XR Glasses SDK. Jde o multiplatformní SDK v jazyce C pro propojení softwaru s brýlemi VITURE. Jeho dokumentace uvádí Android, Linux, Windows a macOS. Samostatné VITURE XR SDK for Unity je popsáno pro aplikace běžící na VITURE Neckband, takže pro aplikaci ovládající brýle BEAST není výchozím bodem.

SDK pro brýle poskytuje aplikaci přístup ke komunikaci se zařízením, datům sledování hlavy, streamování z kamery a vybraným ovládacím prvkům brýlí. Konkrétně u BEAST VITURE dokumentuje nativní sledování 3DoF, kamerový passthrough a nativní ovládání displeje. Z brýlí však nedělá univerzální počítač ani automaticky nevytváří hotovou XR aplikaci. Vytvoříte hostitelskou aplikaci, připojíte BEAST přes USB a z této aplikace voláte SDK.

Postup vývoje: Zvolte hostitelskou platformu -> stáhněte pro ni balíček SDK -> sestavte první ukázku připojení od výrobce -> načtěte data sledování -> přidejte ovládací prvek BEAST nebo funkci kamery -> otestujte aplikaci s brýlemi.

Pro produktový kontext před plánováním softwarové integrace si přečtěte recenzi VITURE BEAST na VRX. Pro podrobnosti o hardwaru se hodí i oficiální produktová stránka VITURE.

ÚVOD:

(pokud už o SDK a podpoře platforem víte, přejděte k hlavnímu návodu)

Co je VITURE BEAST?

VITURE BEAST je XR displej s rozhraním USB-C, vestavěnými senzory a kamerou. V nativním režimu se o sledování 3DoF a podporované efekty zobrazení stará jeho vlastní výpočetní jednotka; v režimu bypass posílá hostitel videosignál, který brýle předávají dál. Toto rozlišení mezi nativním režimem a režimem bypass je důležité, když software mění režim zobrazení nebo chování sledování.

Vývojářské SDK je software, který váš program linkuje, aby mohl s brýlemi komunikovat. Liší se od běžných aplikací VITURE, jako je SpaceWalker, který slouží k používání podporovaných funkcí zobrazení a prostorové obrazovky, nikoli k psaní kódu.

Dvě SDK od VITURE slouží k různým účelům

VITURE XR Glasses SDK:

• K čemu slouží: Nativní C API pro přístup k brýlím, sledování, streamování z kamery a ovládání zařízení na podporovaných hostitelských platformách.
• Použít pro vývoj pro BEAST?: Ano. Toto je SDK pro BEAST, kterému se věnuje tento návod.

VITURE XR SDK for Unity:

• K čemu slouží: Balíček Unity XR dokumentovaný pro tvorbu imerzivních zážitků na VITURE Neckband s integracemi pro Unity, jako je sledování rukou.
• Použít pro vývoj pro BEAST?: Ne jako výchozí SDK pro brýle BEAST. Nezaměňujte ho s nativním SDK pro brýle.

SpaceWalker:

• K čemu slouží: Doprovodný software VITURE pro podporované režimy zobrazení a funkce prostorové obrazovky.
• Použít pro vývoj pro BEAST?: Ne. Jde o aplikaci pro koncové uživatele, nikoli o vývojové prostředí.

Co XR Glasses SDK ovládá

Připojení zařízení:

• Co aplikace může dělat: Najít připojené zařízení, vytvořit jeho handle, inicializovat ho, spustit a řádně ukončit.
• Co si u BEAST zapamatovat: SDK komunikuje s brýlemi prostřednictvím připojení k hostiteli.

Sledování hlavy:

• Co aplikace může dělat: Číst data orientace/IMU a používat rozhraní sledování specifické pro daný model.
• Co si u BEAST zapamatovat: BEAST je dokumentován pro nativní 3DoF; položka 6DoF VIO v tabulce zařízení se týká Luma Ultra.

Ovládání displeje a brýlí:

• Co aplikace může dělat: Číst nebo nastavovat podporovaný jas, hlasitost, režim zobrazení, režim 2D/3D, ztmavení a možnosti nativního režimu.
• Co si u BEAST zapamatovat: V nativním režimu používejte nativní konstanty displeje specifické pro BEAST. Některé kombinace režimu a obnovovací frekvence nejsou podporovány.

Stream z kamery:

• Co aplikace může dělat: Získávat podporované snímky z passthrough kamery prostřednictvím kamerového API SDK.
• Co si u BEAST zapamatovat: BEAST je uveden s passthrough kamerou UVC. Přístup ke kameře je oddělený od sledování 6DoF.

SDK samo o sobě neposkytuje: pracovní postupy vaší aplikace, obchodní logiku, nabídky, ukládání dat, uživatelské účty ani kompletní scénu v Unity. Tyto části vytváří váš aplikační tým kolem funkcí zařízení, které SDK zpřístupňuje. Hlavní stránka pro vývojáře zdůrazňuje tyto čtyři platformy. Od SDK 2.4.0 (6. srpna 2026) uvádí dokumentace pátý cíl: Browser, sestavení ve WebAssembly s API v TypeScriptu, které s brýlemi komunikuje přes WebHID, pouze v Chrome a Chromiu, s podporou BEAST a bez podpory Luma Ultra. Před výběrem produkčního zařízení nebo OS si ověřte aktuální balíček a poznámky k vydání.

Multiplatformní podpora: Android, Linux, Windows a macOS

„Multiplatformní“ znamená, že VITURE poskytuje pro totéž SDK pro brýle sestavení a pokyny k nastavení specifické pro jednotlivé platformy. Neznamená to, že jeden binární soubor poběží beze změn všude. Zvolte hostitele, na kterém má vaše aplikace běžet, a pak použijte odpovídající knihovnu a integrační návod. Aktuální dokumentace API uvádí tyto architektury:

Windows:

• Dokumentovaná architektura: x86_64
• Typický postup nastavení: Desktopová aplikace v C/C++ využívající knihovnu a hlavičkové soubory SDK pro Windows; postupujte podle Quick Start: Desktop (C++).

Linux:

• Dokumentovaná architektura: x86_64 a aarch64
• Typický postup nastavení: Desktopová aplikace v C/C++. Přidejte pravidlo udev od VITURE, aby aplikace mohla přistupovat k rozhraní USB/HID, aniž by běžela pod uživatelem root.

macOS:

• Dokumentovaná architektura: aarch64 (Apple silicon)
• Typický postup nastavení: Desktopová aplikace v C/C++ využívající knihovnu a hlavičkové soubory pro macOS; postupujte podle Quick Start: Desktop (C++).

Android:

• Dokumentovaná architektura: armeabi-v7a a arm64-v8a
• Typický postup nastavení: Aplikace pro Android využívající nativní knihovnu C přes JNI; oprávnění USB a připojení obsluhujte v aplikaci pro Android.

Hlavní stránka pro vývojáře zdůrazňuje tyto čtyři platformy. Podrobná stránka API může časem přidat další cíle nebo změnit podporované architektury, proto si před výběrem produkčního zařízení nebo OS ověřte aktuální balíček a poznámky k vydání.

Co potřebujete před zahájením vývoje

· Brýle VITURE BEAST a datové připojení USB-C k počítači nebo hostitelskému zařízení s Androidem, které chcete podporovat.

· Vývojový počítač s kompilátorem a nástroji pro sestavení pro váš cíl: toolchain C/C++ a CMake pro desktop, nebo Android Studio s komponentami NDK a CMake pro Android.

· Balíček VITURE XR Glasses SDK pro cílovou platformu stažený ze stránky Developer společnosti VITURE.

· Odpovídající dokumentaci SDK, zejména Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming a Native-DOF Devices.

· Základní znalost jazyka, který používá váš aplikační tým: C/C++ pro desktopové příklady a pro typickou integraci do Androidu navíc Kotlin nebo Java a JNI.

Jak sestavit první test s VITURE BEAST SDK

Začněte malou hostitelskou aplikací, která najde BEAST a načte data sledování. Jakmile to bude fungovat, přidejte jeden ovládací prvek nebo funkci kamery.

Krok 1: Zvolte, kde bude vaše aplikace běžet

Zvolte počítač nebo telefon, na kterém bude vaše aplikace běžet; podle toho se určí balíček SDK a návod k nastavení.

1. Zvolte hostitele. Pro počítač použijte Windows, Linux nebo macOS, pro telefon připojený k BEAST Android.

2. Poznamenejte si jeho OS a procesor. Zapište si například Windows x86_64 nebo macOS Apple silicon a pak zkontrolujte tabulku platforem výše.

3. Větev pro Android použijte jen pro aplikaci pro Android. Využívá nativní knihovnu, most JNI a oprávnění USB.

Krok 2: Stáhněte VITURE XR Glasses SDK

Stáhněte oficiální SDK pro brýle a otevřete návod pro svého hostitele. Balíček Unity pro Neckband je určen pro jinou konfiguraci.

1. Otevřete stránku Developer. V prohlížeči přejděte na https://www.viture.com/developer a sjeďte k části „VITURE XR Glasses SDK“.

2. Stáhněte balíček pro svou platformu. Na kartě SDK klikněte na „Download“ a v případě dotazu zvolte svého hostitele.

3. Otevřete návod k nastavení. Na téže kartě klikněte na „Documents“, poté na „Core Concepts“ a pak na „Quick Start: Desktop (C++)“ nebo „Android Integration Guide“.

4. Ověřte kompatibilitu. Vraťte se na stránku Developer, otevřete „Release Notes“ a zkontrolujte svůj OS, procesor a firmware BEAST.

Ke kroku 3 přejděte, až: máte odpovídající knihovnu, hlavičkové soubory a návod k nastavení.

Krok 3: Nastavte SDK na hostitelské platformě

Použijte pouze větev nastavení pro hostitele, kterého jste zvolili v kroku 1.

Pro Windows, Linux nebo macOS

1. Otevřete návod pro desktop. V SDK Documents zvolte „Quick Start: Desktop (C++)“ a mějte ho otevřený vedle editoru kódu.

2. Nalinkujte SDK. Otevřete ukázku nebo svůj projekt a pomocí příkladu CMake z návodu přidejte hlavičkové soubory SDK a knihovnu pro brýle.

V souboru `CMakeLists.txt` svého projektu přidejte cesty k hlavičkovým souborům a knihovnám SDK. `VITURE_SDK_ROOT` nahraďte složkou, do které jste 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. Pouze Linux: povolte přístup k USB. V Terminálu postupujte podle „Linux udev Rule“ a vytvořte `/etc/udev/rules.d/70-viture.rules`; znovu načtěte pravidla a BEAST znovu připojte. Ve Windows a macOS tento krok přeskočte.

4. Sestavte ukázku. Otevřete `main.cpp` z příkladu SDK a před přidáváním funkcí se ujistěte, že se dá sestavit.

Pro Android

1. Vytvořte projekt pro Android. V Android Studiu založte projekt s podporou CMake/NDK a na panelu projektu otevřete `app/src/main`.

2. Zkopírujte soubory SDK. Postupujte podle „Android Integration Guide“: hlavičkové soubory umístěte do `app/src/main/include/` a odpovídající soubor `.so` do `app/src/main/jniLibs/<ABI>/`.

3. Nalinkujte knihovnu. V Android Studiu otevřete `app/src/main/cpp/CMakeLists.txt` a `app/build.gradle.kts` a použijte nastavení CMake, NDK a ABI z návodu.

V `CMakeLists.txt` naimportujte knihovnu SDK a nalinkujte ji k mostu JNI. Tento příklad předpokládá, že soubory SDK jsou ve složkách 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. Přidejte most mezi aplikací a C++. Ve zdrojové složce aplikace vytvořte třídu `GlassesBridge` z návodu; její funkce `external` volají váš kód JNI.

5. Vyžádejte si oprávnění USB. Pomocí `UsbManager` v Androidu najděte BEAST; jakmile uživatel klepne na Povolit, otevřete USB a předejte jeho deskriptor souboru mostu.

Jakmile uživatel klepne na Povolit, otevřete ve své aktivitě v Kotlinu připojení USB a předejte jeho deskriptor souboru nativnímu mostu. `GlassesBridge` nahraďte názvem třídy mostu ve vašem projektu:

val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)

V `glasses_bridge.cpp` předá nativní funkce create tento deskriptor souboru 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; }

Ke kroku 4 přejděte, až: se aplikace sestaví a načte SDK bez chyby chybějícího souboru nebo chyby linkeru.

Krok 4: Připojte BEAST a spusťte první ukázku

Nyní otestujte připojení brýlí. Ve Windows, Linuxu nebo macOS použijte desktopovou ukázku. V Androidu ponechte nastavení USB a JNI z kroku 3; nepoužívejte desktopový kód pro vyhledávání HID.

1. Připojte BEAST. Použijte datový kabel USB-C; v Androidu potvrďte výzvu USB na telefonu.

2. Najděte BEAST a vytvořte jeho handle. Na desktopu zjistěte ID produktu BEAST pomocí vyhledávání HID a poté vytvořte provider voláním xr_device_provider_create(product_id). V Androidu předejte ID produktu i deskriptor souboru z připojení USB.

3. Spusťte sledování. Sledování spustíte registrací callbacku. Callback je funkce, kterou SDK zavolá, když dorazí data sledování. BEAST dodává roll, pitch a yaw v data[0] až data[2] a kvaternion v data[3] až data[6], ale pouze s SDK 2.4.0 nebo novějším a aktualizovaným firmwarem brýlí. Se starším firmwarem se callback polohy (pose) na BEAST nikdy nespustí (VITURE to uvádí v poznámkách k vydání v části „Known Limitations on Beast“): v takovém případě buď zaregistrujte xr_device_provider_register_imu_raw_callback a nezpracovaná data IMU integrujte sami, nebo přepněte brýle do nativního režimu a nechte sledování na nich.

Nad funkci main() přidejte tuto funkci:

</> 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 před inicializací a spuštění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 desktopu použijte handle. V kódu JNI pro Android použijte g_handle.

4. Otevřete stream sledování. Přidejte toto volání do desktopového `main.cpp`; v Androidu ho zpřístupněte přes JNI a zavolejte po `start`.

rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;

Při ukončení aplikace zavřete IMU a poté provider zastavte, vypněte a zničte. V Androidu zavolejte tytéž úklidové funkce před zavření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. Zkontrolujte výstup. Spusťte aplikaci a v desktopové konzoli nebo v Logcatu v Android Studiu sledujte aktualizace připojení a sledování.

Ke kroku 5 přejděte, až: se BEAST připojí a aktualizace sledování budou přicházet bez chyb.

Krok 5: Přidejte jeden ovládací prvek BEAST

Jakmile sledování funguje, přidejte do kódu aplikace pro ovládání zařízení jeden ovládací prvek brýlí, a to až po spuštění handle SDK.

1. Zvolte ovládací prvek. V SDK Documents otevřete „Device Control“ a zkontrolujte, jaké možnosti jasu, hlasitosti nebo displeje BEAST podporuje.

2. Načtěte a nastavte jeho hodnotu. Přidejte volání C/C++ do kódu ovládání; v Androidu je umístěte do `glasses_bridge.cpp` a zpřístupněte přes JNI.

Po spuštění provideru načtěte jas BEAST a vyzkoušejte podporovanou hodnotu. Dokumentovaný 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. Přizpůsobte API displeje režimu. Můžete také nakonfigurovat režim zobrazení BEAST. Nativní režim využívá vestavěné zpracování obrazu v brýlích a podporuje nativní 3DoF. Režim bypass předává videosignál hostitele skrz brýle. Zvolte větev, která odpovídá režimu vybranému ve vaší aplikaci. Nespouštějte obě větve po sobě.

V tomto příkladu je use_native_mode booleovské nastavení ve vaší aplikaci a rc je existující proměnná s výsledkem.

</> 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;

}

Zvolte rozlišení a obnovovací frekvenci, které BEAST podporuje.

4. Otestujte jednu změnu. Spusťte aplikaci, zkontrolujte výsledek na BEAST a poté obnovte původní nastavení.

Důležité: BEAST podporuje nativní 3DoF, ale současný firmware přijímá pouze tři režimy zobrazení: 1920 x 1200 při 60 Hz a 3D side-by-side 3840 x 1200 při 60 Hz v nativním režimu a 3840 x 1200 při 90 Hz v režimu bypass (poznámky k vydání VITURE XR Glasses SDK, 2.3.0 a 2.3.1). Ostatní konstanty projdou kontrolou SDK, ale brýle je odmítnou nebo ignorují, proto po nastavení režim zpětně načtěte a za seznam podporovaných hodnot považujte poznámky k vydání.

Krok 6: Přístup ke kameře přidejte, jen pokud ho aplikace potřebuje

Passthrough kameru přidejte, pouze pokud vaše aplikace potřebuje obrazové snímky. Streamování z kamery je oddělené od sledování hlavy a neposkytuje 6DoF.

1. Otevřete návod ke kameře. V SDK Documents zvolte „Camera Streaming“ a postupujte podle části o nastavení pro vašeho hostitele.

2. Přidejte obsluhu snímků. Ve své aplikaci vytvořte funkci, která přijímá snímky z kamery a předává je té části aplikace, která je potřebuje, například náhledu.

Ve svém modulu kamery v C++ vytvořte provider kamery BEAST a spusťte ho se svým callbackem pro snímky, `on_frame`. Toto volání se dvěma argumenty je určeno pro 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 Androidu předejte jako třetí argument deskriptor souboru USB kamery s využitím nastavení oprávnění z kroku 3:

XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);

3. Nejprve získejte oprávnění. Android potřebuje oprávnění ke kameře a k USB; na desktopu postupujte podle návodu pro danou platformu.

4. Chraňte soukromí. Vysvětlete, k čemu se kamera používá, zaznamenávejte jen to, co daná funkce potřebuje, a v EU postupujte podle procesu GDPR ve vaší organizaci.

Pokud vaše aplikace potřebuje jen sledování nebo ovládání displeje, tento krok přeskočte.

Krok 7: Otestujte a připravte malý pilotní projekt

1. Otestujte opětovné připojení. Restartujte aplikaci, odpojte a znovu připojte BEAST a ověřte, že aplikace zůstává stabilní.

2. Testujte na BEAST. U každé funkce ověřte režim zobrazení, rozlišení, sledování a oprávnění ke kameře vůči firmwaru.

3. Uložte podrobnosti testu. Zaznamenejte verze SDK, OS, procesoru, kompilátoru/NDK a firmwaru, podrobnosti o připojení a chyby.

4. Naplánujte nasazení. Rozhodněte, jak budete hostitelskou aplikaci instalovat a aktualizovat, spravovat přístup ke kameře a data a zajišťovat podporu.

Podmínka pro pilotní projekt: rozšiřujte až poté, co otestujete hostitele, funkce, oprávnění a proces aktualizací.

Co SDK nedělá

VITURE XR Glasses SDK je sada nástrojů pro integraci zařízení, nikoli hotové prostředí pro tvorbu XR obsahu. Zpřístupňuje funkce, které může váš software volat. Váš tým stále vybírá aplikační framework, píše uživatelské rozhraní a logiku úloh, sestavuje aplikaci pro hostitelskou platformu a rozhoduje, jak ji firma nasadí a bude podporovat.

Rovněž nezpřístupňuje všechny funkce na všech modelech VITURE. V aktuální tabulce hardwaru je BEAST uveden s nativním 3DoF a přístupem k passthrough kameře, zatímco Luma Ultra je model uvedený s 3/6DoF a stereo VIO. U každého API, které chcete použít, zkontrolujte tabulku podporovaného hardwaru, místo abyste obecný popis „3DoF/6DoF“ na portálu chápali jako příslib, že BEAST podporuje všechny režimy sledování.

Časté chyby při vývoji s VITURE BEAST SDK

• Stažení Unity XR SDK pro aplikaci ovládající brýle BEAST.: Použijte kartu VITURE XR Glasses SDK; návod pro Unity je dokumentován pro VITURE Neckband.
• Předpoklad, že multiplatformní znamená všude stejný binární soubor nebo stejné nastavení.: Stáhněte správnou knihovnu a postupujte podle návodu k architektuře a připojení pro cílovou platformu.
• Považování BEAST za zařízení s 6DoF VIO, protože portál zmiňuje 6DoF.: Ověřte podporu na úrovni modelu: aktuální tabulka SDK uvádí u BEAST nativní 3DoF a 6DoF VIO u Luma Ultra.
• Volání standardních funkcí režimu zobrazení, když je BEAST v nativním režimu.: Zkontrolujte aktivní režim a použijte odpovídající sadu funkcí – standardní, nebo `native_*`.
• Otevření kamery před udělením oprávnění nebo bez skutečného využití kamery.: Nejprve si vyžádejte oprávnění platformy a streamování z kamery přidejte jen tehdy, když aplikace potřebuje obrazová data.
• Používání SpaceWalkeru jako editoru kódu nebo aplikace pro nastavení SDK.: Použijte stránku Developer, balíček SDK, dokumentaci a editor kódu nebo Android Studio.

Závěr

Vývoj pro VITURE BEAST začíná u VITURE XR Glasses SDK, nikoli u balíčku Unity pro zážitky na Neckband ani u spotřebitelské aplikace SpaceWalker. Jako hostitele zvolte Android, Linux, Windows nebo macOS, stáhněte odpovídající SDK ze stránky Developer společnosti VITURE, postupujte podle návodu pro danou platformu a nejprve sestavte malý program, který se připojí přes USB a načte data sledování. Poté přidejte podporovaný ovládací prvek BEAST nebo funkci kamery a otestujte je na skutečném hardwaru. Pro firmy to znamená oddělení pracovních postupů a dat aplikace od funkcí zařízení, možnost vyvíjet na hostitelské platformě, která odpovídá nasazení, a způsob, jak ověřit konkrétní průmyslový případ použití dříve, než investují do širšího nasazení.

Vytváříte XR workflow pro VITURE BEAST? Prohlédněte si produktovou stránku VITURE BEAST a vývojářskou dokumentaci VITURE, než stanovíte požadavky na svůj pilotní projekt.