Samenvatting
Om voor VITURE BEAST te ontwikkelen, opent u de Developer-pagina van VITURE en kiest u de VITURE XR Glasses SDK. Dit is de cross-platform C-SDK waarmee u software met VITURE-brillen verbindt. De documentatie noemt Android, Linux, Windows en macOS. De aparte VITURE XR SDK for Unity is bedoeld voor ervaringen die op de VITURE Neckband draaien. Die is dus niet het startpunt voor een app die de BEAST-bril aanstuurt.
De glasses SDK geeft een app toegang tot apparaatcommunicatie, head-trackinggegevens, camerastreaming en een selectie van brilinstellingen. Specifiek voor BEAST documenteert VITURE native 3DoF-tracking, camera-passthrough en native displayinstellingen. De SDK maakt van de bril geen computer voor algemeen gebruik en levert ook niet automatisch een kant-en-klare XR-app op. U bouwt zelf een hostapplicatie, verbindt BEAST via USB en roept de SDK vanuit die app aan.
Ontwikkelproces: Kies het hostplatform -> download het bijbehorende SDK-pakket -> bouw het eerste verbindingsvoorbeeld van de fabrikant -> lees trackinggegevens uit -> voeg een BEAST-instelling of camerafunctie toe -> test de app met de bril.
Wilt u meer productcontext voordat u de software-integratie plant? Lees dan de VITURE BEAST-review op VRX. Voor hardwaredetails is ook de officiële productpagina van VITURE nuttig.
Inleiding:
(kent u de SDK en de platformondersteuning al, ga dan direct door naar de stappen)
Wat is VITURE BEAST?
VITURE BEAST is een XR-display met USB-C, ingebouwde sensoren en een camera. In native mode verzorgt de bril met eigen verwerking de 3DoF-tracking en ondersteunde displayeffecten. In bypass mode stuurt de host een videosignaal dat de bril doorgeeft. Dit onderscheid tussen native en bypass is belangrijk zodra software de displaymodus of het trackinggedrag wijzigt.
De developer-SDK is software waaraan uw programma linkt om met de bril te communiceren. Die staat los van alledaagse VITURE-apps zoals SpaceWalker. Die app is bedoeld voor het gebruik van ondersteunde display- en spatial-screenfuncties, niet voor het schrijven van code.
De twee VITURE-SDK's hebben elk een eigen taak
VITURE XR Glasses SDK:
- Waarvoor: Native C-API voor toegang tot de bril, tracking, camerastreaming en apparaatinstellingen op ondersteunde hostplatforms.
- Geschikt voor BEAST-ontwikkeling?: Ja. Dit is de BEAST-SDK die in deze handleiding aan bod komt.
VITURE XR SDK for Unity:
- Waarvoor: Unity XR-pakket, gedocumenteerd voor het bouwen van immersieve ervaringen op de VITURE Neckband, met Unity-integraties zoals hand tracking.
- Geschikt voor BEAST-ontwikkeling?: Niet als standaard-SDK voor de BEAST-bril. Verwar dit pakket niet met de native glasses SDK.
SpaceWalker:
- Waarvoor: Begeleidende software van VITURE voor ondersteunde displaymodi en spatial-screenfuncties.
- Geschikt voor BEAST-ontwikkeling?: Nee. Het is een app voor eindgebruikers, geen ontwikkelomgeving.
Wat de XR Glasses SDK aanstuurt
Apparaatverbinding:
- Wat de app kan: Een aangesloten apparaat detecteren, een device handle aanmaken, deze initialiseren en starten, en de verbinding netjes afsluiten.
- Let op bij BEAST: De SDK communiceert met de bril via de hostverbinding.
Head tracking:
- Wat de app kan: Oriëntatie-/IMU-gegevens uitlezen en de modelspecifieke tracking-interface gebruiken.
- Let op bij BEAST: BEAST is gedocumenteerd voor native 3DoF; de vermelding 6DoF VIO in de apparatentabel geldt voor Luma Ultra.
Display- en brilinstellingen:
- Wat de app kan: Ondersteunde instellingen voor helderheid, volume, displaymodus, 2D/3D-modus, tint en native mode uitlezen of wijzigen.
- Let op bij BEAST: Gebruik in native mode de BEAST-specifieke native displayconstanten. Sommige combinaties van modus en refresh rate worden niet ondersteund.
Camerastream:
- Wat de app kan: Ondersteunde passthrough-cameraframes ophalen via de camera-API van de SDK.
- Let op bij BEAST: BEAST staat vermeld met een passthrough-UVC-camera. Cameratoegang staat los van 6DoF-tracking.
Wat de SDK zelf niet levert: de werkprocessen van uw app, bedrijfslogica, menu's, gegevensopslag, gebruikersaccounts of een complete Unity-scène. Uw applicatieteam bouwt die onderdelen rond de apparaatfuncties die de SDK beschikbaar stelt. De hoofdpagina voor ontwikkelaars belicht deze vier platforms. Sinds SDK 2.4.0 (6 augustus 2026) noemt de documentatie een vijfde target: Browser. Dat is een WebAssembly-build met een TypeScript-API die de bril via WebHID aanspreekt, alleen in Chrome en Chromium. BEAST wordt ondersteund, Luma Ultra niet. Controleer het actuele pakket en de release notes voordat u een apparaat of besturingssysteem voor productie kiest.
Cross-platformondersteuning: Android, Linux, Windows en macOS
“Cross-platform” betekent dat VITURE voor dezelfde glasses SDK platformspecifieke builds en installatie-instructies levert. Het betekent niet dat één binary overal ongewijzigd draait. Kies de host waarop uw applicatie moet draaien en gebruik vervolgens de bijbehorende library en integratiehandleiding. De huidige API-documentatie noemt deze architecturen:
Windows:
- Gedocumenteerde architectuur: x86_64
- Gebruikelijke installatieroute: C/C++-desktopapp met de SDK-library en headers voor Windows; volg Quick Start: Desktop (C++).
Linux:
- Gedocumenteerde architectuur: x86_64 en aarch64
- Gebruikelijke installatieroute: C/C++-desktopapp. Voeg de udev-regel van VITURE toe, zodat de app zonder root-rechten toegang krijgt tot de USB/HID-interface.
macOS:
- Gedocumenteerde architectuur: aarch64 (Apple silicon)
- Gebruikelijke installatieroute: C/C++-desktopapp met de library en headers voor macOS; volg Quick Start: Desktop (C++).
Android:
- Gedocumenteerde architectuur: armeabi-v7a en arm64-v8a
- Gebruikelijke installatieroute: Android-app die de native C-library via JNI gebruikt; regel de USB-toestemming en de verbinding in de Android-app.
De hoofdpagina voor ontwikkelaars belicht deze vier platforms. Op de gedetailleerde API-pagina kunnen in de loop van de tijd targets bijkomen of ondersteunde architecturen veranderen. Controleer daarom het actuele pakket en de release notes voordat u een apparaat of besturingssysteem voor productie kiest.
Wat u nodig hebt voordat u begint
· Een VITURE BEAST-bril en een USB-C-dataverbinding met de computer of Android-host die u wilt ondersteunen.
· Een ontwikkelcomputer met de compiler en buildtools voor uw target: een C/C++-toolchain en CMake voor desktop, of Android Studio met de NDK- en CMake-componenten voor Android.
· Het VITURE XR Glasses SDK-pakket voor het doelplatform, te downloaden via de Developer-pagina van VITURE.
· De bijbehorende SDK-documentatie, met name Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming en Native-DOF Devices.
· Basiskennis van de taal die uw appteam gebruikt: C/C++ voor de desktopvoorbeelden, plus Kotlin of Java en JNI voor een gebruikelijke Android-integratie.
Een eerste test met de VITURE BEAST SDK bouwen
Begin met een kleine hostapp die BEAST vindt en trackinggegevens uitleest. Werkt dat, voeg dan één instelling of camerafunctie toe.
Stap 1: kies waar uw app draait
Kies de computer of telefoon waarop uw app gaat draaien. Dat bepaalt welk SDK-pakket en welke installatiehandleiding u nodig hebt.
1. Kies de host. Gebruik Windows, Linux of macOS voor een computer, of Android voor een telefoon die op BEAST is aangesloten.
2. Noteer het besturingssysteem en de processor. Noteer bijvoorbeeld Windows x86_64 of macOS Apple silicon en controleer daarna de platformtabel hierboven.
3. Volg de Android-route alleen voor een Android-app. Die route gebruikt een native library, een JNI-bridge en USB-toestemming.
Stap 2: download de VITURE XR Glasses SDK
Download de officiële glasses SDK en open de handleiding voor uw host. Het Unity-pakket voor de Neckband is bedoeld voor een andere opstelling.
1. Open de Developer-pagina. Ga in een browser naar https://www.viture.com/developer en scrol naar “VITURE XR Glasses SDK”.
2. Download het pakket voor uw platform. Klik op de SDK-kaart op “Download” en kies uw host als daarom wordt gevraagd.
3. Open uw installatiehandleiding. Klik op dezelfde kaart op “Documents”, daarna op “Core Concepts” en vervolgens op “Quick Start: Desktop (C++)” of “Android Integration Guide”.
4. Controleer de compatibiliteit. Ga terug naar de Developer-pagina, open “Release Notes” en controleer uw besturingssysteem, processor en BEAST-firmware.
Door naar stap 3 zodra: u de bijbehorende library, headers en installatiehandleiding hebt.
Stap 3: installeer de SDK op uw hostplatform
Volg alleen de installatieroute voor de host die u in stap 1 hebt gekozen.
Voor Windows, Linux of macOS
1. Open de desktophandleiding. Kies in SDK Documents “Quick Start: Desktop (C++)” en houd die open naast uw code-editor.
2. Link de SDK. Open het voorbeeld of uw eigen project en voeg met het CMake-voorbeeld uit de handleiding de SDK-headers en de glasses-library toe.
Voeg in de `CMakeLists.txt` van uw project de include- en librarypaden van de SDK toe. Vervang `VITURE_SDK_ROOT` door de map waarin u de SDK hebt uitgepakt:
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. Alleen Linux: geef USB-toegang. Volg in Terminal “Linux udev Rule” en maak `/etc/udev/rules.d/70-viture.rules` aan. Laad de regels opnieuw en sluit BEAST opnieuw aan. Op Windows en macOS slaat u deze stap over.
4. Bouw het voorbeeld. Open `main.cpp` van het SDK-voorbeeld en controleer of het zonder fouten bouwt voordat u functies toevoegt.
Voor Android
1. Maak een Android-project aan. Start in Android Studio een project met CMake/NDK-ondersteuning en open `app/src/main` in het projectpaneel.
2. Kopieer de SDK-bestanden. Volg de “Android Integration Guide”: plaats de headers in `app/src/main/include/` en het bijbehorende `.so`-bestand in `app/src/main/jniLibs/<ABI>/`.
3. Link de library. Open in Android Studio `app/src/main/cpp/CMakeLists.txt` en `app/build.gradle.kts` en neem de CMake-, NDK- en ABI-instellingen uit de handleiding over.
Importeer in `CMakeLists.txt` de SDK-library en link die aan uw JNI-bridge. Dit voorbeeld gaat ervan uit dat de SDK-bestanden in de mappen staan die de Android Integration Guide aangeeft:
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. Voeg de bridge tussen app en C++ toe. Maak in de bronmap van de app de klasse `GlassesBridge` uit de handleiding aan; de `external`-functies daarvan roepen uw JNI-code aan.
5. Vraag USB-toestemming aan. Gebruik `UsbManager` van Android om BEAST te vinden. Zodra de gebruiker op Toestaan tikt, opent u de USB-verbinding en geeft u de file descriptor door aan de bridge.
Open nadat de gebruiker op Toestaan heeft getikt de USB-verbinding in uw Kotlin-activity en geef de file descriptor door aan de native bridge. Vervang `GlassesBridge` door de naam van de bridgeklasse in uw project:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
In `glasses_bridge.cpp` geeft de native create-functie die Android-file descriptor door aan de SDK van 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; }
Door naar stap 4 zodra: uw app bouwt en de SDK laadt zonder foutmelding over een ontbrekend bestand of de linker.
Stap 4: sluit BEAST aan en voer het eerste voorbeeld uit
Test nu de verbinding met de bril. Gebruik op Windows, Linux of macOS het desktopvoorbeeld. Houd op Android de USB- en JNI-configuratie uit stap 3 aan en gebruik geen HID-detectiecode voor desktop.
1. Sluit BEAST aan. Gebruik een USB-C-datakabel; accepteer op Android de USB-melding op de telefoon.
2. Zoek BEAST en maak de handle aan. Zoek op desktop het product-ID van BEAST via HID-detectie en maak daarna de provider aan met xr_device_provider_create(product_id). Geef op Android zowel het product-ID als de file descriptor van de USB-verbinding door.
3. Start de tracking. Start de tracking door een callback te registreren. Een callback is een functie die de SDK aanroept zodra er trackinggegevens binnenkomen. BEAST levert roll, pitch en yaw in data[0] tot en met data[2] en het quaternion in data[3] tot en met data[6], maar alleen met SDK 2.4.0 of later en bijgewerkte firmware op de bril. Met oudere firmware wordt de pose-callback op BEAST nooit aangeroepen (VITURE vermeldt dit in de release notes onder “Known Limitations on Beast”). Registreer in dat geval xr_device_provider_register_imu_raw_callback en integreer de ruwe IMU-gegevens zelf, of zet de bril in native mode en laat de bril de tracking doen.
Voeg deze functie toe boven 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]
);
}
Registreer de callback voordat u de SDK initialiseert en start:
</> 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;
Gebruik handle op desktop. Gebruik g_handle in Android-JNI-code.
4. Open de trackingstream. Voeg deze aanroep toe aan `main.cpp` op desktop. Op Android stelt u hem beschikbaar via JNI en roept u hem aan na `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Sluit bij het afsluiten van de app eerst de IMU en stop, beëindig en verwijder daarna de provider. Roep op Android dezelfde opschoonfuncties aan voordat u de USB-verbinding sluit:
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. Controleer de uitvoer. Start de app en kijk in de desktopconsole of in Logcat van Android Studio of er verbindings- en trackingupdates verschijnen.
Door naar stap 5 zodra: BEAST verbinding maakt en trackingupdates zonder fouten binnenkomen.
Stap 5: voeg één BEAST-instelling toe
Werkt de tracking, voeg dan één brilinstelling toe aan de apparaatbedieningscode van uw app, nadat de SDK-handle is gestart.
1. Kies een instelling. Open in SDK Documents “Device Control” en controleer welke helderheids-, volume- of displayopties BEAST ondersteunt.
2. Lees de waarde uit en stel die in. Voeg de C/C++-aanroepen toe aan uw bedieningscode. Op Android plaatst u ze in `glasses_bridge.cpp` en stelt u ze beschikbaar via JNI.
Lees na het starten van de provider de helderheid van BEAST uit en probeer een ondersteunde waarde. Het gedocumenteerde bereik is 0 tot 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. Stem de display-API af op de modus. U kunt ook de displaymodus van BEAST configureren. Native mode gebruikt de ingebouwde displayverwerking van de bril en ondersteunt native 3DoF. Bypass mode geeft het videosignaal van de host door via de bril. Kies het codepad dat past bij de modus die uw app heeft geselecteerd. Voer niet beide codepaden na elkaar uit.
In dit voorbeeld is use_native_mode een booleaanse instelling in uw app en is rc de bestaande resultaatvariabele.
</> 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;
}
Kies een resolutie en refresh rate die BEAST ondersteunt.
4. Test één wijziging. Start de app, controleer het resultaat op BEAST en zet daarna de oorspronkelijke instelling terug.
Belangrijk: BEAST ondersteunt native 3DoF, maar de huidige firmware accepteert slechts drie displaymodi: 1920 × 1200 bij 60 Hz en 3D side-by-side 3840 × 1200 bij 60 Hz in native mode, en 3840 × 1200 bij 90 Hz in bypass mode (release notes van de VITURE XR Glasses SDK, 2.3.0 en 2.3.1). Andere constanten komen wel door de controle van de SDK, maar de bril weigert of negeert ze. Lees de modus daarom na het instellen terug en beschouw de release notes als de lijst met ondersteunde waarden.
Stap 6: voeg alleen cameratoegang toe als de app die nodig heeft
Voeg de passthrough-camera alleen toe als uw app beeldframes nodig heeft. Camerastreaming staat los van head tracking en levert geen 6DoF.
1. Open de camerahandleiding. Kies in SDK Documents “Camera Streaming” en volg het installatiegedeelte voor uw host.
2. Voeg een framehandler toe. Maak in uw app een functie die cameraframes ontvangt en doorstuurt naar de functie die ze nodig heeft, zoals een preview.
Maak in uw C++-cameramodule de cameraprovider van BEAST aan en start die met uw frame-callback `on_frame`. Deze aanroep met twee argumenten is voor 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);
Geef op Android de USB-file descriptor van de camera door als derde argument, met de toestemmingsconfiguratie uit stap 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Vraag eerst toestemming. Android vereist camera- en USB-toestemming; volg op desktop de platformhandleiding.
4. Bescherm de privacy. Leg uit waarvoor de camera wordt gebruikt, leg alleen vast wat de functie nodig heeft en volg binnen de EU het AVG-proces van uw organisatie.
Sla deze stap over als uw app alleen tracking of displayinstellingen nodig heeft.
Stap 7: test en bereid een kleine pilot voor
1. Test het opnieuw verbinden. Herstart de app, koppel BEAST los en sluit de bril opnieuw aan, en controleer of de app stabiel blijft.
2. Test op BEAST. Controleer per functie de displaymodus, resolutie, tracking en cameratoestemmingen aan de hand van de firmware.
3. Leg testgegevens vast. Noteer de versies van SDK, besturingssysteem, processor, compiler/NDK en firmware, plus verbindingsgegevens en fouten.
4. Plan de uitrol. Bepaal hoe u de hostapp installeert en bijwerkt, hoe u cameratoegang en gegevens beheert en hoe u de ondersteuning regelt.
Voorwaarde voor de pilot: breid pas uit nadat u de host, functies, toestemmingen en het updateproces hebt getest.
Wat de SDK niet doet
De VITURE XR Glasses SDK is een toolkit voor apparaatintegratie, geen kant-en-klare XR-ontwikkelomgeving. De SDK stelt functies beschikbaar die uw software kan aanroepen. Uw team kiest nog steeds zelf een applicatieframework, schrijft de gebruikersinterface en taaklogica, bouwt de app voor het hostplatform en bepaalt hoe de organisatie de app uitrolt en ondersteunt.
Ook maakt de SDK niet elke functie beschikbaar op elk VITURE-model. In de huidige hardwaretabel staat BEAST vermeld met native 3DoF en toegang tot de passthrough-camera, terwijl Luma Ultra het model is met 3/6DoF en stereo-VIO. Controleer voor elke API die u wilt gebruiken de tabel met ondersteunde hardware. Vat de algemene beschrijving “3DoF/6DoF” op het portaal niet op als belofte dat BEAST elke trackingmodus ondersteunt.
Veelgemaakte fouten bij SDK-ontwikkeling voor VITURE BEAST
- De Unity XR SDK downloaden voor een app die de BEAST-bril aanstuurt.: Gebruik de kaart van de VITURE XR Glasses SDK; de Unity-handleiding is gedocumenteerd voor de VITURE Neckband.
- Aannemen dat cross-platform overal dezelfde binary of installatie betekent.: Download de juiste library en volg de handleiding voor de architectuur en verbinding van het doelplatform.
- BEAST behandelen als 6DoF VIO-apparaat omdat het portaal 6DoF noemt.: Controleer de ondersteuning per model: de huidige SDK-tabel vermeldt native 3DoF voor BEAST en 6DoF VIO voor Luma Ultra.
- Standaardfuncties voor de displaymodus aanroepen terwijl BEAST in native mode staat.: Controleer de actieve modus en gebruik de bijbehorende standaardfuncties of de `native_*`-functies.
- De camera openen vóór de toestemmingen of zonder concrete toepassing voor de camera.: Vraag eerst de platformtoestemmingen aan en voeg camerastreaming alleen toe als de app beeldgegevens nodig heeft.
- SpaceWalker gebruiken als code-editor of app om de SDK te installeren.: Gebruik de Developer-pagina, het SDK-pakket, de documentatie en een code-editor of Android Studio.
Conclusie
Ontwikkelen voor VITURE BEAST begint met de VITURE XR Glasses SDK, niet met het Unity-pakket voor Neckband-ervaringen of de consumentenapp SpaceWalker. Kies Android, Linux, Windows of macOS als host, download de bijbehorende SDK via de Developer-pagina van VITURE, volg de platformhandleiding en bouw eerst een klein programma dat via USB verbinding maakt en trackinggegevens uitleest. Voeg daarna een ondersteunde BEAST-instelling of camerafunctie toe en test die op de echte hardware. Voor bedrijven houdt deze aanpak de werkprocessen en gegevens van de applicatie gescheiden van de apparaatfuncties van de bril. U ontwikkelt op het hostplatform dat bij de uitrol past, en teams kunnen een gerichte industriële toepassing valideren voordat ze investeren in een bredere uitrol.
Bouwt u een XR-werkproces voor VITURE BEAST? Bekijk de productpagina van VITURE BEAST en de ontwikkelaarsdocumentatie van VITURE voordat u de eisen voor uw pilot vastlegt.
