Programowanie mobilnych aplikacji VR w środowisku Windows

Autorzy: Dawid Borycki

06.03.2017
Smartfony, nawet te ze średniej półki cenowej, już od jakiegoś czasu pozwalają na wykorzystanie ich jako urządzeń do wirtualnej rzeczywistości (ang. Virtual Reality, VR). Moc obliczeniowa, pamięć i jakość wyświetlacza umożliwiają użycie ich jako ekranu w goglach VR. Na rynku dostępna jest cała gama gogli gotowych do integracji z najpopularniejszymi modelami telefonów, począwszy od Google Cardboard już za kilkanaście złotych. Wirtualna rzeczywistość to aktualnie jeden z kluczowych trendów technologicznych, który otwiera szerokie możliwości nowych zastosowań smartfonów. Co więcej, to trend, który tworzy nowy rynek aplikacji mobilnych VR niewymagających kosztownego hardware'u. W tym artykule znajdziesz parę elementarnych zasad tworzenia mobilnych aplikacji VR w środowisku Windows z wykorzystaniem technologii Unity 3D oraz ALPS VR SDK.

Wprowadzenie ( nie tylko dla geeków ;)

Być może niektórzy z Was pamiętają komputer Commodore 64 ;) Wyposażony był w 64 kB pamięci operacyjnej RAM i 8-bitowy procesor o częstotliwości taktowania 1 MHz. Porównując te wartości do parametrów dzisiejszych smartfonów, aż trudno uwierzyć, że popularny C64 był produkowany i sprzedawany w praktycznie niezmienionej konfiguracji przez dwanaście lat! Być może rosnąca popularność mobilnego VR będzie rewolucją na miarę popularności C64? Aktualnie wielordzeniowe 64-bitowe procesory o częstotliwości taktowania większej o trzy rzędy wielkości niż ten z C64 oraz pamięci operacyjne większe 100-krotnie, stanowiące podstawowe podzespoły smartfonów, zadecydują o dynamicznym rozwoju mobilnych urządzeń do rzeczywistości wirtualnej.

Wirtualna rzeczywistość w swoim modelu pojawiła się już w latach 80' XX wieku. Definicja VR mówi, że to realistyczna i wciągająca trójwymiarowa symulacja środowiska, tworzona przy użyciu interaktywnego oprogramowania i sprzętu i kontrolowana przez ruchy ciała. W praktyce, VR symuluje poczucie obecności w wirtualnym, alternatywnym świecie. Nowoczesny smartfon w połączeniu z prostymi goglami VR tworzy mobilny i funkcjonalny system wirtualnej rzeczywistości. Nie bez znaczenia jest także rosnąca popularność bezprzewodowych kontrolerów ruchu, którą łączą się z odpowiednią aplikacją przez Bluetooth. Ekran smartfonasmartfonu to w zasadzie najważniejszy element VR. Wyświetla on dwa dwuwymiarowe obrazy (stereopary) dla każdego oka osobno. Są one następnie automatycznie rekonstruowane przez ludzki mózg, prowadząc w efekcie do wytworzenia poczucia głębi i przestrzeni.

Obrazy są generowane i wyświetlane w oparciu o układ graficzny urządzenia mobilnego, a gogle VR oddzielają obrazy przeznaczone dla lewego i prawego oka. Natomiast całą resztę, czyli przetwarzanie zarejestrowanej przez oczy (dokładniej mówiąc przez siatkówkę) informacji, realizują odpowiednie obszary ludzkiego mózgu. Mózg samodzielnie rekonstruuje trójwymiarową scenę na podstawie znanych przez niego odległości pomiędzy gałkami ocznymi. Najprościej zrozumieć to zjawisko, koncentrując swój wzrok na odpowiednio oddalonym małym obiekcie. Kiedy spojrzysz na długopis trzymany blisko twarzy, zauważysz efekt paralaksy. Patrząc na przemian raz jednym, raz drugim okiem, odniesiesz wrażenie, że długopis jest odrobinę przesunięty w zależności od tego, które oko jest aktualnie otwarte. Jest to tak zwany efekt paralaksy – odległości pomiędzy lewym i prawym okiem a obiektem są różne. W kontekście optyki geometrycznej efekt ten wynika z różnic kątowych pomiędzy promieniami świetlnymi, odbijanymi od obiektu, a następnie docierającymi do lewego i prawego oka. W tym miejscu warto wspomnieć, że proste zabawki wykorzystujące ten efekt są nawet dołączane do zestawów Happy Meal w restauracjach McDonalds.

