Udvikling til VITURE BEAST: XR Glasses SDK forklaret

Resumé

For at udvikle til VITURE BEAST skal du åbne VITUREs Developer-side og vælge VITURE XR Glasses SDK. Det er det tværplatforms C-SDK, der forbinder software med VITURE-briller. Dokumentationen angiver Android, Linux, Windows og macOS. Det separate VITURE XR SDK for Unity beskrives til oplevelser, der kører på VITURE Neckband, så det er ikke udgangspunktet for en app, der skal styre BEAST-brillerne.

Brille-SDK'et giver en app adgang til enhedskommunikation, data fra hovedtracking, kamerastreaming og udvalgte brillefunktioner. Specifikt for BEAST dokumenterer VITURE native 3DoF-tracking, kamera-passthrough og native skærmstyring. Det gør ikke brillerne til en computer til generelle formål og skaber ikke automatisk en færdig XR-app. Du bygger en værtsapplikation, forbinder BEAST via USB og kalder SDK'et fra den app.

Udviklingsforløb: Vælg værtsplatformen -> download dens SDK-pakke -> byg producentens første forbindelseseksempel -> læs trackingdata -> tilføj en BEAST-styringsfunktion eller kamerafunktion -> test appen med brillerne.

Vil du have produktbaggrund, før du planlægger softwareintegrationen, så se anmeldelsen af VITURE BEAST på VRX. VITUREs officielle produktside er også nyttig for hardwaredetaljer.

INTRODUKTION:

(kender du allerede til SDK og platformsunderstøttelse, så gå videre til den egentlige vejledning)

Hvad er VITURE BEAST?

VITURE BEAST er en USB-C XR-skærm med indbyggede sensorer og et kamera. I native-tilstand håndterer brillernes egen processering 3DoF-tracking og understøttede skærmeffekter; i bypass-tilstand sender værten et videosignal, som brillerne sender uændret igennem. Forskellen mellem native og bypass er vigtig, når software ændrer skærmtilstand eller trackingadfærd.

Udvikler-SDK'et er software, som dit program linker til, så det kan kommunikere med brillerne. Det er adskilt fra VITUREs almindelige apps som SpaceWalker, der er beregnet til at bruge understøttede skærm- og rumlige skærmfunktioner, ikke til at skrive kode.

De to VITURE-SDK'er har forskellige formål

VITURE XR Glasses SDK:

• Hvad det bruges til: Native C-API til enhedsadgang, tracking, kamerastreaming og enhedsstyring for brillerne på tværs af understøttede værtsplatforme.
• Skal det bruges til BEAST-udvikling?: Ja. Det er dette BEAST-SDK, som denne vejledning dækker.

VITURE XR SDK for Unity:

• Hvad det bruges til: Unity XR-pakke, der er dokumenteret til at bygge immersive oplevelser på VITURE Neckband, med Unity-integrationer som håndtracking.
• Skal det bruges til BEAST-udvikling?: Ikke som standard-SDK til BEAST-brillerne. Forveksl det ikke med det native brille-SDK.

SpaceWalker:

• Hvad det bruges til: VITUREs ledsagersoftware til understøttede skærmtilstande og rumlige skærmfunktioner.
• Skal det bruges til BEAST-udvikling?: Nej. Det er en app til slutbrugere, ikke et udviklingsmiljø.

Hvad XR Glasses SDK styrer

Enhedsforbindelse:

• Hvad appen kan: Finde en tilsluttet enhed, oprette et enheds-handle, initialisere den, starte den og lukke den korrekt.
• BEAST-detalje at huske: SDK'et kommunikerer med brillerne via værtsforbindelsen.

Hovedtracking:

• Hvad appen kan: Læse orienterings-/IMU-data og bruge den modelspecifikke trackinggrænseflade.
• BEAST-detalje at huske: BEAST er dokumenteret med native 3DoF; posten for 6DoF VIO i enhedstabellen gælder Luma Ultra.

Skærm- og brillestyring:

• Hvad appen kan: Læse eller indstille understøttet lysstyrke, lydstyrke, skærmtilstand, 2D/3D-tilstand, toning og indstillinger for native-tilstand.
• BEAST-detalje at huske: Brug de BEAST-specifikke native skærmkonstanter i native-tilstand. Nogle kombinationer af tilstand og opdateringshastighed understøttes ikke.

