Streszczenie
Aby tworzyć oprogramowanie dla VITURE BEAST, otwórz stronę Developer firmy VITURE i wybierz VITURE XR Glasses SDK. To wieloplatformowe SDK w języku C służące do łączenia oprogramowania z okularami VITURE. Jego dokumentacja wymienia systemy Android, Linux, Windows i macOS. Osobne VITURE XR SDK for Unity jest opisane jako przeznaczone do aplikacji działających na VITURE Neckband, więc nie jest punktem wyjścia dla aplikacji sterującej okularami BEAST.
SDK do okularów daje aplikacji dostęp do komunikacji z urządzeniem, danych śledzenia ruchów głowy, strumieniowania obrazu z kamery i wybranych funkcji sterowania okularami. W przypadku BEAST VITURE dokumentuje natywne śledzenie 3DoF, podgląd z kamery (passthrough) oraz natywne sterowanie wyświetlaniem. SDK nie zmienia okularów w komputer ogólnego przeznaczenia ani nie tworzy automatycznie gotowej aplikacji XR. Budujesz aplikację hosta, podłączasz BEAST przez USB i wywołujesz SDK z poziomu tej aplikacji.
Przebieg prac: Wybierz platformę hosta -> pobierz odpowiedni pakiet SDK -> zbuduj pierwszy przykład połączenia przygotowany przez producenta -> odczytaj dane śledzenia -> dodaj funkcję sterowania BEAST lub obsługę kamery -> przetestuj aplikację z okularami.
Aby poznać kontekst produktu przed zaplanowaniem integracji oprogramowania, zapoznaj się z recenzją VITURE BEAST na VRX. Przydatna w kwestii szczegółów sprzętowych jest także oficjalna strona produktu VITURE.
WPROWADZENIE:
(jeśli znasz już SDK i obsługiwane platformy, przejdź do głównych wskazówek)
Czym jest VITURE BEAST?
VITURE BEAST to wyświetlacz XR podłączany przez USB-C, z wbudowanymi czujnikami i kamerą. W trybie natywnym śledzenie 3DoF i obsługiwane efekty wyświetlania realizuje własna jednostka przetwarzająca okularów; w trybie bypass host wysyła sygnał wideo, który okulary przekazują dalej. To rozróżnienie między trybem natywnym a bypass ma znaczenie, gdy oprogramowanie zmienia tryb wyświetlania lub sposób śledzenia.
SDK dla deweloperów to oprogramowanie, z którym łączy się Twój program, aby komunikować się z okularami. Jest ono niezależne od codziennych aplikacji VITURE, takich jak SpaceWalker, która służy do korzystania z obsługiwanych funkcji wyświetlania i ekranów przestrzennych, a nie do pisania kodu.
Dwa SDK VITURE służą do różnych zadań
VITURE XR Glasses SDK:
- Do czego służy: Natywne API w C zapewniające dostęp do okularów, śledzenie, strumieniowanie z kamery i sterowanie urządzeniem na obsługiwanych platformach hosta.
- Czy używać go do programowania dla BEAST?: Tak. To SDK dla BEAST, któremu poświęcony jest ten przewodnik.
VITURE XR SDK for Unity:
- Do czego służy: Pakiet Unity XR udokumentowany jako narzędzie do tworzenia immersyjnych doświadczeń na VITURE Neckband, z integracjami Unity, takimi jak śledzenie dłoni.
- Czy używać go do programowania dla BEAST?: Nie jako domyślnego SDK do okularów BEAST. Nie myl go z natywnym SDK do okularów.
SpaceWalker:
- Do czego służy: Oprogramowanie towarzyszące VITURE do obsługiwanych trybów wyświetlania i funkcji ekranów przestrzennych.
- Czy używać go do programowania dla BEAST?: Nie. To aplikacja dla użytkowników końcowych, a nie środowisko programistyczne.
Czym steruje XR Glasses SDK
Połączenie z urządzeniem:
- Co może zrobić aplikacja: Wykryć podłączone urządzenie, utworzyć uchwyt urządzenia, zainicjować je, uruchomić i poprawnie zamknąć.
- O czym pamiętać w przypadku BEAST: SDK komunikuje się z okularami poprzez połączenie z hostem.
Śledzenie ruchów głowy:
- Co może zrobić aplikacja: Odczytywać dane orientacji/IMU i korzystać z interfejsu śledzenia właściwego dla danego modelu.
- O czym pamiętać w przypadku BEAST: BEAST jest udokumentowany z natywnym 3DoF; pozycja 6DoF VIO w tabeli urządzeń dotyczy Luma Ultra.
Wyświetlanie i sterowanie okularami:
- Co może zrobić aplikacja: Odczytywać lub ustawiać obsługiwane wartości jasności, głośności, trybu wyświetlania, trybu 2D/3D, przyciemnienia oraz opcje trybu natywnego.
- O czym pamiętać w przypadku BEAST: W trybie natywnym używaj stałych wyświetlania natywnego przeznaczonych dla BEAST. Niektóre kombinacje trybu i częstotliwości odświeżania nie są obsługiwane.
Strumień z kamery:
- Co może zrobić aplikacja: Uzyskiwać dostęp do obsługiwanych klatek z kamery passthrough za pośrednictwem API kamery w SDK.
- O czym pamiętać w przypadku BEAST: BEAST figuruje na liście z kamerą passthrough UVC. Dostęp do kamery jest niezależny od śledzenia 6DoF.
Samo SDK nie zapewnia: przepływu pracy Twojej aplikacji, logiki biznesowej, menu, przechowywania danych, kont użytkowników ani kompletnej sceny Unity. Te elementy buduje zespół odpowiedzialny za aplikację wokół funkcji urządzenia udostępnianych przez SDK. Główna strona dla deweloperów eksponuje te cztery platformy. Od wersji SDK 2.4.0 (6 sierpnia 2026 r.) dokumentacja wymienia piąty cel: Browser, czyli kompilację WebAssembly z API w TypeScript, która łączy się z okularami przez WebHID, wyłącznie w Chrome i Chromium, z obsługą BEAST i bez obsługi Luma Ultra. Przed wyborem urządzenia lub systemu operacyjnego do zastosowań produkcyjnych sprawdź aktualny pakiet i informacje o wydaniu.
Obsługa wielu platform: Android, Linux, Windows i macOS
„Wieloplatformowość” oznacza, że VITURE udostępnia kompilacje SDK i instrukcje konfiguracji dla poszczególnych platform w ramach tego samego SDK do okularów. Nie oznacza, że jeden plik binarny działa wszędzie bez zmian. Wybierz hosta, na którym ma działać Twoja aplikacja, a następnie użyj odpowiadającej mu biblioteki i przewodnika integracji. Aktualna dokumentacja API wymienia następujące architektury:
Windows:
- Udokumentowana architektura: x86_64
- Typowa ścieżka konfiguracji: Aplikacja desktopowa w C/C++ korzystająca z biblioteki i plików nagłówkowych SDK dla Windows; postępuj zgodnie z Quick Start: Desktop (C++).
Linux:
- Udokumentowana architektura: x86_64 i aarch64
- Typowa ścieżka konfiguracji: Aplikacja desktopowa w C/C++. Dodaj regułę udev od VITURE, aby aplikacja miała dostęp do interfejsu USB/HID bez uruchamiania z uprawnieniami roota.
macOS:
- Udokumentowana architektura: aarch64 (Apple silicon)
- Typowa ścieżka konfiguracji: Aplikacja desktopowa w C/C++ korzystająca z biblioteki i plików nagłówkowych dla macOS; postępuj zgodnie z Quick Start: Desktop (C++).
Android:
- Udokumentowana architektura: armeabi-v7a i arm64-v8a
- Typowa ścieżka konfiguracji: Aplikacja na Androida korzystająca z natywnej biblioteki C przez JNI; obsługę uprawnień USB i połączenia zapewnij w aplikacji na Androida.
Główna strona dla deweloperów eksponuje te cztery platformy. Szczegółowa strona API może z czasem dodawać nowe cele lub zmieniać obsługiwane architektury, dlatego przed wyborem urządzenia lub systemu operacyjnego do zastosowań produkcyjnych sprawdź aktualny pakiet i informacje o wydaniu.
Czego potrzebujesz przed rozpoczęciem prac
· Okulary VITURE BEAST i połączenie danych USB-C z komputerem lub hostem z Androidem, który zamierzasz obsługiwać.
· Komputer deweloperski z kompilatorem i narzędziami do budowania dla docelowej platformy: zestawem narzędzi C/C++ i CMake w przypadku desktopu lub Android Studio z komponentami NDK i CMake w przypadku Androida.
· Pakiet VITURE XR Glasses SDK dla docelowej platformy, pobrany ze strony Developer firmy VITURE.
· Odpowiednia dokumentacja SDK, zwłaszcza sekcje Core Concepts, Quick Start: Desktop (C++), Android Integration Guide, Head Tracking, Device Control, Camera Streaming i Native-DOF Devices.
· Podstawowa znajomość języka używanego przez zespół tworzący aplikację: C/C++ w przypadku przykładów desktopowych oraz Kotlin lub Java i JNI w przypadku typowej integracji z Androidem.
Jak zbudować pierwszy test VITURE BEAST SDK
Zacznij od małej aplikacji hosta, która wykrywa BEAST i odczytuje dane śledzenia. Gdy to zadziała, dodaj jedną funkcję sterowania lub obsługę kamery.
Krok 1: Wybierz, gdzie będzie działać aplikacja
Wybierz komputer lub telefon, na którym będzie działać aplikacja; od tego zależy pakiet SDK i przewodnik konfiguracji.
1. Wybierz hosta. Użyj systemu Windows, Linux lub macOS w przypadku komputera albo Androida w przypadku telefonu podłączonego do BEAST.
2. Zanotuj system operacyjny i procesor. Zapisz na przykład Windows x86_64 lub macOS Apple silicon, a następnie sprawdź powyższą tabelę platform.
3. Ścieżki dla Androida używaj wyłącznie w przypadku aplikacji na Androida. Wykorzystuje ona natywną bibliotekę, mostek JNI i uprawnienia USB.
Krok 2: Pobierz VITURE XR Glasses SDK
Pobierz oficjalne SDK do okularów i otwórz przewodnik dla swojego hosta. Pakiet Unity dla Neckband jest przeznaczony do innej konfiguracji.
1. Otwórz stronę Developer. W przeglądarce przejdź pod adres https://www.viture.com/developer i przewiń do sekcji „VITURE XR Glasses SDK”.
2. Pobierz pakiet dla swojej platformy. Na karcie SDK kliknij „Download” i w razie potrzeby wybierz swojego hosta.
3. Otwórz przewodnik konfiguracji. Na tej samej karcie kliknij „Documents”, następnie „Core Concepts”, a potem „Quick Start: Desktop (C++)” lub „Android Integration Guide”.
4. Sprawdź zgodność. Wróć na stronę Developer, otwórz „Release Notes” i sprawdź swój system operacyjny, procesor oraz oprogramowanie układowe BEAST.
Przejdź do kroku 3, gdy: masz odpowiednią bibliotekę, pliki nagłówkowe i przewodnik konfiguracji.
Krok 3: Skonfiguruj SDK na platformie hosta
Korzystaj wyłącznie ze ścieżki konfiguracji dla hosta wybranego w kroku 1.
Dla systemów Windows, Linux i macOS
1. Otwórz przewodnik dla desktopu. W SDK Documents wybierz „Quick Start: Desktop (C++)” i miej go pod ręką obok edytora kodu.
2. Zlinkuj SDK. Otwórz przykład lub swój projekt, a następnie skorzystaj z przykładu CMake z przewodnika, aby dodać pliki nagłówkowe SDK i bibliotekę okularów.
W pliku `CMakeLists.txt` swojego projektu dodaj ścieżki include i bibliotek SDK. Zastąp `VITURE_SDK_ROOT` folderem, w którym rozpakowano 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. Tylko Linux: zezwól na dostęp do USB. W Terminalu postępuj zgodnie z sekcją „Linux udev Rule” i utwórz plik `/etc/udev/rules.d/70-viture.rules`; przeładuj reguły i ponownie podłącz BEAST. W systemach Windows i macOS pomiń ten krok.
4. Zbuduj przykład. Otwórz plik `main.cpp` z przykładu SDK i upewnij się, że się kompiluje, zanim dodasz kolejne funkcje.
Dla Androida
1. Utwórz projekt na Androida. W Android Studio utwórz projekt z obsługą CMake/NDK i otwórz `app/src/main` w panelu projektu.
2. Skopiuj pliki SDK. Postępuj zgodnie z „Android Integration Guide”: umieść pliki nagłówkowe w `app/src/main/include/`, a odpowiedni plik `.so` w `app/src/main/jniLibs/<ABI>/`.
3. Zlinkuj bibliotekę. W Android Studio otwórz `app/src/main/cpp/CMakeLists.txt` i `app/build.gradle.kts`; zastosuj ustawienia CMake, NDK i ABI z przewodnika.
W `CMakeLists.txt` zaimportuj bibliotekę SDK i zlinkuj ją z mostkiem JNI. Ten przykład zakłada, że pliki SDK znajdują się w folderach wskazanych w 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. Dodaj mostek między aplikacją a C++. W folderze źródłowym aplikacji utwórz klasę `GlassesBridge` z przewodnika; jej funkcje `external` wywołują Twój kod JNI.
5. Poproś o uprawnienia USB. Użyj klasy `UsbManager` Androida, aby znaleźć BEAST; gdy użytkownik stuknie „Zezwól”, otwórz połączenie USB i przekaż jego deskryptor pliku do mostka.
Gdy użytkownik stuknie „Zezwól”, otwórz połączenie USB w aktywności Kotlin i przekaż jego deskryptor pliku do natywnego mostka. Zastąp `GlassesBridge` nazwą klasy mostka w swoim projekcie:
val connection = usbManager.openDevice(device) ?: return val ok = GlassesBridge.create(device.productId, connection.fileDescriptor)
W `glasses_bridge.cpp` natywna funkcja create przekazuje ten deskryptor pliku Androida do SDK 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; }
Przejdź do kroku 4, gdy: aplikacja się kompiluje i ładuje SDK bez błędu brakującego pliku ani błędu linkera.
Krok 4: Podłącz BEAST i uruchom pierwszy przykład
Teraz przetestuj połączenie z okularami. W systemach Windows, Linux i macOS użyj przykładu desktopowego. Na Androidzie zachowaj konfigurację USB i JNI z kroku 3; nie używaj desktopowego kodu wykrywania HID.
1. Podłącz BEAST. Użyj kabla USB-C do transmisji danych; na Androidzie zaakceptuj monit USB wyświetlony w telefonie.
2. Znajdź BEAST i utwórz jego uchwyt. Na desktopie znajdź identyfikator produktu BEAST za pomocą wykrywania HID, a następnie utwórz dostawcę za pomocą xr_device_provider_create(product_id). Na Androidzie przekaż zarówno identyfikator produktu, jak i deskryptor pliku z połączenia USB.
3. Uruchom śledzenie. Śledzenie uruchamia się przez zarejestrowanie wywołania zwrotnego (callbacku). Callback to funkcja, którą SDK wywołuje, gdy nadejdą dane śledzenia. BEAST dostarcza przechylenie, pochylenie i odchylenie (roll, pitch, yaw) w data[0] do data[2], a kwaternion w data[3] do data[6], ale tylko w SDK 2.4.0 lub nowszym i przy zaktualizowanym oprogramowaniu układowym okularów. Przy starszym oprogramowaniu układowym callback pozycji nigdy nie jest wywoływany na BEAST (VITURE wymienia to w sekcji „Known Limitations on Beast” w informacjach o wydaniu): wówczas albo zarejestruj xr_device_provider_register_imu_raw_callback i samodzielnie integruj surowe dane IMU, albo przełącz okulary w tryb natywny i pozwól im realizować śledzenie.
Dodaj tę funkcję nad 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]
);
}
Zarejestruj callback przed zainicjowaniem i uruchomieniem 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;
Na desktopie użyj handle. W kodzie JNI na Androidzie użyj g_handle.
4. Otwórz strumień śledzenia. Dodaj to wywołanie do desktopowego `main.cpp`; na Androidzie udostępnij je przez JNI i wywołaj po `start`.
rc = xr_device_provider_open_imu( handle, VITURE_IMU_MODE_POSE, VITURE_IMU_FREQUENCY_HIGH); if (rc != VITURE_GLASSES_SUCCESS) return rc;
Przy zamykaniu aplikacji zamknij IMU, a następnie zatrzymaj, wyłącz i zniszcz dostawcę. Na Androidzie wywołaj te same funkcje porządkujące przed zamknięciem połączenia 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. Sprawdź wynik. Uruchom aplikację i poszukaj w konsoli na desktopie lub w Logcat w Android Studio komunikatów o połączeniu i aktualizacji śledzenia.
Przejdź do kroku 5, gdy: BEAST się łączy, a aktualizacje śledzenia napływają bez błędów.
Krok 5: Dodaj jedną funkcję sterowania BEAST
Gdy śledzenie działa, dodaj jedną funkcję sterowania okularami w kodzie aplikacji odpowiedzialnym za sterowanie urządzeniem, po uruchomieniu uchwytu SDK.
1. Wybierz funkcję sterowania. W SDK Documents otwórz „Device Control” i sprawdź obsługiwane przez BEAST opcje jasności, głośności lub wyświetlania.
2. Odczytaj i ustaw jej wartość. Dodaj wywołania C/C++ do kodu sterowania; na Androidzie umieść je w `glasses_bridge.cpp` i udostępnij przez JNI.
Po uruchomieniu dostawcy odczytaj jasność BEAST i wypróbuj obsługiwaną wartość. Udokumentowany zakres to od 0 do 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. Dopasuj API wyświetlania do trybu. Możesz też skonfigurować tryb wyświetlania BEAST. Tryb natywny wykorzystuje wbudowane przetwarzanie obrazu w okularach i obsługuje natywne 3DoF. Tryb bypass przekazuje sygnał wideo z hosta przez okulary. Wybierz gałąź odpowiadającą trybowi wybranemu w aplikacji. Nie uruchamiaj obu gałęzi jedna po drugiej.
W tym przykładzie use_native_mode to ustawienie logiczne (Boolean) w aplikacji, a rc to istniejąca zmienna wyniku.
</> 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;
}
Wybierz rozdzielczość i częstotliwość odświeżania obsługiwane przez BEAST.
4. Przetestuj jedną zmianę. Uruchom aplikację, sprawdź efekt na BEAST, a następnie przywróć pierwotne ustawienie.
Ważne: BEAST obsługuje natywne 3DoF, ale obecne oprogramowanie układowe akceptuje tylko trzy tryby wyświetlania: 1920 x 1200 przy 60 Hz oraz 3D side-by-side 3840 x 1200 przy 60 Hz w trybie natywnym, a także 3840 x 1200 przy 90 Hz w trybie bypass (informacje o wydaniu VITURE XR Glasses SDK, wersje 2.3.0 i 2.3.1). Inne stałe przechodzą weryfikację SDK, ale okulary je odrzucają lub ignorują, dlatego po ustawieniu trybu odczytaj go ponownie, a informacje o wydaniu traktuj jako listę obsługiwanych wartości.
Krok 6: Dodaj dostęp do kamery tylko wtedy, gdy aplikacja go potrzebuje
Dodaj kamerę passthrough tylko wtedy, gdy aplikacja potrzebuje klatek obrazu. Strumieniowanie z kamery jest niezależne od śledzenia ruchów głowy i nie zapewnia 6DoF.
1. Otwórz przewodnik dotyczący kamery. W SDK Documents wybierz „Camera Streaming” i postępuj zgodnie z sekcją konfiguracji dla swojego hosta.
2. Dodaj obsługę klatek. W aplikacji utwórz funkcję, która odbiera klatki z kamery i przesyła je do funkcji, która ich potrzebuje, np. podglądu.
W module kamery w C++ utwórz dostawcę kamery BEAST i uruchom go z callbackiem klatek `on_frame`. To wywołanie z dwoma argumentami dotyczy desktopu:
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);
// Po zakończeniu xr_camera_provider_stop(camera); xr_camera_provider_destroy(camera);
Na Androidzie przekaż deskryptor pliku USB kamery jako trzeci argument, korzystając z konfiguracji uprawnień z kroku 3:
XRCameraProviderHandle camera = xr_camera_provider_create(camera_vid, camera_pid, camera_fd);
3. Najpierw uzyskaj uprawnienia. Android wymaga uprawnień do kamery i USB; na desktopie postępuj zgodnie z przewodnikiem dla danej platformy.
4. Chroń prywatność. Wyjaśnij, w jakim celu używana jest kamera, rejestruj tylko to, czego potrzebuje dana funkcja, a w UE stosuj procedurę RODO obowiązującą w Twojej organizacji.
Pomiń ten krok, jeśli aplikacja potrzebuje jedynie śledzenia lub sterowania wyświetlaniem.
Krok 7: Przetestuj i przygotuj mały pilotaż
1. Przetestuj ponowne łączenie. Uruchom ponownie aplikację, odłącz i ponownie podłącz BEAST, a następnie sprawdź, czy aplikacja działa stabilnie.
2. Przetestuj na BEAST. Sprawdź tryb wyświetlania, rozdzielczość, śledzenie i uprawnienia do kamery dla każdej funkcji pod kątem zgodności z oprogramowaniem układowym.
3. Zapisz szczegóły testów. Zanotuj wersje SDK, systemu operacyjnego, procesora, kompilatora/NDK i oprogramowania układowego, szczegóły połączenia oraz błędy.
4. Zaplanuj wdrożenie. Zdecyduj, jak instalować i aktualizować aplikację hosta, zarządzać dostępem do kamery i danymi oraz zapewniać wsparcie.
Warunek pilotażu: rozszerzaj wdrożenie dopiero po przetestowaniu hosta, funkcji, uprawnień i procesu aktualizacji.
Czego SDK nie robi
VITURE XR Glasses SDK to zestaw narzędzi do integracji z urządzeniem, a nie gotowe środowisko do tworzenia treści XR. Udostępnia funkcje, które może wywoływać Twoje oprogramowanie. Twój zespół nadal wybiera framework aplikacji, pisze interfejs użytkownika i logikę zadań, buduje aplikację dla platformy hosta oraz decyduje, jak firma będzie ją wdrażać i wspierać.
SDK nie sprawia też, że każda funkcja jest dostępna w każdym modelu VITURE. W aktualnej tabeli sprzętu BEAST figuruje z natywnym 3DoF i dostępem do kamery passthrough, natomiast Luma Ultra to model wymieniony z 3/6DoF i stereo VIO. Sprawdzaj tabelę obsługiwanego sprzętu dla każdego API, którego zamierzasz używać, zamiast traktować ogólny opis „3DoF/6DoF” w portalu jako obietnicę, że BEAST obsługuje każdy tryb śledzenia.
Typowe błędy przy tworzeniu oprogramowania z VITURE BEAST SDK
- Pobieranie Unity XR SDK do aplikacji sterującej okularami BEAST.: Użyj karty VITURE XR Glasses SDK; przewodnik Unity jest udokumentowany dla VITURE Neckband.
- Zakładanie, że wieloplatformowość oznacza ten sam plik binarny lub tę samą konfigurację wszędzie.: Pobierz właściwą bibliotekę i postępuj zgodnie z przewodnikiem dotyczącym architektury i połączenia dla platformy docelowej.
- Traktowanie BEAST jako urządzenia 6DoF VIO, bo portal wspomina o 6DoF.: Sprawdź obsługę na poziomie modelu: aktualna tabela SDK podaje dla BEAST natywne 3DoF, a 6DoF VIO dla Luma Ultra.
- Wywoływanie standardowych funkcji trybu wyświetlania, gdy BEAST jest w trybie natywnym.: Sprawdź aktywny tryb i użyj odpowiedniego zestawu funkcji: standardowego lub `native_*`.
- Otwieranie kamery przed uzyskaniem uprawnień lub bez potrzeby jej użycia.: Najpierw poproś o uprawnienia platformy i dodawaj strumieniowanie z kamery tylko wtedy, gdy aplikacja potrzebuje danych obrazu.
- Używanie SpaceWalker jako edytora kodu lub aplikacji do konfiguracji SDK.: Korzystaj ze strony Developer, pakietu SDK, dokumentacji oraz edytora kodu lub Android Studio.
Podsumowanie
Tworzenie oprogramowania dla VITURE BEAST zaczyna się od VITURE XR Glasses SDK, a nie od pakietu Unity do doświadczeń na Neckband ani od konsumenckiej aplikacji SpaceWalker. Wybierz Androida, Linuksa, Windows lub macOS jako hosta, pobierz odpowiednie SDK ze strony Developer firmy VITURE, postępuj zgodnie z przewodnikiem dla danej platformy i najpierw zbuduj mały program, który łączy się przez USB i odczytuje dane śledzenia. Następnie dodaj obsługiwaną funkcję sterowania BEAST lub kamery i przetestuj ją na rzeczywistym sprzęcie. W przypadku firm takie podejście oddziela przepływ pracy i dane aplikacji od funkcji urządzenia zapewnianych przez okulary, umożliwia tworzenie oprogramowania na platformie hosta dopasowanej do wdrożenia i daje zespołom sposób na zweryfikowanie konkretnego zastosowania przemysłowego przed zainwestowaniem w szersze wdrożenie.
Tworzysz przepływ pracy XR dla VITURE BEAST? Zanim określisz wymagania pilotażu, zapoznaj się ze stroną produktu VITURE BEAST oraz dokumentacją dla deweloperów VITURE.