VR samo w sobie nie jest wynalazkiem dwudziestego pierwszego wieku. Pod koniec poprzedniego stulecia firma Nintendo zaprezentowała konsolę Virtual Boy. Chociaż nie odniosła ona wówczas rynkowego sukcesu, głównie z powodów ograniczeń technologicznych, to wizualnie stanowi ona prekursora dzisiejszych zestawów VR. Jednym z kluczowych momentów w rozwoju VR było przejęcie firmy Oculus VR przez Facebook w 2014 za niebagatelną kwotę 2 miliardów dolarów. Niedługo potem pojawiły się urządzenia HTC Vive, Playstation VR, a obecnie najwięksi gracze w branży technologicznej inwestują bardzo duże środki w startupy związane z VR. Osobiście z niecierpliwością czekam na pierwsze prezentacje projektu Magic Leap, doinwestowanego w roku 2016 kwotą około 790 milionów dolarów m.in. przez Google i Qualcomm. Projekt Magic Leap, podobnie jak Microsoft HoloLens, wychodzi poza rzeczywistość wirtualną i realizuje bardziej zaawansowane techniki rzeczywistości rozszerzonej, w której trójwymiarowe obrazy są bezpośrednio nakładane na rzeczywistych obiektach. Podobnie jak w przypadku dwuwymiarowych obrazów, generowanych przez Google Glass.

VR na skróty

Myślę, że to wystarczy, żeby dostrzec potencjał VR i zainteresować się na poważnie programowaniem aplikacji VR dla urządzeń mobilnych. Jest to stosunkowo najszybsza i niezbyt kosztowna droga do programowania systemów VR. Poniżej przeczytasz o tym, w jaki sposób można wykorzystać do tego celu gotowe narzędzia programistyczne, dostępne dla platformy Windows. Te narzędzia to: środowisko Visual Studio 2015 Community oraz silnik do trójwymiarowego środowiska Unity. Jest on bardzo często wykorzystywany do tworzenia gier komputerowych. ALPS SDK stanowi rozszerzający pakiet Unity do programowania pod VR. Jeśli ciekawi Cię temat tworzenia gier i co za tym idzie, również i aplikacji VR w Unity 3D, polecam serię artykułów Marka Sawerwaina [3]. W tym artykule skupiam się na poszczególnych etapach konfiguracji środowiska developerskiego, opisania procedury tworzenia prostego układu stereoskopowego w Unity oraz zaprezentowania podstawowych elementów ALPS SDK. Na warsztat wezmę prostą mobilną aplikację VR dla uniwersalnej platformy Windows (UWP). Jednak będzie ją można łatwo rozszerzyć o bardziej zaawansowane elementy, jak to pokazano w [3]. Sam proces tworzenia sceny i pisania skryptów gry nie ulega zasadniczej zmianie.

Środowisko pracy

Środowisko pracy do tworzenia aplikacji VR na platformie Windows składa się z dwóch elementów: Visual Studio oraz Unity 3D. Ten pierwszy stanowi edytor kodu źródłowego C#, natomiast drugi służy do tworzenia scen, obiektów 3D, tworzenia fizycznych interakcji pomiędzy obiektami 3D etc. Mówiąc krótko, w Unity tworzy się UI/UX aplikacji, natomiast w Visual Studio edytuje skrypty C#, implementujące logikę gry/aplikacji. Instalacja Visual Studio, jak również i Unity przebiega automatycznie. W tym artykule wykorzystam Windows 10 Anniversary Edition, Visual Studio 2015 Community oraz najnowszą stabilną wersję Unity 3D 5.42f2 Personal. Można ją pobrać za darmo spod adresu: https://unity3d.com/get-unity/update. Dodatkowo konieczne jest zainstalowanie pakietu Unity Metro Support for Editor-5.4.2f2, aby móc przygotować projekt Visual Studio dla aplikacji UWP.

