Utvikling for VITURE BEAST: XR Glasses SDK forklart

Sammendrag

For å utvikle for VITURE BEAST åpner du VITUREs utviklerside og velger VITURE XR Glasses SDK. Dette er det plattformuavhengige C-SDK-et for å koble programvare til VITURE-briller. Dokumentasjonen oppgir Android, Linux, Windows og macOS. Det separate VITURE XR SDK for Unity er beskrevet for opplevelser som kjører på VITURE Neckband, så det er ikke utgangspunktet for en app som styrer BEAST-brillene.

Brille-SDK-et gir en app tilgang til enhetskommunikasjon, hodesporingsdata, kamerastrømming og utvalgte brillekontroller. Spesifikt for BEAST dokumenterer VITURE native 3DoF-sporing, kameragjennomsyn (passthrough) og native skjermkontroller. Det gjør ikke brillene til en generell datamaskin, og det lager heller ikke automatisk en ferdig XR-app. Du bygger en vertsapplikasjon, kobler til BEAST via USB og kaller SDK-et fra den appen.

Utviklingsflyt: Velg vertsplattform -> last ned SDK-pakken for den -> bygg leverandørens første tilkoblingseksempel -> les sporingsdata -> legg til en BEAST-kontroll eller kamerafunksjon -> test appen med brillene.

For produktkontekst før du planlegger programvareintegrasjonen, se VITURE BEAST-anmeldelsen på VRX. VITUREs offisielle produktside er også nyttig for maskinvaredetaljer.

INNLEDNING:

(Kjenner du allerede til SDK-et og plattformstøtten, kan du gå videre til hovedveiledningen)

Hva er VITURE BEAST?

VITURE BEAST er en USB-C XR-skjerm med innebygde sensorer og et kamera. I native modus håndterer brillenes egen prosessering 3DoF-sporing og støttede skjermeffekter; i bypass-modus sender verten et videosignal som brillene sender videre. Dette skillet mellom native og bypass har betydning når programvare endrer visningsmodus eller sporingsatferd.

Utvikler-SDK-et er programvare som programmet ditt lenker mot, slik at det kan kommunisere med brillene. Det er atskilt fra VITUREs hverdagsapper som SpaceWalker, som er laget for å bruke støttede funksjoner for skjerm og romlige skjermer, ikke for å skrive kode.

De to VITURE-SDK-ene er laget for ulike oppgaver

VITURE XR Glasses SDK:

• Hva det er til: Native C-API for tilgang til brilleenheten, sporing, kamerastrømming og enhetskontroller på tvers av støttede vertsplattformer.
• Bruke det til BEAST-utvikling?: Ja. Dette er BEAST-SDK-et som denne veiledningen dekker.

VITURE XR SDK for Unity:

• Hva det er til: Unity XR-pakke dokumentert for å bygge oppslukende opplevelser på VITURE Neckband, med Unity-integrasjoner som håndsporing.
• Bruke det til BEAST-utvikling?: Ikke som standard-SDK for BEAST-brillene. Ikke forveksle det med det native brille-SDK-et.

SpaceWalker:

• Hva den er til: VITUREs følgeprogramvare for støttede visningsmoduser og funksjoner for romlige skjermer.
• Bruke den til BEAST-utvikling?: Nei. Det er en sluttbrukerapp, ikke et utviklingsmiljø.

Hva XR Glasses SDK styrer

Enhetstilkobling:

• Hva appen kan gjøre: Oppdage en tilkoblet enhet, opprette et enhetshåndtak, initialisere det, starte det og lukke det på riktig måte.
• BEAST-detalj å huske: SDK-et kommuniserer med brillene gjennom vertstilkoblingen.

Hodesporing:

• Hva appen kan gjøre: Lese orienterings-/IMU-data og bruke det modellspesifikke sporingsgrensesnittet.
• BEAST-detalj å huske: BEAST er dokumentert for native 3DoF; 6DoF VIO-oppføringen i enhetstabellen gjelder Luma Ultra.

Skjerm- og brillekontroller:

• Hva appen kan gjøre: Lese eller angi støttet lysstyrke, volum, visningsmodus, 2D/3D-modus, toning og alternativer for native modus.
• BEAST-detalj å huske: Bruk de BEAST-spesifikke native skjermkonstantene i native modus. Enkelte kombinasjoner av modus og oppdateringsfrekvens støttes ikke.

Kamerastrøm:

