Resumo executivo
Para desenvolver para o VITURE BEAST, abra a página Developer da VITURE e escolha o VITURE XR Glasses SDK. Trata-se do SDK multiplataforma em C para ligar software aos óculos VITURE. A sua documentação indica Android, Linux, Windows e macOS. O VITURE XR SDK for Unity, que é um SDK à parte, é descrito para experiências executadas no VITURE Neckband, pelo que não é o ponto de partida para uma aplicação de controlo dos óculos BEAST.
O SDK dos óculos dá a uma aplicação acesso à comunicação com o dispositivo, aos dados de rastreio da cabeça, à transmissão da câmara e a determinados controlos dos óculos. Especificamente para o BEAST, a VITURE documenta rastreio 3DoF nativo, passthrough da câmara e controlos nativos do ecrã. O SDK não transforma os óculos num computador de uso geral nem cria automaticamente uma aplicação XR acabada. Cria-se uma aplicação anfitriã, liga-se o BEAST por USB e chama-se o SDK a partir dessa aplicação.
Fluxo de desenvolvimento: Escolher a plataforma anfitriã -> transferir o respetivo pacote SDK -> compilar o primeiro exemplo de ligação do fabricante -> ler os dados de rastreio -> adicionar um controlo ou uma funcionalidade de câmara do BEAST -> testar a aplicação com os óculos.
Para obter contexto sobre o produto antes de planear a integração de software, consulte a análise do VITURE BEAST na VRX. A página oficial do produto da VITURE também é útil para detalhes de hardware.
INTRODUÇÃO:
(se já conhece o SDK e o suporte de plataformas, avance para as orientações principais)
O que é o VITURE BEAST?
O VITURE BEAST é um ecrã XR USB-C com sensores e câmara integrados. No modo nativo, o seu próprio processamento trata do rastreio 3DoF e dos efeitos de ecrã suportados; no modo bypass, o anfitrião envia um sinal de vídeo que os óculos deixam passar. Esta distinção entre modo nativo e modo bypass é importante quando o software altera o modo de ecrã ou o comportamento do rastreio.
O SDK para programadores é o software ao qual o seu programa se liga para poder comunicar com os óculos. É distinto das aplicações VITURE de uso diário, como o SpaceWalker, que serve para utilizar as funcionalidades de ecrã e de ecrã espacial suportadas, e não para escrever código.
Os dois SDK da VITURE servem para tarefas diferentes
VITURE XR Glasses SDK:
- Para que serve: API C nativa para acesso ao dispositivo dos óculos, rastreio, transmissão da câmara e controlos do dispositivo nas plataformas anfitriãs suportadas.
- Usar para desenvolver para o BEAST?: Sim. É este o SDK do BEAST abordado neste guia.
VITURE XR SDK for Unity:
- Para que serve: Pacote Unity XR documentado para criar experiências imersivas no VITURE Neckband, com integrações Unity como o rastreio das mãos.
- Usar para desenvolver para o BEAST?: Não como SDK predefinido dos óculos BEAST. Não o confunda com o SDK nativo dos óculos.
SpaceWalker:
- Para que serve: Software complementar da VITURE para os modos de ecrã suportados e as funcionalidades de ecrã espacial.
- Usar para desenvolver para o BEAST?: Não. É uma aplicação para utilizadores finais, não um ambiente de desenvolvimento.
O que o XR Glasses SDK controla
Ligação ao dispositivo:
- O que a aplicação pode fazer: Detetar um dispositivo ligado, criar um handle do dispositivo, inicializá-lo, iniciá-lo e fechá-lo de forma limpa.
- Pormenor do BEAST a ter em conta: O SDK comunica com os óculos através da ligação ao anfitrião.
Rastreio da cabeça:
- O que a aplicação pode fazer: Ler dados de orientação/IMU e utilizar a interface de rastreio específica do modelo.
- Pormenor do BEAST a ter em conta: O BEAST está documentado para 3DoF nativo; a entrada 6DoF VIO na tabela de dispositivos refere-se ao Luma Ultra.
Controlos de ecrã e dos óculos:
- O que a aplicação pode fazer: Ler ou definir as opções suportadas de brilho, volume, modo de ecrã, modo 2D/3D, tonalidade e modo nativo.
- Pormenor do BEAST a ter em conta: Utilize as constantes de ecrã nativas específicas do BEAST no modo nativo. Algumas combinações de modo/taxa não são suportadas.
Transmissão da câmara:
- O que a aplicação pode fazer: Aceder às imagens suportadas da câmara de passthrough através da API de câmara do SDK.
- Pormenor do BEAST a ter em conta: O BEAST está listado com uma câmara UVC de passthrough. O acesso à câmara é independente do rastreio 6DoF.
O SDK não fornece, por si só: o fluxo de trabalho da sua aplicação, a lógica de negócio, os menus, o armazenamento de dados, as contas de utilizador nem uma cena Unity completa. A equipa da aplicação constrói essas partes em torno das funções do dispositivo que o SDK disponibiliza. A página principal para programadores destaca estas quatro plataformas. Desde o SDK 2.4.0 (6 de agosto de 2026), a documentação indica um quinto destino: Browser, uma compilação WebAssembly com uma API TypeScript que comunica com os óculos através de WebHID, apenas no Chrome e no Chromium, com suporte para o BEAST e exclusão do Luma Ultra. Verifique o pacote atual e as notas de versão antes de selecionar um dispositivo ou sistema operativo para produção.
Suporte multiplataforma: Android, Linux, Windows e macOS
«Multiplataforma» significa que a VITURE fornece compilações do SDK e instruções de configuração específicas de cada plataforma para o mesmo SDK dos óculos. Não significa que um único binário funcione sem alterações em todo o lado. Escolha o anfitrião onde a sua aplicação tem de ser executada e utilize a biblioteca e o guia de integração correspondentes. A documentação atual da API indica estas arquiteturas:
Windows:
- Arquitetura documentada: x86_64
- Via de configuração habitual: Aplicação de desktop em C/C++ que utiliza a biblioteca e os ficheiros de cabeçalho do SDK para Windows; siga o Quick Start: Desktop (C++).
Linux:
- Arquitetura documentada: x86_64 e aarch64
- Via de configuração habitual: Aplicação de desktop em C/C++. Adicione a regra udev da VITURE para que a aplicação possa aceder à interface USB/HID sem ser executada como root.
macOS:
- Arquitetura documentada: aarch64 (Apple silicon)
- Via de configuração habitual: Aplicação de desktop em C/C++ que utiliza a biblioteca e os ficheiros de cabeçalho para macOS; siga o Quick Start: Desktop (C++).
Android:
- Arquitetura documentada: armeabi-v7a e arm64-v8a
- Via de configuração habitual: Aplicação Android que utiliza a biblioteca C nativa através de JNI; trate da permissão e da ligação USB na aplicação Android.
A página principal para programadores destaca estas quatro plataformas. A página detalhada da API pode acrescentar destinos ou alterar as arquiteturas suportadas ao longo do tempo, por isso verifique o pacote atual e as notas de versão antes de selecionar um dispositivo ou sistema operativo para produção.
O que precisa antes de começar a desenvolver
· Óculos VITURE BEAST e uma ligação de dados USB-C ao computador ou anfitrião Android que pretende suportar.
· Um computador de desenvolvimento com o compilador/as ferramentas de compilação para o seu destino: uma toolchain C/C++ e CMake para desktop, ou o Android Studio com os componentes NDK e CMake para Android.
· O pacote VITURE XR Glasses SDK para a plataforma de destino, transferido a partir da página Developer da VITURE.
· A documentação correspondente do SDK, em especial Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming e Native-DOF Devices.
· Conhecimentos básicos da linguagem utilizada pela equipa da aplicação: C/C++ para os exemplos de desktop e, para uma integração Android típica, também Kotlin ou Java e JNI.
Como criar um primeiro teste com o SDK do VITURE BEAST
Comece com uma pequena aplicação anfitriã que encontre o BEAST e leia os dados de rastreio. Quando isso funcionar, adicione um controlo ou uma funcionalidade de câmara.
Passo 1: Escolher onde a aplicação vai ser executada
Escolha o computador ou telemóvel que vai executar a aplicação; é isso que determina o pacote SDK e o guia de configuração.
1. Escolha o anfitrião. Use Windows, Linux ou macOS num computador, ou Android num telemóvel ligado ao BEAST.
2. Anote o sistema operativo e o processador. Por exemplo, registe Windows x86_64 ou macOS Apple silicon e consulte a tabela de plataformas acima.
3. Siga o ramo Android apenas para uma aplicação Android. Este utiliza uma biblioteca nativa, uma ponte JNI e permissão USB.
Passo 2: Transferir o VITURE XR Glasses SDK
Transfira o SDK oficial dos óculos e abra o guia para o seu anfitrião. O pacote Unity para o Neckband destina-se a uma configuração diferente.
1. Abra a página Developer. Num browser, aceda a https://www.viture.com/developer e desloque-se até «VITURE XR Glasses SDK».
2. Transfira o pacote da sua plataforma. No cartão do SDK, clique em «Download» e escolha o seu anfitrião, se lhe for pedido.
3. Abra o guia de configuração. No mesmo cartão, clique em «Documents», depois em «Core Concepts» e, em seguida, em «Quick Start: Desktop (C++)» ou «Android Integration Guide».
4. Verifique a compatibilidade. Volte à página Developer, abra «Release Notes» e verifique o seu sistema operativo, o processador e o firmware do BEAST.
Avance para o Passo 3 quando: tiver a biblioteca, os ficheiros de cabeçalho e o guia de configuração correspondentes.
Passo 3: Configurar o SDK na plataforma anfitriã
Utilize apenas o ramo de configuração do anfitrião que escolheu no Passo 1.
Para Windows, Linux ou macOS
1. Abra o guia para desktop. Em SDK Documents, escolha «Quick Start: Desktop (C++)» e mantenha-o ao lado do editor de código.
2. Ligue o SDK ao projeto. Abra o exemplo ou o seu projeto e utilize o exemplo de CMake do guia para adicionar os ficheiros de cabeçalho do SDK e a biblioteca dos óculos.
No `CMakeLists.txt` do seu projeto, adicione os caminhos de include e de biblioteca do SDK. Substitua `VITURE_SDK_ROOT` pela pasta onde descompactou o 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. Apenas Linux: permita o acesso USB. No Terminal, siga «Linux udev Rule» e crie `/etc/udev/rules.d/70-viture.rules`; recarregue as regras e volte a ligar o BEAST. Ignore este passo no Windows e no macOS.
4. Compile o exemplo. Abra o `main.cpp` do exemplo do SDK e confirme que compila antes de adicionar funcionalidades.
Para Android
1. Crie um projeto Android. No Android Studio, inicie um projeto com suporte para CMake/NDK e abra `app/src/main` no painel do projeto.
2. Copie os ficheiros do SDK. Siga o «Android Integration Guide»: coloque os ficheiros de cabeçalho em `app/src/main/include/` e o ficheiro `.so` correspondente em `app/src/main/jniLibs/<ABI>/`.
3. Ligue a biblioteca. No Android Studio, abra `app/src/main/cpp/CMakeLists.txt` e `app/build.gradle.kts`; aplique as definições de CMake, NDK e ABI do guia.
No `CMakeLists.txt`, importe a biblioteca do SDK e ligue-a à sua ponte JNI. Este exemplo pressupõe que os ficheiros do SDK estão nas pastas indicadas no 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. Adicione a ponte entre a aplicação e o C++. Na pasta de código-fonte da aplicação, crie a classe `GlassesBridge` do guia; as suas funções `external` chamam o seu código JNI.
5. Peça a permissão USB. Utilize o `UsbManager` do Android para encontrar o BEAST; depois de o utilizador tocar em Permitir, abra a ligação USB e passe o respetivo descritor de ficheiro à ponte.
Depois de o utilizador tocar em Permitir, abra a ligação USB na sua atividade Kotlin e passe o respetivo descritor de ficheiro à ponte nativa. Substitua `GlassesBridge` pelo nome da classe de ponte do seu projeto:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
Em `glasses_bridge.cpp`, a função nativa de criação passa esse descritor de ficheiro Android ao SDK da 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; }
Avance para o Passo 4 quando: a aplicação compilar e carregar o SDK sem erros de ficheiro em falta ou de linker.
Passo 4: Ligar o BEAST e executar o primeiro exemplo
Agora teste a ligação aos óculos. Utilize o exemplo para desktop no Windows, Linux ou macOS. No Android, mantenha a configuração USB e JNI do Passo 3; não utilize código de deteção HID para desktop.
1. Ligue o BEAST. Use um cabo de dados USB-C; no Android, aceite o pedido USB do telemóvel.
2. Encontre o BEAST e crie o respetivo handle. No desktop, encontre o ID de produto do BEAST através da deteção HID e, em seguida, crie o provider com xr_device_provider_create(product_id). No Android, passe tanto o ID de produto como o descritor de ficheiro da ligação USB.
3. Inicie o rastreio. Inicie o rastreio registando um callback. Um callback é uma função que o SDK chama quando chegam dados de rastreio. O BEAST fornece roll, pitch e yaw em data[0] a data[2] e o quaternião em data[3] a data[6], mas apenas com o SDK 2.4.0 ou posterior e com o firmware dos óculos atualizado. Com firmware mais antigo, o callback de pose nunca é acionado no BEAST (a VITURE indica isto em «Known Limitations on Beast» nas suas notas de versão): nesse caso, registe xr_device_provider_register_imu_raw_callback e integre os dados brutos da IMU por conta própria, ou mude os óculos para o modo nativo e deixe que sejam eles a fazer o rastreio.
Adicione esta função acima 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]
);
}
Registe o callback antes de inicializar e iniciar o 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;
Use handle no desktop. No código JNI do Android, use g_handle.
4. Abra o fluxo de rastreio. Adicione esta chamada ao `main.cpp` para desktop; no Android, exponha-a através de JNI e chame-a depois de `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Quando a aplicação terminar, feche a IMU e, em seguida, pare, encerre e destrua o provider. No Android, chame as mesmas funções de limpeza antes de fechar a ligação 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. Verifique o resultado. Execute a aplicação e procure, na consola do desktop ou no Logcat do Android Studio, atualizações de ligação e de rastreio.
Avance para o Passo 5 quando: o BEAST se ligar e as atualizações de rastreio chegarem sem erros.
Passo 5: Adicionar um controlo do BEAST
Depois de o rastreio funcionar, adicione um controlo dos óculos no código de controlo do dispositivo da sua aplicação, após o handle do SDK ter sido iniciado.
1. Escolha um controlo. Em SDK Documents, abra «Device Control» e verifique as opções de brilho, volume ou ecrã suportadas pelo BEAST.
2. Leia e defina o respetivo valor. Adicione as chamadas C/C++ ao seu código de controlo; no Android, coloque-as em `glasses_bridge.cpp` e exponha-as através de JNI.
Depois de iniciar o provider, leia o brilho do BEAST e experimente um valor suportado. O intervalo documentado é 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. Faça corresponder a API de ecrã ao modo. Também pode configurar o modo de ecrã do BEAST. O modo nativo utiliza o processamento de ecrã integrado dos óculos e suporta 3DoF nativo. O modo bypass faz passar o sinal de vídeo do anfitrião pelos óculos. Escolha o ramo que corresponde ao modo selecionado na sua aplicação. Não execute os dois ramos um a seguir ao outro.
Neste exemplo, use_native_mode é uma definição booleana da sua aplicação e rc é a variável de resultado já 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;
}
Escolha uma resolução e uma taxa de atualização suportadas pelo BEAST.
4. Teste uma alteração. Execute a aplicação, verifique o resultado no BEAST e, depois, reponha a definição original.
Importante: O BEAST suporta 3DoF nativo, mas o firmware atual aceita apenas três modos de ecrã: 1920 x 1200 a 60 Hz e 3D lado a lado 3840 x 1200 a 60 Hz no modo nativo, e 3840 x 1200 a 90 Hz no modo bypass (notas de versão do VITURE XR Glasses SDK, 2.3.0 e 2.3.1). Outras constantes passam a verificação do SDK, mas os óculos rejeitam-nas ou ignoram-nas, por isso volte a ler o modo depois de o definir e trate as notas de versão como a lista de valores suportados.
Passo 6: Adicionar acesso à câmara apenas se a aplicação precisar
Adicione a câmara de passthrough apenas se a sua aplicação precisar de imagens. A transmissão da câmara é independente do rastreio da cabeça e não fornece 6DoF.
1. Abra o guia da câmara. Em SDK Documents, escolha «Camera Streaming» e siga a secção de configuração do seu anfitrião.
2. Adicione um handler de frames. Na sua aplicação, crie uma função que receba os frames da câmara e os envie para a funcionalidade que deles precisa, como uma pré-visualização.
No seu módulo de câmara em C++, crie o provider de câmara do BEAST e inicie-o com o seu callback de frames, `on_frame`. Esta chamada com dois argumentos destina-se a 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);
// Quando terminar xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
No Android, passe o descritor de ficheiro USB da câmara como terceiro argumento, utilizando a configuração de permissões do Passo 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Obtenha primeiro as permissões. O Android precisa de permissões de câmara e USB; no desktop, siga o guia da plataforma.
4. Proteja a privacidade. Explique a utilização da câmara, capture apenas o que a funcionalidade precisa e, na UE, siga o processo de RGPD da sua organização.
Ignore este passo se a sua aplicação precisar apenas de rastreio ou de controlos de ecrã.
Passo 7: Testar e preparar um pequeno piloto
1. Teste a religação. Reinicie a aplicação, desligue e volte a ligar o BEAST e verifique se a aplicação se mantém estável.
2. Teste no BEAST. Verifique o modo de ecrã, a resolução, o rastreio e as permissões de câmara de cada funcionalidade face ao firmware.
3. Guarde os detalhes dos testes. Registe as versões do SDK, do sistema operativo, do processador, do compilador/NDK e do firmware, bem como os detalhes da ligação e os erros.
4. Planeie a implementação. Decida como instalar e atualizar a aplicação anfitriã, gerir o acesso à câmara e os dados, e prestar suporte.
Critério do piloto: alargue apenas depois de ter testado o anfitrião, as funcionalidades, as permissões e o processo de atualização.
O que o SDK não faz
O VITURE XR Glasses SDK é um conjunto de ferramentas de integração de dispositivos, não um ambiente de criação XR acabado. Disponibiliza funções que o seu software pode chamar. A sua equipa continua a ter de escolher uma framework de aplicação, escrever a interface de utilizador e a lógica das tarefas, compilar a aplicação para a plataforma anfitriã e decidir como a empresa a vai implementar e suportar.
Também não disponibiliza todas as capacidades em todos os modelos VITURE. Na tabela de hardware atual, o BEAST está listado com 3DoF nativo e acesso à câmara de passthrough, enquanto o Luma Ultra é o modelo listado com 3/6DoF e VIO estéreo. Consulte a tabela de hardware suportado para cada API que planeia utilizar, em vez de interpretar a descrição geral «3DoF/6DoF» do portal como uma garantia de que o BEAST suporta todos os modos de rastreio.
Erros comuns no desenvolvimento com o SDK do VITURE BEAST
- Transferir o Unity XR SDK para uma aplicação de controlo dos óculos BEAST.: Utilize o cartão do VITURE XR Glasses SDK; o guia Unity está documentado para o VITURE Neckband.
- Pressupor que multiplataforma significa o mesmo binário ou a mesma configuração em todo o lado.: Transfira a biblioteca correta e siga o guia de arquitetura e ligação da plataforma de destino.
- Tratar o BEAST como um dispositivo 6DoF VIO porque o portal menciona 6DoF.: Verifique o suporte ao nível do modelo: a tabela atual do SDK indica 3DoF nativo para o BEAST e 6DoF VIO para o Luma Ultra.
- Chamar funções de modo de ecrã padrão enquanto o BEAST está no modo nativo.: Verifique o modo ativo e utilize o conjunto de funções correspondente, padrão ou `native_*`.
- Abrir a câmara antes de obter as permissões ou sem um caso de utilização para a câmara.: Peça primeiro as permissões da plataforma e adicione a transmissão da câmara apenas quando a aplicação precisar de dados de imagem.
- Utilizar o SpaceWalker como editor de código ou aplicação de configuração do SDK.: Utilize a página Developer, o pacote SDK, a documentação e um editor de código ou o Android Studio.
Conclusão
O desenvolvimento para o VITURE BEAST começa com o VITURE XR Glasses SDK, e não com o pacote Unity para experiências no Neckband nem com a aplicação de consumo SpaceWalker. Escolha Android, Linux, Windows ou macOS como anfitrião, transfira o SDK correspondente a partir da página Developer da VITURE, siga o guia da plataforma e comece por criar um pequeno programa que se ligue por USB e leia os dados de rastreio. A partir daí, adicione um controlo ou uma funcionalidade de câmara suportados pelo BEAST e teste-os no hardware real. Para as empresas, esta abordagem separa o fluxo de trabalho e os dados da aplicação das funções de dispositivo dos óculos, permite desenvolver na plataforma anfitriã mais adequada à implementação e dá às equipas uma forma de validar um caso de utilização industrial específico antes de investirem numa implementação mais ampla.
Está a criar um fluxo de trabalho XR para o VITURE BEAST? Explore a página do produto VITURE BEAST e a documentação para programadores da VITURE antes de definir os requisitos do seu piloto.