Tworzenie projektu i przygotowanie sceny

Po przygotowaniu środowiska programistycznego można przystąpić do utworzenia projektu aplikacji oraz trójwymiarowej sceny. W tym celu, po uruchomieniu Unity 3D wystarczy utworzyć nowy projekt o nazwie MobileVR (zob. Rysunek 1). Spowoduje to uaktywnienie edytora Unity (Rysunek 2), w którym możemy zaprojektować trójwymiarową scenę oraz utworzyć dwie przesunięte względem siebie kamery. Będą one symulowały parę oczu.

Rysunek 1. Tworzenie projektu aplikacji 3D w Unity

Rysunek 2. Edytor Unity



Edytor Unity w układzie „2 by 3”, który ustaliłem z wykorzystaniem listy rozwijanej Layout (prawy, górny róg edytora), składa się z pięciu elementów: widoku projektowania sceny i podglądu kamery (lewa strona), hierarchii scen i struktury projektu (środek edytora) oraz inspektora właściwości.

Na początek uzupełniam scenę o płaszczyznę, na której umieszczam kolejne elementy. Aby dodać płaszczyznę do sceny, wystarczy z listy rozwijanej Create, w oknie Hierarchy (zob. Rysunek 2), wybrać opcję 3D Object->Plane (Rysunek 3). Spowoduje to uzupełnienie hierarchii sceny o obiekt Plane. Zwiększam teraz tę płaszczyznę. W tym celu klikam pozycję Plane, a następnie w oknie inspektora przechodzę do grupy Transform, gdzie zmieniam wszystkie składowe X, Y oraz Z skali z 1 na 10 (zob. Rysunek 4). Spowoduje to dziesięciokrotne powiększenie sceny wzdłuż wszystkich osi współrzędnych.

Rysunek 3. Tworzenie płaszczyzny

Rysunek 4. Skalowanie obiektu



Tworzę teraz materiał płaszczyzny. Materiał definiuje właściwości optyczne obiektu 3D, między innymi jego kolor. Aby utworzyć materiał i powiązać go z wybranym elementem sceny, można postąpić następująco: z menu Assets wybieramy opcję Create/Material. Nastąpi wówczas uzupełnienie folderu Assets projektu (zob. dolna część edytora Unity z Rysunku 2) o obiekt New Material. W kolejnym kroku wystarczy kliknąć ten obiekt, a następnie w oknie inspektora kliknąć prostokąt po prawej stronie opcji Albedo. Uruchomi to okno modalne Color, umożliwiające zdefiniowanie barwy. Ja będę korzystał z koloru o następujących składowych RGBA: 0, 0, 64, 255.

Aby teraz powiązać utworzony materiał z płaszczyzną, wystarczy kliknąć materiał i przenieść go na obiekt Plane (w hierarchii sceny). W efekcie nastąpi aktualizacja wyglądu płaszczyzny.

W analogiczny sposób konstruujemy jeszcze cztery obiekty: Capsule, 3D Text, Tree oraz Sphere. Konfigurujemy właściwości tych obiektów następująco:
  • Z wykorzystaniem grupy Transform (opcja Position) aktualizujemy składowe określające pozycję obiektu 3D Text na X: 2, Y: 1, Z: 0. Przechodzimy do grupy Text Mesh, gdzie w polu Text wpisujemy dowolny napis, np. Programista, a za pomocą pola Color definiujemy dowolną barwę; 
  • W podobny sposób zmieniamy pozycję obiektu Tree na X: -1.5, Y: 0, Z: -3, a składową Y skali na 0.25; 
  • Na końcu zmieniamy położenie kapsuły na X: 0, Y: 1, Z:0, a sfery na X: -3, Y: 0.5, Z: 0. 
Mamy już przygotowaną prostą scenę. Możemy oczywiście w dowolny sposób ją zmodyfikować i uzupełnić poszczególne obiekty o materiały lub tekstury czy też zastąpić płaszczyznę terenem zgodnie z opisem ze wspomnianych artykułów o Unity 3D [3]. Jednak do zaimplementowania aspektów dotyczących VR ta prosta scena nam w zupełności wystarczy.

