5/97
CyberGL: Workshop (Folge 2)
In den Weiten des Raums
Nachdem im letzten Teil die angebotenen Grafikbibliotheken im allgemeinen und die grunds�tzlichen Eigenschaften der OpenGL im speziellen beleuchtet wurden, schaffen wir in diesem Kursteil das Basiswissen zur Nutzung der CyberGL.
Zun�chst zu den Voraussetzungen, die erf�llt sein m�ssen, bevor die
CyberGL zum Einsatz kommen kann. F�r die offiziellen
OpenGL-Spezifikationen (s. [1]) mu� die CyberGL sehr genaue und
teilweise sehr aufwendige Berechnungen durchf�hren. Daher ist eine
Flie�kommaeinheit (FPU) zwingend erforderlich � es wird also
mindestens ein 68020-68882-Gespann ben�tigt, besser jedoch in
Kombination mit einem 68040- oder 68060-Prozessor. Au�erdem sollte
m�glichst der Hauptspeicher gut ausgebaut sein. Beispiel: ein
einfaches Programm braucht, um ein Fenster mit der Gr��e 600x450 Pixel
zu zeichnen, schon ca. 1 MB Hauptspeicher. Das alles, um den
Fensterinhalt, den Z-Buffer, interne Buffer, Tabellen, den
CyberGL-Kontext und nicht zuletzt die Bibliothek und das Programm
selbst aufzunehmen. Da CyberGL in erster Linie f�r dreidimensionale,
beleuchtete Szenen designed wurde, sind nat�rlich eine Grafikkarte
oder mindestens ein AGA-Chipset n�tig, um die sehr gro�e Anzahl von
Farben vern�nftig darzustellen.
| Beleuchtungsfunktionen |
| GLvoid glMaterialfv (GLenum face, GLenum pname, GLfloat *params); |
| GLvoid glLightfv (GLenum light, GLenum pname, GLfloat *params); |
Die Bibliothek
Sind alle diese Hardware-Voraussetzungen erf�llt, fehlt nat�rlich noch die Software: In erster Linie ist die Bibliothek selbst n�tig, also die �cybergl.library�. Sie mu� sich in der richtigen Version (68030+ 68882, 68040 oder 68060) im Verzeichnis �LIBS:� befinden. Da die OpenGL einige Funktionen beinhaltet, die sehr viele Parameter und oft auch Flie�kommaparameter doppelter Genauigkeit erwarten und damit mehr Register ben�tigt werden, als vorhanden sind, ist es leider n�tig, einige CyberGL-Funktionen durch eine kleine Link-Bibliothek (�cybergl.lib�) anzupassen. Diese kleine Bibliothek ist nicht zwingend erforderlich, allerdings k�nnen wir dann einige Funktionen (z.B. glOrtho) nicht wie gewohnt aufrufen, sondern es mu� zun�chst eine Struktur mit den Funktionsparametern gef�llt werden und die Funktion erh�lt dann einen Zeiger auf diese Struktur. Neben diesen Bibliotheken sind nat�rlich die Headerdateien n�tig, um ein CyberGL-Programm zu �bersetzen. Sollte sogar CyberGfX V3.0 verf�gbar sein, ist eine Truecolor-Darstellung mit 16 Mio. Farben m�glich � ohne CyberGfX 3.0 mu� man mit maximal 256 Farben auskommen, die aber von der CyberGL so gut wie m�glich ausgenutzt werden.
| Sicht: Verh�ltnis zwischen Breite und H�he des Bildes, vertikaler Kamera�ffnung und Front- und Back-Clipping-Plane |
| Test: Dieses Dreieck wird durch das Programm in Listing 1 erzeugt |
|
Wie sieht nun ein einfaches CyberGL-Programm aus? Im Prinzip funktioniert die Benutzung
der CyberGL genauso wie die der �graphics.library�: Es wird ein
Fenster ge�ffnet, in das anschlie�end gezeichnet werden kann und am
Ende des Programms wird das Fenster wieder geschlossen. Die Funktionen
zum �ffnen und Schlie�en eines CyberGL-Fensters gleichen sogar den
Funktionen der �intuition.library� � im Grunde sind es die Funktionen
der intuition.library erg�nzt um einige entscheidende Kniffe. Die
Funktion zum �ffnen eines CyberGL-Fensters hei�t �openGLWindowTagList�
bzw. �openGLWindowTags� f�r die Stack-Version). Sie erwartet als
Argumente die Breite und H�he des Fensters und eine Tag-Liste. Die
Funktion zum Schlie�en eines CyberGL-Fensters hei�t �closeGLWindow�.
Sie erwartet lediglich das zuvor ge�ffnete Fenster als Argument. Da
ein CyberGL-Window ein abstrakter Datentyp ist, dessen Inhalt dem
Benutzer verborgen bleibt, braucht man zus�tzlich noch die Funktion
�getWindow�, um an das zugeh�rige Intuition-Fenster zu kommen. Diese
Funktion erwartet ein CyberGL-Fenster als Parameter und liefert einen
Zeiger auf das Intuition-Fenster, um etwa auf Messages zu reagieren
(Tastendruck, Mausklicks usw.). Eine weitere wichtige Funktion hei�t
�resizeGLWindow� � sie teilt der CyberGL mit, da� sich die
Fenstergr��e ge�ndert hat. Dies ist n�tig, da die CyberGL nicht
automatisch von Intuition �ber eine Gr��en�nderung informiert wird.
Ein �berblick �ber diese vier wichtigen Funktionen ist in unserem
Infokasten �Funktionen� zu finden.
Ein einfaches Beispiel
Ein einfaches Beispiel demonstriert das Listing 1 � das Ergebnis dieses kleinen Programms ist in Bild �Test� zu sehen. Immer nur in ein Fenster mit Weltkoordinaten zwischen (-1.0,-1.0,-1.0) und (1.0,1.0,1.0) zu zeichnen �det nat�rlich auf die Dauer ziemlich an. Gl�cklicherweise bietet die CyberGL einige Funktionen, um auf einfache Weise verschiedene Parallel- und Zentralprojektionen in die Projektionsmatrix zu laden, die dazu zuerst einmal per �glMatrixMode (GL_PROJECTION)� zur aktuellen Matrix gemacht werden mu�. Nun kann z.B. mit glOrtho (-400.0, 400.0, -300.0, 300.0, 500.0, -500.0) eine Parallelprojektion erzeugt werden, die den Punkt (-400.0, -300.0, 500.0) auf die linke, untere, vordere Ecke des Fensters und den Punkt (400.0, 300.0, -500.0) auf die rechte, obere, hintere Ecke des Fensters abbildet. Nun erscheint es vielleicht merkw�rdig, von einer �vorderen Ecke des Fensters� zu reden, schlie�lich ist ein Fenster doch nur zweidimensional. Allerdings schneidet die CyberGL Fl�chen nicht nur an den Fenstergrenzen ab, bevor sie gezeichnet werden, sondern zus�tzlich an einer vorderen und hinteren Ebene (Front- und Back-Clipping-Plane). Solche Parallelprojektionen sind zwar f�r technische Anwendungen recht n�tzlich, aber das menschliche Auge wei� immer nicht so recht was denn nun vorn und was hinten sein soll, da Objekte in der Realit�t mit zunehmender Entfernung kleiner werden. Darum gibt es weitere Funktionen zum Laden von Zentralprojektionen. Eine davon hei�t �glPerspective� und erwartet den vertikalen �ffnungswinkel der virtuellen Kamera, das Seitenverh�ltnis des Fensters und die Entfernungen zur Front- und Back-Clipping-Plane. Zum besseren Verst�ndnis werfen wir einen Blick auf die Abbildung �Sicht�. Dargestellt ist der sogenannte Sichtpyramidenstumpf, der durch den Augenpunkt (die Position der virtuellen Kamera), das Verh�ltnis zwischen Breite und H�he des Bildes (z.B. 4:3 = 1.333), den vertikalen Kamera�ffnungswinkel (z.B. 40.0 Grad) und die Entfernungen zur Front- und Back-Clipping-Plane (z.B. 0.5 und 50.0) eindeutig definiert ist � das ergibt den Aufruf "glPerspective (40.0, 1.333, 0.5, 50.0)".
| CyberGL-Funktionen |
|---|
| GLvoid *openGLWindowTagList (GLint width, GLint height, struct TagList *tags); |
| GLvoid closeGLWindow (GLvoid *window); |
| struct Window *getWindow (GLvoid *window); |
| GLvoid resizeGLWindow (GLvoid *window, GLint width, GLint height); |
Nun fehlt f�r eine flexible Sichtdefinition nur noch die M�glichkeit, die Kamera beliebig im virtuellen Raum zu positionieren und auf irgendein Objekt auszurichten. Diese Aufgabe �bernimmt die CyberGL-Funktion �glLookAt�. Zuerst wird dazu aber via �glMatrixMode (GL_MODELVIEW)� auf die Modelview-Matrix umgeschaltet, da es sich bei der Kameradefinition um keine Projektion handelt. �glLookAt� erwartet als Argumente die Position der Kamera, den Punkt, auf den die Kamera ausgerichtet ist und einen Vektor, der angibt wo �oben� ist � im n�chternen Zustand au�erhalb eines Flugzeuges sind das meistens die Koordinaten (0.0, 1.0, 0.0). Der Beispielaufruf "glLookAt (4.0,6.0,15.0, 0.0,-1.0,-2.0, 0.0,1.0,0.0)" definiert als Kameraposition den Punkt (4.0,6.0,15.0), als Blickziel den Punkt (0.0,-1.0,-2.0) und als �oben� die Richtung (0.0,1.0,0.0).
|
| W�rfel: Das Objekt mit Beleuchtung durch Listing 2 � Sie finden es auf den Internetseiten des AMIGA-Magazins |
Primitive-Beschreibung
Im letzten Teil des Kurses wurde bereits angek�ndigt, da� es zehn Arten von Primitiven gibt, die in �Primitive� zu sehen sind. Eigentlich gibt es nur Punkte, Linien, Dreiecke, Vierecke und n-Ecke. Aber wie in der Abbildung zu sehen, sind einige sehr n�tzliche Varianten m�glich. Diese machen teilweise mehrfache Aufrufe von glVertex f�r Punkte, die von mehreren Primitiven gemeinsam benutzt werden, �berfl�ssig. Die CyberGL setzt mehrere glVertex-Aufrufe auf v�llig unterschiedliche Arten zu Primitiven zusammen � je nachdem welches Argument die Funktion �glBegin� erh�lt.
|
| Primitives: CyberGL unterst�tzt die Darstellung dieser zehn Objekte |
#include <stdlib.h>
#include <time.h>
#include <math.h>
#include <intuition/intuition.h>
#include <proto/exec.h>
#include <proto/graphics.h>
#define SHARED /* shared library benutzen */
#define GL_APICOMPATIBLE /* stubs aus cybergl.lib benutzen */
#include "cybergl.h" /* cybergl Datentypen */
#include "cybergl_protos.h" /* cybergl Prototypen */
#include "display.h" /* cybergl Fensterfunktionen */
#include "cybergl_pragmas.h" /* cybergl Pragmas */
extern struct Library *CyberGLBase; /* cybergl Library Base */
#define WIDTH 400 /* Fensterbreite */
#define HEIGHT 400 /* Fensterh�he */
void main (int argc, char *argv[])
{
void *glWindow; /* unser cybergl-Fenster */
glWindow = openGLWindowTags (WIDTH, HEIGHT, /* Fenster �ffnen */
GLWA_Title, "Test", /* Titel */
GLWA_DragBar, TRUE, /* Ziehbar */
GLWA_CloseGadget, TRUE, /* Schlie�button */
GLWA_IDCMP, IDCMP_CLOSEWINDOW, /* Messages */
GLWA_RGBAMode, GL_TRUE, /* CyberGL RGBA-Mode */
TAG_DONE);
if (glWindow) /* Fenster ge�ffnet ? */
{
/* Framebuffer (RGBA) und Z-Buffer l�schen */
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBegin (GL_TRIANGLES); /* Primitiv: Dreiecke */
glVertex2d (-0.9, -0.9); /* erste Ecke */
glVertex2d ( 0.9, -0.7); /* zweite Ecke */
glVertex2d (-0.6, 0.9); /* dritte Ecke */
glEnd (); /* Fertig ! */
/* auf Closebutton warten */
Wait (1 << getWindow (glWindow)->UserPort->mp_SigBit);
closeGLWindow (glWindow); /* Fenster schlie�en */
}
}
|
| Listing 1: Diese Programm �ffnet ein Fenster und zeichnet ein Dreieck per CyberGL |
Die Beleuchtung
F�r eine einfache �richtig dreidimensionale� Szene fehlt nun eigentlich nur noch: die Beleuchtung. Da die CyberGL in diesem Punkt eine F�lle von M�glichkeiten und Funktionen bietet, wollen wir uns daher auf das Wesentliche beschr�nken. Die wichtigsten Funktionen f�r eine einfache Beleuchtung finden Sie im Info-Kasten �Beleuchtungs-Funktionen�. Die erste der beiden Funktionen erlaubt es, Materialattribute zu definieren. Wir beschr�nken uns auf die Vorderseiten von Polygonen (die R�ckseiten sind bei statischen Darstellungen schlie�lich sowieso nicht sichtbar) und setzen daher das Argument �face� auf �GL_FRONT� und ver�ndern nur die diffuse Farbe des Materials � �pname� wird also auf �GL_DIFFUSE� gesetzt. Das letzte Argument f�r diese Funktion mu� nun ein Zeiger auf vier (ja vier) Flie�kommawerte sein, die die Farbe bestimmen. Die CyberGL verarbeitet intern alle Farben im RGBA-Format (Rot, Gr�n, Blau, Alpha), wobei jeder der Werte zwischen 0,0 und 1,0 liegen kann. Der Alpha-Kanal wird zwar von der aktuellen CyberGL-Version nicht verwendet, sollte aber trotzdem immer auf 1.0 gesetzt werden. Die zweite Funktion kann diverse Lichtquellenparameter einstellen, aber auch hier beschr�nken wir uns auf die wichtigsten. Wir verwenden genau eine Richtungslichtquelle (vergleichbar mit Sonnenlicht), die wei�es Licht auf unsere Szene fallen l��t. Die Lichtrichtung wird durch einen Punkt angegeben, von dem aus das Licht in Richtung Nullpunkt � also (0.0,0.0,0.0) strahlt. Etwas ungew�hnlich mag die Darstellung des Vektors in vier Dimensionen erscheinen, wie es im Programm zu sehen ist. Dies liegt daran, da� f�r alle Punkte und Vektoren sogenannte homogene Koordinaten verwendet werden. Im Grunde reicht es zu wissen, da� die vierte Koordinate (auch w-Koordinate genannt) normalerweise 1.0 sein sollte, au�er im Fall von Richtungsvektoren (wie hier bei der Richtungslichtquelle), wo sie den Wert 0.0 haben mu�. Mit all diesem Wissen ausgestattet, k�nnen wir nun ein kleines CyberGL-Programm schreiben, das ein Fenster �ffnet, einige Einstellungen vornimmt und dann einen beleuchteten W�rfel darstellt (Listing 2). Nach diesem Kursteil haben wir das n�tige R�stzeug, um in der n�chsten Folge ein etwas komplexeres CyberGL-Programm zu verstehen. Dann wollen wir n�mlich einen Fraktalgebirge-Generator schreiben, der seine Ausgaben in einem CyberGL-Fenster realisiert.
 |
| Beleuchtung: Die Erzeugung dreidimensionaler Objekte mit Lichteffekten unterst�tzt CyberGL auf Wunsch |
Literatur:
[1] The OpenGL Graphics System:
A Specification (Version 1.0), Mark Segal, Kurt
Akeley, 8.Oct 1993
[2] OpenGL Programming Guide, Addison Wesley Publishing Company,
ISBN 0-201-63274-8
� Copyright by MagnaMedia Verlag AG, Haar bei M�nchen
Ver�ffentlichung und Vervielf�ltigung nur mit schriftlicher Genehmigung des Verlags
Kommentare, Fragen, Korrekturen und Kritik bitte an Webmaster AMIGA schicken.
Zuletzt aktualisiert am 15.April 1997.