prev up inhalt next

24.3 Programmbeispiele

Auf den folgenden Seiten werden einige durch deutsche Kommentare erweiterte OpenGl-Beispiele vorgestellt, die alle dem bei Addison-Wesley erschienenen Buch OpenGL Programming Guide entnommen wurden. Das Copyright für diese Programme liegt bei der Firma Silicon Graphics. Aus Platzgründen wurde auf eine explizite Wiederholung der Copyright-Klausel im jeweiligen Quelltext verzichtet. Eine komplette Sammlung aller Beispiele findet sich unter http://trant.sgi.com/opengl/examples/redbook/redbook.html .

hello.c
zeigt in Orthogonalprojektion ein rotes Rechteck auf blauem Hintergrund. Es wird zunächst um eine Einheit in x-Richtung verschoben und danach um 45 Grad gedreht.
wire-cube.c
zeigt in perspektivischer Projektion einen roten Drahtgitterwürfel vor grünem Hintergrund. Der Würfel ist in y-Richtung um den Faktor 1.5 skaliert und um 30 Grad bzgl. der y-Achse gedreht.
wire-prop-cube.c
zeigt in perspektivischer Projektion einen weißen Drahtgittelwürfel vor blauem Hintergrund. Bei Verändern des Ausgabefensters durch den Benutzer wird die Funktion reshape aufgerufen, die eine Neuberechnung des Viewports durchführt.
click.c
zeigt die Interaktion durch die Maus für den Farbwechsel eines Dreiecks. Die globale Variablen g wird durch den linken Maus-Button auf 1, durch den rechten Mausbutton auf 0 gesetzt. In der Funktion display wird dadurch entweder ein gelb oder ein rot erzeugt.
key.c
zeigt die Interaktion durch die Tastatur für den Farbwechsel eines Dreiecks. Die globalen Variablen r,g und b werden durch Betätigen der gleichnamigen Tasten entsprechend gesetzt. In der Funktion display wird dadurch das RGB-Tripel auf rot, grün oder blau gesetzt.
planet.c
zeigt die Interaktion durch die Tastatur für das Fortschalten einer Rotationsbewegung. Durch Drücken der d-Taste wird die Rotation der Erde um sich selbst um 10 Grad angestoßen, durch Drücken der y-Taste wird die Rotation der Erde um die Sonne um 5 Grad angestoßen.
smooth.c
zeigt ein Dreieck mit Farbverlauf. Erreicht wird dies im Smooth-Shading-Modus durch Interpolation von RGB-Werten, welche an den Ecken des Dreiecks vorgegeben sind.
list.c
zeigt eine Anwendung von Display-Listen. Unter dem Namen listName wird ein rotes, gefülltes Dreieck zusammen mit einer Translation hinterlegt. Ein wiederholter Aufruf dieses Namens erzeugt eine Sequenz von nebeneinander platzierten Dreiecken.
bezier-curve.c
zeigt eine durch vier zwei-dimensionale Kontrollpunkte definierte Bezier-Kurve. Zur besseren Sichtbarkeit werden die Kontrollpunkte mit 5-facher Stärke platziert. Die Kurve entsteht durch Auswertung eines Evaluators längs eines von 0 nach 1 in 30 Schritten wandernden Parameters.
bezier-surface.c
zeigt ein durch 16 drei-dimensionale Kontrollpunkte definiertes Bezier-Gitter. Das Gitter entsteht durch Auswertung eines Evaluators längs eines von 0 nach 1 in 8 Schritten und von 0 nach 1 in 30 Schritten wandernden Parameters.
teapot.c
zeigt den klassischen Utah-Teapot in photo-realistischer Projektion. Berücksichtigt werden Reflektionskoeffizienten für diffuses und spekulares Licht, erzeugt von einer Lichtquelle.
teapot-rotate.c
zeigt den klassischen Utah-Teapot in Bewegung. Erreicht wird dies durch die Funktion spinDisplay, welche die Rotation um die y-Achse in 5-Grad-Schritten fortschreibt. spinDisplay wird durch die Registrierung über glutIdleFunc immer dann aufgerufen, wenn keine anderen Events zur Abarbeitung anstehen.

hello.c: Rotes Quadrat, gedreht und verschoben, auf blauem Hintergrund 
#include                          /* Header fuer OpenGl utility toolkit  */
#include                           /* Header fuer C-Library               */

