Sie sind auf Seite 1von 26

OpenGL|ES auf iPhone

Ausarbeitung im Rahmen der LVA: Grafisch Interaktive Systeme

Autor: Markus Staab


Dozent: Prof. Dr. Werner Heinzel
Datum: 20.12.2008
Anhang2

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)....................................................................................................................................6
Deklaration einer Methode.....................................................................................................................................................6
Implementierung einer Klasse (@implementation)...............................................................................................................7
Aufruf 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..................................................................................................................................................................12
Zauberwü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..................................................................................................................................................24
Starten 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
Anhang3

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang4

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.
Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab
Anhang5

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang6

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang7

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang8

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang9

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang10

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)

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang11

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):

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang12

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang13

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

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang14

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang15

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

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang16

• 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

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang17

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang18

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang19

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:

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang20

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang21

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/iP
honeAppProgrammingGuide.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 Dokumentation
Downloads/ => Alle Dateien die heruntergeladen wurden
Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab
Anhang22

Quellen/ => Offlineversion der verwendeten Quellen


XCode Projekt/ => Sourcecode der Ausarbeitung
Ausarbeitung.docx/.pdf => Dokumentation zur Ausarbeitung
Prä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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang23

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


Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab
Anhang24

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 Abbildung
19).

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang25

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.Aufwand
Einarbeitung
Lesen von Tutorials 18
Anschauen von Videotutorials 12
Einlesen in Beispielprogramme 4
iPhone SDK 5

Umsetzung
Bunter 3D Würfel 13
Zauberwürfel 9
Touchscreen Schnittstelle 6

Dokumentation
Entwicklungsdokumentation 17
Anwendungsdokumentation 3
Präsentation 10

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab


Anhang26

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.

Ausarbeitung: OpenGL|ES auf iPhone, Markus Staab