Kamerastream:

• Hvad appen kan: Tilgå understøttede passthrough-kamerabilleder via SDK'ets kamera-API.
• BEAST-detalje at huske: BEAST er angivet med et passthrough-UVC-kamera. Kameraadgang er adskilt fra 6DoF-tracking.

SDK'et leverer ikke i sig selv: din apps arbejdsgang, forretningslogik, menuer, datalagring, brugerkonti eller en komplet Unity-scene. Dit applikationsteam bygger disse dele omkring de enhedsfunktioner, som SDK'et stiller til rådighed. Den primære udviklerside fremhæver disse fire platforme. Siden SDK 2.4.0 (6. august 2026) angiver dokumentationen et femte mål: Browser, en WebAssembly-build med en TypeScript-API, der når brillerne via WebHID, kun i Chrome og Chromium, med understøttelse af BEAST og uden Luma Ultra. Tjek den aktuelle pakke og udgivelsesnoterne, før du vælger en enhed eller et operativsystem til produktion.

Understøttelse på tværs af platforme: Android, Linux, Windows og macOS

„Tværplatform“ betyder, at VITURE leverer platformspecifikke SDK-builds og opsætningsvejledninger til det samme brille-SDK. Det betyder ikke, at én binærfil kører uændret overalt. Vælg den vært, hvor din applikation skal køre, og brug derefter det tilsvarende bibliotek og den tilhørende integrationsvejledning. Den aktuelle API-dokumentation angiver disse arkitekturer:

Windows:

• Dokumenteret arkitektur: x86_64
• Typisk opsætningsforløb: C/C++-skrivebordsapp, der bruger SDK'ets Windows-bibliotek og headerfiler; følg Quick Start: Desktop (C++).

Linux:

• Dokumenteret arkitektur: x86_64 og aarch64
• Typisk opsætningsforløb: C/C++-skrivebordsapp. Tilføj VITUREs udev-regel, så appen kan tilgå USB/HID-grænsefladen uden at køre som root.

macOS:

• Dokumenteret arkitektur: aarch64 (Apple silicon)
• Typisk opsætningsforløb: C/C++-skrivebordsapp, der bruger macOS-biblioteket og headerfilerne; følg Quick Start: Desktop (C++).

Android:

• Dokumenteret arkitektur: armeabi-v7a og arm64-v8a
• Typisk opsætningsforløb: Android-app, der bruger det native C-bibliotek via JNI; håndter USB-tilladelse og forbindelse i Android-appen.

Den primære udviklerside fremhæver disse fire platforme. Den detaljerede API-side kan med tiden tilføje mål eller ændre de understøttede arkitekturer, så tjek den aktuelle pakke og udgivelsesnoterne, før du vælger en enhed eller et operativsystem til produktion.

Det skal du bruge, før du begynder at udvikle

· VITURE BEAST-briller og en USB-C-dataforbindelse til den computer eller Android-vært, du vil understøtte.

· En udviklingscomputer med compiler/build-værktøjer til dit mål: en C/C++-toolchain og CMake til desktop eller Android Studio med NDK- og CMake-komponenterne til Android.

· VITURE XR Glasses SDK-pakken til målplatformen, downloadet fra VITUREs Developer-side.

· Den tilhørende SDK-dokumentation, især Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming og Native-DOF Devices.

· En grundlæggende forståelse af det sprog, dit appteam bruger: C/C++ til desktopeksemplerne samt Kotlin eller Java og JNI til en typisk Android-integration.

Sådan bygger du en første test med VITURE BEAST SDK

Start med en lille værtsapp, der finder BEAST og læser trackingdata. Når det virker, tilføjer du én styrings- eller kamerafunktion.

Trin 1: Vælg, hvor din app skal køre

Vælg den computer eller telefon, der skal køre din app; det afgør SDK-pakken og opsætningsvejledningen.

1. Vælg værten. Brug Windows, Linux eller macOS til en computer eller Android til en telefon, der er forbundet til BEAST.

2. Notér operativsystem og processor. Notér for eksempel Windows x86_64 eller macOS Apple silicon, og tjek derefter platformtabellen ovenfor.

3. Følg kun Android-sporet for en Android-app. Det bruger et native bibliotek, en JNI-bro og USB-tilladelse.

Trin 2: Download VITURE XR Glasses SDK