void init(void) {                            /* Initialisierung                     */
  glClearColor(0.0, 0.0, 1.0, 0.0);          /* setze Blau als Hintergrundfarbe     */
  glMatrixMode(GL_PROJECTION);               /* betrifft Projektionsmatrix          */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glOrtho(0.0, 3.0, 0.0, 2.0, -1.0, 1.0);    /* Orthogonalprojektions-Clip-Ebenen   */
}                                            /* left, right, bottom, top, near, far */

void display(void){                          /* Prozedur zum Zeichnen               */
  glClear(GL_COLOR_BUFFER_BIT);              /* alle Pixel zurecksetzen             */
  glMatrixMode(GL_MODELVIEW);                /* betrifft Modelview-Matrix           */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glRotatef(45,0.0,0.0,1.0);                 /* drehe 45 Grad bzgl. der z-Achse     */
  glTranslatef(1.0, 0.0, 0.0);               /* verschiebe eine Einheit nach rechts */
  glColor3f(1.0, 0.0, 0.0);                  /* Farbe rot                           */ 
  glBegin(GL_POLYGON);                       /* Beginn eines Polygons               */
    glVertex3f(0.25, 0.25, 0.0);             /* links unten                         */
    glVertex3f(0.75, 0.25, 0.0);             /* rechts unten                        */
    glVertex3f(0.75, 0.75, 0.0);             /* rechts oben                         */
    glVertex3f(0.25, 0.75, 0.0);             /* links oben                          */
  glEnd();                                   /* Ende des Polygons                   */
  glFlush();                                 /* direkt ausgeben                     */
}

int main (int argc, char ** argv) {          /* Hauptprogramm                       */
  glutInit(&argc, argv);                     /* initialisiere GLUT                  */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); /* single buffer, true color           */
  glutInitWindowSize(750, 500);              /* initiale Fenstergroesse             */
  glutInitWindowPosition(100,100);           /* initiale Fensterposition            */
  glutCreateWindow("hello");                 /* Fenster mit Aufschrift              */
  init();                                    /* rufe init auf                       */
  glutDisplayFunc(display);                  /* registriere display                 */
  glutMainLoop();                            /* beginne Event-Schleife              */
  return 0;                                  /* ISO C verlangt Rueckgabe            */
}

wire-cube.c: Perspektivische Projektion eines Drahtgitterquaders, ohne Reshape 
#include                           /* Header fuer OpenGl utility toolkit */
#include                            /* Header fuer C-Library              */

void init(void) {                             /* Initialisierung                    */
  glClearColor(0.0, 0.0, 1.0, 0.0);           /* setze Blau als Hintergrundfarbe    */
  glMatrixMode(GL_PROJECTION);                /* ab jetzt: Projektionsmatrix        */
  glLoadIdentity();                           /* lade Einheitsmatrix                */
  glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);      /* left,right,bottom,top,near,far     */
}

void display(void){                           /* Prozedur zum Zeichnen              */
  glClear(GL_COLOR_BUFFER_BIT);               /* alle Pixel zurecksetzen            */
  glMatrixMode(GL_MODELVIEW);                 /* ab jetzt:  Modellierungsmatrix     */
  glColor3f(1.0, 1.0, 1.0);                   /* Farbe rot                          */
  glLoadIdentity();                           /* Einheitsmatrix                     */
  gluLookAt(0.0, 0.0, 5.0,                    /* Kamera-Standpunkt                  */
            0.0, 0.0, 0.0,                    /* Kamera-Fokussiertpunkt             */
            0.0, 1.0, 0.0);                   /* Up-Vektor                          */
  glScalef(1.0, 1.5, 1.0);                    /* Skalierung in 3 Dimensionen        */
  glRotatef(30.0, 0.0, 1.0, 0.0);             /* rotiere 30 Grad um y-Achse         */
  glutWireCube(2.0);                          /* Drahtgitterwuerfel                 */
  glFlush();                                  /* direkt ausgeben                    */
}

int main (int argc, char ** argv) {           /* Hauptprogramm                      */
  glutInit(&argc, argv);                      /* initialisiere GLUT                 */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);  /* single buffer, true color          */
  glutInitWindowSize(750, 500);               /* initiale Fenstergroesse            */
  glutInitWindowPosition(100,100);            /* initiale Fensterposition           */
  glutCreateWindow("wire-cube");              /* Fenster mit Aufschrift             */
  init();                                     /* rufe init auf                      */
  glutDisplayFunc(display);                   /* registriere display                */
  glutMainLoop();                             /* beginne Event-Schleife             */
  return 0;                                   /* ISO C verlangt Rueckgabe           */
}

wire-prop-cube.c: Perspektivische Projektion eines Drahtgittelquaders, mit Reshape 
#include                           /* Header fuer OpenGl utility toolkit */
#include                            /* Header fuer C-Library              */

