====== Erste Schritte ======

Bevor Sie überhaupt etwas, auf den Bildschirm mit OpenGL bringen können, müssen Sie einige Schritte ausgeführt haben. Um die soll es hier gehen.

**Includes**
<code cpp>
#ifdef _WIN32
#include <windows.h>
#endif
 
#ifdef __APPLE__ 
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#include <GL/gl.h>
#endif
</code>

Wichtig ist, dass Mac OSX die glut.h im Allgemeinen woanders installiert als Linux und Windows. Windows will außerdem noch die eigene Windows.h Systembibliothek haben.

**Main-Funktion**

<code cpp>
int main(int argc, char* argv[])
{
  glutInit( &argc, (char **) argv );
  glutInitDisplayMode( GLUT_SINGLE | GLUT_RGBA );
  glutInitWindowSize( 250, 250 );
  glutInitWindowPosition( 100, 100 );
  glutCreateWindow( "hello" );
 
  init();
 
  glutDisplayFunc( display );
  glutMainLoop();
 
  return 0;
}
</code>

Gehen wir nun also den Code einmal durch. Zu Beginn wird mit //glutInit()// die GLUT initialisiert. Vorher ist es Ihnen nicht möglich Funktionen der GLUT zu verwenden. //glutInitDisplayMode()// setzt den Modus der zu zeichnenden Szene. //GLUT_SINGLE// beschreibt, dass lediglich ein einfach gepuffertes Bild erzeugt wird und //GLUT_RGBA// gibt an, dass die Farben jeweils Rot, Grün, Blau und einen Alphawert haben. //glutInitWindowSize()// setzt die Größe des Fenster; //glutInitWindowPosition()// die Position des Fensters auf dem Bildschirm. //glutCreateWindow()// erzeugt schließlich das oben beschriebene Fenster mit dem Titeltext "hello". 

**Init-Funktion**
<code cpp>
void init(void )
{
  /* legt die Farbe nach dem Löschen fest */
  glClearColor( 0.0, 0.0, 0.0, 0.0 );
 
  /* initialisieren des Viewports */
  glMatrixMode( GL_PROJECTION );
  glLoadIdentity();
  glOrtho( 0.0, 1.0, 0.0, 1.0, -1.0, 1.0 );
}
</code>

//glClearColor()// legt die Farbe fest, die das Bild nach dem Löschen mit //glClear()// haben soll. //glMatrixMode()// setzt den Matrix-Modus auf Projektion, //glLoadIdentity()// leert den Matrixstack und //glOrtho()// tut Dinge. FIXME

<code cpp>
glutDisplayFunc( display );
glutMainLoop();
</code>

Die Callback-Funktion //glutDisplayFunc()// legt die Funktion fest, welche das Bild aufbaut und zeichnet. Sie wird immer wieder aufgerufen - sodass das Bild immer wieder aktualisiert wird. //glutMainLoop()// versetzt das Programm in eine Endlosschleife, in der es das Bild immer wieder neu zeichnet und aktualisiert.

**Display-Funktion**

<code cpp>
void display( void )
{
  // lösche alle Pixel
  glClear( GL_COLOR_BUFFER_BIT );
 
  /* Zeichne ein weißes Polygon (in dem Fall Rechteck) mit Ecken auf
   * (0.25, 0.25, 0) und (0.75, 0.75, 0.0)
   */
 
   glColor3f( 1.0, 1.0, 1.0 );
   glBegin( GL_POLYGON );
     glVertex3f( 0.25, 0.25, 0.0 );
     glVertex3f( 0.75, 0.25, 0.0 );
     glVertex3f( 0.75, 0.75, 0.0 );
     glVertex3f( 0.25, 0.75, 0.0 );
   glEnd();
 
   // beginne die gepufferten OpenGL Routinen auszuführen
   glFlush();
}
</code>

//glClear()// löscht das aktuell auf dem Fenster aufgebrachte Bild und füllt es mit der Standardfarbe (siehe oben). //glColor3f// und //glVertex3f// werden später genauer behandelt. Sie kümmern sich prinzipiell darum, dass das Viereck auf dem Bildschirm gezeichnet wird. //glFlush()// führt dazu, dass alle von OpenGL irgendwo gepufferten Aufgaben so schnell wie möglich ausgeführt werden. Auch wenn das nicht innerhalb der festgelegten Zeitspanne geschehen kann, werden die Puffer gelöscht.