Major Projekt

Transcription

Major Projekt

Major Projekt
Module Number:
SAE 610
Block Name:
Major Projekt
Date Submitted:
27.02.2014
Award Name:
BSc (Hons.) Games
Programming
Course:
BGP 1012
Name:
Linus Meng
City:
Hamburg
Country:
Germany
Staffing:
Jan-Friedrich Conrad &
Henning Fischer
Module Leader:
Henning Fischer
Word Count:
8200
Weight:
65% Theoretical / 35% Practical
Bachelor Arbeit
Linus Meng
BGP 1012
16973
Entwicklung von 3D Grafical-User-InterfaceElementen in der Unity 3D Game Engine in
Kombination mit der Virtual-Reality-Brille Oculus
Rift.
SAE Institute Hamburg
ii
Linus Meng
Entwicklung von GUI-Elementen in Unity 3D für die Oculus Rift
27.02.2014
Inhaltsverzeichnis:
Inhaltsverzeichnis: ............................................................................................. iv
Abbildungsverzeichnis ....................................................................................... vi
Eigenständigkeitserklärung ............................................................................... vii
1. Einleitung ........................................................................................................8
1.1 Title ...........................................................................................................8
1.2 These ........................................................................................................8
1.3 Virtual Reality ............................................................................................8
1.4 Die ersten Geräte1 ...................................................................................10
1.4.1 Oculus Rift ........................................................................................11
1.4.2 Omni .................................................................................................12
1.4.3 PrioVR ..............................................................................................13
2. Grundlagen ...................................................................................................15
2.1 Grafical User Interface.............................................................................15
2.2 Oculus Rift Unity 3D Integration ..............................................................15
2.3 Microsoft Visual Studio2...........................................................................19
2.4 Game Engine ..........................................................................................22
2.5 Versionierungsdienst ...............................................................................23
2.6 Raycast3 ..................................................................................................24
3. Methodik....................................................................................................25
3.1 Evaluationsmethode................................................................................25
3.1.1 Kognitiver Walkthrough.....................................................................26
3.1.2 Zielgruppe der Evaluationsmethode .................................................27
3.1.3 Methodenanwendung .......................................................................28
3.2 Beschreibung der Methoden zur Entwicklung der GUI-Elemente............30
3.2.1 Methode eins - Raycast und Objekt ..................................................30
3.2.2 Methode zwei - Raycast und GUI Elemente .....................................30
3.3 Vergleich der Methoden ..........................................................................31
3.3.1 Methode eins - Raycast und Objekt ..................................................31
iv
Linus Meng
27.02.2014
3.3.2 Methode zwei - Raycast und GUI-Elemente .....................................32
3.3.3 Zusammenfassung der Vor- und Nachteile.......................................33
4. Durchführung ................................................................................................34
4.1 Versionierungsdienst ...............................................................................34
4.2 Unity 3D...................................................................................................35
4.3 Oculus Rift Unity 3D Integration ..............................................................35
4.3.1 Raycast und 3D-Objekte...................................................................36
4.3.2 Raycast und GUI-Elemente ..............................................................40
5. Ergebnisse ....................................................................................................42
5.1 Ergebnisse ..............................................................................................42
5.2 Evaluationen............................................................................................43
6. Zusammenfassung und Fazit........................................................................45
6.1 Grundlagen..............................................................................................45
6.2 Methodik..................................................................................................46
6.3 Durchführung...........................................................................................47
6.4 Ergebnisse und Evaluationen..................................................................49
Literaturverzeichnis............................................................................................. li
Anhang .............................................................................................................. lii
Anhang auf CD .................................................................................................. lii
v
Linus Meng
27.02.2014
Abbildungsverzeichnis
Abb. 1: Sensorama von Mortan Heilig, www.telepresence.org (2002) ……………… 10
Abb. 2: Oculus Rift von OculusVR, www.oculusvr.com/ (2014) ……………………….11
Abb. 3: Omni von Virtuix, http://www.virtuix.com/ (2013)………………………………..13
Abb. 4: Sensoren im PrioVR, http://www.priovr.com/ (2014)………………………….. 14
Abb. 5: Tastaturbelegung für die Oculus Rift – Unity 3D Integration,
OculusUnityIntegrationGuide.pdf (2013) – siehe Anhang ………………….. 16
Abb. 6: Konfigurationsmenu, Linus Meng (22.02.2014) ……………………………….. 18
Abb. 7: Sinus Milieu in Deutschland, www.sinus-institut.de (2013) …………………... 27
Abb. 8: Funktion CastRayRightEye(), Linus Meng (22.02.2014) ……………………… 37
Abb. 9: Funktion OnRayCastHit(), Linus Meng (22.02.2014) ………………………..... 38
Abb. 10: Raycast und 3D Objekt, Linus Meng (22.02.2014)…………………………… 39
Abb. 11: Splinter Cell Double Agent, https://www.youtube.com/watch?v=ROoIYGypsN4 (2013) …………………………………………………………… 40
vi
Linus Meng
27.02.2014
Eigenständigkeitserklärung
Hiermit bestätige ich, dass ich die vorliegende Arbeit selbständig verfasst und keine
anderen als die angegebenen Hilfsmittel benutzt habe. Die Stellen der Arbeit, die
dem Wortlaut oder dem Sinn nach anderen Werken (dazu zählen auch
Internetquellen) entnommen sind, wurden unter Angabe der Quelle kenntlich
gemacht.
vii
Linus Meng
27.02.2014
1. Einleitung
Der Zweck vieler Spiele ist es, den Verbraucher zu unterhalten. Um eine Bewertung für
ein Spiel abzugeben, werden meistens verschiedene Kriterien verwendet, wie zum
Beispiel Grafik, Ton, Mehrspieler/Einzelspieler, Umfang, Handlung oder ähnliches. Es
handelt sich meistens um ein „gutes Spiel“, wenn der Verbraucher bestens unterhalten
wird. Es lässt sich beispielsweise schlussfolgern: Je besser das Spiel, desto besser die
scheinbare Realität und umgekehrt.
1.1 Title
Entwicklung von 3D Grafical-User-Interface-Elementen in der Unity 3D Game
Engine in Kombination mit der Virtual-Reality-Brille Oculus Rift.
1.2 These
Es ist möglich mit Hilfe von Unity 3D und dem Oculus SDK, drei dimensionale
Grafical-User-Interface-Elemente zu erstellen, die eine mögliche Alternative zur
Eingabe durch Gamepad, Tastatur oder Maus darstellen.
1.3 Virtual Reality
Übersetzt man „Virtual“ und „Reality“ wörtlich ins deutsche, so ergibt sich „die
virtuelle Realität“. Dieser Begriff wird auch im deutschsprachigen Raum häufig
benutzt. Ein passendes Synonym für „Virtuell“ ist „scheinbar“. Die „scheinbare
Realität“ beschreibt sehr genau, was wir in virtuellen Welten erleben,
beziehungsweise erzeugen wollen.
Im Allgemeinen beschreibt die virtuelle Realität das Erlebnis in einer dreidimensionalen Umgebung, in der sich der Verbraucher bewegen und
interagieren kann. Je nach dem, wie viele unserer menschlichen Sinne in dieser
8
Linus Meng
27.02.2014
virtuellen Welt angeregt werden, desto größer ist die Immersion in die Welt.
Mortan Heilig beschrieb 1955 in seiner Arbeit „The Cinemar of the Future“ zu
wie viel Prozent unsere Sinne einen Einfluss auf die Immersion in einer
virtuellen Welt haben. Demnach:
-
Sehen:
70%
-
Hören:
20%
-
Riechen:
5%
-
Anfassen:
4%
-
Schmecken:
1%
Nach Heilig könnten wir mit einem Gerät, dass unseren Augen die virtuelle Welt
zeigt und Kopfhörern, die den entsprechenden Ton überliefern, bereits 90% der
perfekten Immersion erreichen. Jedoch gehört auch die Kraft, die auf unsere
Körper einwirkt dazu. Das „Feedback“, dass unser Körper erhält, wenn wir
beispielsweise in einem Auto beschleunigen, fehlt in dieser Berechnung.
9
Linus Meng
27.02.2014
1.4 Die ersten Geräte1
Bereits in den 80gern baute Mortan Heilig ein Gerät namens „the Sensorama
Simulator“.
Abb. 1 – Diese Abbildung zeigt den „Sensorama“ von Mortan Heilig
1
10
Sensorama, Inventor in the field of virtual reality, http://www.mortonheilig.com/
Linus Meng
27.02.2014
Dieses Gerät konnte beispielsweise eine Motorradfahrt durch Brooklyn
simulieren. Motorengeräusche, Vibrationen im Sitz, Bild und Gerüche,
erzeugten somit eine virtuelle Welt. Es sollte das neue Theater werden, jedoch
wurde seine Idee nicht ernst genommen und auf Grund der hohen Kosten
wurde dieses Projekt fallen gelassen.
Heutzutage gibt es bereits einige vielversprechende Geräte, die der Vision vom
„Holo-Deck“ nachgehen.
1.4.1 Oculus Rift
Oculus Rift ist ein Headset, die speziell für Videospiele entwickelt wird.
Das Entwicklerstudio “OculusVR” hat 2012 über die Internetplattform
Kickstarter das Projekt mit 2,4 Million USD finanziert. Viele große Firmen
wie zum Beispiel Valve und Epic Games haben das Projekt finanziell
unterstützt und arbeiten seid dem eng mit OculusVR zusammen.
Abb. 2 – Dies ist ein Konzept der Oculus Rift, wie sie in ihrer fertigen Version
aussehen soll.
Die Oculus Rift ist in der Lage, ein drei Dimensionales Bild zu erzeugen,
das auf zwei Bildschirmen mit Hilfe von zwei Linsen auf die Augen des
Benutzers gestrahlt wird. Das Bild wird mit spezieller Software und
11
Linus Meng
27.02.2014
einem Hardware-Modul in das entsprechende Format gebracht. Die
Bildinformation werden mit Hilfe eines HDMI- oder einem DVI- Kabel
übertragen. Zusätzlich wird die Oculus Rift mit einem USB Kabel an den
Computer angeschlossen um Bewegungssensor-Daten zu übertragen.
Außerdem wird sie über ein 9V Kabel mit Storm versorgt.
Die Oculus Rift zeichnet sich durch ein sehr großes Sichtfeld aus,
wodurch es fast keine schwarzen Ränder für den Benutzter sichtbar
sind.
Ein
3-Achsen-Gyrometer
sorgt
für
die
Übertragung
von
Kopfbewegungen. Ziel der Oculus RIft ist es, die Immersion beim
Spielen von Videospielen deutlich zu verbessern.
Ende 2012/Anfang 2013 wurden die ersten Testversionen an Entwickler
verschickt, damit diese neue Technologie getestet und in ersten Spielen
eingebaut werden kann.
Bereits in der frühen Entwicklungsphase wurde allgemeine Skepsis
geäußert. Besonders erfahrene Entwickler haben die bereits bekannten
Probleme
wie
“Motionsickness”
geäußert.
Außerdem
hatte
die
Testversion der Oculus Rift nur eine sehr geringe Auflösung, wodurch
die ersten Erfahrungen Zweifel an der Markttauglichkeit wecken. Jedoch
wurde auch eine sehr große Faszination geteilt, da die Oculus Rift
bereits ein ganz anderes Gefühl des Spielens ermöglichte.
1.4.2 Omni
Die OMNI ist ein Virtual Reality Interface und wird von Virtuix entwickelt.
Mit der OMNI ist es für Spieler möglich sich in Videospielen frei zu
bewegen. Die OMNI überträgt Körperbewegungen mit Hilfe von
spezieller Hard- und Software zum Computer. Auf der achteckigen
Lauffläche kann sich der Spieler auf der Stelle bewegen und diese
Bewegungen werden dann an das Spiel gesendet. Somit kann der
Spieler gehen, laufen, springen und auch sich ducken.
12
Linus Meng
27.02.2014
Abb. 3 – Diese Abbildung zeigt ein Konzept des Omni von der Firma Virtuix.
Ähnlich wie die Oculus Rift befindet sich die OMNI noch in der
Entwicklung. Es liegt nahe, dass man beide Technologien kombinieren
kann und somit ein komplett neues Spielerlebnis erzeugen kann. Virtuix
und OculusVR verfolgen beide das gleiche Ziel. Sie wollen der
Spielebranche die Virtuelle Realität näher bringen und für den
Konsumentenmarkt bezahlbar machen.
1.4.3 PrioVR
PrioVR ist ein Körperanzug, der die Körperbewegungen aufzeichnet und
an den Computer sendet. Ähnlich wie das Konzept des Omni soll der
PrioVR das Gefühl der Immersion im Spiel verbessern. Auch hier wird
die Kombination mit der Oculus Rift gezeigt. Anders als bei der Omni ist
es mit der PrioVR möglich komplexe Bewegungen im Spiel darzustellen.
Jedoch ist es nicht möglich, auf der Stelle zu laufen. Diese Art von
Bewegung wird mit einem Controller in der Hand ausgeführt.
13
Linus Meng
27.02.2014
Abb. 4 – Diese Abbildung zeigt alle Sensoren in einem PrioVR-Anzug je nach
Ausführung.
Es ist vorstellbar, dass eine Kombination aus Oculus Rift, Omni und
PrioVR die größt mögliche Immersion in Spielen erzeugen könnten.
Jede dieser Virtual Reality Komponenten haben ihre eigenen Vorzüge.
Die OMNI und der PRIOVR erzeugen für sich allein nicht das
Spielerlebnis im Vergleich zur Oculus Rift.
14
Linus Meng
27.02.2014
2. Grundlagen
2.1 Grafical User Interface
Das Grafical User Interface (oder auch GUI, zu Deutsch: grafische
Benutzeroberfläche) dient dazu, dem Benutzer den Umgang mit einer Software
zu erleichtern. Früher wurden Computer mit Kommandozeilen gesteuert. In den
80ern wurde der sehr beliebte C64 von Commodore entwickelt, der bereits ein
GUI benutze. Die Bedienung eines Computers über Kommandozeilen ist
umständlich und man musste sich Befehle selber merken. Mit Hilfe eines GUIs
lassen sich ein oder mehrere Befehle in eine Komponente verknüpfen, die dann
anschließend Benutzter freundlich beschriftet ist. Mit Hilfe von GUIs lässt sich
auch eine Vielzahl von Daten grafisch darstellen, sodass der Benutzer diese
schneller verstehen kann.1
2.2 Oculus Rift Unity 3D Integration
In diesem Kapitel wird beschrieben, welche Funktionen die Oculus Rift Unity 3D
Integration mit sich bringt. Das Entwicklerstudio OculusVR hat viele Funktionen,
die nötig sind, um einen Spieler durch eine Szene zu bewegen, bereits
implementiert. Das bedeutet, dass der Spieler folgende Funktionen ausführen
kann, ohne weitere Implementierung durch den Entwickler:
2
GUI (Graphical User Interface), Über GUI, 2012, http://www.focus.de/digital/computer/techniklexikon/guigraphical-user-interface_aid_413051.html
15
Linus Meng
27.02.2014
Abb5: Tastaturbelegung für die Oculus Rift – Unity 3D Integration
In dieser Tabelle sind sowohl Standardfunktionen eines Spielers beschrieben,
als auch spezielle Funktionen für die Oculus Rift. Die rechte Umschalt-Taste
ermöglicht das Umschalten zwischen verschiedenen Szenen. Dies ist
besonders hilfreich, um während der Laufzeit die Szenen zu wechseln und
somit einen längern Testlauf zu ermöglichen. Mit der Zurück-Taste kann man
nun die ausgewählte Szene bestätigen und Unity wird diese automatisch laden.
Die
„X“-Taste
aktiviert
oder
desaktiviert
die
Korrektur
der
Z-Achsen
Verschiebung, die aufgrund von Anhäufungen durch Fehlmessungen des in die
VR-Brille integrierten Magnetometers entstehen.
Die „C“-Taste aktiviert oder deaktiviert den Mauszeiger. Ist der Mauszeiger
deaktiviert, steuern die Mausbewegungen die Drehung des Charakters nach
Links und Rechts. Ist der Mauszeiger jedoch aktiviert, dann kann man mit
diesem mit GUI Elementen interagieren (zum Beispiel auf einen Knopf klicken).
16
Linus Meng
27.02.2014
Die „P“-Taste aktiviert oder deaktviert den „Prediction Mode“. Wenn dieser
Modus aktiviert ist wird berechnet, wo sich der Kopf des Spielers wahrscheinlich
hinbewegen
wird.
Diese
Funktion
ermöglicht,
dass
die
Latenz
der
Übertragungen von Kopfbewegungen verringert wird. Eine wichtige Variable in
dieser Funktion ist die Zeitspanne, die der Computer vorrausrechnen soll
(Prediction Time). Der Standart Wert beträgt 50 Millisekunden. Dieser Wert
kann natürlich angepasst werden, je nach dem in welcher Art von Szenerie der
Spieler sich befindet.
Die „B“-Taste setzt die Ausrichtung der Oculus Rift wieder zurück. Das
bedeutet, dass die Oculus Rift am besten direkt zum Bildschirm ausgerichtet
wird. Damit erkennt das Programm den Nullpunkt ( Der Spieler guckt in diese
Richtung und dies ist die Ausgansposition).
Mit der Leertaste kann man ein Konfigurationsmenu öffnen, das mehrere
Einstellungen hat. Diese Einstellungen lassen sich mit Hilfe dieses Menus zur
Laufzeit ändern. Folgende Einstellungen sind gegeben:

Prediction Amount/Time (in Millisekunden) – Zeitspanne die der
Computer vorausrechnet

Field of View (in Grad) – Das Sichtfeld des Spielers

Interpupillary Distance / IPD (in Millimeter) – Die Pupillendistanz von
Spieler zur Linse

Distortion Constant 1 (K1) – Die Verzerrungskonstante 1

Distortion Constant 2 (K2) – Die Verzerrungskonstante 2

Player Height ( in Metern) – Die Größe des Spielers

Player Movement Speed Multiplier – Der Multiplikator für die
Laufgeschwindigkeit des Spielers
17
Linus Meng
27.02.2014

Player
Rotation
Speed
Multiplier
–
Der
Multiplikator
für
die
Rotationsgeschwindigkeit des Spielers
Abb. 6 – Diese Abbildung zeigt das Konfigurationsmenu, welches zur Laufzeit über die
Leertaste aufgerufen werden kann.
Mit der „F2“-Taste lassen sich alle Einstellung auf den Standartwert
zurücksetzten. Außerdem kann man mit der Tabulator-Taste und den „F3“ bis
„F5“-Tasten seine aktuellen Einstellungen speichern und wieder laden. Die
„F11“-Taste wechselt zwischen dem Vollbild-Modus und dem Fenster-Modus.
18
Linus Meng
27.02.2014
2.3 Microsoft Visual Studio2
Microsoft Visual Studio ist eine integrierte Entwicklungsumgebung (IDE),
die es einem Entwickler ermöglicht, in verschiedenen Programmier-,
Script- und Seitenbeschreibungssprachen (z.B. Visual Basic .Net, C,
C++, C++/CLI, C++/C C#, F#, SQL Server, TypeScript, HTML,
JavaScript und CSS) zu entwickeln. Mit dieser Entwicklungsumgebung
ist es möglich klassische Windows Programme, Programme für die
Microsoft .NET Runtime und auch neuere Windows 8 Applikationen zu
schreiben.
Eine IDE beinhaltet meistens mehrere Komponenten:

Texteditor
Der Texteditor ermöglicht dem Entwickler Dateien zu erstellen
und zu bearbeiten. In diesen Dateien werden Befehle eingeben,
die
der
Compiler
bzw.
Interpreter
analysiert
und
in
Maschinensprache umschreibt.

Compiler bzw. Interpreter
Der Compiler (aus dem englischen für „zusammentragen“) liest
den geschriebenen Text aus den einzelnen Dateien und Relation
zu
deren
Zusammenhängen
und
„übersetzt“
diesen
in
Maschinensprache. Der Interpreter hat dieselbe Aufgabe, aber
dieser analysiert die Dateien, im Gegensatz zum Compiler, zur
Laufzeit. Beide Methoden können Syntax Fehler erkennen und
dem Entwickler melden. Im Allgemeinen sind Interpreter
langsamer in der Ausführung der Programme im Vergleich zu
Compilern.
3
19
Visual Studio, Über .NET, 2012, http://www.microsoft.com/net
Linus Meng
27.02.2014

Linker
Ein Linker hat die Aufgabe die Funktionen und Variablen eines
Programms in Speicheradressen umzuwandeln, um es zu
ermöglichen, dass andere Programme mit diesem Interagieren
können. Dieser Vorgang wird nach der Kompilierung ausgeführt.
Generell unterscheidet man zwischen zwei Arten von Linkern:
-
Statisches Linken
Beim statischen Linken wird das Programm, und dessen
Variablen
und
Funktionen,
einmalig
in
eine
Bibliothek
umgewandelt. Dies hat den Vorteil, dass das umgewandelte
Programm einfacher auf mehreren Plattformen eingesetzt
werden kann, da alle nötigen Dateien am Ende der Entwicklung
einmal umgewandelt werden und somit immer zur Verfügung
stehen.
-
Dynamisches Linken
Beim Dynamischen Linken ist es möglich, dass mehrere
Programme auf dieselbe Bibliothek zugreifen und somit weniger
Speicher verwenden und auch schneller arbeiten. Außerdem ist
es
hierbei
auch
einfacher
nachträgliche
Programme
zu
verändern.

Debugger
Der Debugger ist dafür zuständig, Programmfehler zu suchen
und dem Entwickler zu melden. Außerdem kann der Debugger
das Programm steuern, das bedeutet, dass der Debugger
beispielsweise das Programm anhalten und wieder starten kann.
Zu diesem Zeitpunkt kann der Entwickler dann Variablen
20
Linus Meng
27.02.2014
auslesen
und
somit
den
Programmablauf
genauestens
überprüfen.

