5 Matrixstacks

Um komplexe Bewegungsabläufe innerhalb einer Szenerie zu implementieren, muß es möglich sein, verschiedene Objekte mit verschiedenen Transformationsmatrizen zu versehen.

Bei diesem Roboterarm z.B. wäre es sehr angenehm, wenn man den Oberarm um den Punkt A dreht, daß sich der Unterarm und die Hand mitdrehen. Wenn sich der Unterarm um den Punkt B dreht, soll sich die Hand mitdrehen. Außerdem soll die Hand um den Punkt C drehbar sein. Es ist klar das dazu drei unterschiedliche Matrizen notwendig sind, wobei die Matrix für den Unterarm eine Verknüpfung aus der Stellung des Unterarms mit der Stellung des Oberarms darstellt. Ähnliches gilt für den Unterarm.

In OpenGL gibt es dazu Matrixstacks. Ein Matrixstack erlaubt es, die aktuelle Transformationsmatrix zu sichern, sie mit weiteren Matrizen zu verknüpfen, und danach wieder zu restaurieren. Es gibt in OpenGL drei unterschiedliche Matrixstacks. Den Modelview-, Projection- und Textur-Stack. Der Modelview-Stack beinhaltet die Transformationsmatrizen für die Geometrie, der Projection-Stack enthält die Matrizen für die Kamera und Viewportge-staltung, der Texture-Stack dient zum Manipulieren der Texturkoordinaten.

Folgende Befehle zur Manipulation der Matrixstacks stehen u.a. zu Verfügung:

glMatrixMode ( mode )   //Bestimmt, welcher Matrixstack bearbeitet wird.
                        // ist entweder GL_MODELVIEW, GL_PROJECTION
                        // oder GL_TEXTURE

glPushMatrix()          // sichert die aktuelle Matrix am Stack

glPopMatrix ()	        // holt die letzte Matrix vom Stack

glLoadIdentity()        // Überschreibt die aktuelle Matrix mit der
                        // Einheitsmatrix

Folgende Befehle stehen für Transformationen zur Verfügung:

glTranslate(x, y, z)    // Multipliziert die aktuelle Matrix mit einer
                        // Translationsmatrix in Richtung (x,y,z)
glRotate(angle, x, y, z )
                        // Multipliziert die aktuelle Matrix mit einer
                        // Rotationsmatrix mit -Grad um den Vektor
                        // (x, y , z); Drehung um die X-Achse um 10°:
                        // glRotate ( 10, 1.0, 0.0, 0.0 ); Drehung um den
                        // ersten Meridian auf der Z-Ebene=0:
                        // glRotate( 10, 1.0, 1.0, 0.0 );
glScale(x, y, z )       // Multipliziert die aktuelle Matrix mit einer
                        // Skalierungsmatrix

Folgende Befehle dienen zum Manipulieren des GL_PROJECTION - Stacks:

glFrustum ( left, right, bottom, top, near, far )
                        // Erzeugt eine perspektivische Darstellungsmatrix
                        // und multipliziert diese mit der aktuellen
                        // Matrix. Die vordere Clippingebene wird
                        // definiert durch
                        // ( left, bottom, -near) - ( right, top, -near ),
                        // die hintere Ebene liegt bei (-far)
gluPerspective ( fovy, aspect, zNear, zFar )
                        //  gibt den Sichtbereich in Grad an
                        // ( 0.0 - 180.0 ° ).  ist Breite / Höhe
                        // des Sichtfeldes,  bzw.  sind die
                        // vordere bzw. hintere Clippingebene
glOrtho ( left, right, bottom, top, near, far )
                        // Definiert eine Parallelprojektion im angegeben
                        // Bereich
glOrtho2D ( left, right, bottom, top )
                        // Definiert eine Parallelprojektion im angegeben
                        // Bereich mit den z zwischen -1.0 und 1.0

glMatrixMode ( GL_PROJECTION );
glLoadIdentity();							// Einheitsmatrix laden
gluPerspective ( 65.0, width/height, 1.0, 20.0 ); 	// Darstellung wählen
glMatrixMode ( GL_MODELVIEW );
glLoadIdentity();
gltranslate ( 0.0, 0.0, -5.0 );

glPushMatrix();
  glTranslatef ( -1.0, 0.0, 0.0 );		// Drehmittelpunkt des OberA.
  glRotatef ( w1, 0.0, 0.0, 1.0 );		// Oberarm drehen
  glTranslatef ( 1.0, 0.0, 0.0 );		// zurückschieben
  auxWireBox ( 2.0, 0.4, 1.0 );		// Oberarm zeichnen

  glTranslatef ( 1.0, 0.0, 0.0 );		// DrehMP für Unterarm
  glRotatef ( w2, 0.0, 0.0, 1.0 );		// Unterarm drehen
  glTranslatef ( 1.0, 0.0, 0.0 );		// Mittelpunkt des Unterarms
  auxWireBox ( 2.0, 0.4, 1.0 );		// Unterarm zeichnen

  glTranslatef ( 1.0, 0.0, 0.0 );		// neuer Drehpunkt
  glPushMatrix ();
    glRotatef ( w3, 0.0, 0.0, 1.0 );	// Finger1 drehen
    glTranslatef ( 0.5, 0.0, 0.0 );
    auxWireBox ( 1.0, 0.2, 1.0 );
  glPopMatrix();

  glPushMatrix ();
    glRotatef ( w4, 0.0, 0.0, 1.0 );	// Finger1 drehen
    glTranslatef ( 0.5, 0.0, 0.0 );
    auxWireBox ( 1.0, 0.2, 1.0 );
  glPopMatrix();
glPopMatrix();