OpenGL|ES auf iPhone - hs-fulda.de · Autor: Markus Staab Dozent: Prof. Dr. Werner Heinzel Datum: 20.12.2008 OpenGL|ES auf iPhone Ausarbeitung im Rahmen der LVA: Grafisch Interaktive

Autor: Markus StaabDozent: Prof. Dr. Werner HeinzelDatum: 20.12.2008

OpenGL|ES auf iPhoneAusarbeitung im Rahmen der LVA: Grafisch Interaktive Systeme

2Anhang

MOTIVATION.........................................................................................................................................................4

ZUSAMMENFASSUNG..........................................................................................................................................4

ENTWICKLUNG.....................................................................................................................................................5

1.1. Voraussetzungen .......................................................................................................................................................... 5 1.1.1. iPhone SDK / Software Development Toolkit .................................................................................................................... 5 1.1.2. Objective_C ........................................................................................................................................................................ 5

Deklaration einer Klasse (@interface)....................................................................................................................................6Deklaration einer Methode.....................................................................................................................................................6Implementierung einer Klasse (@implementation)...............................................................................................................7Aufruf einer Methode (message)............................................................................................................................................7

1.2. Plattform ..................................................................................................................................................................... 7 1.2.1. iPhone OS ........................................................................................................................................................................... 7 1.2.2. Anwendungslebenszyklus .................................................................................................................................................. 8 1.2.3. Benutzerinteraktionsmodell .............................................................................................................................................. 9

1.3. Einbettung: OpenGL|ES in iPhone OS ......................................................................................................................... 10 1.3.1. Vorbereiten der OpenGL|ES Umgebung ......................................................................................................................... 11 1.3.2. Realisieren eines 3D Objektes ......................................................................................................................................... 12

Bunter 3D Würfel..................................................................................................................................................................12Zauberwürfel / Rubiks Cube..................................................................................................................................................15

1.3.3. Ansprechen des Touchscreens ........................................................................................................................................ 16

ANWENDUNG......................................................................................................................................................21

QUELLENVERZEICHNIS....................................................................................................................................22

ANHANG...............................................................................................................................................................22

1.4. Dateiverzeichnis / Dateibaum ..................................................................................................................................... 22

1.5. Werkzeuge / iPhone SDK ............................................................................................................................................ 23 1.5.1. Installation ....................................................................................................................................................................... 23 1.5.2. X-Code .............................................................................................................................................................................. 23

Öffnen einer Projektvorlage..................................................................................................................................................24Starten einer Anwendung im Simulator...............................................................................................................................24

1.5.3. iPhone Simulator ............................................................................................................................................................. 25

1.6. Relevante Probleme und deren Lösung ....................................................................................................................... 26 1.6.1. Farben werden nicht korrekt dargestellt ........................................................................................................................ 26 1.6.2. Aktivieren von Anti-Aliasing im Simulator ....................................................................................................................... 26 1.6.3. Auslesen von Gravitationsdaten im Simulator ................................................................................................................ 26 1.6.4. Die Applikation lässt sich nicht auf das Endgerät übertragen ......................................................................................... 26 1.6.5. Festlegen des Startsymbols der Anwendung .................................................................................................................. 26 1.6.6. Funktion/Prozedur/Klasse wird vom Compiler nicht gefunden ...................................................................................... 26

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab

3Anhang

1.7. Aufwand .................................................................................................................................................................... 26

Motivation

Der Trend zur Miniaturisierung von Systemen ist in aller Munde. Zugleich eröffnet diese Entwicklung immer weitere neue Möglichkeiten, da auch die Leistung dieser mobilen Endgeräte immer weiter ansteigt. Diesen Fortschritten ist es zu verdanken, dass sich verschiedene Hersteller gemeinsam an die Ausarbeitung einer reduzierten Version des sehr bekannten und weit verbreiteten Grafikstandards OpenGL gewagt haben. Der neue daraus resultierende Standard OpenGL|ES erfreute sich seit der ersten Verabschiedung der Spezifikation 1.0 im Jahre 2002 großer Beliebtheit bei den Herstellern und wurde sehr schnell auf vielen verschiedenen Plattformen implementiert. Auch aktuelle Geräte aus vielen verschiedenen Bereichen unterstützen diesen oder einen der daraus hervorgegangen Standards. Als Beispiele sind hier aktuelle High-End-Geräte aus der Unterhaltungselektronik wie die Playstation 3 der Firma Sony, die Xbox360 der Firma Microsoft oder die neu Handyplattform Android, die unter der Schirmherrschaft der Firma Google entwickelt wurde zu nennen. Auch die Firma Apple ist mit Ihrem ersten Smartphone, dem iPhone, auf diesen Zug aufgesprungen und unterstützt OpenGL|ES in der Version 1.1. Wie sich dieser Grafikstandard in die Plattform des iPhones einbettet und welche Möglichkeiten die Kombination mit dem iPhone bietet möchte ich im Folgenden exemplarisch darstellen.

Hier ist zu erwähnen, dass entgegen der Rahmenbedingungen für Ausarbeitungen die Sprache Objective_C verwendet wird. Dies wurde mit dem Dozenten bei der Definition des Projektes und dessen Inhalt bereits abgestimmt!

Da das Themengebiet rund um die Entwicklung von iPhone Anwendungen sehr komplex ist, erhebt dieses Dokument keinen Anspruch auf Vollständigkeit. Themen des Umfelds, die für diese Ausarbeitung nicht relevant sind, werden nicht näher erläuter um den Rahmen nicht zu sprengen. Eine umfangreiche Informationssammlung ist im iPhone DevCenter unter http://developer.apple.com/ zu finden.

