GLPhotonMapRender.cc

Go to the documentation of this file.

#include <gra/render/GLPhotonMapRender.h>
#include <gra/camera/CameraGL.h>
#include <esg/energy/PhotonMap.h>
#include <esg/energy/PhotonMapEnergy.h>
#include <esg/geometry/Point3D.h>
#include <esg/explorer/ObjsExplorer.h>
#include <esg/Material.h>
#include <GL/gl.h>

using namespace gra;

const int GLPhotonMapRender::GLOBAL_PHOTONS  (1<<0);
const int GLPhotonMapRender::CAUSTIC_PHOTONS (1<<1);

void GLPhotonMapRender::_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);
    }

    if (scene.root()) {
        ObjsExplorer explorer;
        explorer.explore(*(scene.root()));
        
        SceneGraphObject    * pObj;
        Matrix4               trMat;
        bool                  tr;
        AutoPtr<EnergyCoat> * pACoat;
        EnergyCoat          * pCoat;
        PhotonMapEnergy     * pMap;
            
        while ((pObj = explorer.result(trMat, tr))) {
            if (!(pACoat = pObj->getEnergyState()))              continue;
            if (!(pCoat = pACoat->origObject()))                 continue;
            if (!(pMap = dynamic_cast<PhotonMapEnergy*>(pCoat))) continue;

            if (_mode & GLOBAL_PHOTONS) {
                unsigned nPhotons = pMap->numGlobalPhotons();
                glBegin(GL_POINTS); {
                    PhotonsIterator* pIter = pMap->globalMapIterator();
                    if (pIter) {
                        while (pIter->hasNext()) {
                            const Photon * pPhoton = pIter->next();
                            Vector3 power(pPhoton->getPower());
                            Vector3 loc(pPhoton->getLocation());
                            power.scale(nPhotons);
                            glColor3f(power.x, power.y, power.z);
                            glVertex3f(loc.x, loc.y, loc.z);
                        }
                    }
                } glEnd();
            }

            if (_mode & CAUSTIC_PHOTONS) {
                unsigned nPhotons = pMap->numCausticPhotons();
                glBegin(GL_POINTS); {
                    PhotonsIterator* pIter = pMap->causticsMapIterator();
                    if (pIter) {
                        while (pIter->hasNext()) {
                            const Photon * pPhoton = pIter->next();
                            Vector3 power(pPhoton->getPower());
                            Vector3 loc(pPhoton->getLocation());
                            power.scale(nPhotons);
                            glColor3f(power.x, power.y, power.z);
                            glVertex3f(loc.x, loc.y, loc.z);
                        }
                    }
                } glEnd();
            }
        }
    }
    
    if (_useDisplayList) glEndList();
}

---