void init(void) {                             /* Initialisierung                    */
  glClearColor(0.0, 0.0, 1.0, 0.0);           /* setze Blau als Hintergrundfarbe    */
  glMatrixMode(GL_PROJECTION);                /* ab jetzt: Projektionsmatrix        */
  glLoadIdentity();                           /* lade Einheitsmatrix                */
  glFrustum(-1.0,1.0,-1.0,1.0,1.5,20.0);      /* left,right,bottom,top,near,far     */
}

void display(void){                           /* Prozedur zum Zeichnen              */
  glClear(GL_COLOR_BUFFER_BIT);               /* alle Pixel zurecksetzen            */
  glMatrixMode(GL_MODELVIEW);                 /* ab jetzt:  Modellierungsmatrix     */
  glColor3f(1.0, 0.0, 0.0);                   /* Farbe rot                          */
  glLoadIdentity();                           /* Einheitsmatrix                     */
  gluLookAt(0.0, 0.0, 5.0,                    /* Kamera-Standpunkt                  */
            0.0, 0.0, 0.0,                    /* Kamera-Fokussierpunkt              */
            0.0, 1.0, 0.0);                   /* Up-Vektor                          */
  glScalef(1.0, 1.5, 1.0);                    /* Skalierung in 3 Dimensionen        */
  glRotatef(30.0, 0.0, 1.0, 0.0);             /* rotiere 30 Grad um y-Achse         */
  glutWireCube(2.0);                          /* Drahtgitterwuerfel                 */
  glFlush();                                  /* direkt ausgeben                    */
}

void reshape(int w, int h) {
  GLfloat p = (GLfloat) w / (GLfloat) h;      /* Proportionalitaetsfaktor           */
  glViewport(0, 0, (GLsizei)w, (GLsizei)h);   /* setze Viewport                     */
  glMatrixMode(GL_PROJECTION);                /* betrifft Projektionsmatrix         */
  glLoadIdentity();                           /* lade Einheitsmatrix                */
  if (p > 1.0)                                /* falls breiter als hoch             */
       glFrustum(  -p,  p,-1.0,1.0,1.5,20.0); /* left,right,bottom,top,near,far     */
  else glFrustum(-1.0,1.0,-1/p,1/p,1.5,20.0); /* left,right,bottom,top,near,far     */
}


int main (int argc, char ** argv) {           /* Hauptprogramm                      */
  glutInit(&argc, argv);                      /* initialisiere GLUT                 */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);  /* single buffer, true color          */
  glutInitWindowSize(750, 500);               /* initiale Fenstergroesse            */
  glutInitWindowPosition(100,100);            /* initiale Fensterposition           */
  glutCreateWindow("wire-cube-prop");         /* Fenster mit Aufschrift             */
  init();                                     /* rufe init auf                      */
  glutDisplayFunc(display);                   /* registriere display                */
  glutReshapeFunc(reshape);                   /* registriere reshape                */
  glutMainLoop();                             /* beginne Event-Schleife             */
  return 0;                                   /* ISO C verlangt Rueckgabe           */
}

click.c: Interaktion durch Maus zur Farbwahl 
#include                          /* Header fuer OpenGl utility toolkit  */
#include                           /* Header fuer C-Library               */

GLfloat g=0.0;                               /* globale Variable                   */

void init(void) {                            /* Initialisierung                     */
  glClearColor(0.5, 0.5, 0.5, 0.0);          /* setze Grau als Hintergrundfarbe     */
  glMatrixMode(GL_PROJECTION);               /* betrifft Projektionsmatrix          */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);    /* Orthogonalprojektions-Clip-Ebenen   */
}                                            /* left, right, bottom, top, near, far */

void display(void){                          /* Prozedur zum Zeichnen               */
  glClear(GL_COLOR_BUFFER_BIT);              /* alle Pixel zurecksetzen             */
  glMatrixMode(GL_MODELVIEW);                /* betrifft Modelview-Matrix           */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glColor3f(1.0,g,0.0);                      /* Farbe gemaess RGB-Tripel            */ 
  glBegin(GL_TRIANGLES);                     /* Beginn eines Dreiecks               */
    glVertex3f(0.25, 0.25, 0.0);             /* links unten                         */
    glVertex3f(0.75, 0.25, 0.0);             /* rechts unten                        */
    glVertex3f(0.25, 0.75, 0.0);             /* links oben                          */
  glEnd();                                   /* Ende des Dreiecks                   */
  glFlush();                                 /* direkt ausgeben                     */
}

