Résumé
Pour développer pour VITURE BEAST, ouvrez la page Developer de VITURE et choisissez le VITURE XR Glasses SDK. Il s'agit du SDK C multiplateforme qui permet de connecter des logiciels aux lunettes VITURE. Sa documentation mentionne Android, Linux, Windows et macOS. Le VITURE XR SDK for Unity, distinct, est décrit pour des expériences exécutées sur le VITURE Neckband ; ce n'est donc pas le point de départ pour une application de contrôle des lunettes BEAST.
Le SDK des lunettes donne à une application accès à la communication avec l'appareil, aux données de suivi de la tête, au flux de la caméra et à certaines commandes des lunettes. Pour BEAST en particulier, VITURE documente le suivi 3DoF natif, le passthrough caméra et les commandes d'affichage natives. Il ne transforme pas les lunettes en ordinateur polyvalent et ne crée pas automatiquement une application XR finie. Vous développez une application hôte, vous connectez BEAST en USB et vous appelez le SDK depuis cette application.
Déroulement du développement : Choisir la plateforme hôte -> télécharger son package SDK -> compiler le premier exemple de connexion du fabricant -> lire les données de suivi -> ajouter une commande BEAST ou une fonction caméra -> tester l'application avec les lunettes.
Pour le contexte produit avant de planifier l'intégration logicielle, consultez le test du VITURE BEAST sur VRX. La page produit officielle de VITURE est également utile pour les détails matériels.
INTRODUCTION :
(vous connaissez déjà le SDK et les plateformes prises en charge ? passez directement aux instructions principales)
Qu'est-ce que VITURE BEAST ?
VITURE BEAST est un écran XR USB-C doté de capteurs intégrés et d'une caméra. En mode natif, son propre traitement gère le suivi 3DoF et les effets d'affichage pris en charge ; en mode bypass, l'hôte envoie un signal vidéo que les lunettes transmettent tel quel. Cette distinction entre mode natif et mode bypass est importante lorsque le logiciel modifie le mode d'affichage ou le comportement du suivi.
Le SDK développeur est un logiciel auquel votre programme est lié pour pouvoir communiquer avec les lunettes. Il est distinct des applications VITURE du quotidien comme SpaceWalker, qui sert à utiliser les fonctions d'affichage et d'écran spatial prises en charge, et non à écrire du code.
Les deux SDK VITURE répondent à des besoins différents
VITURE XR Glasses SDK :
- À quoi il sert : API C native pour l'accès aux lunettes, le suivi, le flux caméra et les commandes de l'appareil sur les plateformes hôtes prises en charge.
- À utiliser pour le développement BEAST ? Oui. C'est le SDK BEAST traité dans ce guide.
VITURE XR SDK for Unity :
- À quoi il sert : Package Unity XR documenté pour créer des expériences immersives sur le VITURE Neckband, avec des intégrations Unity comme le suivi des mains.
- À utiliser pour le développement BEAST ? Pas comme SDK par défaut pour les lunettes BEAST. Ne le confondez pas avec le SDK natif des lunettes.
SpaceWalker :
- À quoi il sert : Logiciel compagnon de VITURE pour les modes d'affichage et les fonctions d'écran spatial pris en charge.
- À utiliser pour le développement BEAST ? Non. C'est une application destinée à l'utilisateur final, pas un environnement de développement.
Ce que contrôle le SDK XR Glasses
Connexion de l'appareil :
- Ce que l'application peut faire : Détecter un appareil connecté, créer un handle d'appareil, l'initialiser, le démarrer et le fermer proprement.
- Détail BEAST à retenir : Le SDK communique avec les lunettes via la connexion de l'hôte.
Suivi de la tête :
- Ce que l'application peut faire : Lire les données d'orientation/IMU et utiliser l'interface de suivi propre au modèle.
- Détail BEAST à retenir : BEAST est documenté pour le 3DoF natif ; l'entrée 6DoF VIO du tableau des appareils concerne la Luma Ultra.
Commandes d'affichage et des lunettes :
- Ce que l'application peut faire : Lire ou régler la luminosité, le volume, le mode d'affichage, le mode 2D/3D, la teinte et les options du mode natif pris en charge.
- Détail BEAST à retenir : Utilisez les constantes d'affichage natives propres à BEAST en mode natif. Certaines combinaisons mode/fréquence ne sont pas prises en charge.
Flux caméra :
- Ce que l'application peut faire : Accéder aux images de la caméra passthrough prises en charge via l'API caméra du SDK.
- Détail BEAST à retenir : BEAST est répertorié avec une caméra UVC passthrough. L'accès à la caméra est indépendant du suivi 6DoF.
Le SDK ne fournit pas à lui seul : le workflow de votre application, sa logique métier, ses menus, le stockage des données, les comptes utilisateurs ni une scène Unity complète. Votre équipe applicative construit ces éléments autour des fonctions de l'appareil exposées par le SDK. La page développeur principale met en avant ces quatre plateformes. Depuis le SDK 2.4.0 (6 août 2026), la documentation mentionne une cinquième cible : Browser, une build WebAssembly avec une API TypeScript qui accède aux lunettes via WebHID, uniquement sous Chrome et Chromium, avec prise en charge de BEAST et exclusion de la Luma Ultra. Vérifiez le package actuel et les notes de version avant de choisir un appareil ou un OS de production.
Prise en charge multiplateforme : Android, Linux, Windows et macOS
« Multiplateforme » signifie que VITURE fournit des builds du SDK et des instructions de configuration propres à chaque plateforme pour le même SDK des lunettes. Cela ne veut pas dire qu'un même binaire fonctionne partout sans modification. Choisissez l'hôte sur lequel votre application doit tourner, puis utilisez la bibliothèque et le guide d'intégration correspondants. La documentation actuelle de l'API mentionne les architectures suivantes :
Windows :
- Architecture documentée : x86_64
- Configuration type : Application de bureau C/C++ utilisant la bibliothèque et les en-têtes du SDK Windows ; suivez Quick Start: Desktop (C++).
Linux :
- Architecture documentée : x86_64 et aarch64
- Configuration type : Application de bureau C/C++. Ajoutez la règle udev de VITURE pour que l'application puisse accéder à l'interface USB/HID sans être exécutée en root.
macOS :
- Architecture documentée : aarch64 (Apple silicon)
- Configuration type : Application de bureau C/C++ utilisant la bibliothèque et les en-têtes macOS ; suivez Quick Start: Desktop (C++).
Android :
- Architecture documentée : armeabi-v7a et arm64-v8a
- Configuration type : Application Android utilisant la bibliothèque C native via JNI ; gérez l'autorisation USB et la connexion dans l'application Android.
La page développeur principale met en avant ces quatre plateformes. La page détaillée de l'API peut ajouter des cibles ou modifier les architectures prises en charge au fil du temps ; vérifiez donc le package actuel et les notes de version avant de choisir un appareil ou un OS de production.
Ce dont vous avez besoin avant de développer
· Des lunettes VITURE BEAST et une connexion de données USB-C vers l'ordinateur ou l'hôte Android que vous comptez prendre en charge.
· Un ordinateur de développement équipé du compilateur et des outils de build pour votre cible : une chaîne d'outils C/C++ et CMake pour le bureau, ou Android Studio avec ses composants NDK et CMake pour Android.
· Le package VITURE XR Glasses SDK pour la plateforme cible, téléchargé depuis la page Developer de VITURE.
· La documentation du SDK correspondante, en particulier Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming et Native-DOF Devices.
· Une compréhension de base du langage utilisé par votre équipe applicative : C/C++ pour les exemples de bureau, plus Kotlin ou Java et JNI pour une intégration Android classique.
Comment réaliser un premier test avec le SDK VITURE BEAST
Commencez par une petite application hôte qui détecte BEAST et lit les données de suivi. Une fois que cela fonctionne, ajoutez une commande ou une fonction caméra.
Étape 1 : choisir où votre application s'exécutera
Choisissez l'ordinateur ou le téléphone qui exécutera votre application ; c'est ce qui détermine le package SDK et le guide de configuration.
1. Choisissez l'hôte. Utilisez Windows, Linux ou macOS pour un ordinateur, ou Android pour un téléphone connecté à BEAST.
2. Notez son OS et son processeur. Par exemple, notez Windows x86_64 ou macOS Apple silicon, puis consultez le tableau des plateformes ci-dessus.
3. Ne suivez la branche Android que pour une application Android. Elle utilise une bibliothèque native, un pont JNI et l'autorisation USB.
Étape 2 : télécharger le VITURE XR Glasses SDK
Téléchargez le SDK officiel des lunettes et ouvrez le guide correspondant à votre hôte. Le package Unity pour le Neckband est destiné à une autre configuration.
1. Ouvrez la page Developer. Dans un navigateur, allez sur https://www.viture.com/developer et faites défiler jusqu'à « VITURE XR Glasses SDK ».
2. Téléchargez le package de votre plateforme. Sur la carte du SDK, cliquez sur « Download » et choisissez votre hôte si on vous le demande.
3. Ouvrez votre guide de configuration. Sur la même carte, cliquez sur « Documents », puis sur « Core Concepts », puis sur « Quick Start: Desktop (C++) » ou « Android Integration Guide ».
4. Vérifiez la compatibilité. Revenez à la page Developer, ouvrez « Release Notes » et vérifiez votre OS, votre processeur et le firmware de BEAST.
Passez à l'étape 3 lorsque : vous disposez de la bibliothèque, des en-têtes et du guide de configuration correspondants.
Étape 3 : configurer le SDK sur votre plateforme hôte
Utilisez uniquement la branche de configuration correspondant à l'hôte choisi à l'étape 1.
Pour Windows, Linux ou macOS
1. Ouvrez le guide pour le bureau. Dans SDK Documents, choisissez « Quick Start: Desktop (C++) » et gardez-le à côté de votre éditeur de code.
2. Liez le SDK. Ouvrez l'exemple ou votre projet, puis utilisez l'exemple CMake du guide pour ajouter les en-têtes du SDK et la bibliothèque des lunettes.
Dans le fichier `CMakeLists.txt` de votre projet, ajoutez les chemins d'inclusion et de bibliothèque du SDK. Remplacez `VITURE_SDK_ROOT` par le dossier dans lequel vous avez décompressé le 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. Linux uniquement : autorisez l'accès USB. Dans le Terminal, suivez « Linux udev Rule » et créez `/etc/udev/rules.d/70-viture.rules` ; rechargez les règles et reconnectez BEAST. Ignorez cette étape sous Windows et macOS.
4. Compilez l'exemple. Ouvrez le fichier `main.cpp` de l'exemple du SDK et vérifiez qu'il se compile avant d'ajouter des fonctions.
Pour Android
1. Créez un projet Android. Dans Android Studio, démarrez un projet avec prise en charge de CMake/NDK et ouvrez `app/src/main` dans le panneau du projet.
2. Copiez les fichiers du SDK. Suivez « Android Integration Guide » : placez les en-têtes dans `app/src/main/include/` et le fichier `.so` correspondant dans `app/src/main/jniLibs/<ABI>/`.
3. Liez la bibliothèque. Dans Android Studio, ouvrez `app/src/main/cpp/CMakeLists.txt` et `app/build.gradle.kts` ; appliquez les paramètres CMake, NDK et ABI du guide.
Dans `CMakeLists.txt`, importez la bibliothèque du SDK et liez-la à votre pont JNI. Cet exemple suppose que les fichiers du SDK se trouvent dans les dossiers indiqués dans l'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. Ajoutez le pont entre l'application et le C++. Dans le dossier source de l'application, créez la classe `GlassesBridge` du guide ; ses fonctions `external` appellent votre code JNI.
5. Demandez l'autorisation USB. Utilisez le `UsbManager` d'Android pour trouver BEAST ; une fois que l'utilisateur a appuyé sur « Autoriser », ouvrez la connexion USB et transmettez son descripteur de fichier au pont.
Une fois que l'utilisateur a appuyé sur « Autoriser », ouvrez la connexion USB dans votre activité Kotlin et transmettez son descripteur de fichier au pont natif. Remplacez `GlassesBridge` par le nom de la classe de pont de votre projet :
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
Dans `glasses_bridge.cpp`, la fonction native de création transmet ce descripteur de fichier Android au SDK de 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; }
Passez à l'étape 4 lorsque : votre application se compile et charge le SDK sans erreur de fichier manquant ou d'édition de liens.
Étape 4 : connecter BEAST et exécuter le premier exemple
Testez maintenant la connexion des lunettes. Utilisez l'exemple pour le bureau sous Windows, Linux ou macOS. Sous Android, conservez la configuration USB et JNI de l'étape 3 ; n'utilisez pas le code de détection HID prévu pour le bureau.
1. Connectez BEAST. Utilisez un câble de données USB-C ; sous Android, acceptez l'invite USB du téléphone.
2. Trouvez BEAST et créez son handle. Sur le bureau, trouvez l'ID produit de BEAST via la détection HID, puis créez le provider avec xr_device_provider_create(product_id). Sous Android, transmettez à la fois l'ID produit et le descripteur de fichier issu de la connexion USB.
3. Démarrez le suivi. Démarrez le suivi en enregistrant un callback. Un callback est une fonction que le SDK appelle lorsque des données de suivi arrivent. BEAST fournit le roulis, le tangage et le lacet dans data[0] à data[2] et le quaternion dans data[3] à data[6], mais uniquement avec le SDK 2.4.0 ou ultérieur et un firmware des lunettes à jour. Avec un firmware plus ancien, le callback de pose ne se déclenche jamais sur BEAST (VITURE le signale dans la rubrique « Known Limitations on Beast » de ses notes de version) : dans ce cas, enregistrez xr_device_provider_register_imu_raw_callback et intégrez vous-même les données IMU brutes, ou passez les lunettes en mode natif et laissez-les assurer le suivi.
Ajoutez cette fonction au-dessus de 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]
);
}
Enregistrez le callback avant d'initialiser et de démarrer le 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;
Utilisez handle sur le bureau. Dans le code JNI Android, utilisez g_handle.
4. Ouvrez le flux de suivi. Ajoutez cet appel au fichier `main.cpp` pour le bureau ; sous Android, exposez-le via JNI et appelez-le après `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
À la fermeture de l'application, fermez l'IMU, puis arrêtez le provider, mettez-le hors service et détruisez-le. Sous Android, appelez les mêmes fonctions de nettoyage avant de fermer la connexion 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. Vérifiez la sortie. Lancez l'application et consultez la console de bureau ou Logcat dans Android Studio pour voir les mises à jour de connexion et de suivi.
Passez à l'étape 5 lorsque : BEAST se connecte et que les mises à jour de suivi arrivent sans erreur.
Étape 5 : ajouter une commande BEAST
Une fois le suivi fonctionnel, ajoutez une commande des lunettes dans le code de contrôle de l'appareil de votre application, après le démarrage du handle du SDK.
1. Choisissez une commande. Dans SDK Documents, ouvrez « Device Control » et vérifiez les options de luminosité, de volume ou d'affichage prises en charge par BEAST.
2. Lisez et réglez sa valeur. Ajoutez les appels C/C++ à votre code de contrôle ; sous Android, placez-les dans `glasses_bridge.cpp` et exposez-les via JNI.
Après avoir démarré le provider, lisez la luminosité de BEAST et essayez une valeur prise en charge. La plage documentée va de 0 à 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. Adaptez l'API d'affichage au mode. Vous pouvez aussi configurer le mode d'affichage de BEAST. Le mode natif utilise le traitement d'affichage intégré aux lunettes et prend en charge le 3DoF natif. Le mode bypass transmet le signal vidéo de l'hôte à travers les lunettes. Choisissez la branche qui correspond au mode sélectionné dans votre application. N'exécutez pas les deux branches l'une après l'autre.
Dans cet exemple, use_native_mode est un paramètre booléen de votre application, et rc est la variable de résultat existante.
</> 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;
}
Choisissez une résolution et une fréquence de rafraîchissement prises en charge par BEAST.
4. Testez une seule modification. Lancez l'application, vérifiez le résultat sur BEAST, puis rétablissez le réglage d'origine.
Important : BEAST prend en charge le 3DoF natif, mais le firmware actuel n'accepte que trois modes d'affichage : 1920 x 1200 à 60 Hz et 3D côte à côte 3840 x 1200 à 60 Hz en mode natif, et 3840 x 1200 à 90 Hz en mode bypass (notes de version du VITURE XR Glasses SDK, 2.3.0 et 2.3.1). Les autres constantes passent la vérification du SDK, mais les lunettes les rejettent ou les ignorent ; relisez donc le mode après l'avoir réglé et considérez les notes de version comme la liste des valeurs prises en charge.
Étape 6 : ajouter l'accès à la caméra uniquement si l'application en a besoin
N'ajoutez la caméra passthrough que si votre application a besoin d'images. Le flux caméra est indépendant du suivi de la tête et ne fournit pas de 6DoF.
1. Ouvrez le guide de la caméra. Dans SDK Documents, choisissez « Camera Streaming » et suivez la section de configuration de votre hôte.
2. Ajoutez un gestionnaire d'images. Dans votre application, créez une fonction qui reçoit les images de la caméra et les transmet à la fonction qui en a besoin, comme un aperçu.
Dans votre module caméra C++, créez le provider de caméra de BEAST et démarrez-le avec votre callback d'images, `on_frame`. Cet appel à deux arguments concerne le bureau :
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);
// Une fois terminé xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
Sous Android, transmettez le descripteur de fichier USB de la caméra comme troisième argument, en utilisant la configuration des autorisations de l'étape 3 :
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Obtenez d'abord les autorisations. Android a besoin des autorisations caméra et USB ; sur le bureau, suivez le guide de la plateforme.
4. Protégez la vie privée. Expliquez l'utilisation de la caméra, ne capturez que ce dont la fonction a besoin et suivez la procédure RGPD de votre organisation dans l'UE.
Passez cette étape si votre application n'a besoin que du suivi ou des commandes d'affichage.
Étape 7 : tester et préparer un petit pilote
1. Testez la reconnexion. Redémarrez l'application, débranchez puis rebranchez BEAST et vérifiez que l'application reste stable.
2. Testez sur BEAST. Vérifiez, pour chaque fonction, le mode d'affichage, la résolution, le suivi et les autorisations caméra par rapport au firmware.
3. Enregistrez les détails des tests. Notez les versions du SDK, de l'OS, du processeur, du compilateur/NDK et du firmware, ainsi que les détails de connexion et les erreurs.
4. Planifiez le déploiement. Décidez comment installer et mettre à jour l'application hôte, gérer l'accès à la caméra et les données, et assurer le support.
Condition de passage du pilote : n'étendez le déploiement qu'après avoir testé l'hôte, les fonctions, les autorisations et le processus de mise à jour.
Ce que le SDK ne fait pas
Le VITURE XR Glasses SDK est une boîte à outils d'intégration matérielle, pas un environnement de création XR clé en main. Il expose des fonctions que votre logiciel peut appeler. Votre équipe doit toujours choisir un framework applicatif, écrire l'interface utilisateur et la logique des tâches, compiler l'application pour la plateforme hôte et décider de la manière dont l'entreprise la déploiera et en assurera le support.
Il ne rend pas non plus toutes les fonctionnalités disponibles sur tous les modèles VITURE. Dans le tableau matériel actuel, BEAST figure avec le 3DoF natif et l'accès à la caméra passthrough, tandis que la Luma Ultra est le modèle répertorié avec le 3/6DoF et le VIO stéréo. Consultez le tableau du matériel pris en charge pour chaque API que vous prévoyez d'utiliser, au lieu de considérer la description générale « 3DoF/6DoF » du portail comme la promesse que BEAST prend en charge tous les modes de suivi.
Erreurs courantes lors du développement avec le SDK VITURE BEAST
- Télécharger l'Unity XR SDK pour une application de contrôle des lunettes BEAST : Utilisez la carte VITURE XR Glasses SDK ; le guide Unity est documenté pour le VITURE Neckband.
- Supposer que multiplateforme signifie le même binaire ou la même configuration partout : Téléchargez la bonne bibliothèque et suivez le guide d'architecture et de connexion de la plateforme cible.
- Considérer BEAST comme un appareil 6DoF VIO parce que le portail mentionne le 6DoF : Vérifiez la prise en charge au niveau du modèle : le tableau actuel du SDK indique le 3DoF natif pour BEAST et le 6DoF VIO pour la Luma Ultra.
- Appeler les fonctions standard de mode d'affichage alors que BEAST est en mode natif : Vérifiez le mode actif et utilisez l'ensemble de fonctions correspondant, standard ou `native_*`.
- Ouvrir la caméra avant d'obtenir les autorisations ou sans cas d'usage pour la caméra : Demandez d'abord les autorisations de la plateforme et n'ajoutez le flux caméra que lorsque l'application a besoin de données d'image.
- Utiliser SpaceWalker comme éditeur de code ou application de configuration du SDK : Utilisez la page Developer, le package SDK, la documentation et un éditeur de code ou Android Studio.
Conclusion
Le développement pour VITURE BEAST commence avec le VITURE XR Glasses SDK, et non avec le package Unity destiné aux expériences sur le Neckband ni avec l'application grand public SpaceWalker. Choisissez Android, Linux, Windows ou macOS comme hôte, téléchargez le SDK correspondant depuis la page Developer de VITURE, suivez le guide de sa plateforme et commencez par créer un petit programme qui se connecte en USB et lit les données de suivi. Ensuite, ajoutez une commande BEAST ou une fonction caméra prise en charge et testez-la sur le matériel réel. Pour les entreprises, cette approche sépare le workflow et les données de l'application des fonctions de l'appareil, permet de développer sur la plateforme hôte adaptée au déploiement et donne aux équipes un moyen de valider un cas d'usage industriel ciblé avant d'investir dans un déploiement plus large.
Vous concevez un workflow XR pour VITURE BEAST ? Découvrez la page produit VITURE BEAST et la documentation développeur de VITURE avant de définir les exigences de votre pilote.
