Stereoskopia

W poprzednim rozdziale nie utworzyliśmy jeszcze niczego, co byłoby ściśle związane z VR. Aby to zrobić, potrzebujemy dodatkowej kamery, wbudowanej kamery VR Unity 3D lub odpowiedniego SDK. Najpierw chciałbym pokazać, jak samodzielnie utworzyć i skonfigurować dodatkową kamerę, aby utworzyć własny układ stereoskopowy. Wynika to z faktu, że jak pokażę w dalszej części artykułu, gotowe SDK dla VR implementują również śledzenie ruchów głowy. Ma to na celu automatyczną aktualizację położenia obiektów w scenie (formalnie projekcji sceny) w taki sposób, aby użytkownik miał wrażenie poruszania się „w wirtualnym świecie”.

Ja, na potrzeby tego artykułu, korzystam z emulatora urządzenia z systemem Windows 10, w którym nie ma możliwości emulacji żyroskopu. A to właśnie ten sensor dostarcza informacji o przyspieszeniu kątowym urządzenia. Jednak emulator pozwala symulować odczyty z akcelerometru (przyspieszenie liniowe). Z tego powodu utworzymy prosty system VR, w którym obracanie kamer będzie realizowane w oparciu o dane odczytane z akcelerometru. Następnie pokażę, w jaki sposób odpowiednie SDK upraszczają proces tworzenia kamer i śledzenia ruchów głowy na podstawie automatycznych odczytów z wbudowanych sensorów urządzenia.

W celu utworzenia stereoskopii w Unity 3D postępujemy następująco: zmieniamy nazwę głównej kamery (projekcji sceny) z Main Camera na L, a następnie dodajemy kolejną kamerę (opcja Create/Camera w widoku hierarchii sceny) i zmieniamy jej nazwę na R. W kolejnym kroku, w widoku hierarchii, klikamy kamerę L i przechodzimy do okna inspektora. Odnajdujemy tam grupę Camera, a następnie Viewport Rect i zmieniamy tam parametr W z 1 na 0.5 (zob. Rysunek 5). Spowoduje to zmniejszenie szerokości prostokąta reprezentującego widok z kamery, patrząc w kierunku, w którym kamera jest skierowana. Taka redukcja szerokości ma na celu symulowanie ograniczonego pola widzenia w przypadku zamknięcia prawego oka.

Rysunek 5. Konfiguracja kamery w Unity

W podobny sposób modyfikujemy również parametr W drugiej kamery. Dodatkowo zmieniamy właściwość X w sekcji Viewport Rect z 0 na 0.5. W efekcie w dolnej części okna edytora Unity (zakładka Game) ujrzymy widok z dwóch kamer. Utworzone kamery stanowią niezależne obiekty. Aby uprościć ich przesuwanie w odpowiedzi na aktualizacje informacji z akcelerometru, utworzymy teraz dodatkowy obiekt nadrzędny. Zmiana jego położenia spowoduje również aktualizację pozycji obu kamer (obiektów podrzędnych). Realizacja tego zadania wymaga dodania pustego obiektu typu GameObject (menu GameObject/Create Empty). Następnie wystarczy zmienić jego nazwę na VR Camera, po czym w hierarchii sceny przeciągnąć kamery L i R na VR Camera. W konsekwencji kamery L i R będą obiektami potomnymi VR Camera (zob. Rysunek 6).

Na koniec zmieńmy jeszcze położenie kamery VR w taki sposób, aby jej współrzędne (Position w grupie Transform okna inspektora) miały następujące wartości: X: 0, Y: 1, Z: -10. Spowoduje to, że podgląd gry (zakładka Game) będzie wyglądała analogicznie jak na Rysunku 7.

Rysunek 6. Hierarchia sceny. Kamery L i R są potomkami obiektu VR Camera

Rysunek 7. Widok z kamery VR

Wykorzystanie akcelerometru do aktualizacji kamery VR

