Moin moin und willkommen zum dritten Part dieses Tutorials. In den ersten beiden Parts haben wir die Pygame-Segel gesetzt, nun geht es etwas schneller voran. Diesmal erobern wir mit unserem Tutorial-Kutter das OpenGL-Meer. Am Ende dieses Parts wird endlich etwas zu sehen sein, und zwar: Ein Viereck!

Damit wir die OpenGL-Schnittstelle nutzen können, importieren wir die PyOpenGL-Module. GL stellt einerseits OpenGL-Funktionen bereit, die mit gl beginnen (Beispiel: glVertex()) und andererseits Konstanten, die mit GL_ beginnen (Beispiel: GL_QUADS).
Mit GLU (GL Utility Library) werden weitere hilfreiche Funktionen und Konstanten nach dem gleichen Präfixmuster importiert (Beispiele: gluScaleImage, GLU_FILL).

from OpenGL.GL import *
from OpenGL.GLU import *

Als nächstes definieren wir eine Funktion namens reshape(), die jedesmal aufgerufen werden soll, wenn das Fenster neu angezeigt wird, oder die Fenstergröße verändert wird.
glViewport legt dabei ein Rechteck fest, in dessen Bereich wir unsere Vierecke zeichnen wollen. Es erstreckt sich von unten links (0,0) bis oben rechts (width,height, also 800,600).
Die Zeilen 3-6 beschäftigen sich mit Matrizen. Dazu mehr im nächsten Part.

def reshape((width,height)):
    glViewport(0, 0, width, height)
    glMatrixMode(GL_PROJECTION)
    glLoadIdentity()
    gluPerspective(60, 1.0*width/height, 0.1, 1000.0)
    glMatrixMode(GL_MODELVIEW)

Nun definieren wir eine init() Funktion, die zu Beginn des Programms aufgerufen wird und einige Eigenschaften unserer OpenGL-Umgebung festlegt. glClearColor legt eine weiße Hintergrundfarbe fest und erwartet dabei 4 Parameter: Rot-, Grün- und Blau-Anteil sowie den Alphawert.
Außerdem wird hier unsere reshape()-Funktion zum ersten mal aufgerufen.

def init():
    glClearColor(1.0, 1.0, 1.0, 1.0)
    reshape(screen)

Später im Tutorial fügen wir hier noch weitere OpenGL-Funktionen hinzu. Gleich gehts ans Zeichnen, aber zunächst ein wenig OpenGL-Vokabular:

Primitive
Primitives sind geometrische Grundformen, wie zum Beispiel Punkte, Linien oder Polygone. Diese lassen sich zusammensetzen und ergeben dann komplexere geometrische Formen.

Vertex
Ein Vertex (Plural: Vertices) ist ein Eckpunkt eines Primitives, dessen Position mit Koordinaten festgelegt wird. In OpenGL können mindestens zwei Koordinaten (X,Y) und maximal drei Koordinaten (X,Y,Z,W) angegeben werden, wobei X,Y und Z die 3D-Koordinaten sind. W findet hier zunächst keine Beachtung. Bei 2D-Darstellungen ist die Z-Koordinate immer 0.

Polygon
Ein Polygon ist eine aus mindestens drei Vertices bestehendes Vieleck. Das einfachste Polygon ist das Dreieck

Gentlemen, take your Bleistifts, das Malen kann beginnen. Zunächst definieren wir eine draw-Funktion. In dieser wird zunächst der Bildschirm geleert und mit der oben definierten Hintergrundfarbe (weiß) gefüllt.

def draw():
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)
    ...

Die draw-Funktion geht noch weiter. In OpenGL gibt es eine „virtuelle Kamera“, die aufnimmt, was später am Bildschirm zu sehen ist. Mit gluLookAt können wir Position und Ausrichtung (orientation) dieser Kamera bestimmen. Die ersten drei Parameter (0, 0, 6) bestimmen die Koordinaten der Position, also 6 Einheiten die Z-Achse entlang (Richtung Betrachter). Wir gehen mit der Kamera also im Prinzip 6 „Schritte“ zurück, damit wir etwas sehen.

Die nächsten drei Parameter (0, 0, -100) bestimmen die Koordinaten eines Punktes, auf den die Kamera gerichtet sein soll. In unserem Fall ein negativer Wert auf der Z-Achse (in den Bildschirm hinein). Die letzten drei Parameter (0, 1, 0) bestimmen, wo oben ist. Hier also die Y-Achse gerade nach oben.
Die Funktion glLoadIdentity() wird aufgerufen, um die Einheitsmatrix (identity matrix) zu laden. Somit wird bestimmt, dass die nachfolgende Funktion vom Ursprung des Koordinatensystems (0,0,0) ausgehen soll.

    ...
    glLoadIdentity()
    gluLookAt(0, 0, 6, 0, 0, -100, 0, 1 ,0)
    ...