Quelltextformatierungsfunktion.
Die
Quelltextformatierungsfunktion
hilft
Entwicklern
eine
kontinuierliche Struktur im Programm einzuhalten. Hierbei
werden Standards vom Programm erkannt und zeigen dem
Entwickler wenn er bestimmte Richtlinien missachtet. Dies
steuert dazu bei, das Programm insbesondere für andere
Entwickler lesbarer zu machen.
Unity
3D
ermöglicht
es,
dem
Entwickler
verschiedene
Entwicklungs-
umgebungen zu benutzen. Unity 3D benutzt die Opensource IDE MonoDevelop
als Standart-Entwicklungsumgebung. Für diese Arbeit hat sich der Autor jedoch
aus verschiedenen Gründen für Visual Studio entschieden.
Der Hauptgrund besteht darin, dass der Autor bereits viel Erfahrung mit Visual
Studio hat und dementsprechend die einzelnen Funktionen besser benutzen
kann. Viele Funktionen, die in Visual Studio benutzt worden sind, können auch
in MonoDevelop ausgeführt werden, jedoch sind einige Funktionen in Visual
Studio ausgereifter beziehungsweise nur in Visual Studio vorhanden. Eine der
wichtigsten Funktionen in Visual Studio ist das sogenannte „IntelliSense“.
IntelliSense analysiert den geschriebenen Code zur Laufzeit und erkennt
Fehler. Diese Fehler werden dann sofort in verschiedenen Farben dargestellt.
Wird beispielsweise ein falscher Typ zu einer Variable zugewiesen, wird der
Ausdruck rot unterstrichen. Nun kann der Entwickler mit dem Mauszeiger auf
den Ausdruck zeigen und nun wird ein Tool-Tip angezeigt. Dieser beschreibt
genau, aus welchem Grund der Ausdruck fehlerhaft ist.
21
Linus Meng
27.02.2014
Eine zweite wichtige Eigenschaft ist das Vorschlagen von Code. IntelliSense
erkennt verschiedene Variablen und im welchem Zusammenhang diese mit
dem restlichen Code stehen. Somit bekommt der Entwickler zur Laufzeit
vorgeschlagen, wie der Ausdruck erweitert werden könnte.
Diese beiden Funktionen sind ausschlaggebend für eine schnellere Entwicklung
von Programmen. Aus diesem Grund wird für diese Arbeit Visual Studio 2010
Professional verwendet und nicht MonoDevelop.
2.4 Game Engine
Ein Spiel besteht aus vielen einzelnen Komponenten. Damit diese einzelnen
Komponenten miteinander arbeiten können, benutzten Entwickler sogenannte
„Game Engines“. Diese beinhalten einzelne „Engines“ (oder auch auf Deutsch:
„Motoren“), die die Vielzahl an Komponenten bearbeiten können. Die meisten
Game Engines weisen daher beispielsweise eine Grafik Engine, Physik Engine
und Sound Engine vor. Innerhalb dieser Game Engine können Programmierer
nun die einzelnen Komponenten bearbeiten und kombinieren. Beispielsweise
kann der Programmierer ein Auto mit explodieren lassen und gleichzeitig die
entsprechende Audio Datei abspielen. Dabei muss man bedenken, dass jede
Game Engine die Komponenten anders behandelt. Ob man für die Bewegung
eines Charakters ein, zwei oder drei Komponenten benötigt, hängt von der
jeweiligen Game Engine ab.
Eine Game Engine ist daher das „Framework“ (oder auch Programmiergerüst)
für Spiele. Es enthält viele für die Spiele Entwicklung notwendigen BasisFunktionen bereit, die der Entwickler nicht jedes Mal neu erstellen will und bei
vielen Spielen gleich sind (Bsp. Game-Loop, Update-Callbacks).
Für diese Arbeit ist es relevant, dass der Spieler einen Charakter bewegen, die
Szene durch eine Oculus Rift sehen und mit den GUI-Elementen interagieren
kann.
22
Linus Meng
27.02.2014
2.5 Versionierungsdienst
SVN (Subversion) ist ein Versionierungsdienst, das dafür sorgt, dass alle
Dateien, die hochgeladen werden, archiviert werden und zu einem späteren
Zeitpunkt wieder aufrufbar sind. Da sämtliche Änderungen jeder einzelnen
Datei gespeichert werden kann, lässt sich sowohl der Fortschritt zwischen
einzelnen Updates nachvollziehen, als auch auf eine früherer stabile Version
zurückkehren, falls die aktuelle Version fehlerhaft ist (Rollback).
Als erstes muss der SVN Dienst auf einem Server eingerichtet werden. Sobald
ein Ordner und ein dazugehöriges Benutzerkonto eingerichtet sind, ist es
möglich, von jedem lokalen Computer, der den SVN Client installiert hat (z.B.
Tortiose SVN), auf diesen Ordner zuzugreifen. Zusätzlich muss bei einem
privaten Server – wie es bei dieser Arbeit der Fall ist – der Router des
Netzwerks so eingerichtet werden, dass man auch von außerhalb des lokalen
Netzwerkes darauf zugreifen kann (Portforwarding).
Als nächstes muss noch ein Ordner auf dem lokalen Computer, auf dem
gearbeitet wird, erstellt werden. In diesem Ordner werden nun alle benötigten
Projektdateien kopiert.
Der letzte Schritt beinhaltet das erstmalige Hochladen aller bereits erstellten
Dateien. Dies ist nun der Ausgangspunkt und somit Version eins. Alle weiteren
Uploads
werden
fortlaufend
archiviert
und
erhalten
eine
eindeutige
Revisionsnummer.
Durch dieses System entsteht ein großer Vorteil. Dem Nutzer ist es nun
möglich, von mehreren Computer aus zu arbeiten. Der SVN Client bietet die
Möglichkeit, eine beliebige Version des Projektes herunter zu laden.
Beispielsweise kann man das aktuelle Projekt auf seinen Laptop herunterladen
und wenn man fertig ist, den Fortschritt wieder auf den Server laden und an
seiner Workstation fortsetzten. Sollte der Fall auftreten, dass zwei verschiedene
23
Linus Meng
27.02.2014
Versionen existieren und in beiden Teile zu verwenden sind, so kann Tortoise
SVN diese beiden Versionen in eine Version zusammenfügen (SVN Merge).
Dies funktioniert nicht immer automatisch. Der Nutzer muss selber entscheiden,
welche Teile aus der jeweiligen Version verwendet werden. Der SVN Client
unterstützt den Nutzer jedoch, in dem es anzeigt, welche Inhalte sich
unterscheiden, beziehungsweise welche Inhalte in der jeweiligen Version
fehlen.
2.6 Raycast3
Beide der in Kapitel drei beschriebenen Methoden basieren auf dem Prinzip des
„Raycast“. Hierbei wird ein Strahl von einem Ausgangspunkt in die Szene
geschossen. Länge und Richtung können angegeben und zur Laufzeit
verändert werden. Sobald der Raycast mit einem Objekt kollidiert, kann man
dessen Informationen auslesen. In Unity 3D benötigt ein Raycast vier
Parameter:

Ursprung (in Vector) – Gibt den Ursprung des Raycast an

Richtung (in Vector) – Gibt die Richtung, in der der Raycast
geschossen wird, an

Länge (in float) – Gibt die Länge des Raycast an

Ebenenmaske (in LayerMask) – Ermöglicht das Ignorieren von
Objekten, mit dem der Raycast kollidiert.
4
Raycast, Physics.Raycast, 2013,
http://docs.unity3d.com/Documentation/ScriptReference/Physics.Raycast.html
24
Linus Meng
27.02.2014
3. Methodik
3.1 Evaluationsmethode
Ziel dieser Arbeit ist es, eine weitere Methode der Entwicklung von GUIElementen für die Oculus Rift in Unity 3D zu entwickeln. Dies beinhaltet, dass
die Funktionalität des Programm-Codes überprüft wird. Im Mai 2003 hat sich
Marcus Hegner bereits mit Software-Evaluationmethoden beschäftigt. Er
beschreibt,
dass
es
zwei
grundsätzliche
Arten
von
Methoden
der
Softwareevaluation gibt. Zum einen die Inspektionsmethoden und zum anderen
die Testmethoden. 4
„Vergleichsuntersuchungen zur Effektivität und Effizienz von
Inspektions- und Testmethoden zeigen widersprüchliche Ergebnisse.
[…] Inspektionsmethoden decken Genauigkeits-, Systematik- oder
Konsistenzprobleme auf. […] Wenn es darum geht, die Ganzheitlichkeit
einer Aufgabe zu sehen, sind empirische Testmethoden aber von
Vorteil.“ (Hegner 2003, S. 64)
Für diese Arbeit kommen Inspektionsmethoden in Frage, da nur die
Funktionalität der GUI Elemente geprüft werden sollen. Sollten systematische
Probleme auftauchen, können diese anhand von diesen Vorgehensweisen
erkannt werden. Außerdem würde durch eine kombinierte Überprüfung durch
Testmethoden und Inspektionsmethoden den zeitlichen Aufwand für diese
Arbeit überschreiten.
Es gibt mehrere Überprüfungsarten, die in dieser Arbeit angewendet werden
könnten. Maike Milling und Thomas Gornig haben 2004 eine Arbeit
veröffentlich, in der sie Inspektionsmethoden und Testmethoden vergleichen
und auflisten.
5
25
vgl. Hegner 2003, S.64
Linus Meng
27.02.2014
„Bei einer Inspektion überprüfen, wie der Name bereits sagt, Inspektoren
die Software nach unterschiedlichen Gesichtspunkten. Diese
Inspektoren, oder auch Gutachter sind Experten mit Softwareergonomischen Kenntnissen und Erfahrungen im Umgang mit
Anwendungsprogrammen oder Endanwender, mit bestimmten
Fachkenntnissen.“ (Milling und Gornig 2004, S. 3)
In dieser Arbeit wird diese Inspektion/Evaluation durch den Autor und
Entwickler durchgeführt. Milling und Gornig haben fünf verschiedene Arten der
Inspektionsmethoden aufgelistet:

Heruristische Evaluation

Kognitiver Walkthrough

Consistency Inspection

Standard Inspection