void mouse(int button,int state,int x,int y){/* Maus-Klick bei Koordinate x,y       */ 
  switch(button) {                           /* analysiere den Mausevent            */
    case GLUT_LEFT_BUTTON:                   /* falls linke Taste gedrueckt         */
      if (state==GLUT_DOWN) g=1.0;           /* setzte Gruenanteil auf 1            */
      break;
    case GLUT_RIGHT_BUTTON:                  /* falls rechte Taste gedrueckt        */
      if (state==GLUT_DOWN) g=0.0;           /* setzte Gruenanteil auf 0            */
      break;
  } glutPostRedisplay();                     /* durchlaufe display erneut           */
}

int main (int argc, char ** argv) {          /* Hauptprogramm                       */
  glutInit(&argc, argv);                     /* initialisiere GLUT                  */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); /* single buffer, true color           */
  glutInitWindowSize(350, 350);              /* initiale Fenstergroesse             */
  glutInitWindowPosition(100,100);           /* initiale Fensterposition            */
  glutCreateWindow("click");                 /* Fenster mit Aufschrift              */
  init();                                    /* rufe init auf                       */
  glutDisplayFunc(display);                  /* registriere display                 */
  glutMouseFunc(mouse);                      /* registriere mouse                   */
  glutMainLoop();                            /* beginne Event-Schleife              */
  return 0;                                  /* ISO C verlangt Rueckgabe            */
}

key.c: Interaktion durch Tastatur zur Farbwahl 
#include                          /* Header fuer OpenGl utility toolkit  */
#include                           /* Header fuer C-Library               */

GLfloat r=1.0, g=0.0, b=0.0;                 /* globales RGB-Tripel                 */

void init(void) {                            /* Initialisierung                     */
  glClearColor(0.5, 0.5, 0.5, 0.0);          /* setze Grau als Hintergrundfarbe     */
  glMatrixMode(GL_PROJECTION);               /* betrifft Projektionsmatrix          */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);    /* Orthogonalprojektions-Clip-Ebenen   */
}                                            /* left, right, bottom, top, near, far */

void display(void){                          /* Prozedur zum Zeichnen               */
  glClear(GL_COLOR_BUFFER_BIT);              /* alle Pixel zurecksetzen             */
  glMatrixMode(GL_MODELVIEW);                /* betrifft Modelview-Matrix           */
  glLoadIdentity();                          /* beginne mit Einheitsmatrix          */
  glColor3f(r,g,b);                          /* Farbe gemaess RGB-Tripel            */ 
  glBegin(GL_TRIANGLES);                     /* Beginn eines Dreiecks               */
    glVertex3f(0.25, 0.25, 0.0);             /* links unten                         */
    glVertex3f(0.75, 0.25, 0.0);             /* rechts unten                        */
    glVertex3f(0.25, 0.75, 0.0);             /* links oben                          */
  glEnd();                                   /* Ende des Dreiecks                   */
  glFlush();                                 /* direkt ausgeben                     */
}

void key(unsigned char key, int x, int y){   /* Bei Tastendruck                     */ 
  switch(key) {                              /* analysiere den Tastendruck          */
    case 'r': r=1.0; g=0.0; b=0.0; break;    /* falls 'r': setze Tripel auf Rot     */
    case 'g': r=0.0; g=1.0; b=0.0; break;    /* falls 'g': setze Tripel auf Gruen   */
    case 'b': r=0.0; g=0.0; b=1.0; break;    /* falls 'b': setze Tripel auf Blau    */
  }
  glutPostRedisplay();
}

int main (int argc, char ** argv) {          /* Hauptprogramm                       */
  glutInit(&argc, argv);                     /* initialisiere GLUT                  */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); /* single buffer, true color           */
  glutInitWindowSize(350, 350);              /* initiale Fenstergroesse             */
  glutInitWindowPosition(100,100);           /* initiale Fensterposition            */
  glutCreateWindow("key");                   /* Fenster mit Aufschrift              */
  init();                                    /* rufe init auf                       */
  glutDisplayFunc(display);                  /* registriere display                 */
  glutKeyboardFunc(key);                     /* registriere key                     */
  glutMainLoop();                            /* beginne Event-Schleife              */
  return 0;                                  /* ISO C verlangt Rueckgabe            */
}

planet.c: Interaktion durch Tastatur zur Rotationsbewegung 
#include                                  /* OpenGl Utility Toolkit      */
#include                                   /* C-library                   */

int year = 0, day = 0;                               /* Variablen fuer Drehungen    */