Jetzt zeichnen wir die ersten Primitives. Innerhalb von glBegin(GL_QUADS) und glEnd() bestimmen wir die Vertices unseres Vierecks (Quads). glBegin erwartet als Parameter den Typen des Primitives. Zum Beispiel GL_POLYGON für Polygone oder GL_QUADS für Vierecke. Es existiert eine sehr gute vollständige Liste der Primitive-Typen (inkl. Erläuterungen) im Wiki der Delphi-OpenGL-Community.

Als Nächstes bestimmen wir blau (0.0, 0.0, 1.0) als Füllfarbe. Anschließend werden nacheinander die vier Vertices des ersten Vierecks bestimmt. glVertex2f erwartet dabei die X,Y Koordinaten eines Vertex als Parameter.

Später werden wir sehen, dass es effektivere Möglichkeiten gibt, Primitives zu zeichnen. Zum Beispiel Vertex-Arrays. Aber zu Beginn ist es so in Ordnung. Wir wollen ja nur ein Viereck darstellen.

    ...
    glBegin(GL_QUADS)
    glColor(0, 0, 1.0)
    glVertex2f(-2, 2)  # oben links
    glVertex2f(2, 2)   # oben rechts
    glVertex2f(2, -1)  # unten rechts
    glVertex2f(-2, -1) # unten links
    glEnd()   

    pygame.display.flip()

pygame.display.flip() bewirkt einen OpenGL Buffer Swap. Dazu später mehr, wenn es zu Bewegtbildern kommt. Zunächst genügt die Erklärung, dass diese Funktion den Bildschirminhalt aktualisiert.

An dieser Stelle ein kleiner Einschub zum Thema OpenGL-Syntax. Der Funktionsname glVertex2f sieht ja schon etwas eigenartig aus. Die Erklärung ist allerdings recht simpel. Das angehängte 2f bedeutet, dass die Funktion 2 Parameter (X,Y Koordinaten) des OpenGL-Datentyps float erwartet. Es gibt von vielen OpenGL Funktionen verschiedene Versionen (zum Beispiel glVertex3f, glVertex4i, …).

Nun rufen wir die draw-Funktion innerhalb unseres main loops auf. Das bewirkt, dass das Bild mit jedem Schleifendurchlauf einmal aktualisiert wird. Das macht bisher noch nicht soviel Sinn, aber wenn später Bewegung ins Spiel kommt, ist es unverzichtbar.

def main():
    init()
    maxfps = 100 
    clock = pygame.time.Clock()
    while True:
        clock.tick(maxfps)
        draw()
        get_event()

if __name__ == "__main__":
    main()

So sieht unser Ergebnis aus, wenn wir das Programm ausführen:

Tutorial Part 3 - Ergebnis

Der vollständige Quellcode zum dritten Tutorial-Part (ausgelagert)

Ziel von Part 2 ist das simple Anzeigen eines Pygame-Fensters und die Möglichkeit dieses wieder zu schließen.

Zunächst importieren wir das Pygame-Paket und alle seine Untermodule (z.B. pygame.display, pygame.sound, …), sowie die exit-Funktion aus dem sys-Modul.

import pygame
from sys import exit

Hier wird die Auflösung des Fensters in einem Tupel als Variable screen gespeichert:

screen = (800,600)

In folgender Zeile werden alle Untermodule von pygame initialisiert:

pygame.init()

Die Funktion im folgenden Code-Abschnitt erstellt eine Pygame-Oberfläche und erwartet drei Parameter, von denen die letzten beiden optional sind. Der erste Parameter bestimmt die Auflösung (Variable screen). Im zweiten (optionalen) Parameter legen wir Flags fest, die bestimmen, dass eine OpenGL-Oberfläche erstellt werden soll, die einen doppelten Puffer nutzt. Es gibt noch weitere Flags, die zunächst nicht wichtig sind. Der dritte (optionale) Parameter ist die Farbtiefe in Bit.
Die Funktion pygame.display.set_mode gibt ein Oberflächen-Objekt (surface object) zurück, das wir in der Variable surface speichern.

surface = pygame.display.set_mode(screen, pygame.OPENGL|pygame.DOUBLEBUF, 16)

Als nächstes geben wir dem Pygame-Fenster einen Namen, der in der Titelleiste des Fensters erscheint.