Zusammenfassung

Das folgende Dokument teilt sich auf in 4 Hauptabschnitte.

Im ersten werden Hinweise zur Entwicklung einer Anwendung für das iPhone unter Verwendung der OpenGL|ES Grafikbibliothek dargestellt. Dies beinhaltet eine allgemeine Einführung in die Entwicklungsumgebung, die Programmiersprache Objective_C sowie in die Softwarearchitektur. Daraufhin wird die Implementierung des Grafikstandards anhand eines Beispiels verdeutlicht. Im Anschluss werden Technologien des iPhones beispielhaft mit der Grafikanwendung kombiniert.

Der darauffolgende Abschnitt beinhaltet eine kurze Anwenderdokumentation die alle Funktionen und Möglichkeiten des erstellten Programmes wiederspiegelt. Dies dient hauptsächlich dazu, dem Benutzer die noch teilweise ungewohnten und neuen Eingabemöglichkeiten zu verdeutlichen.

Das Quellenverzeichnis gibt eine kurze Auflistung wieder, aus welchen Quellen die einzelnen Informationen stammen. Die genaue Quelle wird dabei bei den einzelnen Bildern durch Angabe eines Index des Quellenverzeichnisses referenziert (Nach ISO 690).

Im Anhang werden die Entwicklungswerkzeuge vorgestellt, die für die Herstellung von Software für die iPhone OS Plattform angeboten werden.


http://developer.apple.com/

4Anhang

Weiterhin sind dort aufgetretene Probleme dargestellt und deren Lösungen präsentiert. Dieser Abschnitt soll dazu dienen kleinere Fehler schneller zu finden, indem Anhaltspunkte geliefert werden an welchen Stellen die Lösung zu suchen ist.

Abschließend wird in einer kurzen Übersicht der Aufwand beziffert, der mit dieser Ausarbeitung verbunden war. Hier soll Aufgezeigt werden welche der einzelnen Arbeitsbereiche als zeitkritisch einzuschätzen sind und an welchen Stellen die Schwierigkeiten liegen.

Entwicklung

Dieser Abschnitt der Ausarbeitung gibt einen ersten Überblick über das Betriebssystem des iPhones und soll außerdem den interessierten Leser mit ersten Grundlagen zur Entwicklung von OpenGL|ES Anwendungen versorgen. Dabei wird vorausgesetzt, dass Grundkenntnisse im Bereich OpenGL vorhanden sind. Eine Einführung in diese Thematik ist dem Vorlesungsskript zur Lehrveranstaltung „Grafische Datenverarbeitung“ von Prof. Dr. Werner Heinzel zu entnehmen. Dieses Dokument zeigt nur Unterschiede und Problematiken auf, die sich im speziellen um die Entwicklung mit dem iPhone oder mit OpenGL|ES drehen.

1.1.Voraussetzungen

1.1.1. iPhone SDK / Software Development Toolkit

Um für das iPhone Anwendungen entwickeln zu können liefert der Hersteller Apple ein iPhone SDK. Es basiert auf dem für Mac Entwickler bekannten Entwicklungswerkzeug XCode. Diese Software ist nur auf Rechnersystemen lauffähig, die über das Betriebssystem Mac OS X verfügen. Aus diesem Grund ist die Entwicklergemeinde leider bereits relativ stark eingeschränkt, da diese Systeme nur von wenigen Programmierern genutzt werden. Es ist also nochmals zu betonen, dass es aktuell mit einem herkömmlichen PC nicht möglich ist, Software für das iPhone herzustellen! Da der iPod Touch über das gleiche Betriebssystem sowie einem sehr ähnlichen Funktionsumfang verfügt sind viele Programme die für das iPhone geschrieben wurden ebenfalls auf dem iPod Touch lauffähig.

Weiterhin stellt das SDK einen Simulator zur Verfügung, der die Entwicklung deutlich vereinfacht. So können Änderungen sofort getestet werden, ohne dass ein Endgerät angeschafft werden muss.

Eine ausführlichere Beschreibung zum iPhone SDK sowie dem Simulator ist im Kapitel 1.5 zu finden.

1.1.2. Objective_C

Objective_C ist eine auf dem ANSI C basierte Programmiersprache, die zur Entwicklung von Anwendungen auf verschiedenen Mac-Plattformen Verwendung findet. Objective_C erweitert den Standard um Möglichkeiten zur Objektorientierung. Die Syntax und Konzeption ist dabei sehr stark an die Sprache Smalltalk angelehnt. Es wurde darauf geachtet, dass nur die wichtigsten Konzepte in die Sprache übernommen wurden, um die Implementierung möglichst effizient durchführen zu können. So stellt Objective_C u.a. Sprachmittel zum erstellen von Interfaces und Klassen zur Verfügung.

Viele der Frameworks, die auf den oberen Schichten Teile des iPhone OS darstellen sind in dieser Programmiersprache implementiert. Je weiter man sich den unteren Schichten nähert, desto häufiger wird man auf in ANSI C Implementierte Bibliotheken treffen. Weitere Details zum Aufbau des iPhone OS können Sie dem Kapitel 1.2 entnehmen.

Hier finden Sie nun kurz zusammengefasst eine Sprachreferenz, die alle Sprachmittel erklärt, die zum Lesen dieses Dokumentes und der darin enthaltenen Quellcodeabschnitte nötig ist. Die Auflistung spiegelt nicht alle Möglichkeiten von Objective_C wieder.


5Anhang

Deklaration einer Klasse (@interface)

Abbildung 1 Deklaration einer Klasse (1)