void init(void) {
   glClearColor (0.0, 0.0, 1.0, 0.0);                /* blauer Hintergrund          */
   glShadeModel (GL_FLAT);                           /* Flatshading                 */
   glMatrixMode (GL_PROJECTION); glLoadIdentity ();  /* ab jetzt Projektion         */
   gluPerspective(60.0, 1.5, 1.0, 20.0);             /* Blickwinkel, w/h, near, far */
   glMatrixMode(GL_MODELVIEW); glLoadIdentity();     /* ab jetzt Modelview          */
   gluLookAt (0.0,0.0,5.0,0.0,0.0,0.0,0.0,1.0,0.0);  /* Kamera, Fokussier, Up-Vektor*/
}

void display(void){
   glClear (GL_COLOR_BUFFER_BIT);                       /* reset Pixels             */
   glColor3f (1.0, 1.0, 1.0);                           /* Farbe weiss              */
   glPushMatrix();                                      /* sichere Matrix           */
   glRotatef(30.0, 0.0, 1.0, 0.0);                      /* drehe 30 Grad um y       */
   glRotatef(30.0, 1.0, 0.0, 0.0);                      /* drehe 30 Grad um x       */
   glutWireSphere(1.0, 20, 16);                         /* zeichne die Sonne        */
   glRotatef ((GLfloat) year, 0.0, 1.0, 0.0);           /* Drehung um Sonne         */
   glTranslatef (2.0, 0.0, 0.0);                        /* Verschiebung von Sonne   */
   glRotatef ((GLfloat) day, 0.0, 1.0, 0.0);            /* Erd-Drehung              */
   glutWireSphere(0.2, 10, 8);                          /* zeichne die Erde         */
   glPopMatrix();                                       /* restauriere Matrix       */
   glutSwapBuffers();                                   /* tausche Puffer           */
}

void keyboard (unsigned char key, int x, int y){
   switch (key) {                                       /* abhaengig von der Taste  */
     case 'd': day =(day+10) % 360; break;              /* erhoehe Tag um 10        */
     case 'y': year=(year+5) % 360; break;}             /* erhoehe Jahr um 5        */
   glutPostRedisplay();                                 /* rufe display auf         */
}

int main (int argc, char ** argv) {          /* Hauptprogramm                       */
  glutInit(&argc, argv);                     /* initialisiere GLUT                  */
  glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB); /* double buffer, true color           */
  glutInitWindowSize(750, 500);              /* initiale Fenstergroesse             */
  glutInitWindowPosition(100,100);           /* initiale Fensterposition            */
  glutCreateWindow("planet");                /* Fenster mit Aufschrift              */
  init();                                    /* rufe init auf                       */
  glutDisplayFunc(display);                  /* registriere display                 */
  glutKeyboardFunc(keyboard);                /* registriere keyboard                */
  glutMainLoop();                            /* beginne Event-Schleife              */
  return 0;                                  /* ISO C verlangt Rueckgabe            */
}

smooth.c: Dreieck mit Farbverlauf durch Interpolation 
#include                           /* Header fuer OpenGl utility toolkit */
#include                            /* header fuer C-library              */

void init(void) {
   glClearColor (0.0, 0.0, 0.0, 0.0);         /* Hintergrundfarbe schwarz           */
   glShadeModel (GL_SMOOTH);                  /* smooth shading                     */
}

void display(void) {
   glClear (GL_COLOR_BUFFER_BIT);             /* reset Farbpuffer                   */
   glBegin (GL_TRIANGLES);                    /* Beginn der Dreiecks-Knoten         */
   glColor3f  ( 1.0,  0.0, 0.0);              /* Farbe rot                          */ 
   glVertex2f (25.0,  5.0);                   /* Knoten unten rechts                */
   glColor3f  ( 0.0,  1.0, 0.0);              /* Farbe gruen                        */ 
   glVertex2f ( 5.0, 25.0);                   /* Knoten links oben                  */ 
   glColor3f  ( 0.0,  0.0, 1.0);              /* Farbe blau                         */ 
   glVertex2f ( 5.0,  5.0);                   /* Knoten unten links                 */
   glEnd();                                   /* Ende der Dreiecks-Knoten           */
   glFlush ();                                /* direkt ausgeben                    */
}

