Opengl.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include <fstream>
#include <sstream>
#include <GL/glut.h>
#include "glui/glui.h"

#include "timer.h"
#include "Opengl.h"
#include "PhysikEngine.h"
#include "ObjectManager.h"
#include "Configuration.h"
#include "Window.h"
#include "Camera.h"

Opengl ourOpengl;

//Iniatisierung der statischen Klassenvariablen:
int Opengl::freeLight=0;

int Opengl::getNextLight() {
    if(freeLight == 8)
        freeLight = 0;
    freeLight++;

    // Die Opengl lichter sind im Header durchnummeriert
    return GL_LIGHT0+freeLight-1;
}

void Opengl::reloadWindow() {
    HandleReshape(0,0);
}

void Opengl::redraw() {
    glutSetWindow(Window::getMainWindow());
    glutPostRedisplay();
}

void Opengl::CreateEnvironment() {

    // Aktiviere Anti Aliasing fuer Linien
    glEnable(GL_LINE_SMOOTH);

    // Aktiviere Anti Aliasing fuer Polygone
    glEnable(GL_POLYGON_SMOOTH);

    //  Aktiviere Smooth-Shading (ist aber sowieso default)
    glShadeModel(GL_SMOOTH);

    /*
    * Aktiviere Dithering, 
    * Farben, die nicht vom Ausgabegeraetnicht unterstuetzt werden, werden 
    * durch unterschiedlich Farben direkt benachbarter Pixel angenaehert. 
    */
    glEnable(GL_DITHER);


    /*
    * Die Breite einer Linie auf 1 Pixel setzen. Nicht-ganzzahlige
     * Werte sind nur dann interessant, wenn Anti-Aliasing fuer Linien
     * aktiviert ist.
    */
    glLineWidth(1.0);

    // Den gerasterten Durchmesser eines Punktes auf 1 Pixel setzen.
    glPointSize(1.0);

    // Die Vorder- und Rueckseite aller Polygone gefuellt zeichnen:
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

    /*
    * CCW steht fuer clock-counter-wise und definiert die gegen den
     * Uhrzeigersinn gezeichneten Polygone (aus Bildschirm-Sicht) als
     * Vorderseiten; alle anderen werden als Rueckseiten angesehen. 
    * Dies ist wichtig fuer das Backface-Culling, dabei
     * sollen die dem Betrachter abgewandten
     * Polygone ausgeblendet werden.
     * "GL_CW" kehrt die Definition von Vorder und Rueckseiten fuer 
    * Polygone um.
    */
    glFrontFace(GL_CCW);

    // Hintergrundfarbe festlegen auf Schwarz
    glClearColor(0.0, 0.0, 0.0, 0.0);

    //  ermoegliche ein Faerben von Flaechen
    glEnable(GL_COLOR_MATERIAL);
}

void Opengl::RenderObjects() {
    // Einheitsmatrix laden
    glLoadIdentity();

    //Kamera Perspektive laden:
    ourCamera.loadCameraMatrix();

    //Licht einstellungen vornehmen:
    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat mat_shininess[] = { 50.0 };

    //Materialeigenschaften festlegen:
    // enth�t vier ganzzahlige oder Flie�ommawerte welche den RGBA
    //Glanzlichtanteil repr�entieren, der vom Material reflektiert wird.
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);

    // enth�t eine einzelne Ganz- oder Flie�ommazahl welche den
    // Glanzlichtexponent repr�entieren. (Specular Exponent)
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

    /*
    * Aktiviere Backface-Culling
    * Beim Backface-Culling werden verdeckte
    * Flaechen bzw. Linien nicht berechnet, da sie ja sowieso nicht
    * dargestellt werden muessen. OpenGL sieht eine verdeckte Flaeche
    * genau dann als verdeckt an, wenn das Skalarprodukt aus ihrem
    * Normalenvektor und der Blickrichtung der Kamera ein positives Ergebnis
    * liefert.
    */
    glEnable(GL_CULL_FACE);

    //Licht fuer den Naechsten Render Schritt Deaktivieren, die
    // Objekte die Lichtquellen sind schalten dies wieder an.
    for(int i=0; i < 8; i++)
        glDisable(getNextLight());

    //erstes zu vergebendes Licht festlegen:
    freeLight = 0;

    //Objekte Zeichnen:
    ourObjectManager.drawObjects();
}