• Hva appen kan gjøre: Få tilgang til støttede bilder fra passthrough-kameraet via SDK-ets kamera-API.
• BEAST-detalj å huske: BEAST er oppført med et passthrough-UVC-kamera. Kameratilgang er atskilt fra 6DoF-sporing.

SDK-et leverer ikke i seg selv: appens arbeidsflyt, forretningslogikk, menyer, datalagring, brukerkontoer eller en komplett Unity-scene. Applikasjonsteamet ditt bygger disse delene rundt enhetsfunksjonene som SDK-et eksponerer. Hovedsiden for utviklere fremhever disse fire plattformene. Siden SDK 2.4.0 (6. august 2026) har dokumentasjonen oppgitt et femte mål: Browser, et WebAssembly-bygg med et TypeScript-API som når brillene via WebHID, kun i Chrome og Chromium, med støtte for BEAST og uten Luma Ultra. Sjekk gjeldende pakke og versjonsmerknader før du velger en enhet eller et operativsystem for produksjon.

Plattformuavhengig støtte: Android, Linux, Windows og macOS

«Plattformuavhengig» betyr at VITURE leverer plattformspesifikke SDK-bygg og oppsettsinstruksjoner for det samme brille-SDK-et. Det betyr ikke at én binærfil kjører uendret overalt. Velg verten der applikasjonen din skal kjøre, og bruk deretter det tilhørende biblioteket og integrasjonsveiledningen. Den gjeldende API-dokumentasjonen oppgir disse arkitekturene:

Windows:

• Dokumentert arkitektur: x86_64
• Typisk fremgangsmåte for oppsett: C/C++-skrivebordsapp som bruker Windows-SDK-biblioteket og headerfilene; følg Quick Start: Desktop (C++).

Linux:

• Dokumentert arkitektur: x86_64 og aarch64
• Typisk fremgangsmåte for oppsett: C/C++-skrivebordsapp. Legg til VITUREs udev-regel slik at appen får tilgang til USB/HID-grensesnittet uten å kjøre som root.

macOS:

• Dokumentert arkitektur: aarch64 (Apple silicon)
• Typisk fremgangsmåte for oppsett: C/C++-skrivebordsapp som bruker macOS-biblioteket og headerfilene; følg Quick Start: Desktop (C++).

Android:

• Dokumentert arkitektur: armeabi-v7a og arm64-v8a
• Typisk fremgangsmåte for oppsett: Android-app som bruker det native C-biblioteket via JNI; håndter USB-tillatelse og tilkobling i Android-appen.

Hovedsiden for utviklere fremhever disse fire plattformene. Den detaljerte API-siden kan legge til mål eller endre støttede arkitekturer over tid, så sjekk gjeldende pakke og versjonsmerknader før du velger en enhet eller et operativsystem for produksjon.

Dette trenger du før du begynner å utvikle

· VITURE BEAST-briller og en USB-C-datatilkobling til datamaskinen eller Android-verten du planlegger å støtte.

· En utviklingsdatamaskin med kompilator/byggeverktøy for målplattformen: en C/C++-verktøykjede og CMake for skrivebord, eller Android Studio med NDK- og CMake-komponentene for Android.

· VITURE XR Glasses SDK-pakken for målplattformen, lastet ned fra VITUREs utviklerside.

· Den tilhørende SDK-dokumentasjonen, særlig Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming og Native-DOF Devices.

· Grunnleggende forståelse av språket appteamet ditt bruker: C/C++ for skrivebordseksemplene, samt Kotlin eller Java og JNI for en typisk Android-integrasjon.

Slik bygger du en første test med VITURE BEAST SDK

Begynn med en liten vertsapp som finner BEAST og leser sporingsdata. Når det fungerer, legger du til én kontroll- eller kamerafunksjon.

Trinn 1: Velg hvor appen skal kjøre

Velg datamaskinen eller telefonen som skal kjøre appen; dette avgjør SDK-pakken og oppsettsveiledningen.

1. Velg vert. Bruk Windows, Linux eller macOS for en datamaskin, eller Android for en telefon koblet til BEAST.

2. Noter operativsystem og prosessor. Noter for eksempel Windows x86_64 eller macOS Apple silicon, og sjekk deretter plattformtabellen ovenfor.

3. Følg Android-grenen bare for en Android-app. Den bruker et native bibliotek, en JNI-bro og USB-tillatelse.

Trinn 2: Last ned VITURE XR Glasses SDK