void reshape (int w, int h) {
   GLfloat p = (GLfloat) w / (GLfloat) h;     /* berechne Fensterverhaeltnis        */
   glViewport (0,0,(GLsizei)w,(GLsizei)h);    /* lege Viewport fest                 */
   glMatrixMode (GL_PROJECTION);              /* ab jetzt Projektionsmatrix         */
   glLoadIdentity ();                         /* lade Einheitsmatrix                */
   if (p > 1.0)                               /* falls breiter als hoch             */
        gluOrtho2D (0.0,p*30.0,0.0,30.0  );   /* left,right,bottom,top              */
   else gluOrtho2D (0.0,  30.0,0.0,30.0/p);   /* left,right,bottom,top              */
   glMatrixMode(GL_MODELVIEW);
}

int main (int argc, char ** argv) {           /* Hauptprogramm                      */
  glutInit(&argc, argv);                      /* initialisiere GLUT                 */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);  /* single buffer, true color          */
  glutInitWindowSize(750, 500);               /* initiale Fenstergroesse            */
  glutInitWindowPosition(100,100);            /* initiale Fensterposition           */
  glutCreateWindow("smooth");                 /* Fenster mit Aufschrift             */
  init();                                     /* rufe init auf                      */
  glutDisplayFunc(display);                   /* registriere display                */
  glutReshapeFunc(reshape);                   /* registriere reshape                */
  glutMainLoop();                             /* beginne Event-Schleife             */
  return 0;                                   /* ISO C verlangt Rueckgabe           */
}

list.c : Dreiecke definiert durch Display-Liste 
#include                                   /* fuer OpenGl utility toolkit*/
#include                                    /* fuer C-Library             */

GLuint listName;                                      /* Handle fuer Display-Liste  */

void init (void) {
   listName = glGenLists (1);                         /* trage Namen ein            */
   glNewList (listName, GL_COMPILE);                  /* erzeuge Display-Liste      */
      glColor3f (1.0, 0.0, 0.0);                      /* Farbe rot                  */
      glBegin (GL_TRIANGLES);                         /* Beginn Dreiecks-Punkte     */
      glVertex2f (0.0, 0.0);                          /* Knoten links unten         */
      glVertex2f (1.0, 0.0);                          /* Knoten rechts unten        */
      glVertex2f (0.0, 1.0);                          /* Knoten links oben          */
      glEnd ();                                       /* Ende der Dreiecksliste     */
      glTranslatef (1.5, 0.0, 0.0);                   /* Verschiebe nach rechts     */
   glEndList ();                                      /* Ende der Display-Liste     */
   glShadeModel (GL_FLAT);                            /* verwende Flat-Shading      */
}

void display(void) {                                  /* Anzeige-Routine            */
   GLuint i;                                          /* Integer-Variable           */
   glClear (GL_COLOR_BUFFER_BIT);                     /* reset Farb-Puffer          */
   for (i=0; i<10; i++) glCallList(listName);         /* rufe Display-Liste auf     */
   glBegin (GL_LINES);                                /* Beginn Linien-Punkte       */
   glVertex2f (0.0,0.5); glVertex2f(15.0,0.5);        /* zwei Knoten                */
   glEnd ();                                          /* Ende Linen-Punkte          */
   glFlush ();                                        /* direkt ausgeben            */
}

void reshape(int w, int h) {                          /* Reshape-Routine            */
   GLfloat p = (GLfloat) w / (GLfloat) h;             /* Fensterverhaeltnis         */
   glViewport(0, 0, w, h);                            /* setze Viewport             */
   glMatrixMode(GL_PROJECTION); glLoadIdentity();     /* ab jetzt Projektion        */
   if (p > 1 ) gluOrtho2D (0.0, 2.0*p, -0.5, 1.5);    /* links, rechts, unten, oben */
         else  gluOrtho2D (0.0, 2.0, -0.5/p, 1.5/p);  /* links, rechts, unten, oben */ 
   glMatrixMode(GL_MODELVIEW); glLoadIdentity();      /* ab jetzt Modelview         */
}

int main (int argc, char ** argv) {                   /* Hauptprogramm              */
  glutInit(&argc, argv);                              /* initialisiere GLUT         */
  glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);          /* single buffer, true color  */
  glutInitWindowSize(800, 100);                       /* initiale Fenstergroesse    */
  glutCreateWindow("list");                           /* Fenster mit Aufschrift     */
  init();                                             /* rufe init auf              */
  glutDisplayFunc(display);                           /* registriere display        */
  glutReshapeFunc(reshape);                           /* registriere reshape        */
  glutMainLoop();                                     /* beginne Event-Schleife     */
  return 0;                                           /* ISO C verlangt Rueckgabe   */
}

bezier-curve.c: zweidimensionale Bezier-Kurve 
#include 
#include 