Download det officielle brille-SDK, og åbn vejledningen til din vært. Unity-pakken til Neckband er beregnet til en anden opsætning.

1. Åbn Developer-siden. Gå i en browser til https://www.viture.com/developer, og rul ned til „VITURE XR Glasses SDK“.

2. Download pakken til din platform. Klik på „Download“ på SDK-kortet, og vælg din vært, hvis du bliver spurgt.

3. Åbn din opsætningsvejledning. Klik på „Documents“ på samme kort, derefter på „Core Concepts“ og så på „Quick Start: Desktop (C++)“ eller „Android Integration Guide“.

4. Tjek kompatibiliteten. Gå tilbage til Developer-siden, åbn „Release Notes“, og tjek dit operativsystem, din processor og BEAST-firmwaren.

Gå videre til trin 3, når: du har det tilsvarende bibliotek, headerfilerne og opsætningsvejledningen.

Trin 3: Opsæt SDK'et på din værtsplatform

Brug kun opsætningssporet for den vært, du valgte i trin 1.

Til Windows, Linux eller macOS

1. Åbn desktopvejledningen. Vælg „Quick Start: Desktop (C++)“ i SDK Documents, og hav den åben ved siden af din kodeeditor.

2. Link SDK'et. Åbn eksemplet eller dit projekt, og brug derefter vejledningens CMake-eksempel til at tilføje SDK-headerfilerne og brillebiblioteket.

Tilføj SDK'ets include- og biblioteksstier i dit projekts `CMakeLists.txt`. Erstat `VITURE_SDK_ROOT` med den mappe, hvor du pakkede SDK'et ud:

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. Kun Linux: tillad USB-adgang. Følg „Linux udev Rule“ i Terminal, og opret `/etc/udev/rules.d/70-viture.rules`; genindlæs reglerne, og tilslut BEAST igen. Spring over på Windows og macOS.

4. Byg eksemplet. Åbn SDK-eksemplets `main.cpp`, og sørg for, at det kan bygges, før du tilføjer funktioner.

Til Android

1. Opret et Android-projekt. Start et projekt med CMake/NDK-understøttelse i Android Studio, og åbn `app/src/main` i projektpanelet.

2. Kopiér SDK-filerne ind. Følg „Android Integration Guide“: læg headerfilerne i `app/src/main/include/` og den tilsvarende `.so`-fil i `app/src/main/jniLibs/<ABI>/`.

3. Link biblioteket. Åbn `app/src/main/cpp/CMakeLists.txt` og `app/build.gradle.kts` i Android Studio; anvend vejledningens indstillinger for CMake, NDK og ABI.

Importér SDK-biblioteket i `CMakeLists.txt`, og link det til din JNI-bro. Dette eksempel forudsætter, at SDK-filerne ligger i de mapper, der vises 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. Tilføj broen mellem app og C++. Opret vejledningens `GlassesBridge`-klasse i appens kildemappe; dens `external`-funktioner kalder din JNI-kode.

5. Anmod om USB-tilladelse. Brug Androids `UsbManager` til at finde BEAST; når brugeren trykker på Tillad, åbner du USB-forbindelsen og sender dens filbeskrivelse videre til broen.

Når brugeren trykker på Tillad, åbner du USB-forbindelsen i din Kotlin-aktivitet og sender dens filbeskrivelse videre til den native bro. Erstat `GlassesBridge` med navnet på dit projekts broklasse:

val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)

I `glasses_bridge.cpp` sender den native create-funktion denne Android-filbeskrivelse videre til VITUREs 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å videre til trin 4, når: din app kan bygges og indlæser SDK'et uden fejl om manglende filer eller linkerfejl.

Trin 4: Tilslut BEAST, og kør det første eksempel

Test nu forbindelsen til brillerne. Brug desktopeksemplet på Windows, Linux eller macOS. På Android beholder du USB- og JNI-opsætningen fra trin 3; brug ikke desktopkode til HID-søgning.

1. Tilslut BEAST. Brug et USB-C-datakabel; på Android skal du acceptere telefonens USB-prompt.

2. Find BEAST, og opret dens handle. På desktop finder du BEASTs produkt-id via HID-søgning og opretter derefter provideren med xr_device_provider_create(product_id). På Android sender du både produkt-id'et og filbeskrivelsen fra USB-forbindelsen.