Last ned det offisielle brille-SDK-et og åpne veiledningen for verten din. Unity-pakken for Neckband er for et annet oppsett.

1. Åpne utviklersiden. Gå til https://www.viture.com/developer i en nettleser og bla ned til «VITURE XR Glasses SDK».

2. Last ned pakken for plattformen din. Klikk på «Download» på SDK-kortet, og velg vert hvis du blir spurt.

3. Åpne oppsettsveiledningen. Klikk på «Documents» på samme kort, deretter på «Core Concepts», og så på «Quick Start: Desktop (C++)» eller «Android Integration Guide».

4. Sjekk kompatibiliteten. Gå tilbake til utviklersiden, åpne «Release Notes» og sjekk operativsystem, prosessor og BEAST-fastvare.

Gå videre til trinn 3 når: du har riktig bibliotek, headerfiler og oppsettsveiledning.

Trinn 3: Sett opp SDK-et på vertsplattformen

Bruk bare oppsettsgrenen for verten du valgte i trinn 1.

For Windows, Linux eller macOS

1. Åpne skrivebordsveiledningen. Velg «Quick Start: Desktop (C++)» i SDK Documents, og ha den åpen ved siden av kodeeditoren.

2. Lenk inn SDK-et. Åpne eksemplet eller prosjektet ditt, og bruk CMake-eksemplet i veiledningen for å legge til SDK-headerfilene og brillebiblioteket.

I prosjektets `CMakeLists.txt` legger du til SDK-ets include- og bibliotekstier. Erstatt `VITURE_SDK_ROOT` med mappen der du pakket ut SDK-et:

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. Kun Linux: gi USB-tilgang. Følg «Linux udev Rule» i Terminal og opprett `/etc/udev/rules.d/70-viture.rules`; last inn reglene på nytt og koble til BEAST igjen. Hopp over dette på Windows og macOS.

4. Bygg eksemplet. Åpne `main.cpp` i SDK-eksemplet og sørg for at det bygger før du legger til funksjoner.

For Android

1. Opprett et Android-prosjekt. Start et prosjekt med CMake/NDK-støtte i Android Studio, og åpne `app/src/main` i prosjektpanelet.

2. Kopier inn SDK-filene. Følg «Android Integration Guide»: legg headerfilene i `app/src/main/include/` og den tilhørende `.so`-filen i `app/src/main/jniLibs/<ABI>/`.

3. Lenk inn biblioteket. Åpne `app/src/main/cpp/CMakeLists.txt` og `app/build.gradle.kts` i Android Studio; bruk CMake-, NDK- og ABI-innstillingene fra veiledningen.

I `CMakeLists.txt` importerer du SDK-biblioteket og lenker det til JNI-broen din. Dette eksemplet forutsetter at SDK-filene ligger i mappene som vises i 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. Legg til broen mellom appen og C++. Opprett klassen `GlassesBridge` fra veiledningen i appens kildemappe; `external`-funksjonene i den kaller JNI-koden din.

5. Be om USB-tillatelse. Bruk Androids `UsbManager` til å finne BEAST; når brukeren trykker på Tillat, åpner du USB-tilkoblingen og sender filbeskrivelsen til broen.

Når brukeren har trykket på Tillat, åpner du USB-tilkoblingen i Kotlin-aktiviteten og sender filbeskrivelsen til den native broen. Erstatt `GlassesBridge` med navnet på broklassen i prosjektet ditt:

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

I `glasses_bridge.cpp` sender den native create-funksjonen denne Android-filbeskrivelsen videre til VITUREs SDK:

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

Gå videre til trinn 4 når: appen bygger og laster inn SDK-et uten feil om manglende filer eller lenkefeil.

Trinn 4: Koble til BEAST og kjør det første eksemplet

Test nå brilletilkoblingen. Bruk skrivebordseksemplet på Windows, Linux eller macOS. På Android beholder du USB- og JNI-oppsettet fra trinn 3; ikke bruk kode for HID-oppdagelse fra skrivebordsversjonen.

1. Koble til BEAST. Bruk en USB-C-datakabel; på Android godtar du telefonens USB-forespørsel.

2. Finn BEAST og opprett håndtaket. På skrivebordet finner du BEASTs produkt-ID med HID-oppdagelse, og deretter oppretter du provideren med xr_device_provider_create(product_id). På Android sender du både produkt-ID-en og filbeskrivelsen fra USB-tilkoblingen.

