Zusammenfassung
Um für VITURE BEAST zu entwickeln, öffnen Sie die Developer-Seite von VITURE und wählen das VITURE XR Glasses SDK. Dabei handelt es sich um das plattformübergreifende C-SDK, mit dem sich Software an VITURE-Brillen anbinden lässt. Laut Dokumentation werden Android, Linux, Windows und macOS unterstützt. Das separate VITURE XR SDK for Unity ist für Anwendungen beschrieben, die auf dem VITURE Neckband laufen; es ist daher nicht der richtige Ausgangspunkt für eine App zur Steuerung der BEAST-Brille.
Das Brillen-SDK gibt einer App Zugriff auf die Gerätekommunikation, Head-Tracking-Daten, Kamera-Streaming und ausgewählte Brillensteuerungen. Speziell für BEAST dokumentiert VITURE natives 3DoF-Tracking, Kamera-Passthrough und native Display-Steuerungen. Das SDK macht die Brille weder zu einem Universalcomputer, noch erzeugt es automatisch eine fertige XR-App. Sie entwickeln eine Host-Anwendung, verbinden BEAST per USB und rufen das SDK aus dieser App heraus auf.
Entwicklungsablauf: Host-Plattform wählen -> zugehöriges SDK-Paket herunterladen -> erstes Verbindungsbeispiel des Herstellers bauen -> Tracking-Daten auslesen -> eine BEAST-Steuerung oder Kamerafunktion hinzufügen -> App mit der Brille testen.
Produkthintergründe vor der Planung der Softwareintegration finden Sie im VITURE BEAST-Test auf VRX. Auch die offizielle Produktseite von VITURE liefert nützliche Hardwaredetails.
EINFÜHRUNG:
(Wenn Sie SDK und Plattformunterstützung bereits kennen, springen Sie direkt zur eigentlichen Anleitung.)
Was ist VITURE BEAST?
VITURE BEAST ist ein XR-Display mit USB-C-Anschluss, integrierten Sensoren und einer Kamera. Im nativen Modus übernimmt die brilleneigene Verarbeitung das 3DoF-Tracking und unterstützte Display-Effekte; im Bypass-Modus sendet der Host ein Videosignal, das die Brille durchreicht. Diese Unterscheidung zwischen nativem Modus und Bypass ist wichtig, wenn Software den Display-Modus oder das Tracking-Verhalten ändert.
Das Entwickler-SDK ist Software, die Ihr Programm einbindet, um mit der Brille zu kommunizieren. Es ist unabhängig von alltäglichen VITURE-Apps wie SpaceWalker, die zur Nutzung unterstützter Display- und Spatial-Screen-Funktionen dient, nicht zum Programmieren.
Die beiden VITURE-SDKs erfüllen unterschiedliche Aufgaben
VITURE XR Glasses SDK:
- Wofür es gedacht ist: Native C-API für Gerätezugriff, Tracking, Kamera-Streaming und Gerätesteuerung der Brille auf den unterstützten Host-Plattformen.
- Für die BEAST-Entwicklung verwenden?: Ja. Das ist das BEAST-SDK, um das es in diesem Leitfaden geht.
VITURE XR SDK for Unity:
- Wofür es gedacht ist: Unity-XR-Paket, dokumentiert für die Entwicklung immersiver Anwendungen auf dem VITURE Neckband, mit Unity-Integrationen wie Hand-Tracking.
- Für die BEAST-Entwicklung verwenden?: Nicht als Standard-SDK für die BEAST-Brille. Verwechseln Sie es nicht mit dem nativen Brillen-SDK.
SpaceWalker:
- Wofür es gedacht ist: Begleitsoftware von VITURE für unterstützte Display-Modi und Spatial-Screen-Funktionen.
- Für die BEAST-Entwicklung verwenden?: Nein. Es ist eine Endanwender-App, keine Entwicklungsumgebung.
Was das XR Glasses SDK steuert
Geräteverbindung:
- Was die App tun kann: Ein angeschlossenes Gerät erkennen, ein Geräte-Handle erstellen, es initialisieren, starten und sauber schließen.
- Wichtig bei BEAST: Das SDK kommuniziert über die Host-Verbindung mit der Brille.
Head-Tracking:
- Was die App tun kann: Orientierungs-/IMU-Daten auslesen und die modellspezifische Tracking-Schnittstelle nutzen.
- Wichtig bei BEAST: BEAST ist für natives 3DoF dokumentiert; der 6DoF-VIO-Eintrag in der Gerätetabelle bezieht sich auf Luma Ultra.
Display- und Brillensteuerung:
- Was die App tun kann: Unterstützte Werte für Helligkeit, Lautstärke, Display-Modus, 2D/3D-Modus, Tönung und Optionen des nativen Modus auslesen oder setzen.
- Wichtig bei BEAST: Verwenden Sie im nativen Modus die BEAST-spezifischen nativen Display-Konstanten. Einige Kombinationen aus Modus und Bildwiederholrate werden nicht unterstützt.
Kamera-Stream:
- Was die App tun kann: Über die Kamera-API des SDK auf unterstützte Bilder der Passthrough-Kamera zugreifen.
- Wichtig bei BEAST: BEAST ist mit einer Passthrough-UVC-Kamera aufgeführt. Der Kamerazugriff ist unabhängig vom 6DoF-Tracking.
Das SDK stellt von sich aus nicht bereit: den Workflow Ihrer App, Geschäftslogik, Menüs, Datenspeicherung, Benutzerkonten oder eine vollständige Unity-Szene. Diese Teile baut Ihr Anwendungsteam rund um die Gerätefunktionen auf, die das SDK bereitstellt. Die zentrale Developer-Seite hebt diese vier Plattformen hervor. Seit SDK 2.4.0 (6. August 2026) führt die Dokumentation ein fünftes Ziel auf: Browser, ein WebAssembly-Build mit TypeScript-API, der die Brille über WebHID anspricht – nur unter Chrome und Chromium, wobei BEAST unterstützt wird und Luma Ultra ausgenommen ist. Prüfen Sie das aktuelle Paket und die Release Notes, bevor Sie ein Gerät oder Betriebssystem für den Produktiveinsatz auswählen.
Plattformübergreifende Unterstützung: Android, Linux, Windows und macOS
„Plattformübergreifend“ bedeutet, dass VITURE für dasselbe Brillen-SDK plattformspezifische SDK-Builds und Einrichtungsanleitungen bereitstellt. Es bedeutet nicht, dass ein einziges Binary überall unverändert läuft. Wählen Sie den Host, auf dem Ihre Anwendung laufen soll, und verwenden Sie dann die passende Bibliothek und Integrationsanleitung. Die aktuelle API-Dokumentation nennt folgende Architekturen:
Windows:
- Dokumentierte Architektur: x86_64
- Typischer Einrichtungsweg: C/C++-Desktop-App mit der Windows-SDK-Bibliothek und den Headern; folgen Sie „Quick Start: Desktop (C++)“.
Linux:
- Dokumentierte Architektur: x86_64 und aarch64
- Typischer Einrichtungsweg: C/C++-Desktop-App. Fügen Sie die udev-Regel von VITURE hinzu, damit die App ohne Root-Rechte auf die USB-/HID-Schnittstelle zugreifen kann.
macOS:
- Dokumentierte Architektur: aarch64 (Apple Silicon)
- Typischer Einrichtungsweg: C/C++-Desktop-App mit der macOS-Bibliothek und den Headern; folgen Sie „Quick Start: Desktop (C++)“.
Android:
- Dokumentierte Architektur: armeabi-v7a und arm64-v8a
- Typischer Einrichtungsweg: Android-App, die die native C-Bibliothek über JNI nutzt; USB-Berechtigung und Verbindung werden in der Android-App verwaltet.
Die zentrale Developer-Seite hebt diese vier Plattformen hervor. Die ausführliche API-Seite kann im Laufe der Zeit weitere Ziele ergänzen oder die unterstützten Architekturen ändern. Prüfen Sie daher das aktuelle Paket und die Release Notes, bevor Sie ein Gerät oder Betriebssystem für den Produktiveinsatz auswählen.
Was Sie vor der Entwicklung benötigen
· Eine VITURE BEAST-Brille und eine USB-C-Datenverbindung zu dem Computer oder Android-Host, den Sie unterstützen möchten.
· Einen Entwicklungsrechner mit den Compiler-/Build-Tools für Ihr Ziel: eine C/C++-Toolchain und CMake für den Desktop oder Android Studio mit den Komponenten NDK und CMake für Android.
· Das VITURE XR Glasses SDK-Paket für die Zielplattform, heruntergeladen von der Developer-Seite von VITURE.
· Die passende SDK-Dokumentation, insbesondere Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming und Native-DOF Devices.
· Grundkenntnisse in der Sprache, die Ihr App-Team verwendet: C/C++ für die Desktop-Beispiele sowie Kotlin oder Java und JNI für eine typische Android-Integration.
So erstellen Sie einen ersten Test mit dem VITURE BEAST SDK
Beginnen Sie mit einer kleinen Host-App, die BEAST erkennt und Tracking-Daten ausliest. Sobald das funktioniert, fügen Sie eine Steuerung oder Kamerafunktion hinzu.
Schritt 1: Festlegen, wo Ihre App laufen soll
Wählen Sie den Computer oder das Smartphone, auf dem Ihre App laufen soll; davon hängen das SDK-Paket und die Einrichtungsanleitung ab.
1. Host wählen. Verwenden Sie Windows, Linux oder macOS für einen Computer oder Android für ein Smartphone, das mit BEAST verbunden ist.
2. Betriebssystem und Prozessor notieren. Notieren Sie zum Beispiel Windows x86_64 oder macOS Apple Silicon und prüfen Sie dann die Plattformtabelle oben.
3. Den Android-Zweig nur für eine Android-App verwenden. Er nutzt eine native Bibliothek, eine JNI-Brücke und eine USB-Berechtigung.
Schritt 2: Das VITURE XR Glasses SDK herunterladen
Laden Sie das offizielle Brillen-SDK herunter und öffnen Sie die Anleitung für Ihren Host. Das Unity-Paket für das Neckband ist für ein anderes Setup gedacht.
1. Die Developer-Seite öffnen. Rufen Sie im Browser https://www.viture.com/developer auf und scrollen Sie zu „VITURE XR Glasses SDK“.
2. Das Paket für Ihre Plattform herunterladen. Klicken Sie auf der SDK-Karte auf „Download“ und wählen Sie bei Nachfrage Ihren Host.
3. Die Einrichtungsanleitung öffnen. Klicken Sie auf derselben Karte auf „Documents“, dann auf „Core Concepts“ und anschließend auf „Quick Start: Desktop (C++)“ oder „Android Integration Guide“.
4. Kompatibilität prüfen. Kehren Sie zur Developer-Seite zurück, öffnen Sie „Release Notes“ und prüfen Sie Betriebssystem, Prozessor und BEAST-Firmware.
Weiter zu Schritt 3, wenn: Sie die passende Bibliothek, die Header und die Einrichtungsanleitung haben.
Schritt 3: Das SDK auf Ihrer Host-Plattform einrichten
Verwenden Sie nur den Einrichtungszweig für den Host, den Sie in Schritt 1 gewählt haben.
Für Windows, Linux oder macOS
1. Die Desktop-Anleitung öffnen. Wählen Sie in den SDK Documents „Quick Start: Desktop (C++)“ und halten Sie die Anleitung neben Ihrem Code-Editor geöffnet.
2. Das SDK einbinden. Öffnen Sie das Beispiel oder Ihr Projekt und fügen Sie dann anhand des CMake-Beispiels aus der Anleitung die SDK-Header und die Brillen-Bibliothek hinzu.
Fügen Sie in der `CMakeLists.txt` Ihres Projekts die Include- und Bibliothekspfade des SDK hinzu. Ersetzen Sie `VITURE_SDK_ROOT` durch den Ordner, in den Sie das SDK entpackt haben:
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. Nur Linux: USB-Zugriff erlauben. Folgen Sie im Terminal der Anleitung „Linux udev Rule“ und legen Sie `/etc/udev/rules.d/70-viture.rules` an; laden Sie die Regeln neu und schließen Sie BEAST erneut an. Unter Windows und macOS überspringen.
4. Das Beispiel bauen. Öffnen Sie die `main.cpp` des SDK-Beispiels und stellen Sie sicher, dass es sich bauen lässt, bevor Sie Funktionen hinzufügen.
Für Android
1. Ein Android-Projekt anlegen. Starten Sie in Android Studio ein Projekt mit CMake-/NDK-Unterstützung und öffnen Sie `app/src/main` im Projektbereich.
2. Die SDK-Dateien hineinkopieren. Folgen Sie dem „Android Integration Guide“: Legen Sie die Header in `app/src/main/include/` und die passende `.so`-Datei in `app/src/main/jniLibs/<ABI>/` ab.
3. Die Bibliothek einbinden. Öffnen Sie in Android Studio `app/src/main/cpp/CMakeLists.txt` und `app/build.gradle.kts` und übernehmen Sie die CMake-, NDK- und ABI-Einstellungen aus der Anleitung.
Importieren Sie in der `CMakeLists.txt` die SDK-Bibliothek und binden Sie sie an Ihre JNI-Brücke. Dieses Beispiel geht davon aus, dass sich die SDK-Dateien in den im Android Integration Guide gezeigten Ordnern befinden:
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. Die Brücke zwischen App und C++ hinzufügen. Legen Sie im Quellordner der App die Klasse `GlassesBridge` aus der Anleitung an; ihre `external`-Funktionen rufen Ihren JNI-Code auf.
5. USB-Berechtigung anfordern. Ermitteln Sie BEAST über den `UsbManager` von Android; nachdem der Nutzer auf „Zulassen“ getippt hat, öffnen Sie die USB-Verbindung und übergeben deren Dateideskriptor an die Brücke.
Nachdem der Nutzer auf „Zulassen“ getippt hat, öffnen Sie die USB-Verbindung in Ihrer Kotlin-Activity und übergeben deren Dateideskriptor an die native Brücke. Ersetzen Sie `GlassesBridge` durch den Namen der Brückenklasse Ihres Projekts:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
In `glasses_bridge.cpp` übergibt die native create-Funktion diesen Android-Dateideskriptor an das SDK von 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; }
Weiter zu Schritt 4, wenn: Ihre App sich bauen lässt und das SDK ohne Fehler wegen fehlender Dateien oder Linker-Fehler lädt.
Schritt 4: BEAST verbinden und das erste Beispiel ausführen
Testen Sie nun die Verbindung zur Brille. Verwenden Sie unter Windows, Linux oder macOS das Desktop-Beispiel. Behalten Sie unter Android die USB- und JNI-Einrichtung aus Schritt 3 bei; verwenden Sie keinen Desktop-Code zur HID-Erkennung.
1. BEAST verbinden. Verwenden Sie ein USB-C-Datenkabel; bestätigen Sie unter Android die USB-Abfrage des Smartphones.
2. BEAST finden und das Handle erstellen. Ermitteln Sie auf dem Desktop die Produkt-ID von BEAST per HID-Erkennung und erstellen Sie dann den Provider mit xr_device_provider_create(product_id). Übergeben Sie unter Android sowohl die Produkt-ID als auch den Dateideskriptor der USB-Verbindung.
3. Tracking starten. Starten Sie das Tracking, indem Sie einen Callback registrieren. Ein Callback ist eine Funktion, die das SDK aufruft, sobald Tracking-Daten eintreffen. BEAST liefert Roll, Pitch und Yaw in data[0] bis data[2] und das Quaternion in data[3] bis data[6], allerdings nur mit SDK 2.4.0 oder neuer und aktualisierter Brillen-Firmware. Mit älterer Firmware wird der Pose-Callback bei BEAST nie ausgelöst (VITURE führt dies in den Release Notes unter „Known Limitations on Beast“ auf). Registrieren Sie in diesem Fall entweder xr_device_provider_register_imu_raw_callback und integrieren Sie die rohen IMU-Daten selbst, oder schalten Sie die Brille in den nativen Modus und überlassen Sie ihr das Tracking.
Fügen Sie diese Funktion oberhalb von main() ein:
</> 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]
);
}
Registrieren Sie den Callback, bevor Sie das SDK initialisieren und starten:
</> 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;
Verwenden Sie auf dem Desktop handle. Verwenden Sie im Android-JNI-Code g_handle.
4. Den Tracking-Stream öffnen. Fügen Sie diesen Aufruf in die Desktop-`main.cpp` ein; stellen Sie ihn unter Android über JNI bereit und rufen Sie ihn nach `start` auf.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Wenn die App beendet wird, schließen Sie die IMU und stoppen, beenden und zerstören dann den Provider. Rufen Sie unter Android dieselben Aufräumfunktionen auf, bevor Sie die USB-Verbindung schließen:
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. Die Ausgabe prüfen. Führen Sie die App aus und suchen Sie in der Desktop-Konsole oder in Logcat von Android Studio nach Verbindungs- und Tracking-Meldungen.
Weiter zu Schritt 5, wenn: BEAST sich verbindet und Tracking-Updates fehlerfrei eintreffen.
Schritt 5: Eine BEAST-Steuerung hinzufügen
Sobald das Tracking funktioniert, fügen Sie im Gerätesteuerungscode Ihrer App eine Brillensteuerung hinzu – nachdem das SDK-Handle gestartet wurde.
1. Eine Steuerung auswählen. Öffnen Sie in den SDK Documents „Device Control“ und prüfen Sie, welche Helligkeits-, Lautstärke- oder Display-Optionen BEAST unterstützt.
2. Den Wert auslesen und setzen. Fügen Sie die C/C++-Aufrufe in Ihren Steuerungscode ein; legen Sie sie unter Android in `glasses_bridge.cpp` ab und stellen Sie sie über JNI bereit.
Lesen Sie nach dem Start des Providers die Helligkeit von BEAST aus und probieren Sie einen unterstützten Wert aus. Der dokumentierte Bereich reicht von 0 bis 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. Die Display-API auf den Modus abstimmen. Sie können auch den Display-Modus von BEAST konfigurieren. Der native Modus nutzt die integrierte Display-Verarbeitung der Brille und unterstützt natives 3DoF. Der Bypass-Modus reicht das Videosignal des Hosts durch die Brille. Wählen Sie den Zweig, der zum gewählten Modus Ihrer App passt. Führen Sie nicht beide Zweige nacheinander aus.
In diesem Beispiel ist use_native_mode eine boolesche Einstellung in Ihrer App und rc die bereits vorhandene Ergebnisvariable.
</> 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;
}
Wählen Sie eine Auflösung und Bildwiederholrate, die BEAST unterstützt.
4. Eine einzelne Änderung testen. Führen Sie die App aus, prüfen Sie das Ergebnis auf BEAST und stellen Sie anschließend die ursprüngliche Einstellung wieder her.
Wichtig: BEAST unterstützt natives 3DoF, die aktuelle Firmware akzeptiert jedoch nur drei Display-Modi: 1920 x 1200 bei 60 Hz und 3D Side-by-Side 3840 x 1200 bei 60 Hz im nativen Modus sowie 3840 x 1200 bei 90 Hz im Bypass-Modus (Release Notes zum VITURE XR Glasses SDK, 2.3.0 und 2.3.1). Andere Konstanten bestehen zwar die Prüfung des SDK, werden von der Brille aber abgelehnt oder ignoriert. Lesen Sie den Modus daher nach dem Setzen zurück und betrachten Sie die Release Notes als maßgebliche Liste der unterstützten Werte.
Schritt 6: Kamerazugriff nur hinzufügen, wenn die App ihn benötigt
Fügen Sie die Passthrough-Kamera nur hinzu, wenn Ihre App Einzelbilder benötigt. Das Kamera-Streaming ist unabhängig vom Head-Tracking und liefert kein 6DoF.
1. Die Kamera-Anleitung öffnen. Wählen Sie in den SDK Documents „Camera Streaming“ und folgen Sie dem Einrichtungsabschnitt für Ihren Host.
2. Einen Frame-Handler hinzufügen. Erstellen Sie in Ihrer App eine Funktion, die Kamerabilder empfängt und an die Funktion weiterleitet, die sie benötigt, etwa eine Vorschau.
Erstellen Sie in Ihrem C++-Kameramodul den Kamera-Provider von BEAST und starten Sie ihn mit Ihrem Frame-Callback `on_frame`. Dieser Aufruf mit zwei Argumenten gilt für den 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);
// Nach Abschluss xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
Übergeben Sie unter Android den USB-Dateideskriptor der Kamera als drittes Argument und nutzen Sie dabei die Berechtigungseinrichtung aus Schritt 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Zuerst die Berechtigung einholen. Android benötigt Kamera- und USB-Berechtigungen; folgen Sie auf dem Desktop der Plattformanleitung.
4. Den Datenschutz wahren. Erläutern Sie die Kameranutzung, erfassen Sie nur, was die Funktion benötigt, und befolgen Sie in der EU den DSGVO-Prozess Ihrer Organisation.
Überspringen Sie diesen Schritt, wenn Ihre App nur Tracking oder Display-Steuerungen benötigt.
Schritt 7: Testen und einen kleinen Pilotbetrieb vorbereiten
1. Erneutes Verbinden testen. Starten Sie die App neu, trennen Sie BEAST und schließen Sie die Brille wieder an, und prüfen Sie, ob die App stabil bleibt.
2. Auf BEAST testen. Prüfen Sie für jede Funktion Display-Modus, Auflösung, Tracking und Kameraberechtigungen im Abgleich mit der Firmware.
3. Testdetails festhalten. Dokumentieren Sie die Versionen von SDK, Betriebssystem, Prozessor, Compiler/NDK und Firmware sowie Verbindungsdetails und Fehler.
4. Den Rollout planen. Legen Sie fest, wie die Host-App installiert und aktualisiert, Kamerazugriff und Daten verwaltet und der Support organisiert werden.
Pilot-Freigabe: Erweitern Sie den Einsatz erst, nachdem Sie Host, Funktionen, Berechtigungen und Update-Prozess getestet haben.
Was das SDK nicht leistet
Das VITURE XR Glasses SDK ist ein Toolkit zur Geräteintegration, keine fertige XR-Authoring-Umgebung. Es stellt Funktionen bereit, die Ihre Software aufrufen kann. Ihr Team wählt weiterhin ein Anwendungs-Framework, schreibt die Benutzeroberfläche und die Aufgabenlogik, baut die App für die Host-Plattform und entscheidet, wie das Unternehmen sie bereitstellt und betreut.
Außerdem stehen nicht alle Funktionen auf jedem VITURE-Modell zur Verfügung. In der aktuellen Hardwaretabelle ist BEAST mit nativem 3DoF und Zugriff auf die Passthrough-Kamera aufgeführt, während Luma Ultra das Modell mit 3/6DoF und Stereo-VIO ist. Prüfen Sie für jede API, die Sie nutzen möchten, die Tabelle der unterstützten Hardware, statt die allgemeine Portalbeschreibung „3DoF/6DoF“ als Zusage zu verstehen, dass BEAST jeden Tracking-Modus unterstützt.
Häufige Fehler bei der Entwicklung mit dem VITURE BEAST SDK
- Das Unity XR SDK für eine App zur Steuerung der BEAST-Brille herunterladen.: Verwenden Sie die Karte des VITURE XR Glasses SDK; die Unity-Anleitung ist für das VITURE Neckband dokumentiert.
- Annehmen, plattformübergreifend bedeute überall dasselbe Binary oder dieselbe Einrichtung.: Laden Sie die richtige Bibliothek herunter und folgen Sie der Architektur- und Verbindungsanleitung der Zielplattform.
- BEAST als 6DoF-VIO-Gerät behandeln, weil das Portal 6DoF erwähnt.: Prüfen Sie die Unterstützung auf Modellebene: Die aktuelle SDK-Tabelle führt für BEAST natives 3DoF und für Luma Ultra 6DoF-VIO auf.
- Standardfunktionen für den Display-Modus aufrufen, während sich BEAST im nativen Modus befindet.: Prüfen Sie den aktiven Modus und verwenden Sie den passenden Funktionssatz – Standard oder `native_*`.
- Die Kamera vor dem Einholen der Berechtigungen oder ohne konkreten Kamera-Anwendungsfall öffnen.: Fordern Sie zuerst die Plattformberechtigungen an und fügen Sie Kamera-Streaming nur hinzu, wenn die App Bilddaten benötigt.
- SpaceWalker als Code-Editor oder App zur SDK-Einrichtung verwenden.: Nutzen Sie die Developer-Seite, das SDK-Paket, die Dokumentation und einen Code-Editor oder Android Studio.
Fazit
Die Entwicklung für VITURE BEAST beginnt mit dem VITURE XR Glasses SDK – nicht mit dem Unity-Paket für Neckband-Anwendungen und nicht mit der Consumer-App SpaceWalker. Wählen Sie Android, Linux, Windows oder macOS als Host, laden Sie das passende SDK von der Developer-Seite von VITURE herunter, folgen Sie der jeweiligen Plattformanleitung und bauen Sie zunächst ein kleines Programm, das sich per USB verbindet und Tracking-Daten ausliest. Fügen Sie anschließend eine unterstützte BEAST-Steuerung oder Kamerafunktion hinzu und testen Sie sie auf der echten Hardware. Für Unternehmen trennt dieses Vorgehen Workflow und Daten der Anwendung von den Gerätefunktionen der Brille, ermöglicht die Entwicklung auf der Host-Plattform, die zum Einsatzszenario passt, und gibt Teams die Möglichkeit, einen klar umrissenen industriellen Anwendungsfall zu validieren, bevor sie in einen breiteren Rollout investieren.
Sie bauen einen XR-Workflow für VITURE BEAST? Sehen Sie sich die Produktseite zu VITURE BEAST und die Entwicklerdokumentation von VITURE an, bevor Sie die Anforderungen für Ihren Pilotbetrieb festlegen.