void Opengl::RenderUniverse() {
    //Um die fps berechnen zu koennen werden Statisch Werte gespeichert.
    static timeval startTime_;
    timeval startRenderingTime_;
    static double frameTime_=1;
    static int framesCount=1;

    //jede Sekunde werden die fps aktualisiert:
    if( timediffNow(startTime_) > 1) {
        frameTime_=timediffNow(startTime_)/framesCount;
        gettimeofday(&startTime_,0);
        framesCount=1;
    } else
        framesCount++;
    gettimeofday(&startRenderingTime_,0);


    // Z-Buffer, Tiefenpuffer aktivieren
    glEnable(GL_DEPTH_TEST);

    /*
    * Verwende Double-Buffering. Der "Back-Buffer" wird mit Daten gefuellt,
     * nachdem alle Objekte gezeichnet wurden wird der Back-Buffer zum 
    * Front-Buffer gemacht, dies verhindert Flacker-Effekte. 
    */
    glDrawBuffer(GL_BACK);

    // Den Farb- und den Z-Puffer leeren. Sonst koennten alte Zeichendaten er
    // noch vorhanden sein
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //Art wie Gerenderte Objekte dargestellt werden sollen wird gewaehlt:
    if (ourConfiguration.viewModel == 0) {
        //Punkt Ansicht
        glPolygonMode(GL_FRONT_AND_BACK, GL_POINT);
    } else if (ourConfiguration.viewModel == 1) {
        //Drahtmodell-Ansicht
        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
    } else {
        // viewModel == 2 Solide Objekte Anzeigen
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    }


    // Den Projection-Matrix-Stack als Ziel weiterer Matrix Operationen
    // festlegen.
    glMatrixMode(GL_PROJECTION);

    // Einheitsmatrix auf den Stack laden
    glLoadIdentity();

    //Kamera einstellungen der Perspektive laden und mit der aktuellen
    //opengl Matrix multiplizieren
    ourCamera.loadCameraPerspective();

    // Die Modelview Matrix als Ziel weiterer Matrix-Operationen waehlen
    glMatrixMode(GL_MODELVIEW);

    //Festlegen ob Licht Effekte angezeigt werden sollen oder nicht
    if(! ourConfiguration.showLighting) {
        //Licht effekte nicht anzeigen:
        glDisable(GL_LIGHTING);
        glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
    } else {
        //Damit die Texturen mit Lichteffekten Gerendert werden:
        glEnable(GL_LIGHTING);
        glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
    }

    //Farbe der Objekte nicht bercksichtigen wenn texture daruebergelegt wird:
    // glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);

    //Alle Objekte mit den aktuellen Opengl Einstellungen rendern:
    RenderObjects();

    //Licht deaktivieren
    glDisable(GL_LIGHTING);

    /* Den Back-Buffer zum Front-Buffer machen und so die Darstellung der
     * Szene aendern. Das naechste Bild wird aus dem aktualisierten
     * Puffer gezeichnet. Befehle, die direkt nach glutSwapBuffers() stehen,
     * werden erst bei naechstem Swapen ausgefuehrt.
    */
    glutSwapBuffers();


    //Rendering Details text festlegen und setzen:
    stringstream fps_;
    fps_.precision(3);
    fps_ << "fps: " << 1/frameTime_ << " Rt: " <<
    timediffNow(startRenderingTime_);
    Window::setRenderDetails(fps_.str());
}


void Opengl::HandleReshape(int w, int h) {
    // Den Farb- und den Tiefenpuffer leeren.
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Noch nicht von GLUI ueberdeckte Breite und Hoehe ermitteln:
    int tx,ty,tw,th;
    GLUI_Master.get_viewport_area(&tx,&ty,&tw,&th);

    //Falls das Menu nicht angezeigt wird muessen die Werte angepasst
    //werden da GLUI das nicht selbst vornimmt
    if(! ourConfiguration.showMenu ) {
        tw +=tx;
        th +=ty;
        tx=0;
        ty=0;
    }

    //Die Breite und Hoehe des 3D Fenster festlegen:
    glViewport(tx, ty, tw, th);

    // Die Parameter der Kamera ebenfalls anpassen.
    ourCamera.setScreen(tw,th);
}

void Opengl::setAnimation(bool enable) {
    if(ourConfiguration.freezeAnimation && enable &&
            ourObjectManager.getObjectCount()!=0 &&
            ourConfiguration.constructMode == false) {
        //Animation starten falls moeglich und noch nicht gestartet
        Window::setAnimationControls(true);
        ourConfiguration.freezeAnimation = false;
        //Glut Timer fuehrt Callbackfunktion nach ablauf von
        // TIMERUPDATE msec aus
        glutTimerFunc(TIMERUPDATE,& Opengl::HandleTimer,0);
    } else if (! enable || ourObjectManager.getObjectCount()==0
               || ourConfiguration.constructMode) {
        //Animation stopen, glutTimer anhalten
        ourConfiguration.freezeAnimation = true;
        glutTimerFunc(0,& Opengl::HandleTimer,0);
        Window::setAnimationControls(false);
    }
}