Utworzymy teraz prosty skrypt C#, który będzie obracał kamerę VR na podstawie położenia urządzenia. A dokładniej mówiąc, liniowego przyspieszenia wzdłuż osi X odczytanego z akcelerometru. Realizuje się to poprzez dodanie skryptu C# do obiektu VR Camera. Jak to zrobić? Najpierw w widoku hierarchii scen klikamy VR Camera, a następnie w oknie inspektora klikamy przycisk z etykietą Add Component. Spowoduje to uaktywnienie listy (Rysunek 8), w której wybieramy New Script, a następnie ustalamy nazwę skryptu na AccelerometerInput i z listy Language wybieramy C Sharp (zob. Rysunek 8). Na końcu potwierdzamy tę operację za pomocą przycisku Create and Add. Unity uzupełni folder Assets o plik AccelerometerInput.cs i wypełni go zawartością z Listingu 1. Dwukrotne kliknięcie pliku AccelerometerInput.cs w oknie Project spowoduje uruchomienie edytora kodu źródłowego (domyślnie Visual Studio) w celu jego dalszej edycji.

Rysunek 8. Tworzenie skryptu C#

Listing 1. Domyślna zawartość skryptu AccelerometerInput
using UnityEngine;
 
public class AccelerometerInput : MonoBehaviour {
    // Use this for initialization
    void Start () {
    }
   
    // Update is called once per frame
    void Update () {
    }
}
Analizując fragment kodu z Listingu 1, widzimy, że klasa AccelerometerInput dziedziczy po MonoBehavior, bazowej klasie dla wszystkich skryptów. Dodatkowo AccelerometerInput ma dwie metody Start oraz Update. Ich komentarze informują nas o przeznaczeniu metod Start i Update. Mianowicie metoda Start jest wywoływana jednorazowo (bezpośrednio przed wyświetleniem pierwszej ramki) w celu inicjalizacji. Natomiast funkcja Update jest uruchamiana każdorazowo dla każdej ramki.

W tym przykładzie wykorzystamy obie metody. W ramach funkcji Start uzgodnimy orientację widoku urządzenia na Landscape, aby widok aplikacji nie był obracany podczas ruszania urządzeniem, i zapiszemy aktualną transformację opisującą obrót (orientację) kamery. Z kolei w ramach funkcji Update będziemy aktualizowali położenie kamery VR. Dodatkowo dotknięcie ekranu urządzenia spowoduje przywrócenie pierwotnych parametrów kamery.

Implementację opisanych zmian przedstawiłem na Listingu 2. Widzimy, że silnik Unity w prosty sposób umożliwia odczytywanie informacji z czujników urządzenia, jak również informacji o dotknięciu ekranu. Do tego celu wystarczy użyć odpowiednich właściwości i metod klasy Input. Dodatkowo Unity pozwala obracać obiekty (lub bardziej ogólnie wykonywać transformacje/przekształcenia afinicznie) z wykorzystaniem pola transform. W tym przykładzie wykorzystałem to pole do obracania kamery VR z wykorzystaniem macierzy świata [4]. W skrócie jest ona odpowiedzialna za transformowanie (przekształcanie) lokalnego układu współrzędnych.

Listing 2. Aktualizacja kamery VR z wykorzystaniem akcelerometru
using UnityEngine;
 
public class AccelerometerInput : MonoBehaviour
{
    private float previousReading = 0f;
    private const float scaler = 45f;
 
    private Quaternion defaultRotation;
 
    void Start()
    {
        Screen.orientation = ScreenOrientation.LandscapeLeft;
 
        defaultRotation = transform.rotation;
    }
 
    void Update()
    {
        if (Input.touchCount > 0)
        {
            ResetRotation();
        }
     
        Rotate();  
    }
 
    private void Rotate()
    {
        var currentReading = Input.acceleration.x;
        var delta = currentReading - previousReading;
 
        var rotation = scaler * Vector3.up * Time.deltaTime;
 
        if (delta > 0)
        {
            transform.Rotate(rotation, Space.World);
        }
        else if (delta < 0)
        {
            transform.Rotate(-rotation, Space.World);
        }
 
        previousReading = currentReading;
    }
 
    private void ResetRotation()
    {
        previousReading = 0f;
 
        transform.rotation = defaultRotation;
    }
}
Aby uruchomić aplikację, należy ją najpierw skompilować w Unity, a następnie otworzyć wygenerowany w ten sposób projekt w Visual Studio i tam uaktywnić aplikację w emulatorze, w komputerze developerskim lub w urządzeniu mobilnym. Ja będę korzystał z pierwszej opcji, czyli emulatora.

