GLRender.cc

Go to the documentation of this file.

#include <gra/render/GLRender.h>
#include <gra/camera/CameraGL.h>
#include <esg/spacesorting/Heap.h>
#include <esg/geometry/FDH6.h>
#include <esg/explorer/ObjsExplorer.h>
#include <GL/glu.h>

#ifdef HAVE_FREE_GLUT
#include <GL/freeglut.h>
#else
#include <GL/glut.h>
#endif

using namespace gra;

void GLRender::_render(Shader&      shader,
                       FrameBuffer& fb,
                       Camera&      camera,
                       Scene&       scene)
{
    /*
     * This render requires an OpenGL camera (CameraGL class).
     * Therefore we have to instantiate it from the general camera.
     * Although the OpenGL camera is not furher used, its instantiation
     * updates the OpenGL projection and transformation matrices.
     */
    CameraGL cameraGL(camera);

    if (_useDisplayList && _displayList) {
        glCallList(_displayList);
        return;
    }

    if (_useDisplayList) {
        _displayList = glGenLists(1);
        glNewList(_displayList, GL_COMPILE_AND_EXECUTE);
    }

    SceneGraphObject  *  pObj;
    ObjsExplorer         explorer;
    Matrix4              trMat;
    bool                 tr;
    List<TranslucentObj> translucentObjects;
    MatVisitor           visitor;
    
    explorer.explore(*(scene.root()));
    while ((pObj = explorer.result(trMat, tr))) {
        visitor.init();
        pObj->inspectMaterials(visitor);
        if (visitor.avgTransparency() > 0.0) {
            TranslucentObj * t = new TranslucentObj();
            t->pObject = pObj;
            t->transformed = tr;
            if (tr) t->trMat.set(trMat);
            translucentObjects.append(t);
        } else {
            shader.setRenderedShape(pObj, (tr) ? &trMat : NULL);
            // The shader.illuminatePoint() does nothing here
        }
    }

    /*
     * Translucent objects are rendered after opaque objects.
     * TO DO: sort traslucent objects in accord to camera direction
     *        and render them begining with the fartherest.
     */

    GLboolean        depthMask;
    TranslucentObj * pTrObj;

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask);
    glDepthMask(GL_FALSE);

    while ((pTrObj=translucentObjects.remove(translucentObjects.firstItem()))){
        shader.setRenderedShape(pTrObj->pObject,
                                (pTrObj->transformed)?&(pTrObj->trMat):NULL);
        delete pTrObj;
    }

    glDisable(GL_BLEND);
    glDepthMask(depthMask);
    
    if (_useDisplayList) glEndList();
}

---