Samenvatting
Om voor VITURE BEAST te ontwikkelen, open je de Developer-pagina van VITURE en kies je de VITURE XR Glasses SDK. Dat is de platformonafhankelijke C-SDK om software met VITURE-brillen te verbinden. De documentatie vermeldt Android, Linux, Windows en macOS. De afzonderlijke VITURE XR SDK for Unity wordt beschreven voor toepassingen die op de VITURE Neckband draaien en is dus niet het vertrekpunt voor een app die de BEAST-bril aanstuurt.
De bril-SDK geeft een app toegang tot apparaatcommunicatie, headtrackinggegevens, camerastreaming en bepaalde bedieningsfuncties van de bril. Specifiek voor BEAST documenteert VITURE native 3DoF-tracking, camera-passthrough en native beeldscherminstellingen. De SDK maakt van de bril geen computer voor algemeen gebruik en levert ook niet automatisch een kant-en-klare XR-app op. Je bouwt een hostapplicatie, verbindt BEAST via USB en roept de SDK aan vanuit die app.
Ontwikkelproces: Kies het hostplatform -> download het bijbehorende SDK-pakket -> bouw het eerste verbindingsvoorbeeld van de fabrikant -> lees trackinggegevens uit -> voeg een BEAST-bediening of camerafunctie toe -> test de app met de bril.
Voor productcontext voordat je de software-integratie plant, kun je de VITURE BEAST-review op VRX raadplegen. Ook de officiële productpagina van VITURE is nuttig voor hardwaredetails.
INLEIDING:
(ken je de SDK en de platformondersteuning al, ga dan meteen door naar de hoofdhandleiding)
Wat is VITURE BEAST?
VITURE BEAST is een XR-display met USB-C, ingebouwde sensoren en een camera. In de native modus verzorgt de eigen verwerking van de bril de 3DoF-tracking en ondersteunde beeldeffecten; in de bypassmodus stuurt de host een videosignaal dat de bril gewoon doorgeeft. Dat onderscheid tussen native en bypass is belangrijk wanneer software de weergavemodus of het trackinggedrag wijzigt.
De ontwikkelaars-SDK is software waaraan je programma linkt zodat het met de bril kan communiceren. Ze staat los van alledaagse VITURE-apps zoals SpaceWalker, die dient om ondersteunde weergave- en spatial-screenfuncties te gebruiken, niet om code te schrijven.
De twee VITURE-SDK's dienen voor verschillende taken
VITURE XR Glasses SDK:
- Waarvoor dient het: Native C-API voor toegang tot de bril, tracking, camerastreaming en apparaatbediening op de ondersteunde hostplatformen.
- Gebruiken voor BEAST-ontwikkeling?: Ja. Dit is de BEAST-SDK die in deze handleiding aan bod komt.
VITURE XR SDK for Unity:
- Waarvoor dient het: Unity XR-pakket dat gedocumenteerd is voor het bouwen van immersieve toepassingen op de VITURE Neckband, met Unity-integraties zoals handtracking.
- Gebruiken voor BEAST-ontwikkeling?: Niet als standaard-SDK voor de BEAST-bril. Verwar ze niet met de native bril-SDK.
SpaceWalker:
- Waarvoor dient het: Begeleidende software van VITURE voor ondersteunde weergavemodi en spatial-screenfuncties.
- Gebruiken voor BEAST-ontwikkeling?: Nee. Het is een app voor eindgebruikers, geen ontwikkelomgeving.
Wat de XR Glasses SDK aanstuurt
Apparaatverbinding:
- Wat de app kan doen: Een verbonden apparaat detecteren, een apparaathandle aanmaken, het initialiseren, starten en netjes afsluiten.
- BEAST-detail om te onthouden: De SDK communiceert met de bril via de hostverbinding.
Headtracking:
- Wat de app kan doen: Oriëntatie-/IMU-gegevens uitlezen en de modelspecifieke trackinginterface gebruiken.
- BEAST-detail om te onthouden: BEAST is gedocumenteerd voor native 3DoF; de vermelding 6DoF VIO in de apparatentabel geldt voor Luma Ultra.
Beeld- en brilinstellingen:
- Wat de app kan doen: Ondersteunde instellingen voor helderheid, volume, weergavemodus, 2D/3D-modus, tint en native-modusopties uitlezen of instellen.
- BEAST-detail om te onthouden: Gebruik in de native modus de BEAST-specifieke native displayconstanten. Sommige combinaties van modus en verversingsfrequentie worden niet ondersteund.
Camerastream:
- Wat de app kan doen: Via de camera-API van de SDK toegang krijgen tot ondersteunde passthrough-camerabeelden.
- BEAST-detail om te onthouden: BEAST staat vermeld met een passthrough-UVC-camera. Cameratoegang staat los van 6DoF-tracking.
Wat de SDK op zichzelf niet levert: de workflow van je app, bedrijfslogica, menu's, gegevensopslag, gebruikersaccounts of een volledige Unity-scène. Je applicatieteam bouwt die onderdelen rond de apparaatfuncties die de SDK beschikbaar stelt. De hoofdpagina voor ontwikkelaars zet deze vier platformen in de kijker. Sinds SDK 2.4.0 (6 augustus 2026) vermeldt de documentatie een vijfde doelplatform: Browser, een WebAssembly-build met een TypeScript-API die de bril via WebHID bereikt, alleen in Chrome en Chromium, met ondersteuning voor BEAST en uitsluiting van Luma Ultra. Controleer het actuele pakket en de release notes voordat je een productieapparaat of besturingssysteem kiest.
Platformonafhankelijke ondersteuning: Android, Linux, Windows en macOS
'Platformonafhankelijk' betekent dat VITURE platformspecifieke SDK-builds en installatie-instructies levert voor dezelfde bril-SDK. Het betekent niet dat één binary overal ongewijzigd draait. Kies de host waarop je applicatie moet draaien en gebruik dan de bijbehorende bibliotheek en integratiegids. De huidige API-documentatie vermeldt deze architecturen:
Windows:
- Gedocumenteerde architectuur: x86_64
- Gebruikelijke installatieroute: C/C++-desktopapp die de Windows-SDK-bibliotheek en -headers gebruikt; 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 toegang heeft tot de USB/HID-interface zonder als root te draaien.
macOS:
- Gedocumenteerde architectuur: aarch64 (Apple silicon)
- Gebruikelijke installatieroute: C/C++-desktopapp die de macOS-bibliotheek en -headers gebruikt; volg Quick Start: Desktop (C++).
Android:
- Gedocumenteerde architectuur: armeabi-v7a en arm64-v8a
- Gebruikelijke installatieroute: Android-app die de native C-bibliotheek via JNI gebruikt; regel de USB-toestemming en -verbinding in de Android-app.
De hoofdpagina voor ontwikkelaars zet deze vier platformen in de kijker. De gedetailleerde API-pagina kan na verloop van tijd doelplatformen toevoegen of de ondersteunde architecturen wijzigen, dus controleer het actuele pakket en de release notes voordat je een productieapparaat of besturingssysteem kiest.
Wat je nodig hebt voordat je begint te ontwikkelen
· Een VITURE BEAST-bril en een USB-C-dataverbinding met de computer of Android-host die je wilt ondersteunen.
· Een ontwikkelcomputer met de compiler/buildtools voor je doelplatform: 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, gedownload van de Developer-pagina van VITURE.
· De bijbehorende SDK-documentatie, vooral Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming en Native-DOF Devices.
· Basiskennis van de taal die je appteam gebruikt: C/C++ voor de desktopvoorbeelden, plus Kotlin of Java en JNI voor een typische Android-integratie.
Zo bouw je een eerste VITURE BEAST SDK-test
Begin met een kleine hostapp die BEAST vindt en trackinggegevens uitleest. Zodra dat werkt, voeg je één bedienings- of camerafunctie toe.
Stap 1: Kies waar je app zal draaien
Kies de computer of smartphone waarop je app zal draaien; dat bepaalt het SDK-pakket en de installatiegids.
1. Kies de host. Gebruik Windows, Linux of macOS voor een computer, of Android voor een smartphone die met BEAST verbonden is.
2. Noteer het besturingssysteem en de processor. Noteer bijvoorbeeld Windows x86_64 of macOS Apple silicon en controleer dan de platformtabel hierboven.
3. Volg de Android-route alleen voor een Android-app. Die gebruikt een native bibliotheek, een JNI-brug en USB-toestemming.
Stap 2: Download de VITURE XR Glasses SDK
Download de officiële bril-SDK en open de gids voor je 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 je platform. Klik op de SDK-kaart op 'Download' en kies je host als daarom gevraagd wordt.
3. Open je installatiegids. Klik op dezelfde kaart op 'Documents', dan 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 je besturingssysteem, processor en BEAST-firmware.
Ga naar stap 3 wanneer: je de bijbehorende bibliotheek, headers en installatiegids hebt.
Stap 3: Installeer de SDK op je hostplatform
Gebruik alleen de installatieroute voor de host die je in stap 1 hebt gekozen.
Voor Windows, Linux of macOS
1. Open de desktopgids. Kies in SDK Documents 'Quick Start: Desktop (C++)' en houd die naast je code-editor open.
2. Link de SDK. Open het voorbeeld of je project en gebruik het CMake-voorbeeld uit de gids om de SDK-headers en de brilbibliotheek toe te voegen.
Voeg in de `CMakeLists.txt` van je project de include- en bibliotheekpaden van de SDK toe. Vervang `VITURE_SDK_ROOT` door de map waarin je 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 verbind BEAST opnieuw. Sla dit over op Windows en macOS.
4. Bouw het voorbeeld. Open `main.cpp` van het SDK-voorbeeld en zorg dat het bouwt voordat je 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 '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 bibliotheek. Open in Android Studio `app/src/main/cpp/CMakeLists.txt` en `app/build.gradle.kts`; pas de CMake-, NDK- en ABI-instellingen uit de gids toe.
Importeer in `CMakeLists.txt` de SDK-bibliotheek en link ze aan je JNI-brug. Dit voorbeeld gaat ervan uit dat de SDK-bestanden in de mappen staan die in de Android Integration Guide worden getoond:
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 brug tussen app en C++ toe. Maak in de bronmap van de app de klasse `GlassesBridge` uit de gids aan; de `external`-functies ervan roepen je JNI-code aan.
5. Vraag USB-toestemming. Gebruik `UsbManager` van Android om BEAST te vinden; nadat de gebruiker op Toestaan tikt, open je de USB-verbinding en geef je de file descriptor ervan door aan de brug.
Nadat de gebruiker op Toestaan tikt, open je de USB-verbinding in je Kotlin-activity en geef je de file descriptor ervan door aan de native brug. Vervang `GlassesBridge` door de naam van de brugklasse in je 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; }
Ga naar stap 4 wanneer: je app bouwt en de SDK laadt zonder fout over een ontbrekend bestand of een linkerfout.
Stap 4: Verbind BEAST en voer het eerste voorbeeld uit
Test nu de verbinding met de bril. Gebruik het desktopvoorbeeld op Windows, Linux of macOS. Behoud op Android de USB- en JNI-configuratie uit stap 3; gebruik geen HID-detectiecode voor desktop.
1. Verbind BEAST. Gebruik een USB-C-datakabel; accepteer op Android de USB-melding van de smartphone.
2. Zoek BEAST en maak de handle aan. Zoek op desktop de product-ID van BEAST via HID-detectie en maak dan de provider aan met xr_device_provider_create(product_id). Geef op Android zowel de 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 wanneer er trackinggegevens binnenkomen. BEAST levert roll, pitch en yaw in data[0] tot data[2] en het quaternion in data[3] tot data[6], maar alleen met SDK 2.4.0 of later en bijgewerkte brilfirmware. Met oudere firmware wordt de pose-callback op BEAST nooit aangeroepen (VITURE vermeldt dit onder 'Known Limitations on Beast' in de release notes): registreer dan ofwel xr_device_provider_register_imu_raw_callback en integreer de ruwe IMU-gegevens zelf, ofwel schakel de bril over naar de native modus en laat hem zelf tracken.
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 je 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; stel ze op Android beschikbaar via JNI en roep ze 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;
Wanneer de app afsluit, sluit je eerst de IMU en stop je daarna de provider, sluit je hem af en vernietig je hem. Roep op Android dezelfde opruimfuncties aan voordat je 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. Voer de app uit en kijk in de desktopconsole of in Logcat van Android Studio naar verbindings- en trackingupdates.
Ga naar stap 5 wanneer: BEAST verbinding maakt en trackingupdates zonder fouten binnenkomen.
Stap 5: Voeg één BEAST-bediening toe
Zodra de tracking werkt, voeg je één brilbediening toe in de apparaatbedieningscode van je app, nadat de SDK-handle gestart is.
1. Kies een bediening. Open in SDK Documents 'Device Control' en controleer welke helderheids-, volume- of weergaveopties BEAST ondersteunt.
2. Lees de waarde uit en stel ze in. Voeg de C/C++-aanroepen toe aan je bedieningscode; plaats ze op Android in `glasses_bridge.cpp` en stel 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. Je kunt ook de weergavemodus van BEAST instellen. De native modus gebruikt de ingebouwde beeldverwerking van de bril en ondersteunt native 3DoF. De bypassmodus geeft het videosignaal van de host door via de bril. Kies de tak die overeenkomt met de modus die je app gebruikt. Voer de twee takken niet na elkaar uit.
In dit voorbeeld is use_native_mode een Booleaanse instelling in je 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 verversingsfrequentie die BEAST ondersteunt.
4. Test één wijziging. Voer de app uit, controleer het resultaat op BEAST en zet daarna de oorspronkelijke instelling terug.
Belangrijk: BEAST ondersteunt native 3DoF, maar de huidige firmware aanvaardt slechts drie weergavemodi: 1920 x 1200 bij 60 Hz en 3D side-by-side 3840 x 1200 bij 60 Hz in de native modus, en 3840 x 1200 bij 90 Hz in de bypassmodus (release notes van de VITURE XR Glasses SDK, 2.3.0 en 2.3.1). Andere constanten komen door de controle van de SDK, maar de bril weigert of negeert ze. Lees de modus dus opnieuw uit nadat je hem hebt ingesteld 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 je app camerabeelden nodig heeft. Camerastreaming staat los van headtracking en levert geen 6DoF.
1. Open de cameragids. Kies in SDK Documents 'Camera Streaming' en volg het installatiegedeelte voor je host.
2. Voeg een framehandler toe. Maak in je app een functie aan die camerabeelden ontvangt en ze doorstuurt naar de functie die ze nodig heeft, zoals een voorvertoning.
Maak in je C++-cameramodule de cameraprovider van BEAST aan en start hem met je 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 heeft camera- en USB-toestemmingen nodig; volg op desktop de platformgids.
4. Bescherm de privacy. Leg uit waarvoor de camera gebruikt wordt, leg alleen vast wat de functie nodig heeft en volg in de EU het GDPR-proces van je organisatie.
Sla deze stap over als je app alleen tracking of beeldinstellingen nodig heeft.
Stap 7: Test en bereid een kleine pilot voor
1. Test het opnieuw verbinden. Herstart de app, koppel BEAST los en weer aan, en controleer of de app stabiel blijft.
2. Test op BEAST. Controleer voor elke functie de weergavemodus, resolutie, tracking en cameratoestemmingen ten opzichte van de firmware.
3. Bewaar testgegevens. Noteer de versies van SDK, besturingssysteem, processor, compiler/NDK en firmware, de verbindingsgegevens en fouten.
4. Plan de uitrol. Beslis hoe je de hostapp installeert en bijwerkt, hoe je cameratoegang en gegevens beheert en hoe je ondersteuning regelt.
Pilotdrempel: breid pas uit nadat je 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. Ze stelt functies beschikbaar die je software kan aanroepen. Je team kiest nog altijd zelf een applicatieframework, schrijft de gebruikersinterface en de taaklogica, bouwt de app voor het hostplatform en beslist hoe het bedrijf de app zal uitrollen en ondersteunen.
Ze maakt ook niet elke functionaliteit 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 dat met 3/6DoF en stereo-VIO vermeld staat. Controleer de tabel met ondersteunde hardware voor elke API die je wilt gebruiken, in plaats van de algemene beschrijving '3DoF/6DoF' op het portaal te lezen als een belofte dat BEAST elke trackingmodus ondersteunt.
Veelgemaakte fouten bij ontwikkeling met de VITURE BEAST SDK
- De Unity XR SDK downloaden voor een app die de BEAST-bril aanstuurt.: Gebruik de kaart van de VITURE XR Glasses SDK; de Unity-gids is gedocumenteerd voor de VITURE Neckband.
- Aannemen dat platformonafhankelijk betekent dat de binary of de installatie overal dezelfde is.: Download de juiste bibliotheek en volg de architectuur- en verbindingsgids van het doelplatform.
- BEAST behandelen als een 6DoF-VIO-apparaat omdat het portaal 6DoF vermeldt.: Controleer de ondersteuning per model: de huidige SDK-tabel vermeldt native 3DoF voor BEAST en 6DoF VIO voor Luma Ultra.
- Standaardfuncties voor de weergavemodus aanroepen terwijl BEAST in de native modus staat.: Controleer de actieve modus en gebruik de overeenkomende standaardfuncties of de `native_*`-functies.
- De camera openen vóór de toestemmingen of zonder toepassing voor de camera.: Vraag eerst de platformtoestemmingen aan en voeg camerastreaming alleen toe wanneer de app beeldgegevens nodig heeft.
- SpaceWalker gebruiken als code-editor of als 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 bij de VITURE XR Glasses SDK, niet bij het Unity-pakket voor Neckband-toepassingen of de consumentenapp SpaceWalker. Kies Android, Linux, Windows of macOS als host, download de bijbehorende SDK van de Developer-pagina van VITURE, volg de platformgids en bouw eerst een klein programma dat via USB verbinding maakt en trackinggegevens uitleest. Voeg van daaruit een ondersteunde BEAST-bediening of camerafunctie toe en test die op de echte hardware. Voor bedrijven scheidt dit de workflow en gegevens van de applicatie van de apparaatfuncties van de bril, ondersteunt het ontwikkeling op het hostplatform dat bij de uitrol past, en krijgen teams een manier om een afgebakende industriële toepassing te valideren voordat ze in een bredere uitrol investeren.
Bouw je een XR-workflow voor VITURE BEAST? Bekijk de productpagina van VITURE BEAST en de ontwikkelaarsdocumentatie van VITURE voordat je de vereisten voor je pilot vastlegt.
