Hier wird eine Klasse namens MyClass deklariert, die von der Klasse NSObject erbt. Weiterhin werden Datenfelder (count, data, name) und deren Datentypen (int, id, NSString *) definiert. Im Anschluß erfolgt die Auflistung der Prototypen der Methoden (initWithString, createMyClassWithString), die die Klasse zur Verfügung stellt. Der Aufbau eines solchen Prototyps wird im folgenden Abschnitt näher erläutert.

Deklaration einer Methode

Abbildung 2 Prototyp der Methode insertObject (1)

Dieses Schema zeigt den Prototyp der Methode insertObject. Es handelt sich dabei um eine Instanz-Methode, erkennbar am führenden „-“ Zeichen. Statische oder Klassen-Methoden werden durch ein „+“ gekennzeichnet. Direkt nach dem Methodentyp folgt der Rückgabetyp (void). Anschließend steht der Bezeichner der Methode insertObject auf den, getrennt von einem Doppelpunkt, die Parameterliste folgt. Diese Liste beliebiger länge, enthält die einzelnen Parameter und deren Datentypen. Die Datentypen stehen in runden Klammern (id), (NSUInteger) und danach deren Bezeichner anObject, index. Die Schlüsselwörter insertObject, atIndex der Methodensignatur müssen alle beim Aufruf der Methode angegeben werden. Der Aufruf einer Methode wird in einem gesonderten Abschnitt näher erläutert.


6Anhang

Implementierung einer Klasse (@implementation)

Abbildung 3 Implementierung der Klasse MyClass (1)

Der obenstehende Codeausschnitt zeigt die Implementierung der Klasse MyClass. Er realisiert die Methoden initWithString, createMyClassWithString der Deklaration aus dem obigen Abschnitt 1.1.2. Hier werden Datenfelder mit Initalwerten vorbelegt und eine Methode init aus der Superklasse aufgerufen ([super init]). Das Schlüsselwort self bezieht sich dabei immer auf die aktuelle Instanz einer Klasse, das Schlüsselwort super auf die Superklasse.

Aufruf einer Methode (message)

Abbildung 4 Aufruf der Methode insertObject am Objekt myArray (1)

Aufruf der Methode insertObject mit den Parametern anObj und einem 2. Parameter namens atIndex mit dem Wert 0. Die Namen der Parameter werden beim Aufruf immer notiert. Daraus ergibt sich, dass die Reihenfolge der benannten Parameter beliebig sein kann. Der 1. Parameter trägt keinen Namen und wird direkt nach dem Methodennamen, getrennt durch einen Doppelpunkt definiert. Im Allgemeinen spricht man im Kontext von Objective_C nicht von Methodenaufrufen, sondern von Nachrichten (messages) die an Objekte gesendet werden.

Auch das Schachteln von Methodenaufrufen ist möglich:

Abbildung 5 Geschachtelter Methodenaufruf (1)

1.2.Plattform

1.2.1. iPhone OS

Das Betriebssystem des iPhones trägt den Namen des Smartphones selbst: iPhone OS. Es stellt die grundlegende Softwarearchitektur dar und bietet mit vielen verschiedenen APIs (Application Programmable Interfaces) Schnittstellen zu vielen Komponenten des Systems. Der Aufbau und viele der vorhandenen Technologien sind dabei an das Mac OS X Betriebssystems angelehnt.

Das System setzt dabei auf ein Schichtenmodell, das wie folgt strukturiert ist:


7Anhang

Abbildung 6 Schichtenmodell des iPhone OS (2)

Als Basis dient eine Variante des Mac OS X „Mach“ Kernels, bezeichnet mit „Core OS“. Er beinhaltet alle Komponenten zum Starten des Systems und dient außerdem als Schnittstelle zur Hardware.

Darauf baut die Schicht „Core Services“ auf, die grundlegende Dienste zur Verfügung stellt. Als Beispiel sind Schnittstellen zum Zugriff auf Dateien, UNIX Sockets oder POSIX Threads zu nennen. Diese APIs sind hauptsächlich in der Sprache C realisiert und werden in verschiedenen Frameworks bereit gestellt. Ebenfalls ist es auf dieser Schicht möglich, eingebettete Datenbanken wie SQLite anzusprechen.

Je weiter man in die oberen Schichten vordringt, desto umfangreichere und komfortablere Frameworks werden dem Entwickler zur Verfügung gestellt. In der „Media“ Schicht werden Funktionen zum Zeichnen von 2D und 3D Objekten sowie zum Abspielen von Audio und Video bereit gestellt. Hier sind zum einen C basierte Technologien wie OpenGL|ES (3D Grafik), Quartz (2D Grafik) und Core Audio zu finden, als auch das Objective_C basierte Framework zum realisieren von Animationen (Core Animation).

In der obersten Schicht namens „Cocoa Touch“ sind nahezu alle Funktionen im objektorientierten Stil umgesetzt. Sie bietet die Infrastruktur für komfortables verwalten von Dateien oder zur Ausführung von Netzwerkoperationen. Ein sehr mächtiges Framework zum erstellen von Benutzerschnittstellen (UIKit) ist ebenfalls eine Komponente auf dieser Ebene. Es verfügt über die grundsätzlichen UI (User Interface) Klassen zum Erstellen von Fenstern (windows), Ansichten (views) und verschiedene Kontrollkomponenten (controlls). Es bietet eine API zum abfragen des Adressbuchs, der Fotogalerie, den Gravitationssensoren aber auch für viele weitere Hardwarekomponenten an.

1.2.2. Anwendungslebenszyklus

