/*
    points2.c

    - Zeichnet "zufällig" verteilte Punkte.
    - Zur Beschreibung siehe Kommentare in display_func().
    - Leertaste zeichnet neuen Bild.
    - Programmabbruch mit q-Taste - siehe keyboard_func().


    > gluOrtho2D(...) setzt den Koordinatenbereich nicht
      auf einen festen Wert, sondern skaliert den aktuellen
      Bereich um. Am besten setzt man vorher den Standardbereich
      mit glLoadIdentity(), dann ist der mit gluOrtho2D(...)
      erzeugte Bereich gerade der in den Parametern angebene,
      hier also [0, 1] - [0, 1].
      Was passiert, wenn gluOrtho2D(...) ausgelassen wird?
      Schlimmer: was passiert, wenn glLoadIdentity() ausgelassen wird?
      (Bitte mit Drücken der Leertaste mehrere Bilder ansehen.)

    > Wie kann man die Parameter für gluOrtho2D(...) wählen,
      so dass um den Bereich mit den Punkten ein gewisser Rand frei bleibt?

    > In der keyboard_func() wird glutPostRedisplay() aufgerufen,
      damit Glut die display_func() neu aufruft. Zum Testen:
      glutPostRedisplay() bitte mal auskommmentieren: die Leertaste
      bleibt wirkungslos.
      (Rhetorische Frage:) Warum wird glutPostRedisplay() benutzt
      und nicht einfach die display_func() "zu Fuß" aufgerufen?
      Antwort: weil Glut es so will - bitte keine Diskussion ;-)
      Merke: NIE NIE NIE die display_func() selber aufrufen,
      stets den Aufruf mit glutPostRedisplay() "veranlassen"!

    > Spielen mit Zufallszahlen: Was ändert sich im Bild,
      wenn man die Erzeugung der Zufallszahlen verändert, z.B.
      y = drand48 () * drand48 ();
      Mathematisch gesprochen, werden dadurch Zufallszahlen mit
      einer anderen "Verteilung" erzeugt.
      Ideen für weitere Varianten?

    > Spielen mit Zufallszahlen, 2. Teil. Steuerung der Farben
      und Punktgrößen per Zufall. Wie bekommt man ein zufälliges Blau?
      Wie einen zufälligen Grauwert?
      Aufbau eines Bildes in mehreren Schichten, jede Schicht
      mit eigenen Farben, Größen, Punkt-Anzahlen und Zufalls-Verteilungen.
      Die Summe der Schichten verdeckt den Hintergrund fast vollständig.
      Abstrakter Pointillismus...
*/



# include       <stdio.h>
# include       <stdlib.h>
# include       <math.h>
# include       <GL/gl.h>
# include       <GL/glut.h>



static void     display_func (void)
/*********************************/
{
    int         i,
                n = 2000;
    float       x, y;


    /* printf ("display_func()\n"); */

    /* Koordinatenbereich auf Standardbereich setzen: */
    glLoadIdentity ();

    /* Koordinaten so skalieren, dass der Bereich [0,1] x [0,1] wird: */
    gluOrtho2D (0, 1, 0, 1);

    glClearColor (1, 1, 1, 0);
    glClear (GL_COLOR_BUFFER_BIT);

    glColor3f (0, 0, 0);
    glPointSize (4);

    glBegin (GL_POINTS);
    for (i = 0; i < n; i ++)
    {
        /* drand48() liefert eine (Pseudo-)Zufallszahl */
        /* aus dem Interval [0, 1): */
        x = drand48 ();
        y = drand48 ();
        glVertex2f (x, y);
    }
    glEnd ();

    glFlush ();
    glutReportErrors ();
}



static void     keyboard_func (unsigned char key, int x, int y)
/*************************************************************/
{
    switch (key)
    {
        case ' ':   /* Leerzeichen, also Leertaste */
            /* veranlasst erneuten Aufruf von display_func(): */
            glutPostRedisplay ();
            break;

        case 'q':
        case 'Q':
            exit (0);
    }
}



extern int      main (int argc, char **argv)
/******************************************/
{
    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_RGB);

    glutInitWindowPosition (200, 100);
    glutInitWindowSize (600, 600);
    glutCreateWindow ("points2");

    glutDisplayFunc (display_func);
    glutKeyboardFunc (keyboard_func);

    glutMainLoop ();

    return 0;
}