3. Start sporingen. Start sporingen ved å registrere en callback. En callback er en funksjon som SDK-et kaller når sporingsdata kommer inn. BEAST leverer roll, pitch og yaw i data[0] til data[2] og kvaternionet i data[3] til data[6], men bare med SDK 2.4.0 eller nyere og oppdatert fastvare i brillene. Med eldre fastvare utløses pose-callbacken aldri på BEAST (VITURE oppgir dette under «Known Limitations on Beast» i versjonsmerknadene): registrer da enten xr_device_provider_register_imu_raw_callback og integrer de rå IMU-dataene selv, eller sett brillene i native modus og la dem stå for sporingen.

Legg til denne funksjonen over 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]

);

}

Registrer callbacken før du initialiserer og starter SDK-et:

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

Bruk handle på skrivebordet. I Android-JNI-kode bruker du g_handle.

4. Åpne sporingsstrømmen. Legg til dette kallet i `main.cpp` på skrivebordet; på Android eksponerer du det via JNI og kaller det etter `start`.

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

Når appen avsluttes, lukker du IMU-en og stopper, avslutter og destruerer deretter provideren. På Android kaller du de samme oppryddingsfunksjonene før du lukker USB-tilkoblingen:

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. Sjekk utdataene. Kjør appen og se etter tilkoblings- og sporingsoppdateringer i skrivebordskonsollen eller i Logcat i Android Studio.

Gå videre til trinn 5 når: BEAST kobler seg til og sporingsoppdateringer kommer inn uten feil.

Trinn 5: Legg til én BEAST-kontroll

Når sporingen fungerer, legger du til én brillekontroll i appens enhetskontrollkode, etter at SDK-håndtaket er startet.

1. Velg en kontroll. Åpne «Device Control» i SDK Documents og sjekk hvilke alternativer for lysstyrke, volum eller visning BEAST støtter.

2. Les og angi verdien. Legg til C/C++-kallene i kontrollkoden; på Android legger du dem i `glasses_bridge.cpp` og eksponerer dem via JNI.

Når provideren er startet, leser du BEASTs lysstyrke og prøver en støttet verdi. Det dokumenterte området er 0 til 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. Tilpass skjerm-API-et til modusen. Du kan også konfigurere BEASTs visningsmodus. Native modus bruker brillenes innebygde skjermprosessering og støtter native 3DoF. Bypass-modus sender vertens videosignal gjennom brillene. Velg grenen som samsvarer med modusen appen din har valgt. Ikke kjør begge grenene etter hverandre.

I dette eksemplet er use_native_mode en boolsk innstilling i appen din, og rc er den eksisterende resultatvariabelen.

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

}

Velg en oppløsning og oppdateringsfrekvens som BEAST støtter.

4. Test én endring. Kjør appen, sjekk resultatet på BEAST, og gjenopprett deretter den opprinnelige innstillingen.

Viktig: BEAST støtter native 3DoF, men gjeldende fastvare godtar bare tre visningsmoduser: 1920 x 1200 ved 60 Hz og 3D side-ved-side 3840 x 1200 ved 60 Hz i native modus, og 3840 x 1200 ved 90 Hz i bypass-modus (versjonsmerknader for VITURE XR Glasses SDK, 2.3.0 og 2.3.1). Andre konstanter passerer SDK-ets kontroll, men brillene avviser eller ignorerer dem, så les av modusen igjen etter at du har angitt den, og behandle versjonsmerknadene som listen over støttede verdier.

Trinn 6: Legg bare til kameratilgang hvis appen trenger det

Legg bare til passthrough-kameraet hvis appen din trenger bilderammer. Kamerastrømming er atskilt fra hodesporing og gir ikke 6DoF.

1. Åpne kameraveiledningen. Velg «Camera Streaming» i SDK Documents og følg oppsettsdelen for verten din.

2. Legg til en rammehåndterer. Opprett en funksjon i appen som mottar kamerarammer og sender dem til funksjonen som trenger dem, for eksempel en forhåndsvisning.

Opprett BEASTs kameraprovider i C++-kameramodulen og start den med rammecallbacken din, `on_frame`. Dette kallet med to argumenter er for skrivebordet:

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

// Når du er ferdig xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);

På Android sender du kameraets USB-filbeskrivelse som tredje argument, med tillatelsesoppsettet fra trinn 3:

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

3. Skaff tillatelse først. Android krever kamera- og USB-tillatelser; på skrivebordet følger du plattformveiledningen.