Der Lebenszyklus einer Anwendung beschreibt eine Sequenz von Ereignissen (events), die zwischen Start (launch) und Ende (termination) des Programms ausgelöst werden. Eine Anwendung wird dabei vom Benutzer direkt im Hauptmenu des Smartphones durch berühren des dazugehörigen Symbols gestartet. Das UIKit Framework übernimmt fortan die Kontrolle über das Geschehen. Es führt die main() Methode (UIApplicationMain) der Anwendung aus und beginnt anschließend die nötigen Ressourcen zu initialisieren. Die Benutzerschnittstelle wird vorbereitet und eine Schleife zum abarbeiten von Ereignissen wird erzeugt (event loop). Durch den Benutzer oder das System ausgelöste Ereignisse werden durch diese Schleife an die Applikation weitergereicht und von dieser behandelt. Dieser Ablauf ist aus dem folgenden Diagramm ersichtlich:


8Anhang

Abbildung 7 Lebenszyklus einer Anwendung (3)

Um die Implementierung von Applikationen für den Entwickler möglichst einfach zu halten erlaubt das iPhone OS nur die Ausführung eines einzigen Programmes. Aufgrund dieser Prämisse muss sich der Programmierer nicht um die Synchronisation von Zugriffen auf viele der vorhandenen Technologien kümmern. Es bringt allerdings auch den Nachteil mit sich, dass keine Anwendungen im Hintergrund ausgeführt werden können.

1.2.3. Benutzerinteraktionsmodell

Zu jederzeit, wenn der Benutzer mit einer der Benutzerschnittstellen interagiert oder Aufgrund von programmatischen Änderungen, wird eine komplexe Folge von Ereignissen innerhalb des UIKit Frameworks ausgelöst, um diese Eingaben zu behandeln. An bestimmten Punkten innerhalb dieser Sequenz ruft das UIKit Methoden der aktuellen Ansicht (view) auf, sodass es der Anwendung ermöglicht wird ebenfalls auf die Interaktionen zu reagieren. Dieses Verhalten ist dem aus der Sprache C bekannten Callback Konzept ähnlich. Das folgende Schema zeigt einen kurzen Überblick über den Verlauf einer Benutzereingabe über den Touchscreen des iPhones.


9Anhang

Abbildung 8 Interaktionsmodell bei Touchscreen-Berührungen (3)

Die Berührung des Touchscreens durch den Benutzer wird vom Touch Framework erkannt und verarbeitet. Es rechnet Bewegungen auf Pixelkoordinaten um und erkennt grundlegende Gestiken. Aufgrund der von Apple patentierten Multitouch Technologie ist es möglich die Koordinaten mehrere Finger zeitgleich zu erfassen. Diese Informationen werden an die Laufzeitumgebung des Anwenderprogramms, also dem UIKit übergeben. Es kommuniziert die Daten an die Applikation. Dort können die anwendungsspezifischen Auswertungen vorgenommen werden. Aufgrund der Auswertungen wird ggf. die Ansicht (view) der Anwendung angepasst und das Neuzeichnen der Oberfläche durch die Methode setNeedsLayout oder setNeedsDisplay veranlasst. Die Compositor Komponente setzt die Änderungen der Ansichten zusammen und gibt die Befehle an die Hardware weiter. Das Display stellt nun die neuen Gegebenheiten dar.

1.3.Einbettung: OpenGL|ES in iPhone OS

OpenGL|ES befindet sich neben der 2D Grafikbibliothek Quartz und dem Framework für Animationen auf dem Media Layer des iPhone OS Betriebssystems. Um den 3D Grafikstandard innerhalb einer iPhone Anwendung nutzen zu können sind einige Vorkehrungen zu treffen. Auch sind an vielen Stellen kleinere manuelle Eingriffe nötig, die im OpenGL Standard noch automatisiert von der Umgebung gelöst wurden. Der Entwickler hat somit noch tieferen Eingriff in die Arbeitsweise der Rendering-Pipeline bzw. muss Ressourcen zur Verfügung stellen, die sonst automatisch allokiert wurden. Näheres dazu steht im Kapitel 1.3.1. Ebenfalls sollte an dieser Stelle erwähnt werden, dass bei der Programmierung mit OpenGL|ES auf dem iPhone weder die GLU noch die GLUT zur Verfügung stehen. Dies erfordert es in manchen Situationen, dass einzelne Funktionen manuell implementiert werden müssen, welche unter OpenGL noch als Teil der Bibliothek ausgeliefert wurden. Viele dieser Funktionen sind im Internet frei zugänglich und können daher einfach bezogen werden. Dabei muss aber darauf geachtet werden, dass keine Urheberrecht verletzt wird (Quellenangaben, Copyrights, Lizenzmodelle,…).

In den anschließenden Abschnitten wird an kleinen Codeausschnitten beschrieben, wie sich die verschiedenen Technologien in Kombination mit OpenGL|ES nutzen lassen.


10Anhang

1.3.1. Vorbereiten der OpenGL|ES Umgebung

Um eine OpenGL|ES Anwendung auf dem iPhone zu betreiben ist es nötig eine Schnittstelle zwischen der Rendering-Pipeline der Grafikbibliothek und dem Fenstersystem des iPhoneOS herzustellen. Diese Aufgabe übernimmt die sog. EAGL API. Um diese erforderlichen Schritte nicht alle manuell durchführen zu müssen, wird eine OpenGL|ES Projektvorlage für die XCode Entwicklungsumgebung als Grundlage verwendet. Eine detaillierte Beschreibung von OpenGL|ES und der EAGL API ist dem Vortrag von Herrn Dr. Götzelmann (Fa. Navigon, Würzburg) zu entnehmen. Ebenso liegt die OpenGL|ES Spezifikation auf dem Datenträger bei. Das öffnen der Projektvorlage ist im Kapitel 1.5 dargestellt.