GLfloat ctrlpoints[4][3] = {
        {-4.0, -4.0, 0.0}, {-2.0, 4.0, 0.0}, 
        { 2.0, -4.0, 0.0}, { 4.0, 4.0, 0.0}};

void init(void)
{
   glClearColor(0.0, 0.0, 0.0, 0.0);
   glShadeModel(GL_FLAT);
   glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlpoints[0][0]);
   glEnable(GL_MAP1_VERTEX_3);
   glMatrixMode(GL_PROJECTION); glLoadIdentity();
   glOrtho(-7.5, 7.5, -5.0, 5.0, -5.0, 5.0);
   glMatrixMode(GL_MODELVIEW); glLoadIdentity();
}

void display(void)
{
   int i;
   glClear(GL_COLOR_BUFFER_BIT);
   glColor3f(1.0, 1.0, 1.0);
   glBegin(GL_LINE_STRIP);
      for (i=0; i<=30; i++) glEvalCoord1f((GLfloat) i/30.0);  
   glEnd();
   glPointSize(5.0);
   glColor3f(1.0, 1.0, 0.0);
   glBegin(GL_POINTS);
      for (i=0; i<4; i++) glVertex3fv(&ctrlpoints[i][0]);
   glEnd();
   glFlush();
}

int main(int argc, char** argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (750, 500);
   glutInitWindowPosition (100, 100);
   glutCreateWindow ("bezier-curve");
   init ();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0;
}

bezier-surface.c : dreidimensionale Bezierkurve 
#include 
#include 

GLfloat ctrlpoints[4][4][3] = {
   {{-1.5, -1.5,  4.0}, {-0.5, -1.5,  2.0}, {0.5, -1.5, -1.0}, {1.5, -1.5,  2.0}}, 
   {{-1.5, -0.5,  1.0}, {-0.5, -0.5,  3.0}, {0.5, -0.5,  0.0}, {1.5, -0.5, -1.0}}, 
   {{-1.5,  0.5,  4.0}, {-0.5,  0.5,  0.0}, {0.5,  0.5,  3.0}, {1.5,  0.5,  4.0}}, 
   {{-1.5,  1.5, -2.0}, {-0.5,  1.5, -2.0}, {0.5,  1.5,  0.0}, {1.5,  1.5, -1.0}}
};

void display(void) {
   int i, j;
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glColor3f(1.0, 1.0, 1.0);
   glPushMatrix ();
   glRotatef(85.0, 1.0, 1.0, 1.0);
   for (j = 0; j <= 8; j++) {
      glBegin(GL_LINE_STRIP);
      for (i = 0; i <= 30; i++) glEvalCoord2f((GLfloat)i/30.0, (GLfloat)j/8.0);
      glEnd();
      glBegin(GL_LINE_STRIP);
      for (i = 0; i <= 30; i++) glEvalCoord2f((GLfloat)j/8.0, (GLfloat)i/30.0);
      glEnd();
   }
   glPopMatrix ();
   glFlush();
}

void init(void) {
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &ctrlpoints[0][0][0]);
   glEnable(GL_MAP2_VERTEX_3);
   glMapGrid2f(20, 0.0, 1.0, 20, 0.0, 1.0);
   glEnable(GL_DEPTH_TEST);
   glShadeModel(GL_FLAT);
   glMatrixMode(GL_PROJECTION); glLoadIdentity();
   glOrtho(-6.0, 6.0, -4.0, 4.0, -4.0, 4.0);
   glMatrixMode(GL_MODELVIEW); glLoadIdentity();
}

int main(int argc, char** argv) {
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
   glutInitWindowSize (750, 500); glutInitWindowPosition (100, 100);
   glutCreateWindow ("bezier-surface"); init ();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0;
}

teapot.c: Teekanne mit Beleuchtung 
#include                           
#include                       

void init(void) {
   GLfloat mat_diffuse[]      = { 1.0, 0.3, 0.3, 1.0 };
   GLfloat mat_specular[]     = { 1.0, 1.0, 1.0, 1.0 };  
   GLfloat mat_shininess[]    = { 50.0 }; 
   GLfloat light_position[]   = { 1.0, 1.0, 1.0, 0.0 };
   glClearColor (0.0, 0.0, 0.0, 0.0);
   glShadeModel (GL_SMOOTH);
   glMaterialfv (GL_FRONT,  GL_DIFFUSE,   mat_diffuse);
   glMaterialfv (GL_FRONT,  GL_SPECULAR,  mat_specular);
   glMaterialfv (GL_FRONT,  GL_SHININESS, mat_shininess); 
   glLightfv    (GL_LIGHT0, GL_POSITION,  light_position);
   glEnable(GL_LIGHTING);
   glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);
}