void Opengl::singleStep() {
    //Falls es keine Objekte gibt muss nichts gemacht werden
    if( ourObjectManager.getObjectCount()==0)
        return;
    Vector oldpos_;

    //Following mode aktiv,um auf Objekt zoomen zu koennen
    //muss veraenderung der Position ermittelt werden
    if (ourConfiguration.clickedObject !=0)
        oldpos_= ourConfiguration.clickedObject->getScaledPos();

    //Aktuelle Positionen der Objekte speichern:
    ourObjectManager.nextTimeStep();

    //Integrator starten und Objekt positionen veraendern:
    PhysikEngine::simulateGravity(ourConfiguration.getTime());

    //Falls der Following Modus Aktiviert wurde:
    if (ourConfiguration.clickedObject !=0 && ourConfiguration.followObject) {
        Object * obj=ourConfiguration.clickedObject;
        //Neue Position des Objekts ermitteln
        Vector pos_ = obj->getScaledPos();
        if(ourConfiguration.viewToObjectsFlightDirection) {
            //beliebiger Abstand muss ermoeglicht werden:
            double r_ = obj->getScaledRadius();
            Vector projCenter_ = pos_ + obj->v.getNormalised() *  (r_+10.0);
            //Kamera Projektionszentrum auf Ojektposition setzen:
            ourCamera.setProjectionCenter(projCenter_);
            Vector newPos_ = pos_ + obj->v.getNormalised() *  (r_+1.0);
            //Kamera umsetzen:
            ourCamera.setPosition(newPos_);

            //neuen upper Vector bestimmen:
            Vector oldNormal_ = oldpos_.crossProduct(ourCamera.getUpper());
            Vector newUpper_ = oldNormal_.crossProduct(newPos_);
            if(newUpper_.length() == 0)
                newUpper_ = Vector(1,0,0);
            ourCamera.setUpper(newUpper_);
        } else {
            //blicke auf objekt von selbem Abstand
            Vector diff(pos_-oldpos_ );
            Vector newPos_ = ourCamera.getPosition() +diff;
            //Kamera Position und Projektionszentrum relativ zur alten Position
            //veraendern.
            ourCamera.setProjectionCenter( ourCamera.getProjectionCenter() +
                                           diff);
            ourCamera.setPosition(newPos_);
        }

    }

    //Falls das Attribut Fenster gezeigt wird muss bei bewegung der Objekte der
    //Inhalt aktualisiert werden um Aktuelle Position und Geschwindigkeit des
    // Objekts anzuzeigen.
    if(Object::attributeWindowShown())
        ourConfiguration.clickedObject->refreshAttributes();
    else
        redraw();
}


int Opengl::getObjectID(int x, int y) {
    // Anzahl der Objekte die an Position sich befinden
    int objectsFound = 0;
    int viewportCoords[4] = {0};

    /* Dieser Array wird die Opengl Namen die Angeklickt wurden enthalten
     * Die Groesse ist willkuerlich auf 32 gesetzt. Opengl speichert neben dem 
     * Namen weitere Information die nicht benoetigt wird, fuer jedes Objekt
     * desses ID gespeichert wird werden 4 Speicherzellen benoetigt.
     */
    unsigned int selectBuffer[32] = {0};

    /*
     * Mit dieser Funktion wird die Puffergroesse mit dem Puffer als
     * Selectionspuffer registriert.
     */
    glSelectBuffer(32, selectBuffer);

    /*
     * Diese Funktion gibt einen Vektor von der gewuenschten Information zurueck.
     * In unserem Fall wird der Viewport vektor angefordert
     */
    glGetIntegerv(GL_VIEWPORT, viewportCoords);

    // Die zureuckgegeben werte muessen angepasst werden um die Groesse der
    // Nachrichtenleiste zu beruecksichtigen.
    y-=viewportCoords[1] ;

    // Im Folgenden wird nun die Szene gezeichnet und die Position der Objekte
    // mit der Position (X,Y) auf der Projektion verglichen.
    glMatrixMode(GL_PROJECTION);

    //Lege eine neue Matrix auf den Stack damit die 3D Projektion nicht
    // beeinflusst wird
    glPushMatrix();

    //Rendert die Objekte veraendert allerdings nicht den Frame Buffer
    //Die Namen aller gerenderten Objekte werden stattdessen ermittelt.
    glRenderMode(GL_SELECT);
    glLoadIdentity();

    /*
     *Erzeuge eine Projektionsmatrix die um die Position gelegt wird mit einer 
     *Toleranz von 2 Pixeln. Normalerweise erlaubt diese Funktion das Rendern in
     * der Ausgewaehlten Region, da wir GL_SELECT als Render Modus gewaehlt 
     * haben wird stattdessen die ID des Objekts gespeichert. (MAGIC)
     */
    gluPickMatrix(x, viewportCoords[3] - y, 2, 2, viewportCoords);

    //Kamera Matrix multiplizieren
    ourCamera.loadCameraPerspective();

    // Model ansicht laden
    glMatrixMode(GL_MODELVIEW);

    //Objekte Zeichnen:
    RenderObjects ();

    /*  Wenn in den GL_Render Modus gewechselt wird gibt dieser die Anzahl der
     * gefundenen Objekte in der Spezifizierten Region zurueck.
     */
    objectsFound = glRenderMode(GL_RENDER);

    //Matrix Modus auf normal zurueckstellen
    glMatrixMode(GL_PROJECTION);
    //Das entfernen der Manipulierten Matrix vom Stack verwirft alles.
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);

    if (objectsFound > 0) {
        /* Falls mehr als ein Objekt gefunden wurde muessen die Tiefen Werte
         * aller Objekte verglichen werden und das Objekt das am Naehsten ist
         * ausgewaehlt werden.
         * Fuer jedes Objekt gibt es 4 Werte. 
         * 2: Minimaler Tiefen wert
         * 4: Objektname
         */
        //Auswahl der Tiefe des ersten Objekts.
        unsigned int lowestDepth = selectBuffer[1];

        //Namen des ersten Objekts
        int selectedObject = selectBuffer[3];

        for(int i = 1; i < objectsFound; i++) {
            if(selectBuffer[(i * 4) + 1] < lowestDepth) {
                //Das aktuelle Objekt ist naeher als das bereits ausgewaehlte.
                lowestDepth = selectBuffer[(i * 4) + 1];
                selectedObject = selectBuffer[(i * 4) + 3];
            }
        }

        //sicherheitscheck: es kommt evtl. vor das andere Objekte existieren
        // Diese duerfen nicht als Speicherort interpretiert werden.
        if (selectedObject < 100000)
            return 0;
        else
            // Gib namen des ausgewaehlten Objekts zurueck
            return selectedObject;
    }

    // Es wurde nicht auf ein Objekt geklickt:
    return 0;
}

