Resumen ejecutivo
Para desarrollar para VITURE BEAST, abre la página Developer de VITURE y elige el VITURE XR Glasses SDK. Es el SDK multiplataforma en C para conectar software con las gafas VITURE. Su documentación incluye Android, Linux, Windows y macOS. El VITURE XR SDK for Unity, un SDK independiente, se describe para experiencias que se ejecutan en el VITURE Neckband, por lo que no es el punto de partida para una aplicación de control de las gafas BEAST.
El SDK de las gafas da a una aplicación acceso a la comunicación con el dispositivo, los datos de seguimiento de la cabeza, la transmisión de la cámara y determinados controles de las gafas. En el caso concreto de BEAST, VITURE documenta seguimiento 3DoF nativo, passthrough de cámara y controles nativos de pantalla. No convierte las gafas en un ordenador de uso general ni crea automáticamente una aplicación XR terminada. Tú desarrollas una aplicación anfitriona, conectas BEAST por USB y llamas al SDK desde esa aplicación.
Flujo de desarrollo: Elige la plataforma anfitriona -> descarga su paquete del SDK -> compila el primer ejemplo de conexión del fabricante -> lee los datos de seguimiento -> añade un control de BEAST o una función de cámara -> prueba la aplicación con las gafas.
Para conocer el contexto del producto antes de planificar la integración del software, consulta la reseña de VITURE BEAST en VRX. La página oficial del producto de VITURE también resulta útil para los detalles del hardware.
INTRODUCCIÓN:
(si ya conoces el SDK y la compatibilidad de plataformas, pasa a la guía principal)
¿Qué es VITURE BEAST?
VITURE BEAST es una pantalla XR USB-C con sensores integrados y una cámara. En el modo nativo, su propio procesamiento se encarga del seguimiento 3DoF y de los efectos de pantalla compatibles; en el modo bypass, el anfitrión envía una señal de vídeo que las gafas dejan pasar. Esta distinción entre modo nativo y bypass es importante cuando el software cambia el modo de pantalla o el comportamiento del seguimiento.
El SDK para desarrolladores es software que se enlaza con tu programa para que este pueda comunicarse con las gafas. Es independiente de las aplicaciones cotidianas de VITURE, como SpaceWalker, que sirve para usar las funciones de pantalla y de pantalla espacial compatibles, no para escribir código.
Los dos SDK de VITURE sirven para tareas distintas
VITURE XR Glasses SDK:
- Para qué sirve: API nativa en C para el acceso al dispositivo de gafas, el seguimiento, la transmisión de la cámara y los controles del dispositivo en las plataformas anfitrionas compatibles.
- ¿Usarlo para desarrollar para BEAST?: Sí. Es el SDK de BEAST que trata esta guía.
VITURE XR SDK for Unity:
- Para qué sirve: Paquete XR para Unity documentado para crear experiencias inmersivas en el VITURE Neckband, con integraciones de Unity como el seguimiento de manos.
- ¿Usarlo para desarrollar para BEAST?: No como SDK predeterminado para las gafas BEAST. No lo confundas con el SDK nativo de las gafas.
SpaceWalker:
- Para qué sirve: Software complementario de VITURE para los modos de pantalla compatibles y las funciones de pantalla espacial.
- ¿Usarlo para desarrollar para BEAST?: No. Es una aplicación para el usuario final, no un entorno de desarrollo.
Qué controla el XR Glasses SDK
Conexión del dispositivo:
- Qué puede hacer la aplicación: Detectar un dispositivo conectado, crear un handle del dispositivo, inicializarlo, iniciarlo y cerrarlo de forma limpia.
- Detalle de BEAST que conviene recordar: El SDK se comunica con las gafas a través de la conexión del anfitrión.
Seguimiento de la cabeza:
- Qué puede hacer la aplicación: Leer datos de orientación/IMU y usar la interfaz de seguimiento específica del modelo.
- Detalle de BEAST que conviene recordar: BEAST está documentado para 3DoF nativo; la entrada 6DoF VIO de la tabla de dispositivos corresponde a Luma Ultra.
Controles de pantalla y de las gafas:
- Qué puede hacer la aplicación: Leer o ajustar las opciones compatibles de brillo, volumen, modo de pantalla, modo 2D/3D, tintado y modo nativo.
- Detalle de BEAST que conviene recordar: En modo nativo, usa las constantes de pantalla nativas específicas de BEAST. Algunas combinaciones de modo y frecuencia no son compatibles.
Transmisión de la cámara:
- Qué puede hacer la aplicación: Acceder a los fotogramas compatibles de la cámara passthrough mediante la API de cámara del SDK.
- Detalle de BEAST que conviene recordar: BEAST figura con una cámara UVC passthrough. El acceso a la cámara es independiente del seguimiento 6DoF.
Lo que el SDK no proporciona por sí solo: el flujo de trabajo de tu aplicación, la lógica de negocio, los menús, el almacenamiento de datos, las cuentas de usuario ni una escena de Unity completa. Tu equipo de desarrollo construye esas partes en torno a las funciones del dispositivo que expone el SDK. La página principal para desarrolladores destaca estas cuatro plataformas. Desde el SDK 2.4.0 (6 de agosto de 2026), la documentación incluye un quinto destino: Browser, una compilación WebAssembly con una API en TypeScript que se comunica con las gafas mediante WebHID, solo en Chrome y Chromium, con BEAST compatible y Luma Ultra excluido. Consulta el paquete actual y las notas de la versión antes de elegir un dispositivo o un sistema operativo para producción.
Compatibilidad multiplataforma: Android, Linux, Windows y macOS
«Multiplataforma» significa que VITURE ofrece compilaciones del SDK específicas para cada plataforma e instrucciones de configuración para el mismo SDK de las gafas. No significa que un mismo binario funcione sin cambios en todas partes. Elige el anfitrión en el que debe ejecutarse tu aplicación y usa después la biblioteca y la guía de integración correspondientes. La documentación actual de la API recoge estas arquitecturas:
Windows:
- Arquitectura documentada: x86_64
- Configuración habitual: Aplicación de escritorio en C/C++ con la biblioteca y los encabezados del SDK para Windows; sigue Quick Start: Desktop (C++).
Linux:
- Arquitectura documentada: x86_64 y aarch64
- Configuración habitual: Aplicación de escritorio en C/C++. Añade la regla udev de VITURE para que la aplicación pueda acceder a la interfaz USB/HID sin ejecutarse como root.
macOS:
- Arquitectura documentada: aarch64 (Apple silicon)
- Configuración habitual: Aplicación de escritorio en C/C++ con la biblioteca y los encabezados para macOS; sigue Quick Start: Desktop (C++).
Android:
- Arquitectura documentada: armeabi-v7a y arm64-v8a
- Configuración habitual: Aplicación Android que usa la biblioteca nativa en C mediante JNI; gestiona el permiso USB y la conexión en la propia aplicación Android.
La página principal para desarrolladores destaca estas cuatro plataformas. La página detallada de la API puede añadir destinos o cambiar las arquitecturas compatibles con el tiempo, así que consulta el paquete actual y las notas de la versión antes de elegir un dispositivo o un sistema operativo para producción.
Qué necesitas antes de empezar a desarrollar
· Gafas VITURE BEAST y una conexión de datos USB-C con el ordenador o el anfitrión Android que vayas a admitir.
· Un ordenador de desarrollo con el compilador y las herramientas de compilación para tu destino: una cadena de herramientas C/C++ y CMake para escritorio, o Android Studio con sus componentes NDK y CMake para Android.
· El paquete del VITURE XR Glasses SDK para la plataforma de destino, descargado desde la página Developer de VITURE.
· La documentación del SDK correspondiente, en especial Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming y Native-DOF Devices.
· Conocimientos básicos del lenguaje que usa tu equipo de desarrollo: C/C++ para los ejemplos de escritorio, además de Kotlin o Java y JNI para una integración típica en Android.
Cómo crear una primera prueba con el SDK de VITURE BEAST
Empieza con una pequeña aplicación anfitriona que encuentre BEAST y lea los datos de seguimiento. Cuando funcione, añade un control o una función de cámara.
Paso 1: Elige dónde se ejecutará tu aplicación
Elige el ordenador o el teléfono que ejecutará tu aplicación; de ello dependen el paquete del SDK y la guía de configuración.
1. Elige el anfitrión. Usa Windows, Linux o macOS para un ordenador, o Android para un teléfono conectado a BEAST.
2. Anota su sistema operativo y su procesador. Por ejemplo, anota Windows x86_64 o macOS Apple silicon y consulta después la tabla de plataformas anterior.
3. Sigue la rama de Android solo si se trata de una aplicación Android. Utiliza una biblioteca nativa, un puente JNI y el permiso USB.
Paso 2: Descarga el VITURE XR Glasses SDK
Descarga el SDK oficial de las gafas y abre la guía de tu anfitrión. El paquete de Unity para Neckband corresponde a otra configuración.
1. Abre la página Developer. En un navegador, ve a https://www.viture.com/developer y desplázate hasta «VITURE XR Glasses SDK».
2. Descarga el paquete de tu plataforma. En la tarjeta del SDK, haz clic en «Download» y elige tu anfitrión si se te pide.
3. Abre tu guía de configuración. En la misma tarjeta, haz clic en «Documents», luego en «Core Concepts» y después en «Quick Start: Desktop (C++)» o «Android Integration Guide».
4. Comprueba la compatibilidad. Vuelve a la página Developer, abre «Release Notes» y comprueba tu sistema operativo, tu procesador y el firmware de BEAST.
Pasa al paso 3 cuando: tengas la biblioteca, los encabezados y la guía de configuración correspondientes.
Paso 3: Configura el SDK en tu plataforma anfitriona
Usa solo la rama de configuración del anfitrión que elegiste en el paso 1.
Para Windows, Linux o macOS
1. Abre la guía de escritorio. En SDK Documents, elige «Quick Start: Desktop (C++)» y tenla a mano junto a tu editor de código.
2. Enlaza el SDK. Abre el ejemplo o tu proyecto y usa el ejemplo de CMake de la guía para añadir los encabezados del SDK y la biblioteca de las gafas.
En el `CMakeLists.txt` de tu proyecto, añade las rutas de inclusión y de bibliotecas del SDK. Sustituye `VITURE_SDK_ROOT` por la carpeta en la que descomprimiste el 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: permite el acceso USB. En Terminal, sigue «Linux udev Rule» y crea `/etc/udev/rules.d/70-viture.rules`; recarga las reglas y vuelve a conectar BEAST. Omite este paso en Windows y macOS.
4. Compila el ejemplo. Abre el `main.cpp` del ejemplo del SDK y asegúrate de que compila antes de añadir funciones.
Para Android
1. Crea un proyecto Android. En Android Studio, inicia un proyecto compatible con CMake/NDK y abre `app/src/main` en el panel del proyecto.
2. Copia los archivos del SDK. Sigue «Android Integration Guide»: coloca los encabezados en `app/src/main/include/` y el archivo `.so` correspondiente en `app/src/main/jniLibs/<ABI>/`.
3. Enlaza la biblioteca. En Android Studio, abre `app/src/main/cpp/CMakeLists.txt` y `app/build.gradle.kts`; aplica los ajustes de CMake, NDK y ABI de la guía.
En `CMakeLists.txt`, importa la biblioteca del SDK y enlázala con tu puente JNI. Este ejemplo supone que los archivos del SDK están en las carpetas indicadas en la 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. Añade el puente entre la aplicación y C++. En la carpeta de código fuente de la aplicación, crea la clase `GlassesBridge` de la guía; sus funciones `external` llaman a tu código JNI.
5. Solicita el permiso USB. Usa `UsbManager` de Android para encontrar BEAST; cuando el usuario pulse Permitir, abre la conexión USB y pasa su descriptor de archivo al puente.
Cuando el usuario pulse Permitir, abre la conexión USB en tu actividad de Kotlin y pasa su descriptor de archivo al puente nativo. Sustituye `GlassesBridge` por el nombre de la clase puente de tu proyecto:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
En `glasses_bridge.cpp`, la función nativa create pasa ese descriptor de archivo de Android al 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; }
Pasa al paso 4 cuando: tu aplicación compile y cargue el SDK sin errores de archivos que faltan ni del enlazador.
Paso 4: Conecta BEAST y ejecuta el primer ejemplo
Ahora prueba la conexión de las gafas. Usa el ejemplo de escritorio en Windows, Linux o macOS. En Android, mantén la configuración USB y JNI del paso 3; no uses el código de detección HID de escritorio.
1. Conecta BEAST. Usa un cable de datos USB-C; en Android, acepta el aviso USB del teléfono.
2. Encuentra BEAST y crea su handle. En escritorio, encuentra el ID de producto de BEAST mediante la detección HID y crea después el proveedor con xr_device_provider_create(product_id). En Android, pasa tanto el ID de producto como el descriptor de archivo de la conexión USB.
3. Inicia el seguimiento. Inicia el seguimiento registrando un callback. Un callback es una función a la que llama el SDK cuando llegan datos de seguimiento. BEAST entrega el alabeo, el cabeceo y la guiñada (roll, pitch y yaw) en data[0] a data[2] y el cuaternión en data[3] a data[6], pero solo con el SDK 2.4.0 o posterior y un firmware de las gafas actualizado. Con firmware antiguo, el callback de pose nunca se activa en BEAST (VITURE lo recoge en el apartado «Known Limitations on Beast» de sus notas de la versión): en ese caso, registra xr_device_provider_register_imu_raw_callback e integra tú mismo los datos brutos de la IMU, o cambia las gafas al modo nativo y deja que ellas se encarguen del seguimiento.
Añade esta función encima 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]
);
}
Registra el callback antes de inicializar e iniciar el 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;
Usa handle en escritorio. En el código JNI de Android, usa g_handle.
4. Abre el flujo de seguimiento. Añade esta llamada al `main.cpp` de escritorio; en Android, exponla mediante JNI y llámala después de `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Cuando la aplicación se cierre, cierra la IMU y después detén, apaga y destruye el proveedor. En Android, llama a las mismas funciones de limpieza antes de cerrar la conexión 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. Comprueba la salida. Ejecuta la aplicación y busca en la consola de escritorio o en Logcat de Android Studio las actualizaciones de conexión y de seguimiento.
Pasa al paso 5 cuando: BEAST se conecte y lleguen actualizaciones de seguimiento sin errores.
Paso 5: Añade un control de BEAST
Cuando el seguimiento funcione, añade un control de las gafas en el código de control del dispositivo de tu aplicación, después de que se inicie el handle del SDK.
1. Elige un control. En SDK Documents, abre «Device Control» y comprueba las opciones de brillo, volumen o pantalla compatibles con BEAST.
2. Lee y ajusta su valor. Añade las llamadas en C/C++ a tu código de control; en Android, colócalas en `glasses_bridge.cpp` y exponlas mediante JNI.
Después de iniciar el proveedor, lee el brillo de BEAST y prueba un valor compatible. El rango documentado es de 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. Adapta la API de pantalla al modo. También puedes configurar el modo de pantalla de BEAST. El modo nativo usa el procesamiento de pantalla integrado de las gafas y admite 3DoF nativo. El modo bypass hace pasar la señal de vídeo del anfitrión a través de las gafas. Elige la rama que corresponda al modo seleccionado en tu aplicación. No ejecutes ambas ramas una tras otra.
En este ejemplo, use_native_mode es un ajuste booleano de tu aplicación y rc es la variable de resultado existente.
</> 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;
}
Elige una resolución y una frecuencia de actualización compatibles con BEAST.
4. Prueba un único cambio. Ejecuta la aplicación, comprueba el resultado en BEAST y restaura después el ajuste original.
Importante: BEAST admite 3DoF nativo, pero el firmware actual solo acepta tres modos de pantalla: 1920 x 1200 a 60 Hz y 3D side-by-side 3840 x 1200 a 60 Hz en modo nativo, y 3840 x 1200 a 90 Hz en modo bypass (notas de la versión del VITURE XR Glasses SDK, 2.3.0 y 2.3.1). Otras constantes superan la comprobación del SDK, pero las gafas las rechazan o las ignoran, así que vuelve a leer el modo después de ajustarlo y toma las notas de la versión como la lista de valores compatibles.
Paso 6: Añade acceso a la cámara solo si la aplicación lo necesita
Añade la cámara passthrough solo si tu aplicación necesita fotogramas de imagen. La transmisión de la cámara es independiente del seguimiento de la cabeza y no proporciona 6DoF.
1. Abre la guía de la cámara. En SDK Documents, elige «Camera Streaming» y sigue la sección de configuración de tu anfitrión.
2. Añade un gestor de fotogramas. En tu aplicación, crea una función que reciba los fotogramas de la cámara y los envíe a la funcionalidad que los necesite, como una vista previa.
En tu módulo de cámara en C++, crea el proveedor de cámara de BEAST e inícialo con tu callback de fotogramas, `on_frame`. Esta llamada con dos argumentos es para escritorio:
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 terminar xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
En Android, pasa el descriptor de archivo USB de la cámara como tercer argumento, usando la configuración de permisos del paso 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Obtén primero los permisos. Android necesita permisos de cámara y USB; en escritorio, sigue la guía de la plataforma.
4. Protege la privacidad. Explica el uso de la cámara, captura solo lo que necesite la funcionalidad y sigue el proceso de RGPD de tu organización en la UE.
Omite este paso si tu aplicación solo necesita seguimiento o controles de pantalla.
Paso 7: Prueba y prepara un piloto pequeño
1. Prueba la reconexión. Reinicia la aplicación, desconecta y vuelve a conectar BEAST, y comprueba que la aplicación se mantiene estable.
2. Prueba en BEAST. Comprueba con el firmware el modo de pantalla, la resolución, el seguimiento y los permisos de cámara de cada funcionalidad.
3. Guarda los detalles de las pruebas. Anota las versiones del SDK, el sistema operativo, el procesador, el compilador/NDK y el firmware, así como los detalles de conexión y los errores.
4. Planifica el despliegue. Decide cómo instalar y actualizar la aplicación anfitriona, gestionar el acceso a la cámara y los datos, y ofrecer soporte.
Criterio para el piloto: amplía solo después de haber probado el anfitrión, las funcionalidades, los permisos y el proceso de actualización.
Lo que el SDK no hace
El VITURE XR Glasses SDK es un kit de herramientas de integración de dispositivos, no un entorno de creación XR terminado. Expone funciones a las que tu software puede llamar. Tu equipo sigue teniendo que elegir un framework de aplicación, escribir la interfaz de usuario y la lógica de las tareas, compilar la aplicación para la plataforma anfitriona y decidir cómo la empresa la desplegará y le dará soporte.
Tampoco hace que todas las capacidades estén disponibles en todos los modelos de VITURE. En la tabla de hardware actual, BEAST figura con 3DoF nativo y acceso a la cámara passthrough, mientras que Luma Ultra es el modelo que figura con 3/6DoF y VIO estéreo. Consulta la tabla de hardware compatible para cada API que vayas a usar, en lugar de interpretar la descripción general «3DoF/6DoF» del portal como una garantía de que BEAST admite todos los modos de seguimiento.
Errores habituales al desarrollar con el SDK de VITURE BEAST
- Descargar el Unity XR SDK para una aplicación de control de las gafas BEAST.: Usa la tarjeta del VITURE XR Glasses SDK; la guía de Unity está documentada para el VITURE Neckband.
- Suponer que multiplataforma significa el mismo binario o la misma configuración en todas partes.: Descarga la biblioteca correcta y sigue la guía de arquitectura y conexión de la plataforma de destino.
- Tratar BEAST como un dispositivo 6DoF VIO porque el portal menciona 6DoF.: Comprueba la compatibilidad de cada modelo: la tabla actual del SDK indica 3DoF nativo para BEAST y 6DoF VIO para Luma Ultra.
- Llamar a las funciones estándar de modo de pantalla mientras BEAST está en modo nativo.: Comprueba el modo activo y usa el conjunto de funciones correspondiente: el estándar o `native_*`.
- Abrir la cámara antes de tener los permisos o sin un caso de uso que la requiera.: Solicita primero los permisos de la plataforma y añade la transmisión de la cámara solo cuando la aplicación necesite datos de imagen.
- Usar SpaceWalker como editor de código o como aplicación de configuración del SDK.: Usa la página Developer, el paquete del SDK, la documentación y un editor de código o Android Studio.
Conclusión
El desarrollo para VITURE BEAST empieza con el VITURE XR Glasses SDK, no con el paquete de Unity para experiencias en Neckband ni con la aplicación de consumo SpaceWalker. Elige Android, Linux, Windows o macOS como anfitrión, descarga el SDK correspondiente desde la página Developer de VITURE, sigue su guía de plataforma y crea primero un pequeño programa que se conecte por USB y lea los datos de seguimiento. A partir de ahí, añade un control de BEAST o una función de cámara compatibles y pruébalos en el hardware real. Para las empresas, este enfoque separa el flujo de trabajo y los datos de la aplicación de las funciones del dispositivo de las gafas, permite desarrollar en la plataforma anfitriona que mejor se adapte al despliegue y ofrece a los equipos una forma de validar un caso de uso industrial concreto antes de invertir en un despliegue más amplio.
¿Estás creando un flujo de trabajo XR para VITURE BEAST? Consulta la página del producto VITURE BEAST y la documentación para desarrolladores de VITURE antes de definir los requisitos de tu piloto.