Der interessierte Leser wird beim ersten Anblick des Quellcodes der EAGLView Klasse des Beispielprojektes bereits erste Unterschiede zu einer herkömlichen OpenGL-Anwendung entdecken. So sind Methoden zum erstellen und zerstören des Framebuffers, Renderbuffers und Depthbuffers (Z-Buffer) vorhanden. Weiterhin werden diese Puffer an die OpenGL|ES Engine, als auch über die EAGL API an das Fenstersystem gebunden:

Abbildung 9 Erstellen des Frame-, Render- und Z-Buffers (4)


11Anhang

Abbildung 10 Freigeben des Speichers der Buffer (4)

Weiterhin ist es nötig, die layerClass zu überschreiben, sodass ein EAGLLayer verwendet wird:

Abbildung 11 Überschreiben der layerClass zur EAGL-Anbindung (4)

Aufgrund dieser Änderungen ist es nun möglich durch überschreiben der drawView Methode 3D Objekte zu realisieren. Diese erfüllt die gleichen Funktionen wie die Display-Funktion bei Verwendung der GLUT. Folgendes Grundgerüst der Methode bietet eine erste Ausgangsbasis:

Abbildung 12 Grundgerüst der drawView Methode (4)

1.3.2. Realisieren eines 3D Objektes

Bunter 3D Würfel

Da die OpenGL|ES Umgebung nun fertig konfiguriert wurde, geht es im nächsten Schritt daran ein einfaches 3D Objekt zu realisieren. Im Gegensatz zu OpenGL muss dies mit Vertex-Arrays geschehen, da die Prozeduren glBegin() und glEnd() in der OpenGL|ES Spezifikation nicht vorgesehen sind. Im folgenden Beispiel wird ein Würfel realisiert, dessen Außenflächen mit 6 verschiedenen Farben dargestellt werden sollen:

Anlegen der Geometriedaten im Vertex-Array (CUBE_DIMENSION = 0.15):


12Anhang

Abbildung 13 Aufbau des Vertex-Arrays

Anlegen der Indizes zum Zeichnen der Seitenflächen:

Abbildung 14 Index-Array zur Realisierung des Würfels

Anlegen der Indizes zum Zeichnen eines schwarzen 1 Pixel dicken Rahmens:

Abbildung 15 Array mit Indizes für die Ränder/Kanten

Der nachstehende Ausschnitt zeigt die drawCube Methode, die aus der drawView Methode mittels [self drawCube] aufgerufen wird. Diese zeichnet den Würfel im Ursprung des Koordinatensystems. Zuerst werden die einzelnen Seitenflächen mittels glDrawElements dargestellt und anschließend ein dünner schwarzer Rahmen zur Betonung der Kanten darübergelegt.


13Anhang

Abbildung 16 Methode zur Realisierung eines bunten Würfels im Koordinatenzentrum mit schwarzen Kanten

Dieses Projekt aus der XCode Umgebung gestartet ergibt nun folgendes Bild im Simulator:

Abbildung 17 3D Darstellung des Würfels im Simulator

Hier wurde vorausgesetzt, dass in der drawView Methode vorm Aufruf der drawCube Methode der Viewport mit glViewPort(), der Z-Buffer mit glEnable(GL_DEPTH_TEST), die Hintergrundfarbe mit glClearColor() und glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) als auch ein Viewing-Volumen mittels glOrtho() sowie die Kamera anhand gluLookAt() (5) gesetzt wurde. Weiterhin wurde das Shadingmodell mit glShadeMode(GL_FLAT) festgelegt. Die Prozedur gluLookAt() muss dabei selbst implementiert werden, da weder


14Anhang

die GLU noch die GLUT in der Umgebung enthalten ist. Dieses Grundgerüst ist in Abbildung 25, nochmals dargestellt.

Zauberwürfel / Rubiks Cube

Aufbauend auf diesem Würfel soll nun im Folgenden ein sog. Rubiks Cube erstellt werden. Dazu werden 27 Exemplare des zuvor gezeichneten Würfels in 3x9 Würfel-Ebenen zusammengesetzt. Damit die Seiten des Würfels nicht alle einfarbig sind, werden die Würfel anhand der Schleifenvariablen rotiert um einen bunten Gesamteindruck zu erhalten. Um dies zu ermöglichen wird der Zustand der aktuellen Matrize mittels glPushMatrix() und glPopMatrix() gesichert. Außerdem soll der schwarze Rahmen der einzelnen Würfel sichtbar bleiben, daher werden die einzelnen Objekte um den Wert CUBE_MARGIN verschoben.

Abbildung 18 Methode zum erstellen eines Zauberwürfels

Nochmaliges starten des neuen Programms ergibt folgendes Gesamtbild im Simulator:


15Anhang

Abbildung 19 3D Zauberwürfel abgebildet im Simulator

In der Methode drawView wurde in diesem Zug der Aufruf der Methode [self drawCube] durch[self drawRubiksCube] ersetzt.

Diese 3D Geometrie werden wir in den nächsten Abschnitten des Kapitels weiter Ausbauen, um eine Interaktion mit dem Benutzer zu ermöglichen.

1.3.3. Ansprechen des Touchscreens

Um dem Anwender die Möglichkeit zu geben, den Zauberwürfel zu drehen, gilt es nun die Schnittstelle zum Touchscreen näher zu ergründen. Die API umfasst dabei 4 Methoden die in der View überschrieben werden müssen. Diese besitzen folgende Signaturen:

Abbildung 20 API zur Behandlung von Touchscreen-Events (3)