void Opengl::HandleTimer(int value) {
    if(ourConfiguration.freezeAnimation || ourObjectManager.getObjectCount()==0)
        return;

    singleStep();
    glutTimerFunc(TIMERUPDATE,& Opengl::HandleTimer,0);
}


void Opengl::init(int & argc, char **argv) {
    /* Initialisierung der Glut-Bibliothek. Glut extrahiert dabei
    * Kommandozeilen-Optionen, die fuer sich selbst bestimmt sind
    * und aendert ggf. den Wert argc. Auf diese Optionen soll an
    */
    glutInit(&argc, argv);

    /* Darstellungsart fuer anschliessend erzeugte Fenster
    * festlegen. Dieser Methode werden Veroderungen von Bitmasken uebergeben.
     *  - GLUT_DOUBLE: Double-Buffering aktivieren
     *  - GLUT_RGB (= GLUT_RGB): RGB-Farbmodell
     * - GLUT_DEPTH: Tiefen-Puffer fuer das Fenster aktivieren 
    */
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);

    //Hauptfenstergroesse Festlegen:
    glutInitWindowSize( ourCamera.getScreenWidth(),
                        ourCamera.getScreenHeight() );
    //Fenster erzeugen
    int mainWindow=glutCreateWindow("Solar system construction kit");

    // "Callback-Funktionen" festlegen
    /* Setzt die Display-"Callback"-Funktion fuer das aktuelle Fenster.
     * Die Funktion "RenderUniverse" wird
     * von OpenGL aufgerufen, sobald die Szene neugezeichnet werden soll,
     * unter anderem bei Neuzeichnungsaufrufe des Window-Systems. 
    */
    glutDisplayFunc(& Opengl::RenderUniverse);

    /* Setzt die Reshape-Callback-Funktion fuer das aktuelle Fenster.
      * Die Funktion HandleReshape  wird von OpenGL aufgerufen, sobald 
    * (z. B. vom Benutzer) die Fenstergroesse
      * geaendert wird (auch direkt vor dem ersten Aufruf der Display-Funktion).
      */
    GLUI_Master.set_glutReshapeFunc(& Opengl::HandleReshape);

    //Weitere Fenster erzeugen, dafuer ist Window zustaendig:
    Window::CreateWindows(mainWindow);

    //Es gibt keinen Idle Callback => explizit auf NULL setzen
    GLUI_Master.set_glutIdleFunc(NULL);

    // Hier noch einige OpenGL-spezifische Initialisierungen
    CreateEnvironment();

    // Den Mauscursor des Window-Systems auch innerhalb des OpenGL-Fensters
    // nutzen.
    glutSetCursor(GLUT_CURSOR_INHERIT);

}

void Opengl::loop() {
    glutMainLoop();
}

---