3. Start tracking. Start tracking ved at registrere et callback. Et callback er en funktion, som SDK'et kalder, når der kommer trackingdata. BEAST leverer roll, pitch og yaw i data[0] til data[2] og kvaternionen i data[3] til data[6], men kun med SDK 2.4.0 eller nyere og opdateret brillefirmware. På ældre firmware udløses pose-callbacket aldrig på BEAST (VITURE nævner dette under „Known Limitations on Beast“ i sine udgivelsesnoter): registrer i så fald xr_device_provider_register_imu_raw_callback, og integrer selv de rå IMU-data, eller skift brillerne til native-tilstand, og lad dem selv stå for trackingen.

Tilføj denne funktion over 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]

);

}

Registrer callbacket, før du initialiserer og starter SDK'et:

</> 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;

Brug handle på desktop. I Android-JNI-kode bruger du g_handle.

4. Åbn trackingstreamen. Tilføj dette kald til desktop-`main.cpp`; på Android eksponerer du det via JNI og kalder 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 afsluttes, lukker du IMU'en og stopper, lukker ned og destruerer derefter provideren. På Android kalder du de samme oprydningsfunktioner, før du lukker USB-forbindelsen:

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. Tjek outputtet. Kør appen, og se efter forbindelses- og trackingopdateringer i desktopkonsollen eller i Logcat i Android Studio.

Gå videre til trin 5, når: BEAST forbinder, og trackingopdateringer kommer ind uden fejl.

Trin 5: Tilføj én BEAST-styringsfunktion

Når trackingen virker, tilføjer du én brillestyring i din apps kode til enhedsstyring, efter at SDK-handlet er startet.

1. Vælg en styringsfunktion. Åbn „Device Control“ i SDK Documents, og tjek BEASTs understøttede indstillinger for lysstyrke, lydstyrke eller skærm.

2. Læs og indstil værdien. Tilføj C/C++-kaldene til din styringskode; på Android lægger du dem i `glasses_bridge.cpp` og eksponerer dem via JNI.

Når provideren er startet, læser du BEASTs lysstyrke og prøver en understøttet værdi. Det dokumenterede interval er 0 til 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. Tilpas skærm-API'et til tilstanden. Du kan også konfigurere BEASTs skærmtilstand. Native-tilstand bruger brillernes indbyggede skærmprocessering og understøtter native 3DoF. Bypass-tilstand sender værtens videosignal igennem brillerne. Vælg den gren, der svarer til appens valgte tilstand. Kør ikke begge grene efter hinanden.

I dette eksempel er use_native_mode en boolesk indstilling i din app, og rc er den eksisterende resultatvariabel.

</> 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ælg en opløsning og opdateringshastighed, som BEAST understøtter.

4. Test én ændring. Kør appen, tjek resultatet på BEAST, og gendan derefter den oprindelige indstilling.

Vigtigt: BEAST understøtter native 3DoF, men den nuværende firmware accepterer kun tre skærmtilstande: 1920 x 1200 ved 60 Hz og 3D side-by-side 3840 x 1200 ved 60 Hz i native-tilstand samt 3840 x 1200 ved 90 Hz i bypass-tilstand (udgivelsesnoter til VITURE XR Glasses SDK, 2.3.0 og 2.3.1). Andre konstanter består SDK'ets kontrol, men brillerne afviser eller ignorerer dem, så læs tilstanden tilbage, efter at du har indstillet den, og betragt udgivelsesnoterne som listen over understøttede værdier.

Trin 6: Tilføj kun kameraadgang, hvis appen har brug for det

Tilføj kun passthrough-kameraet, hvis din app har brug for billedrammer. Kamerastreaming er adskilt fra hovedtracking og giver ikke 6DoF.

1. Åbn kameravejledningen. Vælg „Camera Streaming“ i SDK Documents, og følg opsætningsafsnittet for din vært.

2. Tilføj en frame-handler. Opret en funktion i din app, der modtager kamerabilleder og sender dem videre til den funktion, der skal bruge dem, f.eks. en forhåndsvisning.

Opret BEASTs kameraprovider i dit C++-kameramodul, og start den med dit frame-callback, `on_frame`. Dette kald med to argumenter er til 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);

// Når du er færdig xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);

På Android sender du kameraets USB-filbeskrivelse med som tredje argument ved hjælp af tilladelsesopsætningen fra trin 3:

XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);