Um die gewünschte Funktion zu realisieren sind nur 2 der aufgeführten Methoden nötig (touchesBegan, touchesMoved). Die beiden anderen werden einfach als leere Methoden überschrieben (touchesEnded, touchesChancelled).

Es sollen dabei folgende Funktionen implementiert werden:

• Gestik mit einem Finger

o einmalige Berührung des Touchscreens / Single Touch

Bewegung des Fingers in X-Richtung dreht den Würfel um die Y-Achse

Bewegung des Fingers in Y-Richtung dreht den Würfel um die X-Achse

o dreimalige Berührung des Touchscreens / Triple Touch

Animierte Bewegung des Würfels zurück in die Ausgangslage


16Anhang

• Gestik mit zwei Fingern

o Gestik „Pinch-Open“: Vergrößern des Würfels (Hineinzoomen)

o Gestik „Pinch-Close“: Verkleinern des Würfels (Herauszoomen)

Abbildung 21 Beispiel der Pinch-Open und Pinch-Close Gestik (6)

Die Methode touchesBegan() wird vom UIKit benachrichtigt, wenn der Benutzer den Touchscreen berührt. Die Anzahl der Finger die das Display berühren wird mit [allTouches count] ermittelt. Um später zu errechnen welche Distanz der Finger des Benutzers über den Touchscreen zurückgelegt hat, werden die Koordinaten des Druckpunktes in einem Datenfeld gespeichert. Bei der Berührung mit zwei Fingern wird der Abstand zwischen den Fingern in einem weiteren Datenfeld zwischengespeichert. Eine dreifache Berührung des Touchscreens animiert den Würfel zurück in die Ausgangslage.

Abbildung 22 Behandlung des Events bei der ersten Berührung auf dem Touchscreen


17Anhang

Die Entfernung zwischen den Punkten wird dabei mit folgender Methode berechnet:

Abbildung 23 Hilfsfunktion zur Berechnung des Abstands zwischen 2 Punkten (7)

Jede weitere Bewegung bei gehaltenem Fingerkontakt zum Touchscreen führt zur Ausführung der Methode touchesMoved(). Es folgt die gleiche Untersuchung zwecks Anzahl der Finger auf dem berührungsempfindlichen Display und Zählen der Berührungen. Die Koordinaten der neuen Berührungspunkte werden verwendet, um zu berechnen wie groß die Entfernung war, die überstrichen worden ist seit der letzten Berührung. Anschließend werden die neuen Berührungspunkte als Ausgangskoordinaten festgelegt. Der Aufruf von [self setNeedsLayout] erzwingt, dass die drawView Methode wieder aufgerufen und somit die Anzeige auf dem Display aktualisiert wird. Im Fall der Zwei-Finger-Gestik wird die vorherig gespeicherte Distanz von der neuen Distanz zwischen den Berührungspunkten subtrahiert. So ist ebenfalls bekannt, welche Strecke die Finger überstrichen haben. Die kalkulierten Werte für die Entfernungen sind nach Ablauf der Methode in den Datenfeldern movedX, movedY und movedZ gespeichert:


18Anhang

Abbildung 24 Behandlung der Events beim überfahren des Touchscreen

Da nun alle nötigen Werte zur Verfügung stehen müssen diese noch in der Methode drawView berücksichtigt werden. Der untenstehende Ausschnitt zeigt dabei den vollständigen Quellcodeausschnitt inklusive aller nötigen Initialisierungen:


19Anhang

Abbildung 25 Behandlung der ermittelten Benutzerinteraktionen in der drawView Methode

Die Werte der Variablen movedX und movedY werden 1:1 zur Rotation um die entsprechenden Achsen verwendet. movedZ wird mit dem Faktor SCALE_FACTOR mulitpliziert damit eine feinere Justierung des Zoom-Faktors möglich ist. Außerdem darf sich der Zoom-Faktor maximal zwischen SCALE_MAX und SCALE_MIN bewegen, damit die Kanten und Flächen des Würfels das Viewing-Volumen nicht verlassen bzw. sich der Betrachter nicht in den Würfel hinein bewegen kann.

Der Folgende Bildausschnitt zeigt nochmal die Struktur des Programms in zusammengefasster Form. Da nur Änderungen in der EAGLView-Klasse durchgeführt wurden, ist ein Klassendiagramm an dieser Stelle überflüssig:


20Anhang

Abbildung 26 Übersicht der Programmstruktur

Die Konstanten sind mit roten Kästen markiert. Darauf folgt die Deklaration der Klasse die alle öffentlichen Methoden beinhaltet. Die Implementierung der Klasse realisiert alle öffentlichen Methoden sowie einige private Funktionen zur Gliederung des Programms in logische Blöcke.

Der Quellcode des Projektes befindet sich ebenfalls auf dem Datenträger. Aus Gründen der Übersichtlichkeit wurde der Quellcode nicht nochmals im Anhang des Dokumentes beigefügt!

Anwendung

Die Bedienung der Anwendung erfolgt nach den im Kapitel 1.3.3 vorgestellten Prinzipien. Zuerst muss die Applikation vom Hauptmenu des Gerätes gestartet werden. Sobald dies mit einem Druck auf das Symbol erfolgt ist, wird der Würfel auf dem Display angezeigt.


21Anhang

Mittels überfahren des Touchscreens in horizontaler Richtung, kann der Würfel um die Y-Achse gedreht werden. Ebenfalls ist es möglich, den Würfel um die X-Achse zu drehen. Dies geschieht durch überfahren des Touchscreens in vertikaler Richtung.