4. Beskytt personvernet. Forklar hvordan kameraet brukes, ta bare opp det funksjonen trenger, og følg organisasjonens GDPR-prosess i EU.

Hopp over dette trinnet hvis appen bare trenger sporing eller skjermkontroller.

Trinn 7: Test og forbered en liten pilot

1. Test ny tilkobling. Start appen på nytt, koble BEAST fra og til igjen, og sjekk at appen forblir stabil.

2. Test på BEAST. Sjekk visningsmodus, oppløsning, sporing og kameratillatelser for hver funksjon opp mot fastvaren.

3. Lagre testdetaljer. Noter versjoner av SDK, operativsystem, prosessor, kompilator/NDK og fastvare, samt tilkoblingsdetaljer og feil.

4. Planlegg utrullingen. Bestem hvordan vertsappen skal installeres og oppdateres, hvordan kameratilgang og data skal håndteres, og hvordan brukerstøtte skal gis.

Pilotkrav: utvid bare etter at du har testet vert, funksjoner, tillatelser og oppdateringsprosess.

Hva SDK-et ikke gjør

VITURE XR Glasses SDK er et verktøysett for enhetsintegrasjon, ikke et ferdig utviklingsmiljø for XR-innhold. Det eksponerer funksjoner som programvaren din kan kalle. Teamet ditt må fortsatt velge et applikasjonsrammeverk, skrive brukergrensesnittet og oppgavelogikken, bygge appen for vertsplattformen og bestemme hvordan virksomheten skal ta den i bruk og gi støtte for den.

Det gjør heller ikke alle funksjoner tilgjengelige på alle VITURE-modeller. I den gjeldende maskinvaretabellen er BEAST oppført med native 3DoF og tilgang til passthrough-kamera, mens Luma Ultra er modellen som er oppført med 3/6DoF og stereo-VIO. Sjekk tabellen over støttet maskinvare for hvert API du planlegger å bruke, i stedet for å lese den generelle «3DoF/6DoF»-beskrivelsen på portalen som et løfte om at BEAST støtter alle sporingsmoduser.

Vanlige feil ved utvikling med VITURE BEAST SDK

• Å laste ned Unity XR SDK for en app som styrer BEAST-brillene.: Bruk VITURE XR Glasses SDK-kortet; Unity-veiledningen er dokumentert for VITURE Neckband.
• Å anta at plattformuavhengig betyr samme binærfil eller oppsett overalt.: Last ned riktig bibliotek og følg arkitektur- og tilkoblingsveiledningen for målplattformen.
• Å behandle BEAST som en 6DoF VIO-enhet fordi portalen nevner 6DoF.: Sjekk støtten på modellnivå: den gjeldende SDK-tabellen oppgir native 3DoF for BEAST og 6DoF VIO for Luma Ultra.
• Å kalle standardfunksjoner for visningsmodus mens BEAST er i native modus.: Sjekk den aktive modusen og bruk det tilsvarende funksjonssettet, enten standard eller `native_*`.
• Å åpne kameraet før tillatelsene er gitt, eller uten et konkret bruksbehov for kamera.: Be om plattformtillatelsene først, og legg bare til kamerastrømming når appen trenger bildedata.
• Å bruke SpaceWalker som kodeeditor eller oppsettsapp for SDK-et.: Bruk utviklersiden, SDK-pakken, dokumentasjonen og en kodeeditor eller Android Studio.

Konklusjon

Utvikling for VITURE BEAST starter med VITURE XR Glasses SDK, ikke med Unity-pakken for Neckband-opplevelser eller forbrukerappen SpaceWalker. Velg Android, Linux, Windows eller macOS som vert, last ned det tilhørende SDK-et fra VITUREs utviklerside, følg plattformveiledningen, og bygg først et lite program som kobler til via USB og leser sporingsdata. Deretter legger du til en støttet BEAST-kontroll eller kamerafunksjon og tester den på den faktiske maskinvaren. For virksomheter skiller dette applikasjonens arbeidsflyt og data fra brillenes enhetsfunksjoner, støtter utvikling på den vertsplattformen som passer utrullingen, og gir teamene en måte å validere et avgrenset industrielt bruksområde på før de investerer i en bredere utrulling.

Bygger du en XR-arbeidsflyt for VITURE BEAST? Utforsk produktsiden for VITURE BEAST og VITUREs utviklerdokumentasjon før du definerer kravene til piloten din.