Feature Inspection
3.1.1 Kognitiver Walkthrough
Für diese Arbeit komm der Kognitiver Walkthrough (o. kognitives
Verfahren) in Frage, da diese Arbeit die Funktionalität der GUI-Elemente
untersucht und diese mit Hilfe des kognitiven Verfahren erläutert werden
können. Das Verfahren untersucht die Software-Ergonomie5, wobei
Effektivität und Effizient eine entscheidende Rolle spielen.6
Um ein kognitives Verfahren durchführen zu können, muss vorher eine
Zielgruppe definiert werden, anhand deren theoretischen Wissens über
das Programm, der Gutachter die Funktionalität des Programms
beurteilen kann.
6
Software-Ergonomie, Was ist Software-Ergonomie?, 2011, http://www.ergonomieleitfaden.de/index.htm
7
vgl. Milling; Gornig, 2004, S. 3-6
26
Linus Meng
27.02.2014
3.1.2 Zielgruppe der Evaluationsmethode
Für diese Arbeit ist die Zielgruppe eindeutig. Die Oculus Rift ist eine
komplett neue Technologie in der Spielebranche und viele Verbraucher
sind fasziniert von diesem Gerät und offen für neue Spielmethoden. Im
Sinus Milieus finden wir eine grobe Aufteilung der Bürger in
unterschiedliche Gruppierungen, die verschiedenen Eigenschaften
haben. Für diese Arbeit ist das adaptiv-pragmatische Milieu interessant,
da jene genau in die Zielgruppe fallen. Dies sind zumeist junge Leute,
die offen für neue Technologien und Ideen sind. Außerdem fallen
darunter auch die sogenannten „Early Adopter“. Die Early Adopters sind
jene, die zumeist die neuste Technologie kaufen und konsumieren. Die
Oculus Rift ist genau diese Art von Technologie.
Abb. 7 – Die Sinus-Milieus in Deutschland. Beschreibung und grafische
Darstellung der unterschiedlichen Milieus in Deutschland.
27
Linus Meng
27.02.2014
Schlussfolgernd kann man sagen, dass diese Zielgruppe hauptsächlich
aus dem adaptiv-pragmatischen Milieus kommt und jüngere Leute (1830 Jahre alt) anspricht. Eine weitere Einschränkung wird sein, dass nur
PC Spieler sich für diese Technologie interessieren, da die Oculus Rift
bisher auch nur für den PC entwickelt wird.
Man kann davon ausgehen, dass die meisten Leute in dieser Zielgruppe
sehr gut mit einem PC zu Recht kommen und wahrscheinlich auch
fortgeschrittene Erfahrung in Computerspielen haben. Da die Bedienung
der Oculus Rift komplett intuitiv ist, wird die Evaluation der GUIElemente nur sehr gering durch dieses neue Eingabegerät verfälscht.
Zusätzlich wird erwartet, dass die Bedienung der neuen Elemente
mindestens genau so einfach ist.
3.1.3 Methodenanwendung
Als letztes muss das Szenario beschrieben werden, in der die zu
entwickelnde Methode getestet wird. Hierbei handelt es sich um eine 3D
Szene, die in Unity 3D erstellt wird und mit so wenig wie möglich
Objekten gefüllt wird, um eine Verfälschung der Evaluation zu
vermeiden. Die Szene beinhaltet einen Boden, einen Charakter den der
Spieler steuern kann und einen Würfel mit dem der Spieler interagieren
kann. Dieser Würfel repräsentiert mögliche GUI-Elemente.
Der zu testende Ablauf sieht wie folgt aus:
1. Der Spieler guckt mit der Oculus Rift auf den Würfel und
verweilt dort.
2. Nach drei Sekunden wird der Würfel sich Rot färben und
nach weiteren drei Sekunden Blau. Dies wiederholt sich bis
der Spieler sich entschließt nicht mehr auf den Würfel zu
gucken.
28
Linus Meng
27.02.2014
3. Der Würfel behält seine Farbe bis der Spieler erneut drei
Sekunden auf diesen guckt.
4. Sollte der Spieler keine drei Sekunden auf den Würfel
gucken, wird der Countdown abgebrochen und fängt von
vorne an.
Daraus ergeben sich folgende Funktionen, die das Programm beinhalten
muss:
1. Der Würfel muss seine Farbe ändern können.
2. Es muss möglich sein drei Sekunden herunter zu zählen und
dieses muss wiederholbar sein.
3. Es muss möglich sein den Countdown abzubrechen.
4. Feststellen, ob der Spieler auf den Würfel guckt.
29
Linus Meng
27.02.2014
3.2 Beschreibung der Methoden zur Entwicklung
der GUI-Elemente
3.2.1 Methode eins - Raycast und Objekt
Bei dieser Methode werden Standart-Objekte zu GUI-Elementen
umgebaut. Beispielsweise kann man hier eine Ebene nutzten, um darauf
eine Karte der Szenerie anzuzeigen. Da die Kommunikation zwischen
Raycasts und Objekten in Unity 3D bereits gegeben ist, ist es
wahrscheinlich, dass diese Methode Erfolg haben wird.
Die Kommunikation zwischen Raycast und Objekt bedeutet, dass man
sowohl
Informationen
des
Objektes
abfragen
kann,
als
auch
Informationen oder Befehle diesem Objekt schicken kann.
3.2.2 Methode zwei - Raycast und GUI Elemente
Die zweite Variante funktioniert ähnlich wie die erste. Jedoch werden
keine 3D-Objekte in der Szene beschossen sondern GUI-Elemente, die
auf einer Ebene im 3D-Raum liegen. Hierbei stellt sich die Frage, ob es
möglich
ist,
GUI-Elemente
mit
einem
Raycast
anzusprechen.
Normalerweise würde es einen Konflikt geben, da der Startpunkt von
dem Raycast in der Kamera des Spielers beginnt und somit GUIElemente, die in der Kamera liegen, nicht getroffen werden können, da
diese nicht im 3D-Raum liegen. Vermutlich wird der Raycast die Ebene
erkennen, auf der die GUI-Elemente liegen, aber die Ebene selber nicht.
Möglicherweise kann man dennoch anhand der Position eines GUIElements und anhand des Treffpunkts des Raycasts, die GUI-Elemente
ansprechen. Falls dies möglich ist, stellt sich dennoch die Frage, ob die
30
Linus Meng
27.02.2014
erste Methode nicht schneller zu implementieren ist, und ob die
zusätzlichen Funktionen der Standard GUI-Elemente den Aufwand der
zweiten Methode rechtfertigt.
3.3 Vergleich der Methoden
3.3.1 Methode eins - Raycast und Objekt
Folgende Vorteile lassen sich in Methode eins feststellen:

Standard Objekte lassen sich in Unity 3D sehr leicht
ansprechen. Das bedeutet, dass diese Objekte leicht zu
bearbeiten sind, ohne die ursprüngliche Implementation
zu ändern.

Die Objekte lassen sich auch leicht durch komplexe 3D
Objekte austauschen, welche beispielsweise in Autodesk
Maya oder 3DS Max erstellt wurden.

Diese
Methode
lässt
sich
auch
auf
generelle
Spielfunktionen übertragen, da 3D Objekte auch in der
restlichen Szene auftauchen.
Folgende Nachteile lassen sich in Methode eins feststellen:

Da Standard Objekte verwendet werden, sind die
Möglichkeiten begrenzt. Das bedeutet, dass viele visuelle
Funktionen (wie zum Beispiel ein Mouse-Hower-Effekt)
nicht vorhanden sind.
31
Linus Meng
27.02.2014

Positionierung der GUI-Elemente müsste auch vom
Entwickler selber implementiert werden, da sich diese
nicht automatisch mit dem Spieler mitbewegen.
3.3.2 Methode zwei - Raycast und GUI-Elemente
Folgende Vorteile lassen sich in Methode zwei feststellen:

Viele Funktionen, die bei GUI-Elementen herkömmlich
sind, lassen sich auch bei dieser Methode benutzten (wie
zum Beispiel ein Mouse-Hower-Effekt).

Sämtliche Positionierungen werden bereits berechnet und
müssen nicht erneut implementiert werden.

Auch in dieser Methode ist es möglich, diese in anderen
Bereichen des Spiels erneut zu benutzten.
Folgende Nachteile lassen sich in Methode zwei feststellen:

Um neue GUI-Elemente zu verwenden, müssen diese
von Entwickler selber geschrieben werden. Dies ist
kompliziert, da die vorgefertigten GUI-Elemente tief in der
Game Engine integriert sind.

GUI-Elemente können lediglich im visuellen Bereich
konfiguriert werden.

Diese GUI-Elemente lassen sich nicht durch 3D Objekte
austauschen.
32
Linus Meng
27.02.2014
3.3.3 Zusammenfassung der Vor- und Nachteile
Anhand der vorherigen Auflistung lässt sich erkennen, dass Methode
eins weniger Nachteile bietet, als Methode zwei. Besonders wichtig ist
das Potenzial, welches sich in Methode eins befindet. Diese Methode
könnte dafür sorgen, dass es in Zukunft nur noch 3D-Szenen gibt und
GUI-Elemente nicht mehr in einer Kamera verbaut werden. Methode
zwei hingegen hat den Vorteil, dass es bereits viele Funktionen für
bestehende GUI Elemente gibt in Unity 3D und somit mit dieser Variante
viele Möglichkeiten offen bleiben. Vermutlich wird Methode eins ein
solides Ergebnis bringen, da diese auf einfache Funktionen zurückgreift
und kein bestehender Code umgeschrieben werden muss. Daher ist zu
erwarten, dass diese Methode ein zufriedenstellendes Ergebnis liefern
wird. Bei Methode zwei ist zu erwarten, dass es Probleme bei der
Implementierung geben wird, wobei bestehender Code durch den
Entwickler (OculusVR) bearbeitet werden muss. Sollte diese Methode
jedoch funktionieren, könnte ein grafisch schöneres Ergebnis bei
gleicher Funktionalität erzielt werden.
33
Linus Meng
27.02.2014
4. Durchführung
4.1 Versionierungsdienst
Als erster Schritt wurde die Datensicherung und Versionierung sichergestellt.
Dies ist einer der wichtigsten Maßnahmen, damit auch über einen langen
Zeitraum und mehreren hundert Veränderungen im Projekt, alle Daten gesichert
sind.
Zusätzlich
können
mit
Subversion
alle
Versionen
der
Dateien
wiederhergestellt werden und Veränderungen die bereits mehrere Wochen oder
Monate zurückliegen erneut nachvollzogen werden.
Nun wurde ein Ordner erstellt, in dem sich sämtliche Dateien befinden. Dazu
gehören sowohl die Projekt Dateien von Unity 3D, als auch alle Dokumente und
Referenzen der restlichen Arbeit. Als nächstes wird ein Repository erstellt,
welches den Ordner auf dem lokalen PC mit dem Ordner auf dem Server
verbindet. Alle bereits erstellten Dateien werden auf einen lokalen Server
hochgeladen und gespeichert. Jetzt können neue Dateien hinzugefügt werden
oder bereits existierende bearbeitet und mit dem Server synchronisiert werden.
Als Server dient ein Synology DS212+ mit dem Paket Subversion und für den
Client wird ein PC mit der Software Tortoise SVN verwendet. Mit Hilfe dieser
Methode, ist es sichergestellt, dass keine Dateien verloren gehen. Sollten
einzelne Dateien oder auch das gesamte Projekte auf der Workstation verloren
gehen, ist es jederzeit möglich die Dateien von Server erneut runterzuladen.
34
Linus Meng
27.02.2014
4.2 Unity 3D
Unity 3D ist die Game Engine, die in dieser Arbeit benutzt wird, um GUI
Elemente für die Oculus Rift zu entwickeln. Für diese Arbeit wurde die ProVersion von Unity 3D verwendetet, da die Oculus Rift Integration nur mit dieser
funktioniert. Bei dem Kauf eines Developer-Kits der Oculus Rift, ist es möglich,
für einen Zeitraum von drei Monaten die Pro-Version von Untiy 3D zu benutzen.
Es wurde also Unity 3D installiert und die Pro-Version aktiviert.
Als nächstes wurde eine Szene erstellt, die es dem Spieler erlaubt, sich auf
einer Ebene zu bewegen. Diese „Test-Szene“ wurde im Laufe dieser Arbeit
mehrfach bearbeitet. Die Bearbeitungen wurden jedoch hauptsächlich im Code
vorgenommen, um bestimmte Ereignisse darzustellen, wie zum Beispiel das
Ablaufen eines Countdowns, der anzeigt wie lange der Spieler auf ein Objekt
gucken muss, bis das Objekt aktiviert wird. Alle Objekte in dieser Szene sind
vorgefertigt und werden mit Unity 3D mitgeliefert. Das bedeutet, dass in dieser
Arbeit keine grafischen Entwicklungen vorgenommen wurden, sondern nur
funktionale Entwicklungen.
4.3 Oculus Rift Unity 3D Integration
Um die Oculus Rift Unity 3D Integration im bestehenden Projekt zu nutzen,
muss ein Custom-Package von OculusVR eingebunden werden. Dieses Paket
wurde von der offiziellen Website von OculusVR (www.oculusvr.com)
heruntergeladen. In diesem Paket befinden sich weitere Assets, die verwendet
wurden, um die bestehende Szene zu bearbeiten, damit die Oculus Rift
verwendet werden kann. Dazu gehört das Spieler Objekt, welches mehrere
Dateien enthält, die die Berechung der 3D-Szene übernehmen. Außerdem
werden mehrere Werkzeuge integriert, damit der Entwickler direkt die gespielte
Szene analysieren oder gegebenenfalls anpassen kann (wie zum Beispiel
Bilder pro Sekunde, Field of View, Prediction Time, IPD oder Augenhöhe
(Spielergröße)).
Der Autor hat festgestellt, dass die Entwickler von der Oculus Rift (OculusVR)
eine eigene Klasse (guiHelper) geschrieben haben, die von der ursprünglichen
35
Linus Meng
27.02.2014
GUI-Klasse ableitet. Mit Hilfe dieser Klasse ist es möglich, dass GUI Elemente
nicht mehr in einer Kamera liegen, sonder davor. Dies ist besonders wichtig, da
für stereoskopisches 3D zwei Kameras benötigt werden, die die beiden Augen
simulieren. Sollten nun alle GUI-Elemente in einer Kamera liegen, würden diese
nur auf dem linken bzw. rechten Auge sichtbar sein, was natürlich nicht
angenehm für den Spieler sein würde. Man kann die GUI-Elemente auch nicht
einfach auf beide Kameras kopieren, da dann sämtliche Berechnung der drei
dimensionalen Sicht, die bereits für die Darstellung der Szene gemacht werden,
erneut durchgeführt werden müssten. Somit hat OculusVR eine Ebene erzeugt
in den GUI-Elemente direkt vor dem Spieler schweben. Diese Ebene kann nun
auch in Große, Rotation und Skalierung angepasst werden. Damit gehören die
GUI-Elemente sozusagen zum 3D Raum, jedoch sind die GUI Elemente selber
nicht drei dimensional und können auch nicht angesprochen werden.
Im folgenden Kapitel wird beschrieben wie die beiden erforschten Methoden
angewendet wurden.
4.3.1 Raycast und 3D-Objekte
Als Testfunktion für diese Methode sollte ein Strahl aus der rechten
Kamera des Spielers in die Szene geschossen werden. Sobald dieser
mit einem Objekt kolliediert, dass den Tag „GUI“ enthält, wird ein Countdown ausgelöst, der einen konstanten Wert herunterzählt. In diesem
Beispiel sind es drei Sekunden. Solange der Spieler auf das Objekt mit
dem Tag „GUI“ schaut, werden die drei Sekunden heruntergezählt. Falls
der Spieler nicht mehr auf das Objekt schaut, wird der Cound-Down auf
drei Sekunden zurückgesetzt. Sobald die drei Sekunden abgelaufen
sind, verändert sich die Farbe des Objektes zu rot. Schaut der Spieler
erneut drei Sekunden auf das Objekt, verändert sich die Farbe zu blau.
36
Linus Meng
27.02.2014
Damit dies funktioniert wurden folgende Schritte durchgeführt:
Abb. 8 – In dieser Abbildung lässt sich die Funktion CastRayRightEye()
erkennen. In dieser Funktion wird der Raycast initialisiert.
Zuerst werden mehrere Variablen erstellt. Zum einen der Strahl selber,
der vom Typ „Ray“ ist, welches eine Klasse von Unity 3D ist. Als
nächstes werden drei Variablen erstellt, die zur Abfrage des CoundDowns gehören („currentOjectName“ vom Typ „String“, „timer“ vom Typ
„float“ und die konstante Variable „WAIT_FOR_SECONDS“ vom Typ
„const float“). Als nächstes wird der Strahl initialisiert, der von der
rechten Kamera nach vorne in die Szene geschossen wird. Sollte dieser
etwas treffen, wird die Funktion „OnRayCastHit()“ aufgerufen. Diese
Funktion prüft, ob der Strahl ein Objekt mit dem Tag „GUI“ trifft. Sollte
dies der Fall sein, wird der Name dieses Objektes in der Variable
„currentObjektName“ gespeichert, damit dieses Objekt später modifiziert
werden kann.
37
Linus Meng
27.02.2014
Abb. 9 – In dieser Abbildung sieht man die OnRayCastHit() Funktion. Diese
Funktion analysiert die Trefferinformationen des Raycasts, wenn dieser ein
Objekt trifft.
Gleichzeitig werden drei Sekunden herunter gezahlt. Dies wird mit den
Variablen „timer“ und „Time.deltaTime“ realisiert. Diese zieht die
vergangen Zeit seid dem letzten Aufruf ab und subtrahiert diesen Wert
von den gegeben drei Sekunden. Sobald drei Sekunden abgelaufen
38
Linus Meng
27.02.2014
sind, wird nun Mithilfe der Trefferinformationen des Raycasts das Objekt
modifiziert. Zuerst wird die Farbe des Objektes mit Hilfe der Funktionen
„renderer.material.color = Color.Red“ auf Rot gesetzt. Nach den
nächsten drei Sekunden wird die Farbe auf Blau gesetzt („Color.Blue“).
Dies geschieht nun im Wechsel, bis der Spieler nicht mehr auf das
Objekt schaut.
Abb. 10 – In dieser Abbildung sieht man den Strahl (weiß) und das getroffenen
Objekt, welches derzeit Rot gefärbt ist.
Die im Kapitel 4.3 beschrieben Funktion der Klasse von OculusVR
(„guiHelper“) wurde hier genutzt, um dem Spieler anzuzeigen wie lange
er noch auf das Objekt gucken muss, bis das Event ausgelöst wird.
Mit dieser Erkenntnis könnten sich Spielmechaniken erzielen lassen, die
bereits in früheren Spielen erfolgreich waren, wie zum Beispiel in
Splinter Cell Double Agent.
In diesem Spiel muss der Spieler Dateien von einem Terminal
herunterladen. Dazu hält der Spieler die linke und die rechte Maustaste
gedrückt, während er auf das Terminal zielt. Diese Kombination von
zwei Tasten und das Zielen auf das Objekt könnte mit der Oculus Rift
und der oben beschrieben Funktion vereinfacht werden, indem der
39
Linus Meng
27.02.2014
Spieler auf das Objekt schaut und der Download automatisch ausgeführt
wird, solange der Spieler auf das Objekt schaut.
Abb. 11 – In dieser Abbildung kann man erkennen, wie der Spieler im Spiel
Splinter Cell Double Agent die Daten an einem Terminal herunterladen muss.
4.3.2 Raycast und GUI-Elemente
Ähnlich wie bei der ersten Methode wird auch hier ein Strahl aus der
rechten Kamera des Spielers geschossen. Jedoch sollte in dieser
Methode kein 3D Objekt angeschossen werden, sondern eine 2D
Ebene, die zur Laufzeit erzeugt wird. Diese 2D Ebene wurde von den
Entwicklern der
Oculus
Rift
erstellt,
um die
dreidimensionalen
Berechungen nur einmal durchzuführen. Hierbei entstanden folgende
Probleme:

