Synthèse
Pour développer pour VITURE BEAST, ouvrez la page Developer de VITURE et choisissez le VITURE XR Glasses SDK. Il s’agit du SDK multiplateforme en C qui permet de connecter un logiciel aux lunettes VITURE. Sa documentation mentionne Android, Linux, Windows et macOS. Le VITURE XR SDK for Unity, distinct, est présenté 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 l’accès à la communication avec l’appareil, aux données de suivi de la tête, au flux de la caméra et à certains contrôles des lunettes. Pour BEAST en particulier, VITURE documente le suivi 3DoF natif, le passthrough caméra et les contrôles d’affichage natifs. Il ne transforme pas les lunettes en ordinateur polyvalent et ne crée pas automatiquement une application XR finalisée. Vous développez une application hôte, connectez BEAST en USB et appelez le SDK depuis cette application.
Processus de développement : choisir la plateforme hôte -> télécharger le package SDK correspondant -> compiler le premier exemple de connexion fourni par le fabricant -> lire les données de suivi -> ajouter un contrôle BEAST ou une fonction caméra -> tester l’application avec les lunettes.
Pour situer le 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 caractéristiques matérielles.
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 se contentent de transmettre. 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 contrôles de l’appareil sur les plateformes hôtes prises en charge.
- À utiliser pour développer pour 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 développer pour BEAST ? Pas en tant que 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 développer pour 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.
- Point à retenir pour BEAST : 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.
- Point à retenir pour BEAST : BEAST est documenté pour le 3DoF natif ; l’entrée 6DoF VIO du tableau des appareils concerne la Luma Ultra.
Affichage et contrôles 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.
- Point à retenir pour BEAST : En mode natif, utilisez les constantes d’affichage natives propres à BEAST. Certaines combinaisons de mode et de 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.
- Point à retenir pour BEAST : BEAST est répertorié avec une caméra UVC passthrough. L’accès à la caméra est indépendant du suivi 6DoF.
Ce que 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 ou une scène Unity complète. C’est votre équipe applicative qui développe ces éléments autour des fonctions de l’appareil exposées par le SDK. La page Developer 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 version WebAssembly dotée d’une API TypeScript qui accède aux lunettes via WebHID, uniquement sous Chrome et Chromium, avec prise en charge de BEAST mais pas 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, pour un même SDK des lunettes, des versions et des instructions de configuration propres à chaque plateforme. Cela ne veut pas dire qu’un même binaire fonctionne partout sans modification. Choisissez l’hôte sur lequel votre application doit s’exécuter, 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 Developer 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 avec l’ordinateur ou l’hôte Android que vous prévoyez de prendre en charge.
· Un ordinateur de développement équipé du compilateur et des outils de build adaptés à 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, notamment Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming et Native-DOF Devices.
· Des connaissances de base du langage utilisé par votre équipe applicative : C/C++ pour les exemples de bureau, ainsi que Kotlin ou Java et JNI pour une intégration Android classique.
Comment réaliser un premier test du 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 un contrôle 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 une 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, rendez-vous 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 fiche du SDK, cliquez sur « Download » et choisissez votre hôte si cela vous est demandé.
3. Ouvrez votre guide de configuration. Sur la même fiche, 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
N’utilisez que 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 assurez-vous qu’il se compile avant d’ajouter des fonctionnalités.
Pour Android
1. Créez un projet Android. Dans Android Studio, créez un projet avec prise en charge 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 indiqués dans le 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` décrite dans le 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 ni erreur d’édition de liens.
Étape 4 : connecter BEAST et exécuter le premier exemple
Testez maintenant la connexion aux 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 ordinateur, trouvez l’identifiant produit de BEAST grâce à la détection HID, puis créez le provider avec xr_device_provider_create(product_id). Sous Android, transmettez à la fois l’identifiant 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 gérer 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 ordinateur. Dans le code JNI Android, utilisez g_handle.
4. Ouvrez le flux de suivi. Ajoutez cet appel au fichier `main.cpp` de 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, éteignez et détruisez le provider. 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 le Logcat d’Android Studio pour voir les messages de connexion et les mises à jour du suivi.
Passez à l’étape 5 lorsque : BEAST se connecte et que les mises à jour du suivi arrivent sans erreur.
Étape 5 : ajouter un contrôle BEAST
Une fois le suivi fonctionnel, ajoutez un contrôle 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 un contrôle. 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 également configurer le mode d’affichage de BEAST. Le mode natif utilise le traitement d’affichage intégré des 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 correspondant 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 : n’ajouter l’accès à la caméra que 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 correspondant à 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 fonctionnalité qui en a besoin, par exemple 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 nécessite les autorisations caméra et USB ; sur ordinateur, suivez le guide de la plateforme.
4. Protégez la vie privée. Expliquez l’usage de la caméra, ne capturez que ce dont la fonctionnalité a besoin et, dans l’UE, suivez la procédure RGPD de votre organisation.
Ignorez cette étape si votre application n’a besoin que du suivi ou des contrôles d’affichage.
Étape 7 : tester et préparer un petit projet 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 fonctionnalité, le mode d’affichage, la résolution, le suivi et les autorisations caméra au regard du firmware.
3. Conservez 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 pour le pilote : n’élargissez le déploiement qu’après avoir testé l’hôte, les fonctionnalités, 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 métier, 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 indiqué avec le 3/6DoF et le VIO stéréo. Consultez le tableau du matériel pris en charge pour chaque API que vous comptez utiliser, plutôt que de considérer la mention générale « 3DoF/6DoF » du portail comme la garantie que BEAST prend en charge tous les modes de suivi.
Erreurs fréquentes lors du développement avec le SDK VITURE BEAST
- Télécharger le SDK Unity XR pour une application de contrôle des lunettes BEAST : utilisez la fiche 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.
- Traiter 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 de mode d’affichage standard alors que BEAST est en mode natif : vérifiez le mode actif et utilisez le jeu de fonctions correspondant, standard ou `native_*`.
- Ouvrir la caméra avant d’avoir les autorisations ou sans cas d’usage nécessitant 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 votre plateforme et commencez par créer un petit programme qui se connecte en USB et lit les données de suivi. Ajoutez ensuite un contrôle BEAST ou une fonction caméra pris en charge, puis testez-les sur le matériel réel. Pour les entreprises, cette approche sépare le workflow et les données de l’application des fonctions matérielles des lunettes, permet de développer sur la plateforme hôte adaptée au déploiement et offre 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 ? Consultez la page produit VITURE BEAST ainsi que la documentation développeur de VITURE avant de définir les exigences de votre projet pilote.