Kompilacja projektu w Unity wymaga kliknięcia menu File/Build Settings… lub użycia skrótu klawiaturowego CTRL+SHIFT+B. W efekcie nastąpi uaktywnienie okna modalnego z Rysunku 9, w którym z listy dostępnych platform wybieramy Windows Store. Następnie w liście SDK zaznaczamy opcję Universal 10.0, a w UWP Build type – XAML, po czym klikamy przycisk z etykietą Build. Po wskazaniu folderu docelowego, np. MobileVR-build, i odczekaniu kilku chwil nastąpi wygenerowanie projektu XAML/C# dla Visual Studio, czyli MobileVR.sln. Będzie on zlokalizowany we wskazanym wcześniej folderze. Po otwarciu projektu MobileVR.sln mamy możliwość uruchomienia aplikacji VR, co realizuje się za pomocą standardowych technik.

Rysunek 9. Konfiguracja kompilacji w Unity.

Aby zaprezentować działanie aplikacji, uruchomiłem ją w emulatorze urządzenia Windows 10 Mobile. Umożliwia on emulowanie akcelerometru, co wywołuje obroty kamery. Jak widać na Rysunku 10, obracanie kamery pozwala użytkownikowi „odczuwać” świat wirtualny. Chociaż ten świat zawiera jedynie proste elementy 3D, to można go samodzielnie uzupełnić według konkretnych potrzeb. Te zmiany, w połączeniu z informacjami wejściowymi, rejestrowanymi za pomocą klasy Input stanowi podstawę tworzenia aplikacji VR.

Rysunek 10. Obrót urządzenia powoduje aktualizację położenia kamery VR

ALPS VR SDK

W poprzednim rozdziale bardzo szybko utworzyliśmy stereoskopię. Jednak jest to stosunkowo prosty układ, który nie uwzględnia podstawowych aspektów optycznych, związanych z dystorsją obrazu. Można to oczywiście zaimplementować samodzielnie lub wykorzystać jedno z gotowych narzędzi (zestawów) programistycznych dla VR. Są one dystrybuowane jako pakiety dla Unity. Jednym z nich jest ALPS VR SDK (ms-alpsvr). Jest on dostępny pod adresem: https://github.com/peted70/mva-vrdemo/blob/master/ms-alpsvr.unitypackage.

Aby przedstawić jego przykładowe użycie w projekcie Unity zapisałem utworzoną wcześniej scenę jako MainScene. Pojawi się ona wówczas w folderze Assets w oknie projektu. Uaktywniając tam menu kontekstowe MainScene, mamy możliwość wyeksportowania sceny jako pakietu Unity (opcja Export Package…). W efekcie scena, którą utworzyliśmy, może być użyta w innych projektach, dzięki czemu nie musimy powtarzać naszej pracy.

Rysunek 11. Import pakietów Unity

Zatem, po wyeksportowaniu sceny, tworzymy nowy projekt Unity o nazwie MobileVR-ALPS.

Następnie, w oknie Project, uaktywniamy menu kontekstowego, gdzie wybieramy Import Package/Custom Package… (Rysunek 11) i wskazujemy przygotowany wcześniej pakiet, zawierający MainScene. Spowoduje to zaimportowanie sceny do nowego projektu. Będzie ona widoczna w strukturze projektu. Przenieśmy ją do widoku hierarchii scen, a następnie usuńmy domyślną scenę.

W analogiczny sposób zaimportujmy pakiet ms-alpsvr. Spowoduje to uzupełnienie projektu o dużą liczbę dodatkowych obiektów, a w szczególności o folder ALPS. Odnajdźmy w nim folder Prefabs, a następnie obiekt ALPSCamera, który dodajemy do sceny. Zmieńmy pozycję tej nowej kamery na X: 0, Y: 1, Z: -10. Następnie, w sekcji ALPS Controller (Script) inspektora atrybutów obiektu ALPSCamera, z listy rozwijanej Device wybierzmy CARDBOARD. Przy okazji usuwamy naszą kamerę VR Camera, gdyż nie będzie już potrzebna.