Die Rückmeldung des Raycast erfolgte nicht, da die
Ebene über keine Kollisionsberechnung verfügt. Daher
konnten auch keine Informationen über dieses Objekt
ausgelesen werden.
40
Linus Meng
27.02.2014

Da das Objekt zur Laufzeit über ein Script initialisiert
wird, war es auch nicht möglich, die Ebene über den
Unity
3D
Editor
zu
bearbeiten
und
eine
Kollisionskomponente (Rigidbody - Physikkomponente)
hinzuzufügen.
Dadurch wurde das Script, welches die 2D Ebene erstellt, bearbeitet und
versucht, eine Kollisionskomponente einzubauen. Dies erwies sich als
äußerst schwierig, da das Script von einer anderen Klasse abgeleitet
wird, welche sich am Ende einer Baumstruktur befindet. Dies führte
dazu, dass mehrere Scripts bearbeitet werden mussten. Schlussendlich
hatte der Autor keinen Erfolg, diese Methode zu implementieren.
Daraus folgend hätten sich wahrscheinlich weitere Probleme ergeben.
Sobald die Ebene eine Kollisionskomponente bekommen hätte, wäre
diese auch mit allen anderen Objekten in der Szene kollidiert. Daraus
folgt, dass eine clevere Positionierung benötigt werden würde, um eine
Fehlfunktion ausschließen zu können.
41
Linus Meng
27.02.2014
5. Ergebnisse
5.1 Ergebnisse
Nach dem Beenden der Entwicklungsphase hat sich herausgestellt, dass
Methode eins die einzige ist, die erfolgreich implementiert werden konnte. Alle
Ziele in dieser Methode wurden erreicht. Diese Methode erweitert GUI
Elemente sowohl in der Hinsicht, dass der Spieler mit Kopfbewegungen diese
ansteuern kann, als auch, dass die GUI Elemente im 3D Raum liegen und somit
die Immersion des Spielers fördern. Es ist möglich mit der Oculus Rift 3D
Objekte anzusprechen und somit auch vorgefertigte Kommandos auszuführen.
Je nach Bedarf des Spiels können an einer bestimmten Position im Code nun
beliebig viele Funktionen aufgerufen werden, die das Spielgeschehen
beeinflussen. Zum Beispiel kann über diese Interaktion mit dem Objekt eine
Explosion in der Szene ausgelöst werden, oder aber der Spieler kann sein
Inventar öffnen. Dadurch ist diese Methode nicht nur für spezifische Genres
bestimmt, sonder kann für jedes Oculus Rift Spiel verwendet werden.
Die zweite Methode erwies sich als nicht erfolgreich. Es war dem Autor nicht
möglich, diese Methode in der gegebenen Zeit zu implementieren. Mehrere
Fehler sind aufgetreten. Zum einen war es nicht möglich die 2D Ebene
anzusprechen auf Grund von fehlender Kollisionsabfrage und zum anderen
wurde dieses Objekt zur Laufzeit initialisiert, was die Bearbeitung erschwerte.
Die Kollisionsabfrage fand nicht statt, da der Strahl durch die Ebene hindurch
geschossen ist. Das liegt daran, dass auf der 2D Ebene keine „Collider“Komponente ist. Generell ist es möglich, auch zur Laufzeit weitere
Komponenten zu einem Objekt hinzuzufügen, jedoch war dieses Objekt von
den Entwicklern der Oculus Rift entworfen und basierte daher nicht auf der
üblichen Zugänglichkeit anderer Unity 3D Objekte.
Die
Entwicklung
einer
Alternativmethode,
oder
das
Verändern
der
Vorgehensweise, hätten den zeitlichen Rahmen dieser Arbeit überschritten.
42
Linus Meng
27.02.2014
5.2 Evaluationen
Evaluiert man die erste Methode anhand des kognitiven Verfahrens, entsteht
folgende Frage:
Ist der Ablauf der zu benutzenden Funktionen klar und kann der Spieler anhand
des in Kapitel 3.1.3 beschriebenen Ablaufs diesen erkennen?
Aufgrund der sehr einfach gehaltenen Testszene kann der Spieler alle
Funktionen mit seinen Kopfbewegungen erreichen. Mit Hilfe des Countdowns
wird dem Spieler eine Rückmeldung gegeben, die ihn dazu animiert, weiterhin
auf das Objekt zu gucken. Sobald der Würfel sich Rot färbt, wird der Spieler von
dem Objekt wegschauen. Diese Rückmeldungen reichen aus, um dem Spieler
intuitiv die Funktionen mitzuteilen. Daraus ergeben sich folgende Vorteile für
diese Methode:

Der Spieler muss keine Tastenkombinationen erlernen, um mit
dem GUI-Element zu interagieren.

Der Spieler muss keine Maus benutzten, um mit GUI-Elementen
zu interagieren, oder sich in der dreidimensionalen Szene
umzugucken.
Folgende Nachteile lassen sich in dieser Methode erkennen:

Der Spieler muss die Oculus Rift benutzten, um mit den GUIElementen interagieren zu können.

