Sintesi
Per sviluppare per VITURE BEAST, apri la pagina Developer di VITURE e scegli il VITURE XR Glasses SDK. Si tratta dell’SDK multipiattaforma in C per collegare il software agli occhiali VITURE. La sua documentazione elenca Android, Linux, Windows e macOS. Il VITURE XR SDK for Unity, distinto dal primo, è descritto per esperienze eseguite sul VITURE Neckband, quindi non è il punto di partenza per un’app di controllo degli occhiali BEAST.
L’SDK per gli occhiali consente a un’app di accedere alla comunicazione con il dispositivo, ai dati di tracciamento della testa, allo streaming della fotocamera e ad alcuni controlli degli occhiali. Per BEAST in particolare, VITURE documenta il tracciamento 3DoF nativo, il passthrough della fotocamera e i controlli nativi del display. L’SDK non trasforma gli occhiali in un computer generico né crea automaticamente un’app XR finita. Sei tu a sviluppare un’applicazione host, a collegare BEAST tramite USB e a richiamare l’SDK da quell’app.
Flusso di sviluppo: Scegli la piattaforma host -> scarica il relativo pacchetto SDK -> compila il primo esempio di connessione fornito dal produttore -> leggi i dati di tracciamento -> aggiungi una funzione di controllo o della fotocamera di BEAST -> testa l’app con gli occhiali.
Per un inquadramento del prodotto prima di pianificare l’integrazione software, consulta la recensione di VITURE BEAST su VRX. Anche la pagina ufficiale del prodotto di VITURE è utile per i dettagli hardware.
INTRODUZIONE:
(se conosci già l’SDK e il supporto delle piattaforme, passa direttamente alla guida principale)
Che cos’è VITURE BEAST?
VITURE BEAST è un display XR USB-C con sensori e fotocamera integrati. In modalità nativa, è la sua elaborazione interna a gestire il tracciamento 3DoF e gli effetti di visualizzazione supportati; in modalità bypass, l’host invia un segnale video che gli occhiali lasciano passare. Questa distinzione tra modalità nativa e bypass è importante quando il software modifica la modalità di visualizzazione o il comportamento del tracciamento.
L’SDK per sviluppatori è un software a cui il tuo programma si collega per poter comunicare con gli occhiali. È distinto dalle app VITURE di uso quotidiano come SpaceWalker, che serve a utilizzare le funzioni di visualizzazione e di schermo spaziale supportate, non a scrivere codice.
I due SDK di VITURE servono a scopi diversi
VITURE XR Glasses SDK:
- A cosa serve: API C nativa per l’accesso agli occhiali, il tracciamento, lo streaming della fotocamera e i controlli del dispositivo sulle piattaforme host supportate.
- Da usare per lo sviluppo su BEAST?: Sì. È l’SDK per BEAST trattato in questa guida.
VITURE XR SDK for Unity:
- A cosa serve: Pacchetto Unity XR documentato per creare esperienze immersive sul VITURE Neckband, con integrazioni Unity come il tracciamento delle mani.
- Da usare per lo sviluppo su BEAST?: Non come SDK predefinito per gli occhiali BEAST. Non va confuso con l’SDK nativo per gli occhiali.
SpaceWalker:
- A cosa serve: Software complementare di VITURE per le modalità di visualizzazione e le funzioni di schermo spaziale supportate.
- Da usare per lo sviluppo su BEAST?: No. È un’app per utenti finali, non un ambiente di sviluppo.
Cosa controlla l’XR Glasses SDK
Connessione del dispositivo:
- Cosa può fare l’app: Rilevare un dispositivo collegato, creare un handle del dispositivo, inizializzarlo, avviarlo e chiuderlo correttamente.
- Dettaglio da ricordare su BEAST: L’SDK comunica con gli occhiali tramite la connessione dell’host.
Tracciamento della testa:
- Cosa può fare l’app: Leggere i dati di orientamento/IMU e utilizzare l’interfaccia di tracciamento specifica per il modello.
- Dettaglio da ricordare su BEAST: BEAST è documentato per il 3DoF nativo; la voce 6DoF VIO nella tabella dei dispositivi riguarda Luma Ultra.
Controlli del display e degli occhiali:
- Cosa può fare l’app: Leggere o impostare le opzioni supportate di luminosità, volume, modalità di visualizzazione, modalità 2D/3D, oscuramento e modalità nativa.
- Dettaglio da ricordare su BEAST: In modalità nativa usa le costanti di visualizzazione native specifiche per BEAST. Alcune combinazioni di modalità e frequenza non sono supportate.
Stream della fotocamera:
- Cosa può fare l’app: Accedere ai fotogrammi supportati della fotocamera passthrough tramite l’API della fotocamera dell’SDK.
- Dettaglio da ricordare su BEAST: BEAST è elencato con una fotocamera UVC passthrough. L’accesso alla fotocamera è separato dal tracciamento 6DoF.
Ciò che l’SDK non fornisce da solo: il flusso di lavoro della tua app, la logica di business, i menu, l’archiviazione dei dati, gli account utente o una scena Unity completa. È il team che sviluppa l’applicazione a costruire queste parti attorno alle funzioni del dispositivo esposte dall’SDK. La pagina principale per sviluppatori mette in evidenza queste quattro piattaforme. Dall’SDK 2.4.0 (6 agosto 2026) la documentazione elenca un quinto target: Browser, una build WebAssembly con API TypeScript che raggiunge gli occhiali tramite WebHID, solo su Chrome e Chromium, con BEAST supportato e Luma Ultra escluso. Controlla il pacchetto attuale e le note di rilascio prima di scegliere un dispositivo o un sistema operativo per la produzione.
Supporto multipiattaforma: Android, Linux, Windows e macOS
“Multipiattaforma” significa che VITURE fornisce build dell’SDK e istruzioni di configurazione specifiche per ciascuna piattaforma, per lo stesso SDK degli occhiali. Non significa che un unico binario funzioni ovunque senza modifiche. Scegli l’host su cui deve girare la tua applicazione, quindi usa la libreria e la guida all’integrazione corrispondenti. L’attuale documentazione delle API elenca queste architetture:
Windows:
- Architettura documentata: x86_64
- Percorso di configurazione tipico: App desktop C/C++ che utilizza la libreria e gli header dell’SDK per Windows; segui Quick Start: Desktop (C++).
Linux:
- Architettura documentata: x86_64 e aarch64
- Percorso di configurazione tipico: App desktop C/C++. Aggiungi la regola udev di VITURE in modo che l’app possa accedere all’interfaccia USB/HID senza essere eseguita come root.
macOS:
- Architettura documentata: aarch64 (Apple silicon)
- Percorso di configurazione tipico: App desktop C/C++ che utilizza la libreria e gli header per macOS; segui Quick Start: Desktop (C++).
Android:
- Architettura documentata: armeabi-v7a e arm64-v8a
- Percorso di configurazione tipico: App Android che utilizza la libreria C nativa tramite JNI; gestisci l’autorizzazione USB e la connessione nell’app Android.
La pagina principale per sviluppatori mette in evidenza queste quattro piattaforme. La pagina dettagliata delle API potrebbe aggiungere target o modificare le architetture supportate nel tempo, quindi controlla il pacchetto attuale e le note di rilascio prima di scegliere un dispositivo o un sistema operativo per la produzione.
Cosa ti serve prima di iniziare a sviluppare
· Occhiali VITURE BEAST e una connessione dati USB-C al computer o all’host Android che intendi supportare.
· Un computer di sviluppo con il compilatore e gli strumenti di build per il tuo target: una toolchain C/C++ e CMake per desktop, oppure Android Studio con i componenti NDK e CMake per Android.
· Il pacchetto VITURE XR Glasses SDK per la piattaforma di destinazione, scaricato dalla pagina Developer di VITURE.
· La documentazione SDK corrispondente, in particolare Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming e Native-DOF Devices.
· Una conoscenza di base del linguaggio usato dal team che sviluppa l’app: C/C++ per gli esempi desktop, più Kotlin o Java e JNI per una tipica integrazione Android.
Come creare un primo test con l’SDK di VITURE BEAST
Inizia con una piccola app host che trovi BEAST e legga i dati di tracciamento. Quando funziona, aggiungi una funzione di controllo o della fotocamera.
Passo 1: scegli dove verrà eseguita la tua app
Scegli il computer o il telefono su cui girerà la tua app: da questo dipendono il pacchetto SDK e la guida di configurazione.
1. Scegli l’host. Usa Windows, Linux o macOS per un computer, oppure Android per un telefono collegato a BEAST.
2. Annota sistema operativo e processore. Ad esempio, annota Windows x86_64 o macOS Apple silicon, quindi controlla la tabella delle piattaforme riportata sopra.
3. Segui il percorso Android solo per un’app Android. Richiede una libreria nativa, un bridge JNI e l’autorizzazione USB.
Passo 2: scarica il VITURE XR Glasses SDK
Scarica l’SDK ufficiale per gli occhiali e apri la guida relativa al tuo host. Il pacchetto Unity per Neckband è pensato per una configurazione diversa.
1. Apri la pagina Developer. In un browser, vai su https://www.viture.com/developer e scorri fino a “VITURE XR Glasses SDK”.
2. Scarica il pacchetto per la tua piattaforma. Nella scheda dell’SDK, fai clic su “Download” e, se richiesto, scegli il tuo host.
3. Apri la guida di configurazione. Nella stessa scheda, fai clic su “Documents”, poi su “Core Concepts” e infine su “Quick Start: Desktop (C++)” o “Android Integration Guide”.
4. Verifica la compatibilità. Torna alla pagina Developer, apri “Release Notes” e controlla sistema operativo, processore e firmware di BEAST.
Passa al Passo 3 quando: disponi della libreria, degli header e della guida di configurazione corrispondenti.
Passo 3: configura l’SDK sulla piattaforma host
Usa solo il percorso di configurazione relativo all’host scelto nel Passo 1.
Per Windows, Linux o macOS
1. Apri la guida desktop. In SDK Documents, scegli “Quick Start: Desktop (C++)” e tienila accanto al tuo editor di codice.
2. Collega l’SDK. Apri l’esempio o il tuo progetto, quindi usa l’esempio CMake della guida per aggiungere gli header dell’SDK e la libreria glasses.
Nel file `CMakeLists.txt` del progetto, aggiungi i percorsi di include e delle librerie dell’SDK. Sostituisci `VITURE_SDK_ROOT` con la cartella in cui hai estratto l’SDK:
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. Solo Linux: consenti l’accesso USB. Nel Terminale, segui “Linux udev Rule” e crea `/etc/udev/rules.d/70-viture.rules`; ricarica le regole e ricollega BEAST. Salta questo passaggio su Windows e macOS.
4. Compila l’esempio. Apri il file `main.cpp` dell’esempio dell’SDK e verifica che venga compilato prima di aggiungere funzioni.
Per Android
1. Crea un progetto Android. In Android Studio, avvia un progetto con supporto CMake/NDK e apri `app/src/main` nel pannello del progetto.
2. Copia i file dell’SDK. Segui “Android Integration Guide”: inserisci gli header in `app/src/main/include/` e il file `.so` corrispondente in `app/src/main/jniLibs/<ABI>/`.
3. Collega la libreria. In Android Studio, apri `app/src/main/cpp/CMakeLists.txt` e `app/build.gradle.kts`; applica le impostazioni CMake, NDK e ABI indicate nella guida.
In `CMakeLists.txt`, importa la libreria dell’SDK e collegala al tuo bridge JNI. Questo esempio presuppone che i file dell’SDK si trovino nelle cartelle indicate nella 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. Aggiungi il bridge tra app e C++. Nella cartella dei sorgenti dell’app, crea la classe `GlassesBridge` descritta nella guida; le sue funzioni `external` richiamano il tuo codice JNI.
5. Richiedi l’autorizzazione USB. Usa `UsbManager` di Android per trovare BEAST; dopo che l’utente tocca Consenti, apri la connessione USB e passa il relativo file descriptor al bridge.
Dopo che l’utente tocca Consenti, apri la connessione USB nella tua activity Kotlin e passa il relativo file descriptor al bridge nativo. Sostituisci `GlassesBridge` con il nome della classe bridge del tuo progetto:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
In `glasses_bridge.cpp`, la funzione nativa create passa quel file descriptor Android all’SDK di 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; }
Passa al Passo 4 quando: la tua app viene compilata e carica l’SDK senza errori di file mancanti o del linker.
Passo 4: collega BEAST ed esegui il primo esempio
Ora testa la connessione con gli occhiali. Usa l’esempio desktop su Windows, Linux o macOS. Su Android, mantieni la configurazione USB e JNI del Passo 3; non usare il codice di rilevamento HID per desktop.
1. Collega BEAST. Usa un cavo dati USB-C; su Android, accetta la richiesta USB del telefono.
2. Trova BEAST e crea il relativo handle. Su desktop, trova il product ID di BEAST tramite il rilevamento HID, quindi crea il provider con xr_device_provider_create(product_id). Su Android, passa sia il product ID sia il file descriptor della connessione USB.
3. Avvia il tracciamento. Avvia il tracciamento registrando una callback. Una callback è una funzione che l’SDK richiama quando arrivano i dati di tracciamento. BEAST fornisce roll, pitch e yaw da data[0] a data[2] e il quaternione da data[3] a data[6], ma solo con l’SDK 2.4.0 o successivo e con il firmware degli occhiali aggiornato. Con firmware precedenti la callback della posa non viene mai attivata su BEAST (VITURE lo segnala tra le “Known Limitations on Beast” nelle note di rilascio): in tal caso registra xr_device_provider_register_imu_raw_callback e integra autonomamente i dati IMU grezzi, oppure passa gli occhiali alla modalità nativa e lascia che siano loro a gestire il tracciamento.
Aggiungi questa funzione sopra 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]
);
}
Registra la callback prima di inizializzare e avviare l’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;
Su desktop usa handle. Nel codice JNI per Android, usa g_handle.
4. Apri lo stream di tracciamento. Aggiungi questa chiamata al file `main.cpp` desktop; su Android, esponila tramite JNI e richiamala dopo `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Quando l’app termina, chiudi l’IMU, quindi arresta, spegni ed elimina il provider. Su Android, richiama le stesse funzioni di pulizia prima di chiudere la connessione 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. Controlla l’output. Esegui l’app e verifica nella console desktop o nel Logcat di Android Studio gli aggiornamenti di connessione e tracciamento.
Passa al Passo 5 quando: BEAST si connette e gli aggiornamenti del tracciamento arrivano senza errori.
Passo 5: aggiungi un controllo di BEAST
Quando il tracciamento funziona, aggiungi un controllo degli occhiali nel codice di controllo del dispositivo della tua app, dopo l’avvio dell’handle dell’SDK.
1. Scegli un controllo. In SDK Documents, apri “Device Control” e verifica le opzioni di luminosità, volume o visualizzazione supportate da BEAST.
2. Leggi e imposta il valore. Aggiungi le chiamate C/C++ al tuo codice di controllo; su Android, inseriscile in `glasses_bridge.cpp` ed esponile tramite JNI.
Dopo aver avviato il provider, leggi la luminosità di BEAST e prova un valore supportato. L’intervallo documentato va da 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. Abbina l’API di visualizzazione alla modalità. Puoi anche configurare la modalità di visualizzazione di BEAST. La modalità nativa utilizza l’elaborazione del display integrata negli occhiali e supporta il 3DoF nativo. La modalità bypass fa passare attraverso gli occhiali il segnale video dell’host. Scegli il ramo corrispondente alla modalità selezionata nella tua app. Non eseguire entrambi i rami uno dopo l’altro.
In questo esempio, use_native_mode è un’impostazione booleana della tua app e rc è la variabile di risultato già esistente.
</> 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;
}
Scegli una risoluzione e una frequenza di aggiornamento supportate da BEAST.
4. Testa una modifica alla volta. Esegui l’app, verifica il risultato su BEAST, quindi ripristina l’impostazione originale.
Importante: BEAST supporta il 3DoF nativo, ma il firmware attuale accetta solo tre modalità di visualizzazione: 1920 x 1200 a 60 Hz e 3D side-by-side 3840 x 1200 a 60 Hz in modalità nativa, e 3840 x 1200 a 90 Hz in modalità bypass (note di rilascio del VITURE XR Glasses SDK, 2.3.0 e 2.3.1). Le altre costanti superano il controllo dell’SDK, ma gli occhiali le rifiutano o le ignorano: rileggi quindi la modalità dopo averla impostata e considera le note di rilascio come l’elenco dei valori supportati.
Passo 6: aggiungi l’accesso alla fotocamera solo se l’app ne ha bisogno
Aggiungi la fotocamera passthrough solo se la tua app ha bisogno di fotogrammi. Lo streaming della fotocamera è separato dal tracciamento della testa e non fornisce il 6DoF.
1. Apri la guida alla fotocamera. In SDK Documents, scegli “Camera Streaming” e segui la sezione di configurazione relativa al tuo host.
2. Aggiungi un gestore dei fotogrammi. Nella tua app, crea una funzione che riceva i fotogrammi della fotocamera e li invii alla funzione che ne ha bisogno, ad esempio un’anteprima.
Nel modulo fotocamera C++, crea il camera provider di BEAST e avvialo con la tua callback per i fotogrammi, `on_frame`. Questa chiamata a due argomenti è per 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);
// Al termine xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
Su Android, passa come terzo argomento il file descriptor USB della fotocamera, utilizzando la configurazione delle autorizzazioni del Passo 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Ottieni prima le autorizzazioni. Android richiede le autorizzazioni per fotocamera e USB; su desktop, segui la guida della piattaforma.
4. Tutela la privacy. Spiega l’uso della fotocamera, acquisisci solo ciò che serve alla funzione e, nell’UE, segui la procedura GDPR della tua organizzazione.
Salta questo passo se la tua app ha bisogno solo del tracciamento o dei controlli del display.
Passo 7: testa e prepara un piccolo progetto pilota
1. Testa la riconnessione. Riavvia l’app, scollega e ricollega BEAST e verifica che l’app resti stabile.
2. Testa su BEAST. Verifica per ogni funzione modalità di visualizzazione, risoluzione, tracciamento e autorizzazioni della fotocamera in relazione al firmware.
3. Salva i dettagli dei test. Registra le versioni di SDK, sistema operativo, processore, compilatore/NDK e firmware, oltre ai dettagli di connessione e agli errori.
4. Pianifica il rollout. Decidi come installare e aggiornare l’app host, come gestire l’accesso alla fotocamera e i dati e come fornire assistenza.
Soglia per il pilota: estendi l’utilizzo solo dopo aver testato host, funzioni, autorizzazioni e processo di aggiornamento.
Cosa non fa l’SDK
Il VITURE XR Glasses SDK è un toolkit di integrazione con il dispositivo, non un ambiente di authoring XR completo. Espone funzioni che il tuo software può richiamare. Spetta comunque al tuo team scegliere un framework applicativo, scrivere l’interfaccia utente e la logica delle attività, compilare l’app per la piattaforma host e decidere come l’azienda la distribuirà e la supporterà.
Inoltre, non rende disponibili tutte le funzionalità su ogni modello VITURE. Nell’attuale tabella hardware, BEAST è elencato con 3DoF nativo e accesso alla fotocamera passthrough, mentre Luma Ultra è il modello elencato con 3/6DoF e VIO stereo. Controlla la tabella dell’hardware supportato per ogni API che intendi usare, invece di interpretare la descrizione generica “3DoF/6DoF” del portale come una garanzia che BEAST supporti tutte le modalità di tracciamento.
Errori comuni nello sviluppo con l’SDK di VITURE BEAST
- Scaricare l’Unity XR SDK per un’app di controllo degli occhiali BEAST.: Usa la scheda del VITURE XR Glasses SDK; la guida Unity è documentata per il VITURE Neckband.
- Pensare che multipiattaforma significhi lo stesso binario o la stessa configurazione ovunque.: Scarica la libreria corretta e segui la guida all’architettura e alla connessione della piattaforma di destinazione.
- Trattare BEAST come un dispositivo 6DoF VIO perché il portale cita il 6DoF.: Verifica il supporto a livello di modello: l’attuale tabella dell’SDK indica per BEAST il 3DoF nativo e il 6DoF VIO per Luma Ultra.
- Richiamare le funzioni standard della modalità di visualizzazione mentre BEAST è in modalità nativa.: Verifica la modalità attiva e usa il set di funzioni corrispondente, standard o `native_*`.
- Aprire la fotocamera prima di ottenere le autorizzazioni o senza un caso d’uso che la richieda.: Richiedi prima le autorizzazioni della piattaforma e aggiungi lo streaming della fotocamera solo quando l’app ha bisogno di dati di immagine.
- Usare SpaceWalker come editor di codice o app di configurazione dell’SDK.: Usa la pagina Developer, il pacchetto SDK, la documentazione e un editor di codice o Android Studio.
Conclusione
Lo sviluppo per VITURE BEAST parte dal VITURE XR Glasses SDK, non dal pacchetto Unity per le esperienze su Neckband né dall’app consumer SpaceWalker. Scegli Android, Linux, Windows o macOS come host, scarica l’SDK corrispondente dalla pagina Developer di VITURE, segui la guida della piattaforma e realizza innanzitutto un piccolo programma che si connetta tramite USB e legga i dati di tracciamento. A quel punto, aggiungi un controllo o una funzione della fotocamera supportati da BEAST e testali sull’hardware reale. Per le aziende, questo approccio separa il flusso di lavoro e i dati dell’applicazione dalle funzioni del dispositivo, consente di sviluppare sulla piattaforma host più adatta alla distribuzione e offre ai team un modo per convalidare un caso d’uso industriale mirato prima di investire in un rollout più ampio.
Stai creando un flusso di lavoro XR per VITURE BEAST? Consulta la pagina prodotto di VITURE BEAST e la documentazione per sviluppatori di VITURE prima di definire i requisiti del tuo progetto pilota.
