Sammanfattning
För att utveckla för VITURE BEAST öppnar du VITURE:s utvecklarsida och väljer VITURE XR Glasses SDK. Det är den plattformsoberoende C-SDK:n för att ansluta programvara till VITURE-glasögon. Dokumentationen listar Android, Linux, Windows och macOS. Den separata VITURE XR SDK for Unity beskrivs för upplevelser som körs på VITURE Neckband, så den är inte utgångspunkten för en app som styr BEAST-glasögonen.
Glasögon-SDK:n ger en app tillgång till enhetskommunikation, huvudspårningsdata, kameraströmning och utvalda glasögonkontroller. Specifikt för BEAST dokumenterar VITURE nativ 3DoF-spårning, kamera-passthrough och nativa skärmkontroller. Den gör inte glasögonen till en dator för allmänt bruk och skapar inte automatiskt en färdig XR-app. Du bygger en värdapplikation, ansluter BEAST via USB och anropar SDK:n från den appen.
Utvecklingsflöde: Välj värdplattform -> ladda ner dess SDK-paket -> bygg leverantörens första anslutningsexempel -> läs spårningsdata -> lägg till en BEAST-kontroll eller kamerafunktion -> testa appen med glasögonen.
Om du vill ha produktsammanhang innan du planerar mjukvaruintegrationen kan du läsa recensionen av VITURE BEAST på VRX. VITURE:s officiella produktsida är också användbar för hårdvarudetaljer.
INLEDNING:
(känner du redan till SDK:n och plattformsstödet kan du gå vidare till huvudvägledningen)
Vad är VITURE BEAST?
VITURE BEAST är en XR-skärm med USB-C, inbyggda sensorer och en kamera. I nativt läge sköter glasögonens egen bearbetning 3DoF-spårning och de skärmeffekter som stöds; i bypass-läge skickar värden en videosignal som glasögonen släpper igenom. Skillnaden mellan nativt läge och bypass-läge spelar roll när programvaran ändrar visningsläge eller spårningsbeteende.
Utvecklar-SDK:n är programvara som ditt program länkar mot för att kunna kommunicera med glasögonen. Den är skild från vardagliga VITURE-appar som SpaceWalker, som är till för att använda de visningsfunktioner och funktioner för rumsliga skärmar som stöds, inte för att skriva kod.
De två VITURE-SDK:erna är till för olika uppgifter
VITURE XR Glasses SDK:
- Vad den är till för: Nativt C-API för åtkomst till glasögonenheten, spårning, kameraströmning och enhetskontroller på de värdplattformar som stöds.
- Använda den för BEAST-utveckling?: Ja. Det är den BEAST-SDK som den här guiden handlar om.
VITURE XR SDK for Unity:
- Vad den är till för: Unity XR-paket som är dokumenterat för att bygga immersiva upplevelser på VITURE Neckband, med Unity-integrationer som handspårning.
- Använda den för BEAST-utveckling?: Inte som standard-SDK för BEAST-glasögonen. Förväxla den inte med den nativa glasögon-SDK:n.
SpaceWalker:
- Vad den är till för: VITURE:s kompletterande programvara för de visningslägen och funktioner för rumsliga skärmar som stöds.
- Använda den för BEAST-utveckling?: Nej. Det är en app för slutanvändare, inte en utvecklingsmiljö.
Vad XR Glasses SDK styr
Enhetsanslutning:
- Vad appen kan göra: Upptäcka en ansluten enhet, skapa ett enhetshandtag, initiera det, starta det och stänga det korrekt.
- BEAST-detalj att komma ihåg: SDK:n kommunicerar med glasögonen via värdanslutningen.
Huvudspårning:
- Vad appen kan göra: Läsa orienterings-/IMU-data och använda det modellspecifika spårningsgränssnittet.
- BEAST-detalj att komma ihåg: BEAST är dokumenterad för nativ 3DoF; posten för 6DoF VIO i enhetstabellen gäller Luma Ultra.
Skärm- och glasögonkontroller:
- Vad appen kan göra: Läsa av eller ställa in ljusstyrka, volym, visningsläge, 2D/3D-läge, tonning och alternativ för nativt läge, i den mån de stöds.
- BEAST-detalj att komma ihåg: Använd de BEAST-specifika nativa skärmkonstanterna i nativt läge. Vissa kombinationer av läge och uppdateringsfrekvens stöds inte.
Kameraström:
- Vad appen kan göra: Komma åt bildrutor från passthrough-kameran, i den mån de stöds, via SDK:ns kamera-API.
- BEAST-detalj att komma ihåg: BEAST listas med en UVC-kamera för passthrough. Kameraåtkomst är skild från 6DoF-spårning.
SDK:n tillhandahåller inte i sig: appens arbetsflöde, affärslogik, menyer, datalagring, användarkonton eller en komplett Unity-scen. Ditt applikationsteam bygger de delarna kring de enhetsfunktioner som SDK:n exponerar. Den huvudsakliga utvecklarsidan lyfter fram dessa fyra plattformar. Sedan SDK 2.4.0 (6 augusti 2026) listar dokumentationen ett femte mål: Browser, ett WebAssembly-bygge med ett TypeScript-API som når glasögonen via WebHID, endast i Chrome och Chromium, där BEAST stöds och Luma Ultra är undantaget. Kontrollera det aktuella paketet och versionsinformationen innan du väljer en enhet eller ett operativsystem för produktion.
Plattformsoberoende stöd: Android, Linux, Windows och macOS
”Plattformsoberoende” innebär att VITURE tillhandahåller plattformsspecifika SDK-byggen och installationsanvisningar för samma glasögon-SDK. Det betyder inte att en och samma binärfil körs oförändrad överallt. Välj den värd där din applikation behöver köras och använd sedan motsvarande bibliotek och integrationsguide. Den aktuella API-dokumentationen listar följande arkitekturer:
Windows:
- Dokumenterad arkitektur: x86_64
- Typisk installationsväg: C/C++-skrivbordsapp som använder Windows-SDK:ns bibliotek och header-filer; följ Quick Start: Desktop (C++).
Linux:
- Dokumenterad arkitektur: x86_64 och aarch64
- Typisk installationsväg: C/C++-skrivbordsapp. Lägg till VITURE:s udev-regel så att appen kan komma åt USB/HID-gränssnittet utan att köras som root.
macOS:
- Dokumenterad arkitektur: aarch64 (Apple silicon)
- Typisk installationsväg: C/C++-skrivbordsapp som använder macOS-biblioteket och header-filerna; följ Quick Start: Desktop (C++).
Android:
- Dokumenterad arkitektur: armeabi-v7a och arm64-v8a
- Typisk installationsväg: Android-app som använder det nativa C-biblioteket via JNI; hantera USB-behörighet och anslutning i Android-appen.
Den huvudsakliga utvecklarsidan lyfter fram dessa fyra plattformar. Den detaljerade API-sidan kan med tiden lägga till mål eller ändra vilka arkitekturer som stöds, så kontrollera det aktuella paketet och versionsinformationen innan du väljer en enhet eller ett operativsystem för produktion.
Vad du behöver innan du börjar utveckla
· VITURE BEAST-glasögon och en USB-C-dataanslutning till den dator eller Android-värd du planerar att stödja.
· En utvecklingsdator med kompilator/byggverktyg för ditt mål: en C/C++-verktygskedja och CMake för skrivbord, eller Android Studio med NDK- och CMake-komponenterna för Android.
· VITURE XR Glasses SDK-paketet för målplattformen, nedladdat från VITURE:s utvecklarsida.
· Motsvarande SDK-dokumentation, särskilt Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming och Native-DOF Devices.
· Grundläggande kunskaper i det språk som ditt appteam använder: C/C++ för skrivbordsexemplen, samt Kotlin eller Java och JNI för en typisk Android-integration.
Så bygger du ett första test med VITURE BEAST SDK
Börja med en liten värdapp som hittar BEAST och läser spårningsdata. När det fungerar lägger du till en kontroll eller kamerafunktion.
Steg 1: Välj var appen ska köras
Välj den dator eller telefon som ska köra appen; det avgör vilket SDK-paket och vilken installationsguide du använder.
1. Välj värd. Använd Windows, Linux eller macOS för en dator, eller Android för en telefon som är ansluten till BEAST.
2. Notera operativsystem och processor. Anteckna till exempel Windows x86_64 eller macOS Apple silicon och kontrollera sedan plattformstabellen ovan.
3. Följ Android-spåret endast för en Android-app. Det använder ett nativt bibliotek, en JNI-brygga och USB-behörighet.
Steg 2: Ladda ner VITURE XR Glasses SDK
Ladda ner den officiella glasögon-SDK:n och öppna guiden för din värd. Unity-paketet för Neckband är avsett för en annan konfiguration.
1. Öppna utvecklarsidan. Gå i en webbläsare till https://www.viture.com/developer och skrolla ner till ”VITURE XR Glasses SDK”.
2. Ladda ner paketet för din plattform. Klicka på ”Download” på SDK-kortet och välj din värd om du blir tillfrågad.
3. Öppna din installationsguide. Klicka på ”Documents” på samma kort, sedan på ”Core Concepts” och därefter på ”Quick Start: Desktop (C++)” eller ”Android Integration Guide”.
4. Kontrollera kompatibiliteten. Gå tillbaka till utvecklarsidan, öppna ”Release Notes” och kontrollera ditt operativsystem, din processor och BEAST-firmwaren.
Gå vidare till steg 3 när: du har rätt bibliotek, header-filer och installationsguide.
Steg 3: Konfigurera SDK:n på din värdplattform
Använd bara installationsspåret för den värd du valde i steg 1.
För Windows, Linux eller macOS
1. Öppna skrivbordsguiden. Välj ”Quick Start: Desktop (C++)” i SDK Documents och ha den öppen bredvid kodredigeraren.
2. Länka SDK:n. Öppna exemplet eller ditt projekt och använd sedan guidens CMake-exempel för att lägga till SDK:ns header-filer och glasögonbiblioteket.
Lägg till SDK:ns include- och bibliotekssökvägar i projektets `CMakeLists.txt`. Ersätt `VITURE_SDK_ROOT` med mappen där du packade upp SDK:n:
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. Endast Linux: tillåt USB-åtkomst. Följ ”Linux udev Rule” i terminalen och skapa `/etc/udev/rules.d/70-viture.rules`; läs in reglerna på nytt och anslut BEAST igen. Hoppa över detta på Windows och macOS.
4. Bygg exemplet. Öppna SDK-exemplets `main.cpp` och se till att det går att bygga innan du lägger till funktioner.
För Android
1. Skapa ett Android-projekt. Starta ett projekt med stöd för CMake/NDK i Android Studio och öppna `app/src/main` i projektpanelen.
2. Kopiera in SDK-filerna. Följ ”Android Integration Guide”: lägg header-filerna i `app/src/main/include/` och motsvarande `.so`-fil i `app/src/main/jniLibs/<ABI>/`.
3. Länka biblioteket. Öppna `app/src/main/cpp/CMakeLists.txt` och `app/build.gradle.kts` i Android Studio; tillämpa guidens inställningar för CMake, NDK och ABI.
Importera SDK-biblioteket i `CMakeLists.txt` och länka det till din JNI-brygga. Exemplet förutsätter att SDK-filerna ligger i de mappar som visas i 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. Lägg till bryggan mellan appen och C++. Skapa guidens `GlassesBridge`-klass i appens källmapp; dess `external`-funktioner anropar din JNI-kod.
5. Begär USB-behörighet. Använd Androids `UsbManager` för att hitta BEAST; när användaren har tryckt på Tillåt öppnar du USB-anslutningen och skickar dess fildeskriptor till bryggan.
När användaren har tryckt på Tillåt öppnar du USB-anslutningen i din Kotlin-aktivitet och skickar dess fildeskriptor till den nativa bryggan. Ersätt `GlassesBridge` med namnet på ditt projekts bryggklass:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
I `glasses_bridge.cpp` skickar den nativa create-funktionen den Android-fildeskriptorn vidare till VITURE:s SDK:
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; }
Gå vidare till steg 4 när: appen byggs och läser in SDK:n utan fel om saknade filer eller länkningsfel.
Steg 4: Anslut BEAST och kör det första exemplet
Testa nu anslutningen till glasögonen. Använd skrivbordsexemplet på Windows, Linux eller macOS. På Android behåller du USB- och JNI-konfigurationen från steg 3; använd inte skrivbordskoden för HID-identifiering.
1. Anslut BEAST. Använd en USB-C-datakabel; på Android godkänner du telefonens USB-fråga.
2. Hitta BEAST och skapa dess handtag. På skrivbordet hittar du BEAST:s produkt-ID med HID-identifiering och skapar sedan providern med xr_device_provider_create(product_id). På Android skickar du både produkt-ID:t och fildeskriptorn från USB-anslutningen.
3. Starta spårningen. Starta spårningen genom att registrera en callback. En callback är en funktion som SDK:n anropar när spårningsdata kommer in. BEAST levererar roll, pitch och yaw i data[0] till data[2] och kvaternionen i data[3] till data[6], men bara med SDK 2.4.0 eller senare och uppdaterad firmware i glasögonen. Med äldre firmware anropas pose-callbacken aldrig på BEAST (VITURE listar detta under ”Known Limitations on Beast” i sin versionsinformation): registrera då antingen xr_device_provider_register_imu_raw_callback och integrera rå IMU-data själv, eller växla glasögonen till nativt läge och låt dem sköta spårningen.
Lägg till den här funktionen ovanför 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]
);
}
Registrera callbacken innan du initierar och startar SDK:n:
</> 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;
Använd handle på skrivbordet. I Android-JNI-kod använder du g_handle.
4. Öppna spårningsströmmen. Lägg till det här anropet i skrivbordsappens `main.cpp`; på Android exponerar du det via JNI och anropar det efter `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
När appen avslutas stänger du IMU:n och stoppar, stänger ner och förstör sedan providern. På Android anropar du samma städfunktioner innan du stänger USB-anslutningen:
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. Kontrollera utdata. Kör appen och leta efter anslutnings- och spårningsuppdateringar i skrivbordskonsolen eller i Logcat i Android Studio.
Gå vidare till steg 5 när: BEAST ansluter och spårningsuppdateringar kommer in utan fel.
Steg 5: Lägg till en BEAST-kontroll
När spårningen fungerar lägger du till en glasögonkontroll i appens kod för enhetsstyrning, efter att SDK-handtaget har startat.
1. Välj en kontroll. Öppna ”Device Control” i SDK Documents och kontrollera vilka alternativ för ljusstyrka, volym eller skärm som BEAST stöder.
2. Läs av och ställ in värdet. Lägg till C/C++-anropen i din kontrollkod; på Android lägger du dem i `glasses_bridge.cpp` och exponerar dem via JNI.
När providern har startat läser du av BEAST:s ljusstyrka och provar ett värde som stöds. Det dokumenterade intervallet är 0 till 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. Anpassa skärm-API:t efter läget. Du kan också konfigurera BEAST:s visningsläge. Nativt läge använder glasögonens inbyggda skärmbearbetning och stöder nativ 3DoF. Bypass-läge släpper igenom värdens videosignal via glasögonen. Välj den gren som motsvarar det läge appen har valt. Kör inte båda grenarna efter varandra.
I det här exemplet är use_native_mode en boolesk inställning i din app, och rc är den befintliga resultatvariabeln.
</> 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;
}
Välj en upplösning och uppdateringsfrekvens som BEAST stöder.
4. Testa en ändring. Kör appen, kontrollera resultatet i BEAST och återställ sedan den ursprungliga inställningen.
Viktigt: BEAST stöder nativ 3DoF, men den aktuella firmwaren accepterar bara tre visningslägen: 1920 x 1200 vid 60 Hz och 3D sida vid sida 3840 x 1200 vid 60 Hz i nativt läge, samt 3840 x 1200 vid 90 Hz i bypass-läge (versionsinformation för VITURE XR Glasses SDK, 2.3.0 och 2.3.1). Andra konstanter klarar SDK:ns kontroll men avvisas eller ignoreras av glasögonen, så läs av läget efter att du har ställt in det och betrakta versionsinformationen som listan över värden som stöds.
Steg 6: Lägg bara till kameraåtkomst om appen behöver det
Lägg bara till passthrough-kameran om appen behöver bildrutor. Kameraströmning är skild från huvudspårning och ger inte 6DoF.
1. Öppna kameraguiden. Välj ”Camera Streaming” i SDK Documents och följ installationsavsnittet för din värd.
2. Lägg till en bildrutehanterare. Skapa en funktion i appen som tar emot kamerabildrutor och skickar dem till den funktion som behöver dem, till exempel en förhandsvisning.
Skapa BEAST:s kameraprovider i din C++-kameramodul och starta den med din bildrute-callback, `on_frame`. Det här anropet med två argument gäller skrivbordet:
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);
// När du är klar xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
På Android skickar du kamerans USB-fildeskriptor som tredje argument, med behörighetskonfigurationen från steg 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Skaffa behörighet först. Android kräver kamera- och USB-behörigheter; på skrivbordet följer du plattformsguiden.
4. Skydda integriteten. Förklara hur kameran används, fånga bara det som funktionen behöver och följ organisationens GDPR-process inom EU.
Hoppa över det här steget om appen bara behöver spårning eller skärmkontroller.
Steg 7: Testa och förbered en liten pilot
1. Testa återanslutning. Starta om appen, koppla ur och anslut BEAST igen och kontrollera att appen förblir stabil.
2. Testa på BEAST. Kontrollera varje funktions visningsläge, upplösning, spårning och kamerabehörigheter mot firmwaren.
3. Spara testdetaljer. Dokumentera versionerna av SDK, operativsystem, processor, kompilator/NDK och firmware samt anslutningsdetaljer och fel.
4. Planera utrullningen. Bestäm hur värdappen ska installeras och uppdateras, hur kameraåtkomst och data ska hanteras och hur support ska skötas.
Pilotspärr: utöka först när du har testat värden, funktionerna, behörigheterna och uppdateringsprocessen.
Vad SDK:n inte gör
VITURE XR Glasses SDK är en verktygslåda för enhetsintegration, inte en färdig miljö för att skapa XR-innehåll. Den exponerar funktioner som din programvara kan anropa. Ditt team måste fortfarande välja ett applikationsramverk, skriva användargränssnittet och uppgiftslogiken, bygga appen för värdplattformen och bestämma hur verksamheten ska driftsätta och supporta den.
Den gör inte heller alla funktioner tillgängliga på alla VITURE-modeller. I den aktuella hårdvarutabellen listas BEAST med nativ 3DoF och åtkomst till passthrough-kamera, medan Luma Ultra är den modell som listas med 3/6DoF och stereo-VIO. Kontrollera tabellen över hårdvara som stöds för varje API du planerar att använda, i stället för att läsa portalens allmänna beskrivning ”3DoF/6DoF” som ett löfte om att BEAST stöder alla spårningslägen.
Vanliga misstag vid utveckling med VITURE BEAST SDK
- Att ladda ner Unity XR SDK för en app som styr BEAST-glasögonen.: Använd kortet för VITURE XR Glasses SDK; Unity-guiden är dokumenterad för VITURE Neckband.
- Att anta att plattformsoberoende betyder samma binärfil eller konfiguration överallt.: Ladda ner rätt bibliotek och följ målplattformens guide för arkitektur och anslutning.
- Att behandla BEAST som en 6DoF VIO-enhet för att portalen nämner 6DoF.: Kontrollera stödet på modellnivå: den aktuella SDK-tabellen listar nativ 3DoF för BEAST och 6DoF VIO för Luma Ultra.
- Att anropa standardfunktioner för visningsläge medan BEAST är i nativt läge.: Kontrollera det aktiva läget och använd motsvarande uppsättning standardfunktioner eller `native_*`-funktioner.
- Att öppna kameran innan behörigheterna finns eller utan ett användningsfall för kameran.: Begär plattformsbehörigheterna först och lägg bara till kameraströmning när appen behöver bilddata.
- Att använda SpaceWalker som kodredigerare eller app för SDK-installation.: Använd utvecklarsidan, SDK-paketet, dokumentationen och en kodredigerare eller Android Studio.
Slutsats
Utveckling för VITURE BEAST börjar med VITURE XR Glasses SDK, inte med Unity-paketet för Neckband-upplevelser eller konsumentappen SpaceWalker. Välj Android, Linux, Windows eller macOS som värd, ladda ner motsvarande SDK från VITURE:s utvecklarsida, följ dess plattformsguide och bygg först ett litet program som ansluter via USB och läser spårningsdata. Lägg därefter till en BEAST-kontroll eller kamerafunktion som stöds och testa den på den faktiska hårdvaran. För företag skiljer detta applikationens arbetsflöde och data från glasögonens enhetsfunktioner, möjliggör utveckling på den värdplattform som passar driftsättningen och ger teamen ett sätt att validera ett avgränsat industriellt användningsfall innan de investerar i en bredare utrullning.
Bygger du ett XR-arbetsflöde för VITURE BEAST? Utforska produktsidan för VITURE BEAST och VITURE:s utvecklardokumentation innan du definierar kraven för din pilot.