Der Spieler könnte Schwierigkeiten haben, kleine GUI-Elemente
mit der Oculus Rift genau anzuschauen.
Fast man nun die Ergebnisse und die Evaluation zusammen, kann man
erkennen, dass die Methode eins erfolgreich implementiert und getestet wurde.
Die Methode wurde ohne größere Komplikationen dem bestehenden CodeGerüst hinzugefügt. Alle Funktionen sind für einen Spieler nachvollziehbar und
43
Linus Meng
27.02.2014
verständlich. Kritisch betrachtet sind die Vorteile der ersten Methode in Summe
größer als die Nachteile, die sich dadurch ergeben. Vergleicht man diese
Methode mit der aus dem Spiel Splinter Cell Double Agent, lässt sich klar
erkennen, dass die Spielsteuerung klar vereinfacht wurde. Aus einer
Kombination
von
drei
Aktionen
(Mausbewegung,
Rechter-
und
Linkermaustaste) wurde eine einzige Aktion (Kopfbewegung). Hierbei lässt sich
das potenzial der 3D Visualisierung durch die Oculus Rift erkennen, sondern
auch welches Potenzial die Oculus Rift im Bereich Spielsteuerung und GUI
Einbindung hat.
44
Linus Meng
27.02.2014
6. Zusammenfassung und Fazit
Ziel dieser Arbeit war es, drei dimensionale GUI-Elemente in Unity 3D für die Oculus
Rift zu entwickeln. Viele Aspekte wurden dabei berücksichtig.
Es gab zahlreiche Projekte in den letzten Jahrzehnten, die versucht haben eine
virtuelle Realität zu erstellen. Viele davon haben den heutigen Stand der virtuellen
Realität maßgeblich geprägt. Die Oculus Rift ist eine der vielversprechenden Projekte
und ist stark daran beteiligt, dass weitere Projekte wie die Omni und der PrioVR
zustande gekommen sind. Die Oculus Rift Überzeugt mit ihrer präzisen Übertragung
der Kopfbewegungen und dem Ziel, eine 3D-Brille für den Konsumentenmarkt zu
entwickeln.
6.1 Grundlagen
In dieser Arbeit wurden mehrere Methoden eingesetzt und miteinander
kombiniert. GUI-Elemente haben einen entscheidenden Beitrag daran, dass der
Spieler sich näher am Spiel befindet. Viele aufwendige Kommandos werden
durch das GUI vereinfacht und grafisch dargestellt. In Bezug auf die Oculus
Rift, sollte dies genau so, wenn nicht gar besser sein. Um grafische Elemente
für die Oculus Rift zu ermöglichen, wurde Unity 3D, die von OculusVR
entwickelte Unity Integration und Visual Studio benutzt. Unity 3D ist eine Game
Engine welche in der Lage ist für verschiedenste Plattformen Spieleentwicklung
zu ermöglichen. Für diese Arbeit wurde Untiy 3D verwendet, da zum einen der
Autor viel Erfahrung mit Unity 3D und der GUI Entwicklung in dieser Game
Engine hat und zum anderen, weil Unity 3D die erste Entwicklungsumgebung
war, mit der die Oculus Rift kompatibel war. Die Oculus Rift Unity Integration ist
eine Vorraussetzung, damit die Oculus Rift mit Unity 3D benutzt werden kann.
Diese Unity Integration bietet außerdem einige Funktionen, auf die ein
Entwickler zugreifen kann. Zum einen lassen sich Variablen anschauen,
beziehungsweise anpassen, um Spiele zu optimieren. Außerdem ist es möglich
bestehenden Code anzupassen oder neuen Code hinzuzufügen. Dadurch ist es
möglich,
neue
Spieleentwicklung
Funktionen
zu
zu
schreiben
entdecken.
Visual
und
neue
Studio
Methoden
2010
wurde
der
als
45
Linus Meng
27.02.2014
Entwicklungsumgebung verwendet. Diese ermöglicht das Schreiben und
Bearbeiten von Code-Dateien, mit Hilfe von verschiedensten Funktionen, wie
zum Beispiel IntelliSense. IntelliSense analysiert bestehenden Code und weist
den Entwickler darauf hin, wenn ein Ausdruck nicht korrekt geschrieben wurde.
Außerdem kann es auch einzelne Ausdrücke dem Entwickler vorschlagen, wie
der gesamte Ausdruck vollendet werden könnte. Auf Grund dieser und der
bereits vorhandenen Erfahrung mit Visual Studio wurde diese der in Unity 3D
bereits eingebundenen Entwicklungsumgebung MonoDevelop vorgezogen.
Die Grundlage, auf der sich die beiden angewandten Methoden beziehen, ist
die Klasse des Raycast. In Untiy 3D ist diese eine Standard Klasse und lässt
sich mit vielen anderen Komponenten verknüpfen. Bei einem Raycast wird ein
Strahl in eine drei dimensionale Szene geschossen. Dieser Strahl hat einen
Startpunkt, eine Richtung und gegebenenfalls auch einen Endpunkt. Sobald
dieser Strahl einen Gegenstand trifft, können Informationen über diesen
abgerufen werden. Weiter können auch Informationen zurückgesendet werden
und somit den Gegenstand der getroffen wurde zur Laufzeit bearbeiten.
6.2 Methodik
Da in dieser Arbeit neue Software geschrieben worden ist, musste auch eine
entsprechende Evaluation dieser Software vorgenommen werden. Hierzu hat
im Jahr 2003 Marcus Hegner zwei Evaluationsarten aufgestellt. Zum einen die
Inspektionsmethoden und zum anderen die Testmethoden. Diese Methoden
wurden wiederum 2004 von Maike Milling und Thomas Gornig verglichen. Für
diese Arbeit kam eine Inspektionsmethode in Frage, da Testmethoden den
Umfang dieser Arbeit überschreiten würden. Zu den Inspektionsmethoden
gehört das Kognitive Verfahren, bei dem die Software-Ergonomie anhand von
Fragestellungen und Beschreibungen untersucht wird.
Um dieses Verfahren anzuwenden, musste eine Zielgruppe definiert werden, in
die die Oculus Rift und die potentiellen Spiele hineinpassen. Da die Oculus Rift
eine sehr neue Technologie ist, sind hauptsächlich Fachkundige an dieser
Technik interessiert. Dazu gehören zum einen die Entwickler, als auch die
Verbraucher, die sich für Computerspiele interessieren. Diese Merkmale lassen
46
Linus Meng
27.02.2014
sich hauptsächlich in dem „adaptiv-pragmatischen“ Sinus Milieu wiederfinden.
In diese Kategorie fallen auch die so genannten „Early Adopters“. Die Early
Adopters interessieren sich besonders für die neueste Gegenstände auf dem
Markt, unter anderem auch Technologien. Die Oculus Rift gehört zu diesen
neuartigen Technologien.
In dieser Arbeit wurden zwei neue Methoden verglichen, um einerseits die
Immersion des Spielers im Spiel zu verbessern und andererseits die GUIElemente für die Oculus Rift zu verbessern. Die erste Methode benutzt die
Funktion eines Raycasts und bestehende 3D-Objekte aus Unity 3D. Hierbei
wird ein Raycast erzeugt, der in die Szene geschossen wird und mit dem 3D
Objekt kollidieren soll, um danach dieses Objekt zu modifizieren. Bei dieser
Methode entsteht der Vorteil, dass beide Funktionen problemlos kombiniert
werden können, da beide bereits in Unity 3D vorhanden sind. Außerdem kann
man auch das 3D Objekt nachträglich austauschen und verbessern. Nachteil
hingegen ist, dass das 3D Objekt nur wenige bereits vorhandene Funktionen
zur grafischen Darstellung besitzt. Diese müssten nachträglich von einem
Entwickler hinzugefügt werden. Die zweite Methode benutzt auch die Funktion
eines Raycast, kombiniert diese aber mit bestehenden GUI-Elementen. Hierbei
wird ein Raycast in die Szene geschossen und dieser sollte dann mit den
modifizierten GUI-Elementen von den OculusVR Entwicklern kollidieren.
Standard GUI-Elemente aus Unity 3D können nicht verwendet werden, da diese
in der Kamera des Spielers liegen und somit nicht vom Raycast getroffen
werden können. Bei den modifizierten GUI-Elementen von OculusVR wurden
die Standard GUI-Elemente auf eine durchsichtige 2D Ebene vor dem Spieler
verschoben. Nun stellte sich die Frage, ob der Raycast mit dieser Ebene
kollidieren kann.
6.3 Durchführung
Zu Beginn dieser Arbeit wurde ein Versionierungsdienst eingerichtet, der
sicherstellt, dass alle Dateien dieser Arbeit auf einem externen Server gesichert
sind. Mit Subversion und dem Tool SVN Tortoise ist es auch möglich alle
Dateiversionen
rekursiv
wiederherzustellen.
Dadurch
lassen
sich
auch
Veränderungen an Projektdateien nachvollziehen, die bereits vor mehreren
47
Linus Meng
27.02.2014
Wochen gemacht wurden. Hierzu wird ein Server eingerichtet, der die Dateien
verwaltet. Außerdem wird ein Ordner auf der privaten Workstation erstellt in
dem alle Projektdateien gespeichert werden. Nun wird der Ordner mit dem
Server verknüpft, sodass der Entwickler jederzeit neue Dateien hochladen,
beziehungsweise
bestehende
Dateien
herunterladen
kann.
Damit
ist
sichergestellt, dass im Falle einer Korruption der Daten keinerlei Datenverluste
entstehen können.
Als nächstes wurden Unity 3D, Oculus Rift Unity 3D Integration und Visual
Studio installiert und eingerichtet. Wichtig hierbei war es, dass Unity 3D vor der
Untiy Integration installiert wird, da Unity eine Vorraussetzung für die Unity
Integration ist. Außerdem war es wichtig, dass das Unity 3D und Visual Studio
miteinander verknüpft werden, sodass in Visual Studio geschriebener Code
direkt in Unity 3D benutzt werden konnte.
In Unity 3D wurde nun eine Testszene erstellt, in der die beiden verschiedenen
Methoden getestet werden konnten. Die Szene beinhaltet nur die nötigsten
Objekte, damit keine Verfälschungen während der Evaluation entstehen
können.
Die erste Methode wurde mit der Unity Funktion „Ray()“ und einer Reihe von
Abfragen realisiert. Hierbei wurde zuerst der Raycast initialisiert und mit den
Parametern „Startpunkt“ und „Richtung“ definiert. Der Startpunkt befindet sich in
der rechten Kamera des Spielers, sodass der Strahl immer beim Spieler
anfängt. Die Richtung wurde mit einem Vektor, der vom Spieler nach vorne
geht, definiert. Dadurch wurde sichergestellt, dass der Strahl sich mit dem
Spieler bewegt. Als nächstes wurde abgefragt, ob der Strahl das GUI-Objekt,
welches in der Szene platziert ist, trifft. Falls dem so ist, startet ein Countdown,
der dem Spieler signalisiert, wie lange er noch auf dieses Objekt gucken muss.
Sobald der Spieler drei Sekunden auf dieses Objekt geguckt hat, wird das
Objekt mit der Funktion „renderer.material.color = Color.red“ auf die Farbe rot
gesetzt. Sollte der Spieler weitere drei Sekunden auf das Objekt gucken, färbt
es sich blau. Durch eine weitere Abfrage, ob das Objekt bereits rot oder blau ist,
kann die jeweils andere Farbe zugewiesen werden und somit ist dieser Prozess
mehrfach wiederholbar.
48
Linus Meng
27.02.2014
Ähnlich wie bei der ersten Methode wurde bei der zweiten versucht, die Ebene
zu treffen, auf der die modifizierten GUI-Elemente liegen. Hierbei hat sich
herausgestellt, dass diese Ebene keine Kollisionsabfrage enthält. Aus diesem
Grund war es auch nicht möglich, diese Ebene mit einem Raycast
anzusprechen. Daraufhin wurde versucht, eine Kollisionskomponente zu dieser
2D Ebene hinzuzufügen, jedoch hat die komplexe Implementierung den Autor
daran gehindert, diese Bearbeitung durchzuführen. Zusätzlich wird die 2D
Ebene zur Laufzeit erstellt. Das bedeutet, dass diese nicht im Editor bearbeitbar
war, was die Modifizierung nochmals erschwerte.
6.4 Ergebnisse und Evaluationen
Fast man die Ergebnisse zusammen hat sich herausgestellt, dass die erste
Methode erfolgreich implementiert werden konnte. Jedoch konnte die zweite
Methode nicht in der gegebenen Zeit implementiert werden. Fehlende
Zugänglichkeit in der Bearbeitung der modifizierten GUI Elementen führte dazu,
dass keine Kollisionsabfrage über einen Raycast stattfinden konnte. Die
Überarbeitung der Vorgehensweise in Methode zwei hätte zudem den zeitlichen
Rahmen dieser Arbeit überschritten. Zufriedenstellend dagegen war die erste
Methode. Hierbei war es möglich die Kommunikation zwischen Raycast und 3D
Objekt herzustellen. Die erste Methode weist allerdings auch einen Nachteil auf.
Hierbei sind die Funktionen des GUI-Elements sehr eingeschränkt, da dieses
nur ein Standard Objekt in Unity 3D ist. Hier müsste der Entwickler weitere
grafische Funktionen einbauen, damit diese Methode in einem Spiel
verwendbar ist.
Bei der Evaluation der ersten Methode konnte anhand einer Fragestellung
festgestellt werden, dass der Spieler aus der entsprechenden Zielgruppe in der
Lage sein würde die GUI Funktionen zu benutzten. Diese wurde anhand des
Funktionsablaufs und der Benutzerbeschreibung bestätig. Vergleicht man diese
Methode mit einem anderen Spiel, in dem ähnliche Ablaufe stattfinden, wie zum
Beispiel Splinter Cell Double Agent, kann man erkennen, dass der Bedienablauf
durch die Oculus Rift und den neuen GUI-Elementen vereinfacht wurde.
49
Linus Meng
27.02.2014
Anhand der Ergebnisse und der Evaluation wurde die These dieser Arbeit
bestätigt. Es ist möglich, GUI-Elemente für die Oculus Rift mit Hilfe von Unity
3D zu erstellen. Es wurde zwar nur eine Methode erfolgreich umgesetzt,
dennoch konnte diese Methode überzeugen und die These bestätigen.
Sollte jedoch diese Methode in fertigen Spielen zum Einsatz kommen, muss
vorerst die These umgebaut werden, sodass verschiedene Methoden getestet
werden können. Außerdem sollten auch mehrere Evaluationsmethoden
angewandt werden, damit ein größeres Spektrum an Tests abgedeckt werden
kann. Hierbei müssten auch weitere grafische Elemente entwickelt werden,
damit Testmethoden mit Probanten durchgeführt werden können. Damit würde
sich eine optimale Testumgebung schaffen lassen, die sowohl grafische, als
auch
funktionelle
Entwicklungen
enthält
und
darauf
basierend
auch
Inspektionsmethoden und Testmethoden durchführen könnte.
50
Dokumentation der Bachelor Arbeit von Linus Meng
27.02.2014
Literaturverzeichnis
1. http://www.mortonheilig.com/
2. http://www.focus.de/digital/computer/technik-lexikon/guigraphical-userinterface_aid_413051.html, 2012
3. http://www.microsoft.com/net, 2012
4. http://docs.unity3d.com/Documentation/ScriptReference/Physics.Raycast.html, 2014
5. Hegner, Marcus (2003): Methoden zur Evaluation von Software.
InformationsZentrum. Bonn. Online verfügbar unter
http://www.gesis.org/fileadmin/upload/forschung/publikationen/gesis_reihen/i
z_arbeitsberichte/ab_29.pdf
6. http://www.ergonomie-leitfaden.de/index.htm, 2011
7. Milling, Maike; Gornig, Thomas (2004): Usability Engeneering.
Inspektionsmethoden vs. Testmethoden. Online verfügbar unter
http://wwwswt.informatik.unirostock.de/deutsch/Mitarbeiter/michael/lehre/Usab_WS2003/vortrag_02/Aus
arbeitung.pdf
li
27.02.2014
Anhang
1. Dokumentation der praktischen Arbeit
Anhang auf CD
1. Bachelor Arbeit von Linus Meng
2. Screenshots und eigene Bilder
3. OculusUnityIntegrationGuide - PDF
4. Usability Engeneering Inspektionsmethoden vs. Testmethoden von
Maike Milling und Thomas Gornig - PDF
5. Methoden zur Evaluation von Software von Marcus Hegner – PDF
lii
27.02.2014
Dokumentation
Zeitraum:
01.09.2013 – 29.09.2013
Milestone:
Milestone 1
Tätigkeit:
Recherche
Ergebnis:
Grundlegende Literatur
Beschreibung der Aufgabe:
Innerhalb der ersten Woche war es vorgesehen, dass intensive Recherche über
folgende Themen betrieben wird:
Virtual Reality