pygame.display.set_caption("Hallo Welt!")

Innerhalb der Funktion get_input() werden Events erkannt und bearbeitet. Ein Event kann ein Tastenanschlag auf der Tastatur sein, oder in unserem Beispiel das Klicken auf den Schließen-Button des Fensters.

def get_event():
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit()

Nun benötigen wir den main loop, damit das Fenster sichtbar bleibt. Hier wartet das Programm auf Events. Der Codeabschnitt clock.tick(maxfps) sorgt dafür, dass Frames per Second (FPS) begrenzt werden. Das ist deshalb sinnvoll, um die CPU-Auslastung gering zu halten. Andernfalls würde die Schleife so schnell es geht durchlaufen werden. Später bringen wir hier weitere Dinge unter.

def main():
    maxfps = 100 
    clock = pygame.time.Clock()
    while True:
        clock.tick(maxfps)
        get_event()

if __name__ == "__main__":
    main()

Führt man das Programm aus, erscheint ein schwarzes Fenster mit dem Titel „Hallo Welt!“, das quasi danach schreit, gleich wieder geschlossen zu werden Aber keine Angst, im nächsten Part wird es mehr zu sehen geben!

Hier noch einmal der komplette Quellcode aus Part 2 des Tutorials:

import pygame
from sys import exit

screen = (800,600)

pygame.init()
surface = pygame.display.set_mode(screen, pygame.OPENGL|pygame.DOUBLEBUF, 16)
pygame.display.set_caption("Hallo Welt!")

def get_event():
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            exit()

def main():
    maxfps = 100 
    clock = pygame.time.Clock()
    while True:
        clock.tick(maxfps)
        get_event()

if __name__ == "__main__":
    main()

Wenn Ihr folgen wollt, solltet ihr bereits Python-Kenntnisse besitzen. Pygame-Kenntnisse sind nicht unbedingt Voraussetzung aber hilfreich, da ich nicht so ausführlich darauf eingehe. OpenGL ist für mich neu und ich versuche beim Schreiben des Tutorials selbst dazuzulernen und setze dementsprechend keine OpenGL-Kenntnisse voraus.

Zunächst ein paar Worte zu OpenGL, PyOpenGL und Pygame:

OpenGL (Open Graphics Library) ist eine Schnittstelle (API) zur Entwicklung von 2D- und 3D-Grafik. Derzeit befindet sich OpenGL in einer Umbruchsphase. Das heißt, viele Befehle aus der mittlerweile 17 Jahre alten API werden ausgemistet, sodass zukünftig weitaus perfomantere Techniken genutzt werden, um anderen APIs – wie zum Beispiel DirectX – wieder Konkurrenz machen zu können. In diesem Tutorial werden allerdings die klassischen Programmiertechniken zum Einsatz kommen, da der Einstieg in die 3D-Programmierung damit in meinen Augen wesentlich verständlicher ist.

PyOpenGL ist ein plattformunabhängiges Python-Binding zu OpenGL. Es ist wie eine Hülle (Wrapper) um OpenGL zu verstehen, die Befehle unter Python zur Verfügung stellt. Version in diesem Tutorial: PyOpenGL 3.0.0 (unterstützt OpenGL 1.1 bis 3.0): http://pyopengl.sourceforge.net

PyGame ist eine Sammlung von Modulen, die vor allem der Spieleentwicklung dienen. Es sind zum Beispiel Module zur Steuerung von Grafik und Sound enthalten, sowie Module zum Abfragen von Eingabegeräte wie Maus, Tastatur oder Gamepad. Version in diesen Tutorial: Pygame 1.8.1: http://www.pygame.org

Pygame stellt also quasi das Grundgerüst unseres Programms dar. Deshalb gehe ich in Part 2 überwiegend auf Pygame ein und lege den Grundstein für das weitere Vorgehen. Später folgen dann die 3D-Animationen in OpenGL.

Nun ist er da, mein neuer Blog. Was soll das hier nur werden? Also: In Zukunft wird es hier Blogposts geben, die sich mit Python beschäftigen. Zum einen werde ich versuchen, ein OpenGL-Projekt, das ich für die Uni durchführen werde, hier zu dokumentieren. Bisher weiß ich ganz grob, in welche Richtung das gehen soll (3D Animation, Gamepad-Steuerung).

Ansonsten beschäftige ich mich momentan intensiv mit dem Web-Framework Django, und werde ab und zu mal ein paar Kniffe präsentieren, die das Leben einfacher machen.

Habt Ihr Fragen, Anregungen, Kritik oder Ähnliches: Immer her damit! Feedback ist mir sehr wichtig!