Um den Würfel zu vergrößern (hineinzoomen) legt man 2 Finger auf das berührungsempfindliche Display und spreizt diese anschließend auseinander. Um den Würfel zu verkleinern (herauszoomen) spreizt man die Finger bevor man diese auf den Touchscreen legt. Daraufhin bewegt man die Finger bei gehaltener Displayberührung zusammen. Diese zwei Gesten werden im Umfeld der iPhone-Entwicklung als „Pinch-Open“ bzw. „Pinch-Close“ Gestik bezeichnet und sind in der Abbildung 21 nochmals dargestellt.

Durch schnelles dreifaches antippen des Displays wird der Würfel wieder in die Ausgangsposition zurück versetzt.

Quellenverzeichnis

1. Apple Inc. Learning Objective-C A Primer. Apple Developer Connection. [Online] [Zitat vom: 18. 12 2008.] http://developer.apple.com/iphone/gettingstarted/docs/objectivecprimer.action.

2. —. iPhone OS Overview. Apple Developer Connection. [Online] [Zitat vom: 18. 12 2008.] http://developer.apple.com/iphone/gettingstarted/docs/iphoneosoverview.action.

3. —. iPhone Application Programming Guide. [Online] [Zitat vom: 3. 12 2008.] https://developer.apple.com/iphone/library/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/iPhoneAppProgrammingGuide.pdf.

4. —. Code Sample: OpenGL|ES. Apple Developer Connection. [Online] [Zitat vom: 20. 12 2008.] http://developer.apple.com/iphone/library/codinghowtos/GraphicsAndAnimation/index.html#3D-DISPLAY_OPENGL_ES_CONTENT.

5. jshmrsn. MacRumors: Forums. [Online] [Zitat vom: 19. 12 2008.] http://forums.macrumors.com/showthread.php?t=547587.

6. Apple Inc. Creating an iPhone Application. Apple Developer Connection. [Online] [Zitat vom: 22. 12 2008.] http://developer.apple.com/iphone/gettingstarted/docs/creatingiphoneapps.action.

7. —. Code Sample: Touch Events. Apple Developer Connection. [Online] [Zitat vom: 22. 12 2008.] http://developer.apple.com/iphone/library/samplecode/Touches/index.html.

8. —. Tools for iPhone OS Development. Apple Developer Connection. [Online] [Zitat vom: 15. 12 2008.] http://developer.apple.com/iphone/gettingstarted/docs/iphonedevtools.action.

Zum Aufruf der Quellen wird ein gültiger Mac Developer Zugang benötigt. Eine Offlineversion der Quellen ist auf der CD im Verzeichnis „Quellen“ zu finden.

Anhang

1.4.Dateiverzeichnis / Dateibaum

Bilder/ => Alle Bilder der DokumentationDownloads/ => Alle Dateien die heruntergeladen wurden


22Anhang

Quellen/ => Offlineversion der verwendeten QuellenXCode Projekt/ => Sourcecode der AusarbeitungAusarbeitung.docx/.pdf => Dokumentation zur AusarbeitungPräsentation.pptx/.pdf => Präsentation zur Ausarbeitung

Abbildung 27 Dateibaum des Datenträgers

1.5.Werkzeuge / iPhone SDK

Das offizielle iPhone SDK enthält viele Werkzeuge, die frei von der Firma Apple zur Verfügung gestellt werden. Es beinhaltet die für Mac übliche Entwicklungsumgebung X-Code sowie einen Simulator der für erste Tests sehr gut geeignet ist. Es sind weitere Programme enthalten, wie zum Beispiel das Profilingwerkzeug Instruments, sowie den Editor Interface Builder zum leichten erstellen der Benutzerschnittstelle. Die zwei zuletzt genannten Tools wurden für die Durchführung der Ausarbeitung nicht verwendet.

1.5.1. Installation

Wie unter dem Mac Betriebssystem üblich, gestaltet sich die Installation des iPhone SDK sehr einfach und problemlos. Die heruntergeladene iphone_sdk_for_iphone_os_2.1__final.dmg ist doppelt anzuklicken und im sich öffnenden Dialog muss das X-Code Symbol auf den Applications-Ordner mittels Drag and Drop gezogen werden. Es erscheint nach kurzer Ladezeit ein Assistent der die Installation begleitet. Die vorgegebenen Einstellungen können beibehalten werden, sodass durch mehrfaches klicken des next-Buttons die Installation durchgeführt werden kann.

1.5.2. X-Code

Die Entwicklungsumgebung X-Code dient zur Erstellung von Anwendungen für alle Mac Plattformen, ob für mobile Endgeräte (iPhone, iPod Touch) oder für das Betriebssystem Mac OS. Apple selbst setzt das Werkzeug ebenfalls zur Programmierung des hauseigenen Betriebssystems ein.


23Anhang

Abbildung 28 X-Code Entwicklungsumgebung (8)

Das Werkzeug ist im groben und ganzen in 3 Bereiche aufgeteilt. Oben befindet sich die Toolbar zum kompilieren und starten des aktuellen Projektes, sowie einer Auswahlbox die zur Einstellung der Zielplattform dient (Simulator, Endgerät, Firmware Version, …). Links befindet sich ein Dateibaum der alle Dateien und Ordner des Projektes zeigt. Ebenfalls werden dort Fehler und Warnungen sowie Suchergebnisse angezeigt. Auch ist es möglich, das Projekt an ein SCM Tool (Source Code Management) wie zum Beispiel Subversion anzubinden. Auf der rechten Seite ist der Inhalt des aktuell im Dateibaum ausgewählten Elementes angezeigt.

Öffnen einer Projektvorlage

Um die Projektvorlage für eine OpenGL|ES Anwendung zu öffnen gehen Sie wie folgt vor:

• X-Code starten