Geschichte und Entwicklung der Virtuellen Realität

Aktueller Stand der Oculus Rift

Zukünftige Projekte
Oculus Rift

GUI- Entwicklung

Unity 3D

GUI-Entwicklung

Oculus Rift Integration
Vorgehensweise:
Zu Beginn war es wichtig, einen Überblick über das gesamte Thema zu bekommen. Da
ich bereits einige Erfahrung mit der Entwicklung von GUI-Elementen in Unity 3D hatte,
ging es darum, diese mit der Benutzung von virtueller Realität zu verbinden. Dafür ist
es notwendig gewesen, dass zunächst die Entstehung von Virtual Reality untersucht
wird.
liii
27.02.2014
Als nächstes musste die Oculus Rift und ihrer Unity 3D Integration untersucht werden,
um Verbindungen zwischen der Entwicklung vergangener 3D-Brillen zu erstellen.
Nun mussten andere Projekte gefunden werden, die vielleicht ähnliche Ergebnisse
erstreben.
Ergebnis:
Seit dem ersten Versuch eine 3D-Brille zu erstellen, gab es einige Projekte die
dasselbe Ziel hatten. Heute gibt es einige vielversprechende Projekte wie zum Beispiel
Oculus Rift oder Omni. Auch wenn Omni keine 3D-Brille entwickelt, versuchen sie
dennoch eine virtuelle Welt zu erstellen bzw. die Realität mit einer virtuellen Welt zu
ergänzen. Dies ist das gleiche Ziel, was die Entwickler der Oculus Rift verfolgen.
Der Versuch eine virtuelle Welt zu erstellen, ließ nicht lange auf sich warten.
Sensorama wurde von Mortan Heilig entwickelt. Sensorama ist eine Maschine, die
versucht alle menschlichen Sinneseindrücke zu simulieren. Diese Maschine kann
beispielsweise Vibrationen im Sitz, Gerüche oder ein stereoskopisches Bild erzeugen.
Bereits damals hat Mortan Heilig gezeigt, dass das Erzeugen einer virtuellen Realität
möglich ist, jedoch waren die Kosten der Produktion zu hoch, und zusätzlich traf seine
Idee meistens auf Desinteresse.
Hinweis: Ina Arendt, die als Supervisor für diese Arbeit dient, hat bei der Suche nach
geeigneten Quellen dem Autor geholfen.
Probleme:
Mein größtes Problem entstand, als ich meinen ersten Auftrag bekommen habe. Ich
wurde von Benjamin Lach gefragt, ob ich ein Programm schreiben kann, dass
Farbinformationen aus einer Bilddatei/Videodatei auslesen und speichern kann.
Daraufhin hat er mich mit meinem heutigen Auftraggeber Klaus Kaireis in Kontakt
gebracht. Da dieses Programm mehrere hundert Stunden und somit einen ähnlichen
Aufwand wie diese Bachelorarbeit beansprucht, war es mir nicht möglich diese Arbeit
bis Dezember 2013 zu beenden. Grundsätzlich ist es nicht aufwändig, Farbwerte aus
Bild- und Videodateien auszulesen, da dieses Programm aber kein Entwicklungstool
bzw. kein internes Tool, sondern gegebenenfalls weiterverkauft werden soll, muss das
liv
27.02.2014
fertige Programm nicht nur komplett fehlerfrei sein, sonder auch professionell gestaltet
werden. Zusätzlich muss dieses Programm auch einen Kopierschutz enthalten. All
diese Funktionen werden wahrscheinlich insgesamt einen Zeitaufwand von 600
Stunden beanspruchen.
Verbesserungen:
In diesem Fall ist es schwierig zu sagen ob Fehler gemacht wurden. Ich hätte den
Auftrag ablehnen können und mich somit viel besser auf diese Arbeit konzentrieren
können, jedoch könnte der Auftrag das Sprungbrett für meinen Berufseinstieg sein.
Diese Chance wollte ich mir nicht entgehen lassen.
Schlussendlich stehe ich unter einem hohen Zeitdruck. Und um dies zu bewältigen,
musste ich klare Trennungen machen und mir meine Zeit für das jeweilige Projekt
blockweise einteilen.
lv
27.02.2014
Dokumentation
Zeitraum:
30.09.2013 – 3.10.2013
Milestone:
Milestone 2
Tätigkeit:
Erstellung der Entwicklungsumgebung
und des Kapitles „Einleitung“
Ergebnis:
Entwickungsumgebung erstellt,
Kapitel „Einleitung“ nicht fertig
Bevor die Entwicklung der GUI Elementen beginnen konnte, musste die passende
Entwicklungsumgebung geschaffen werden. Dazu gehört:

Erwerbung der Oculus Rift

Das Einrichten von Unity 3D und Aktivierung der Unity 3D pro Lizenz

Das Einrichten von Visual Studio und Verknüpfung mit Unity 3D

Das Einrichten von der Oculus Rift und der Oculus Rift Unity 3D
Integration

Das Einrichten von SVN Tortoise und dem SVN Dienst auf dem Server
Zusätzlich sollte bis zum 3.10.2013 das erste Kapitel („Einleitung“) fertig gestellt
werden. Dazu gehört:

Die Beschreibung von Virtual Reality und ihrer Geschichte

Die Beschreibung vergangener Virtual Reality Projekte

Die Beschreibung aktueller Projekte im Bereich Virtual Reality
Vorgehensweise:
Es ist wichtig, dass man bei der Einrichtung dieser Entwicklungsumgebung, die
Reihenfolge einzelnen Komponenten in der richtigen reinfolge behandelt. Das
einfachste Beispiel ist, dass man die Oculus Rift Unity 3D Integration nicht vor Unity 3D
lvi
27.02.2014
einrichten kann, da Unity 3D die Basis für die Integration ist. Deshalb entstand bei der
Einrichtung der Entwicklungsumgebung folgende Reinfolge:

SVN Tortoise und SVN Server

Unity 3D

Oculus Rift Unity 3D Integration