void display(void) {
   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
   glPushMatrix();
   glRotatef(-40.0, 0.0, 1.0, 0.0);
   glRotatef( 20.0, 1.0, 0.0, 0.0); 
   glutSolidTeapot(1.0);
   glPopMatrix(); glFlush ();
}

void reshape (int w, int h){
   GLfloat p = (GLfloat) w / (GLfloat) h;
   glViewport (0, 0, (GLsizei) w, (GLsizei) h);
   glMatrixMode (GL_PROJECTION); glLoadIdentity();
   if (p > 1.0) glOrtho(-1.5*p,1.5*p,-1.5,1.5,-10.0,10.0);
           else glOrtho(-1.5,1.5,-1.5/p,1.5/p,-10.0,10.0);
   glMatrixMode(GL_MODELVIEW); 
   glLoadIdentity();
}

int main(int argc, char** argv) {
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
   glutInitWindowSize (750, 500); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow ("teapot");
   init ();
   glutDisplayFunc(display); 
   glutReshapeFunc(reshape);
   glutMainLoop(); return 0;
}

teapot-rotate.c: rotierende Teekanne 
#include                                      /* OpenGl Utiltiy Toolkit  */
#include                                       /* C-library               */ 

int g;                                                   /* Variable fuer Gradzahl  */

void init(void) {
   GLfloat mat_diffuse[]      = { 1.0, 0.3, 0.3, 1.0 };  /* diffuse Farbe           */
   GLfloat mat_specular[]     = { 1.0, 1.0, 1.0, 1.0 };  /* spekulare Farbe         */
   GLfloat mat_shininess[]    = { 50.0 };                /* Reflexionskoeffizient   */
   GLfloat light_position[]   = { 1.0, 1.0, 1.0, 0.0 };  /* Lichtquellenposition    */
   glClearColor (0.0, 0.0, 0.0, 0.0);                    /* Hintergrundfarbe        */
   glShadeModel (GL_SMOOTH);                             /* smooth shading          */
   glMaterialfv(GL_FRONT, GL_DIFFUSE,  mat_diffuse);     /* diffuse Farbzuweisung   */
   glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);    /* spekulare Farbzuweisung */
   glMaterialfv(GL_FRONT, GL_SHININESS,mat_shininess);   /* Reflexionszuweisung     */
   glLightfv   (GL_LIGHT0,GL_POSITION, light_position);  /* Lichtpositionszuweisung */
   glEnable(GL_LIGHTING); glEnable(GL_LIGHT0);           /* Beleuchtung aktivieren  */
   glEnable(GL_DEPTH_TEST);                              /* Tiefentest aktiveren    */
   glMatrixMode (GL_PROJECTION); glLoadIdentity();       /* ab jetzt Projektion     */ 
   glOrtho(-1.95,1.95,-1.5,1.5,-10.0,10.0);              /* links,rechts,unten,oben */
   glMatrixMode(GL_MODELVIEW); glLoadIdentity();         /* ab jetzt Modelview      */ 
}

void display(void) {
   glClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);    /* reset Buffer            */
   glPushMatrix();                                       /* rette Matrix            */ 
   glRotatef((GLfloat) g, 0.0, 1.0, 0.0);                /* g grad Grad um y-Achse  */
   glRotatef( 20.0, 1.0, 0.0, 0.0);                      /* 20 Grad um x-Achse      */
   glutSolidTeapot(1);                                   /* zeichne Teapot          */ 
   glPopMatrix();                                        /* restauriere Matrix      */
   glutSwapBuffers();                                    /* wechsele Puffer         */
}

void spinDisplay(void) {
  g = (g + 5) % 360;                                     /* Gradzahl um 5 erhoehen  */
  glutPostRedisplay();                                   /* display erneut aufrufen */
}

int main(int argc, char** argv) {
   glutInit(&argc, argv);                                /* initialisiere GLUT      */
   glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH); /* Double buffer, ...      */
   glutInitWindowSize (750, 500);                        /* initiale Fenstergroesse */
   glutInitWindowPosition (100, 100);                    /* initiale Fensterposition*/
   glutCreateWindow ("teapot-rotate");                   /* Fenster mit Aufschrift  */
   init ();                                              /* Initialisierung         */
   glutDisplayFunc(display);                             /* registriere display     */
   glutIdleFunc(spinDisplay);                            /* registriere spinDisplay */
   glutMainLoop(); return(0);                            /* starte Hauptschleife    */
}

prev up inhalt next