• Im Menu File auswählen

• Es klappt das Untermenu auf und daraus ist der Eintrag New Projekt zu selektieren

• Anschließend öffnet sich ein Dialog indem der Eintrag iPhone OS gewählt werden muss

• Im rechten Teil des Dialogs ist der Eintrag OpenGL ES Application zu markieren

• Schließen des Dialogs durch Druck auf den Button Choose…

Starten einer Anwendung im Simulator

Um das in X-Code geöffnete Projekt im Simulator zu starten muss in der Auswahlbox der Toolbar folgende Eintrage aktiviert werden:

1. Active SDK: Simulator – iPhone OS 2.0

2. Active Configuration: Debug

3. Active Target: OpenGL|ES


24Anhang

4. Active Executable: OpenGL|ES – iPhone Simulator 2.0

Die Benennung dieser Einträge ist vom Namen des geöffneten Projektes abhängig!

Gestartet wird die Anwendung letztendlich durch einen Klick auf Build and Go.

1.5.3. iPhone Simulator

Anhand des iPhone Simulators ist es einfach möglich eine Anwendung zu testen. Die Applikation wird wie in Kapitel 1.5.2 beschrieben gestartet und daraufhin im Simulator dargestellt (vergl. Abbildung 17 oder Abbildung19).

Abbildung 29 Simulator Schnittstelle in X-Code (8)

Nun kann mit der Maus der Simulator bedient werden. Tippen auf das Display wird durch einen Mausklick, das überfahren mit einem Finger durch das Halten der Maustaste simuliert. Ebenso versteht der Simulator die Pinch-Open bzw. Pinch-Close Gestik (siehe Abbildung 21). Dazu muss bei gedrückter ALT-Taste, ebenfalls mit gehaltener Maustaste, der Pfeil über den Simulator bewegt werden. Um ins Hauptmenu des iPhone OS zurückzukehren ist der Knopf unterhalb des Displays zu drücken. Auch das drehen des Simulators in 90° Schritten ist möglich. In der Menüleiste unter dem Eintrag Hardware sind Befehle zum Links- sowie Rechts-drehen zu entdecken. Zugleich kann in diesem Menu die Version der Firmware geändert werden.


25Anhang

1.6.Relevante Probleme und deren Lösung

1.6.1. Farben werden nicht korrekt dargestellt

Die Farben innerhalb des OpenGL|ES Beispielprojektes werden im Format GRAB definiert. Warum dies der Fall ist bzw. wie man diese Einstellung geändert werden kann wurde aus Zeitgründen nicht näher ergründet.

1.6.2. Aktivieren von Anti-Aliasing im Simulator

Im hier vorliegenden Simulator mit der iPhone OS Version 2.1 wird Anti-Aliasing nicht unterstützt.

1.6.3. Auslesen von Gravitationsdaten im Simulator

Der Simulator liefert leider keine Gravitationsdaten bei Abfragen über die entsprechende API.

1.6.4. Die Applikation lässt sich nicht auf das Endgerät übertragen

Dieses Problem ist ebenfalls während der Entwicklung aufgetreten und konnte bisher leider nicht gelöst werden. Generell ist es nötig den Quellcode mit dem Kommandozeilenprogramm codesign digital zu signieren. Dafür wiederrum ist ein digitales Apple Developer Zertifikat nötig.

1.6.5. Festlegen des Startsymbols der Anwendung

Das Startsymbol der Anwendung kann in der Datei Info.plist festgelegt werden. Das Bild sollte im PNG Format vorliegen und in den Ordner Resources kopiert werden. Anschließend in der Datei Info.plist unter dem Schlüssel Icon file den Dateinamen angeben.

1.6.6. Funktion/Prozedur/Klasse wird vom Compiler nicht gefunden

Um eine Funktion/Prozedur/Klasse aus einem der Frameworks verwenden zu können, muss dieses zuvor dem Projekt hinzugefügt werden. Dies geschieht durch öffnen des Kontextmenus auf dem Ordner Frameworks und auswählen des Menüpunktes Add -> Existing Frameworks. Anschließend öffnet sich der Mac Dateiexplorer (finder) und das entsprechende Framework kann ausgewählt werden. Wenn die Projektvorlage für OpenGL|ES eingesetzt wird, sind die für dieses Dokument nötigen Programmteile bereits referenziert.

1.7.AufwandEinarbeitung

Lesen von Tutorials 18Anschauen von Videotutorials 12Einlesen in Beispielprogramme 4iPhone SDK 5

UmsetzungBunter 3D Würfel 13Zauberwürfel 9Touchscreen Schnittstelle 6

DokumentationEntwicklungsdokumentation 17Anwendungsdokumentation 3Präsentation 10


26Anhang

Anhang 11

Gesamtaufwand in Stunden 108

Zur Entwicklung wurde dabei ein PowerBook G4 eingesetzt welches mit dem Betriebssystem Mac OS X 10.5 Leopard ausgestattet ist. Die Programmierung wurde vollständig in X-Code durchgeführt und mit dem iPhone Simulator getestet. Als Testendgerät wurde ein iPod Touch mit der Firmware in Version 2.1 verwendet. Die Dokumentation ist unter Zuhilfenahme von Microsoft Office 2007 entstanden. Zur Aufarbeitung von Bildschirmfotos oder Bildern wurde GIMP 2.6.3 eingesetzt.


Documents

OpenGL|ES auf iPhone - hs-fulda.de · Autor: Markus Staab Dozent: Prof. Dr. Werner Heinzel Datum: 20.12.2008 OpenGL|ES auf iPhone Ausarbeitung im Rahmen der LVA: Grafisch Interaktive