3. Indhent tilladelse først. Android kræver kamera- og USB-tilladelser; på desktop følger du platformvejledningen.

4. Beskyt privatlivet. Forklar, hvordan kameraet bruges, optag kun det, funktionen har brug for, og følg din organisations GDPR-proces i EU.

Spring dette trin over, hvis din app kun har brug for tracking eller skærmstyring.

Trin 7: Test, og forbered en lille pilot

1. Test genforbindelse. Genstart appen, frakobl BEAST, og tilslut den igen, og tjek, at appen forbliver stabil.

2. Test på BEAST. Tjek hver funktions skærmtilstand, opløsning, tracking og kameratilladelser i forhold til firmwaren.

3. Gem testoplysninger. Notér versioner af SDK, operativsystem, processor, compiler/NDK og firmware samt forbindelsesoplysninger og fejl.

4. Planlæg udrulningen. Beslut, hvordan værtsappen skal installeres og opdateres, hvordan kameraadgang og data skal administreres, og hvordan support skal håndteres.

Pilotkriterium: udvid først, når du har testet værten, funktionerne, tilladelserne og opdateringsprocessen.

Hvad SDK'et ikke gør

VITURE XR Glasses SDK er et værktøjssæt til enhedsintegration, ikke et færdigt miljø til at skabe XR-indhold. Det stiller funktioner til rådighed, som din software kan kalde. Dit team skal stadig vælge et applikationsframework, skrive brugergrænsefladen og opgavelogikken, bygge appen til værtsplatformen og beslutte, hvordan virksomheden vil udrulle og supportere den.

Det gør heller ikke alle funktioner tilgængelige på alle VITURE-modeller. I den aktuelle hardwaretabel er BEAST angivet med native 3DoF og adgang til passthrough-kamera, mens Luma Ultra er den model, der er angivet med 3/6DoF og stereo-VIO. Tjek tabellen over understøttet hardware for hvert API, du vil bruge, i stedet for at læse portalens generelle „3DoF/6DoF“-beskrivelse som et løfte om, at BEAST understøtter alle trackingtilstande.

Almindelige fejl ved udvikling med VITURE BEAST SDK

• At downloade Unity XR SDK til en app, der skal styre BEAST-brillerne.: Brug kortet VITURE XR Glasses SDK; Unity-vejledningen er dokumenteret til VITURE Neckband.
• At antage, at tværplatform betyder den samme binærfil eller opsætning overalt.: Download det korrekte bibliotek, og følg målplatformens vejledning til arkitektur og forbindelse.
• At behandle BEAST som en 6DoF VIO-enhed, fordi portalen nævner 6DoF.: Tjek understøttelsen på modelniveau: den aktuelle SDK-tabel angiver native 3DoF for BEAST og 6DoF VIO for Luma Ultra.
• At kalde standardfunktioner til skærmtilstand, mens BEAST er i native-tilstand.: Tjek den aktive tilstand, og brug det tilsvarende funktionssæt: standard eller `native_*`.
• At åbne kameraet, før tilladelserne er givet, eller uden et konkret behov for kameraet.: Anmod først om platformens tilladelser, og tilføj kun kamerastreaming, når appen har brug for billeddata.
• At bruge SpaceWalker som kodeeditor eller app til SDK-opsætning.: Brug Developer-siden, SDK-pakken, dokumentationen og en kodeeditor eller Android Studio.

Konklusion

Udvikling til VITURE BEAST starter med VITURE XR Glasses SDK, ikke med Unity-pakken til Neckband-oplevelser eller forbrugerappen SpaceWalker. Vælg Android, Linux, Windows eller macOS som vært, download det tilsvarende SDK fra VITUREs Developer-side, følg platformvejledningen, og byg først et lille program, der forbinder via USB og læser trackingdata. Derfra kan du tilføje en understøttet BEAST-styringsfunktion eller kamerafunktion og teste den på den faktiske hardware. For virksomheder adskiller det applikationens arbejdsgang og data fra brillernes enhedsfunktioner, understøtter udvikling på den værtsplatform, der passer til udrulningen, og giver teams mulighed for at validere et afgrænset industrielt anvendelsesscenarie, før de investerer i en bredere udrulning.

Bygger du en XR-arbejdsgang til VITURE BEAST? Se produktsiden for VITURE BEAST og VITUREs udviklerdokumentation, før du fastlægger kravene til din pilot.