Visual Studio
SVN Tortoise und SVN Server wurden als erstes eingerichtet, da die Datensicherung
eines der wichtigsten Bestandteile dieser Arbeit bildet. Außerdem arbeitet Tortoise
unabhängig von der restlichen Entwicklungsumgebung und hat somit keinen Einfluss
auf diese. Als nächstes muss Unity 3D und die dazu gehörige Oculus Rift Integration
eingerichtet werden. Dazu gehört auch, dass eine einfache Szene entwickelt wird, in
der die jeweiligen GUI Elemente im späteren Verlauf dieser Arbeit getestet werden
können. Als letztes wird Visual Studio installiert, eingerichtet und mit Unity 3D
verknüpft. Hierbei wird Visual Studio auf die C#-Grundeinstellung gesetzt, da in Unity
3D man entweder mit C#, JavaScript oder Boo programmieren kann. Außerdem ist der
Großteil der Oculus Rift Integration in C# programmiert worden, daher liegt es nahe,
dass auch weitere Programmteile in C# programmiert werden.
Ergebnis:
Die Entwicklungsumgebung wurde erfolgreich erstellt. Hierbei wurden Unity 3D, Unity
3D Integration und Visual Studio erfolgreich miteinander verknüpft. Nun lassen sich
neue Code-Dateien in Visual Studio schreiben und direkt in Unity 3D ausführen.
Zusätzlich lassen sich auch alle Dateien aus der Oculus Rift Unity Integration
bearbeiten. Übergreifend wurde in allen Programmen C# als Programmiersprache
festgelegt und verwendet.
Bis zum 3.10.2013 wurde das Kapitel „Einleitung“ nicht fertig gestellt. Das Einrichten
der Entwicklungsumgebung benötigte bis zu diesem Zeitpunkt alle zeitlichen
Ressourcen.
lvii
27.02.2014
Probleme:
Das Einrichten von SVN Tortoise verlief problemlos, sobald die richtigen Kommandos
für das Ansprechen des SVN Servers herausgefunden wurden. In diesem Fall musste
der Server über https-Protokoll aufgerufen werden. In Bezug auf das Hinzufügen und
Aktualisieren der Dateien auf dem Server mussten immer noch alle Dateien manuell
hinzugefügt werden.
Verbesserungen:
Die Aktualisierung der Dateien ließe sich mit einem Plug-In für Visual Studio
vereinfachen. Jedoch hat der Autor keinerlei Erfahrung mit diesem Tool und die
Einarbeitung wurde wahrscheinlich mehr Zeit in Anspruch nehmen, als dass das Tool
diese wieder gut machen könnte.
lviii
27.02.2014
Dokumentation
Zeitraum:
3.10.2013 – 22.12.2013
Milestone:
Milestone 3
Tätigkeit:
- Fertigstellung des Kapitels
Grundlagen
- Entwicklung der beiden Methoden
zur Darstellung von 3D GUIElementen
Ergebnis:
- Grundlagen Kapitel fertig
- Methode eins fertig
- Methode zwei nicht realisierbar
Das Grundlagen-Kapitel sollte folgende Unterkapitel enthalten:
1. Grafical User Interface
-
Beschreibung eines GUIs und ihrer Funktion
2. Oculus Rift Unity Integration
-
Beschreibung der Unity Integration für die Oculus Rift.
-
Genauer
Beschreibung
der
einzelnen
Funktionen
und
deren
Zusammenhang in Bezug auf die zu entwickelnden Methoden
3. Microsoft Visual Studio
-
Beschreibung der Funktionen von Visual Studio
-
Warum wurde Visual Studio gewählt und nicht die eingebaute
Entwicklungsumgebung MonoDevelop?
4. Game Engine
-
Beschreibung der verwendeten Game Engine Unity 3D
-
Warum wurde Unity 3D als Game Engine verwendet?
-
Welche Vor- und Nachteile bietet Unity 3D?
5. Versionierungsdienst
-
Warum wird ein Versionierungsdienst verwendet
lix
27.02.2014
-
Welche Vor- und Nachteile bietet ein Versionierungsdienst
6. Raycast
-
Was ist ein Raycast
-
Warum wird ein Raycast in dieser Arbeit und in
beiden Methoden
verwendet?
Nach der Fertigstellung des Grundlagenkapitels sollte die Entwicklung der zu
untersuchenden Methoden eins und zwei beginnen. Hierbei sollten zwei Methoden
erarbeitet werden, die die Benutzung der Oculus Rift in Bezug auf GUI-Elemente
vereinfachen. Beide Methoden sollten sich eine Eigenschaft teilen, damit für die
Entwicklung eine gemeinsame Grundlage gegeben ist.
Vorgehensweise:
An dieser Stelle wurde starke Grundlagenforschung betrieben, um sicherzustellen,
dass alle Programme und Methoden richtig verstanden und beschrieben worden sind.
Dazu wurden Webseiten der jeweiligen Hersteller /Entwickler gelesen und wichtige
Abschnitte abgespeichert. Zusätzlich wurden mögliche Zusammenhänge anhand von
Mind-Maps dargestellt.
Bei der Entwicklung der beiden Methoden zur Entwicklung von 3D GUI-Elementen,
wurde zuerst nach Evaluationsmethoden für Software gesucht. Danach wurden diese
genauer eingeschränkt. Daraufhin wurden zwei Methoden entwickelt, die zum einen
vergleichbar sind und zum anderen anhand der Evaluationsmethode untersucht
werden können.
Ergebnis:
Herausgestellt hat sich, dass GUI-Elemente bereits in den 80ern in dem C64 Computer
von Comodore befunden haben. Diese dienen im Allgemeinen dazu die Benutzung
eines Computers für den Verbraucher zu vereinfachen. Hierzu werden einzelne order
mehrere Kommandozeilen in eine grafische Oberfläche eingebaut, die für den
Benutzer einfacher zu verstehen und zu behalten sind.
lx
27.02.2014
In der Unity Integration wurde herausgefunden, dass es ein Objekt mit dem Namen
„guiHelper“ gibt, die die 2D Ebene der GUI-Elemente aus der Kamera entfernt und
diese vor den Charakter platziert. Mit Hilfe dieser Ebene lassen sich Unity 3D GUIElemente anzeigen.
Es hat sich herausgestellt, dass man Unity 3D und Visual Studio miteinander
verknüpfen kann, sodass geschriebener Code in Visual Studio direkt in Unity 3D
ausgeführt werden kann.
Zusammenfassend haben sich einige Vorgehensweisen und Funktionen in den
einzelnen Programmen als geeignet erwiesen und ermöglichen eine Evaluation
anhand einer Inspektionsmethode. Mit Hilfe des Kognitiven Verfahrens sollen die
Methoden am Ende evaluiert werden. Dieses Verfahren überprüft eine Software
anhand von systematischen Fehlern und Fragestellungen. Diese werden anschließend
durch einen Gutachter geprüft.
Probleme:
Es hat sich herausgestellt, dass der verringerte Zeitraum, der durch die beruflichen
Tätigkeiten des Autors entstanden ist, nur eine Evaluationsmethode in dieser Arbeit
zulässt. Dies führt dazu, dass das GUI in seiner Gesamtheit nicht repräsentativ
dargestellt werden kann.
Verbesserungen:
Aus zeitlichen Gründen kann in dieser Arbeit nur eine einzige Evaluationsmethode
angewendet werden. Um eine repräsentative Darstellung und Evaluation eines
gesamten GUIs zu erstellen, müsste man in einer weiteren Arbeit eine Kombination
aus mehreren Inspektionsmethoden anwenden, beziehungsweise auch Testmethoden
und grafische Elemente einbinden.
lxi
27.02.2014
Dokumentation
Zeitraum:
22.12.2013 – 31.01.2014
Milestone:
Milestone 4
Tätigkeit:
- Fertigstellung des Kapitels Methodik
und Durchführung
Ergebnis:
Durchführung und Methodik
abgeschlossen
Das Methodikkapitel sollte folgende Unterkapitel enthalten:
1. Evaluationsmethode
2. Zielgruppe der Evaluationsmethode
3. Methodenanwendung
4. Beschreibung der Methoden zur Entwicklung der GUI-Elemente
5. Abschließender Vergleich der Methoden
Innerhalb dieser Kapitel sollten Zusammenhänge zwischen Evaluation der der
entwickelten Methoden erläutert werden.
Das Durchführungskapitel sollte die komplette Beschreibung der Entwicklung
enthalten. Hiezu gehört:
1. Das Entwickeln der beiden Methoden
2. Die Implementierung der beiden Methoden
In diesem Kapitel sollten alle Programme in Bezug auf die entwickelten Methoden
betrachtet werden.
lxii
27.02.2014
Vorgehensweise:
Mit dem Methodik Kapitel wurden Methoden ausführlich beschrieben und deren
Anwendung begründet. Vorrausetzungen für die nachfolgende Evaluation war es, die
angewandte Inspektionsmethode zu erläutern und ihre Durchführung vorzubereiten.
Um die Entwicklung klar widerspiegeln zu können, wurden sämtliche Veränderungen
und Neuerung aufgelistet und beschrieben. Dabei wurde genau auf Funktionalität
geachtet.
Ergebnis:
In dem Methodikkapitel wurde die Vorgehensweise klar definiert und auf die darauf
folgende Evaluation geachtet. Hierbei wurden Funktionen mit Hilfe von Fragestellungen
und Abläufen definiert. Zusätzlich wurde eine Zielgruppe definiert an die sich das
Produkt Oculus Rift wendet. Anschließend wurden beide entwickelten Methoden und
deren Zusammenhänge erläutert. Abschließend wurde begründet, warum die
Evaluationsmethode in dieser Arbeit Anwendung findet.
Um nach der Durchführung eine Evaluation durchführen zu können, wurde bei der
Erstellung der Szene darauf geachtet, möglichst wenig Objekte zu verwenden, damit
bei der Evaluation keine Verfälschungen auftreten. Hierbei entstand eine Szene, die
nur aus einem steuerbaren Charakter, einem GUI-Element und einem Boden bestand.
Sämtliche Funktionen wurden innerhalb des GUI-Elements und des Charakters
implementiert.
lxiii
27.02.2014
Probleme:
Wie schon im vorherigen Milestone beschrieben, hat sich erneut herausgestellt, dass
es mehrere Methodiken bedarf, um eine repräsentative Darstellung für die Industrie
herstellen zu können. Es wurde erst im Nachhinein festgestellt, dass eine Zielgruppe
definiert werden müsste. Dies stellte sich heraus, als die Vorbereitung zur Evaluation
getroffen wurde. Das Kognitive Verfahren setzt voraus, dass die Evaluation anhand
von Fragestellung durchgeführt wird. Jedoch wird diese Fragestellung in Bezug auf die
Fachkenntnisse der Benutzer erläutert.
Verbesserungen:
Schlussfolgernd hätte die Evaluationsmethode genauer studiert werden müssen, damit
diese im späteren Verlauf der Arbeit nicht mehr hätte angepasst werden müssen.
Möglicherweise hätten weitere Quellen das Verständnis der Evaluationsmethode
besser beschrieben und hätten daher dem Autor ein klareres Bild dieser Methode
gezeigt.
lxiv
27.02.2014
Dokumentation
Zeitraum:
31.01.2014 – 27.02.2014
Milestone:
Milestone 5
Tätigkeit:
Fertigstellung der Kapitel Ergebnisse
und Zusammenfassung
Überarbeitung der Formalen Vorgaben
Ergebnis:
Schriftlicher Teil der Bachelor Arbeit
fertig gestellt.
Abschließend
zu
dieser
Arbeit
sollten
die
Kapitel
„Ergebnisse“
und
„Zusammenfassung“ geschrieben werden.
In das Ergebniskapitel gehören zum einen die Zusammenfassung der entwickelten
Methoden
und
deren
erfolgreiche
Implementierung,
und
zum
anderen
die
darauffolgenden Evaluation anhand der Überprüfungsmethode.
Zuletzt sollten noch sämtliche Formale Vorgaben erfüllt erwerden, wie zum Beispiel:
korrekte Zitierweise und Aufbau der Arbeit.
Vorgehensweise:
Zuerst musste erklärt werden, welche Vor- und Nachteile sich in den beiden
entwickelten Methoden ergeben haben. Darauf folgte der Vergleich der beiden
Methoden und ob diese sich in der Industrie anwenden ließen. Anschließend wurden
beide Methoden anhand der vorbereiteten Überprüfung evaluiert. Dabei war zu
beachten, die Eigenschaften der Überprüfung (Fragestellungen und Zielgruppe) zu
verfolgen.
Danach wurde die komplette Arbeit zusammengefasst. Jedes Kapitel wurde in kürzerer
Form umgeschrieben und unwichtige Punkte wurden wegelassen.
lxv
27.02.2014
Ergebnis:
Es hat sich herausgestellt, dass die zweite Methode – welche auf Raycast und
bestehende GUI-Elemente basiert – nicht in dieser Arbeit anwendbar ist. Dem Autor ist
es nicht gelungen, diese Methode in der gegebenen Zeit zu implementieren.
Die erste Methode hingegen war erfolgreich. Sie konnte sowohl implementiert, als auch
anschließend evaluiert werden.
Probleme:
Es traten einige Probleme mit der zweiten Entwicklungsmethode auf. Hierbei war es
nicht möglich, mit einem Raycast die 2D Ebene anzusprechen. Grund dafür war die
fehlende Kollisionskomponente. Es wurde versucht, diese in den bestehenden Code
der Oculus Rift Entwickler einzubauen, jedoch erwies sich das als sehr schwierig, da
die 2D Ebene zur Laufzeit erstellt wird, was die Bearbeitung im Editor nicht mehr
möglich machte.
Verbesserungen:
Zusammenfassend hätte man hier eine alternative Methode entwickeln können, jedoch
ließ der sehr knappe Zeitrahmen dies nicht zu. Möglicherweise hätte auch ein tieferes
Verständnis der Oculus Rift Unity Integration dabei geholfen, dieses Problem zu lösen.
Hier hätte man zurück in die Grundlagenforschung gehen müssen, um eine genauere
Recherche durchführen zu können.
lxvi

Major Projekt

Transcription

Similar documents

Ausgabe 6 – März 2014

Effiziente AC/DC-Wandler mit SiC-MOSFETs

Universität Ulm

Einsatz von WebGL zur Erstellung von Websites mit indexierbaren

Methoden zur Evaluation von Software

Immersion und Interaktion in Virtual Reality Anwendungen