Sam projekt jest już gotowy do uruchomienia. Jednak nie będzie on działał poprawnie na emulatorze ze względu na moduł śledzenia ruchów głowy. Do poprawnego działania potrzebne jest urządzenie. Możemy jednak skorzystać z podglądu gry w Unity, który można uaktywnić za pomocą ikony trójkąta. W efekcie możemy podejrzeć widok aplikacji i wirtualnie poruszać się po scenie z wykorzystaniem myszy lub touchpada (Rysunek 12).

Rysunek 12. Podgląd działania kamery VR z pakietu ALPS VR SDK

Warto zauważyć, że ALPS VR automatycznie śledzi ruchy głowy na podstawie danych z żyroskopu. Jest za to odpowiedzialny skrypt ALPSGyro.cs z Listingu 3 (folder Assets/ALPS/Scripts). Dodatkowo ALPS VR posiada również prosty skrypt ExplodingBottle.cs (folder Assets/VisrTestScene). Pokazuje on (Listing 4), w jaki sposób można zaimplementować wirtualną interakcję użytkownika z obiektami sceny. W tym przypadku polega to na wykonaniu odpowiedniej akcji w przypadku uderzenia promieniem w bryłę sztywną (rigid body).

Listing 3. Zawartość pliku ALPSGyro.cs

using UnityEngine;
 
public class ALPSGyro : MonoBehaviour
{
    private Gyroscope gyro;
    private Quaternion initialRotation;
 
    // Use this for initialization
    void Start()
    {
        Screen.sleepTimeout = SleepTimeout.NeverSleep;
 
        if (SystemInfo.supportsGyroscope)
        {
            Input.gyro.enabled = true;
        }
        else
        {
            Debug.Log("No Gyro Support");
        }
 
        initialRotation = transform.rotation;
    }
 
    // Update is called once per frame
    void Update()
    {
        if (SystemInfo.supportsGyroscope)
        {
            if (Input.touchCount > 0)
            {
                transform.rotation = initialRotation;
            }
 
            Vector3 orientationSpeed = Input.gyro.rotationRateUnbiased * Time.deltaTime;
            transform.rotation = transform.rotation * Quaternion.Euler(
               -orientationSpeed.x, -orientationSpeed.y, orientationSpeed.z);
        }
    }
}
Listing 4. Zawartość skryptu ExplodingBottle.cs

using UnityEngine;
 
[RequireComponent(typeof(Rigidbody))]
public class ExplodingBottle : MonoBehaviour {
 
    void OnLookStateAction(RaycastHit rayHit)
    {        
        GetComponent().AddForceAtPosition(
           rayHit.normal * -5, rayHit.point, ForceMode.Impulse);
    }
}
 

Podsumowanie

Tworzenie mobilnych aplikacji VR odkrywa kolejne perspektywy dla zastosowania smartfonów. W niedalekiej przyszłości może doprowadzić to do powstania zupełnie nowej gałęzi dla aplikacji mobilnych. Jak starałem się pokazać Tobiepokazałem w tym artykule, tworzenie tego typu aplikacji ułatwia środowisko Unity oraz dedykowane zestawy narzędzi programistycznych. Mam nadzieję, że tekst okazał się przydatny. Trzymam kciuki za Twoje działania w tym zakresie i do zobaczenia na blogu!

Literatura i odnośniki

[1] Google Cardboard: https://goo.gl/QTuUPj
[2] Magic Leap: https://www.magicleap.com/#/home
[3] M. Sawerwain, Unity 3D. Robimy grę. Programista 10/2014, 11/2014 and 12/2014
[4] J. Matulewski, Macierze w grafice 3D. Programista 11/2014

DAWID BORYCKI

Doktor nauk fizycznych. Wykładowca w Instytucie Chemii Fizycznej Polskiej Akademii Nauk. Zajmuje się projektowaniem i wdrażaniem algorytmów analizy cyfrowej obrazowania i sterowania prototypami obrazowania biomedycznego. Współautor wielu książek na temat programowania i międzynarodowych zgłoszeń patentowych.