GLEnergyRender.cc

Go to the documentation of this file.

#include <gra/render/GLEnergyRender.h>
#include <gra/camera/CameraGL.h>
#include <esg/explorer/ObjsExplorer.h>
#include <GL/gl.h>
#include <assert.h>

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


using namespace gra;

#define __SET_MAP_FACET(c,e,s) { \
   glBegin(GL_POLYGON); { \
        glTexCoord2f(0.0, 0.0); \
        glVertex3f((c).x + s[0] * (e.x/2),  \
                   (c).y + s[1] * (e.y/2),  \
                   (c).z + s[2] * (e.z/2)); \
        glTexCoord2f(0.0, 1.0); \
        glVertex3f((c).x + s[3] * (e.x/2),  \
                   (c).y + s[4] * (e.y/2),  \
                   (c).z + s[5] * (e.z/2)); \
        glTexCoord2f(1.0, 1.0); \
        glVertex3f((c).x + s[6] * (e.x/2),  \
                   (c).y + s[7] * (e.y/2),  \
                   (c).z + s[8] * (e.z/2)); \
        glTexCoord2f(1.0, 0.0); \
        glVertex3f((c).x + s[9]  * (e.x/2),  \
                   (c).y + s[10] * (e.y/2),  \
                   (c).z + s[11] * (e.z/2)); \
   } glEnd(); }

void GLEnergyRender::_render_light_map(LightMap& lightMap)
{
    Color3f color;
    int s1[12] = {-1,-1,+1,-1,+1,+1,+1,+1,+1,+1,-1,+1};
    int s2[12] = {+1,-1,-1,+1,+1,-1,-1,+1,-1,-1,-1,-1};
    int s3[12] = {-1,-1,-1,-1,+1,-1,-1,+1,+1,-1,-1,+1};
    int s4[12] = {+1,-1,+1,+1,+1,+1,+1,+1,-1,+1,-1,-1};
    int s5[12] = {-1,+1,+1,-1,+1,-1,+1,+1,-1,+1,+1,+1};
    int s6[12] = {-1,-1,-1,-1,-1,+1,+1,-1,+1,+1,-1,-1};
    
    for (int i = 0; i < 6; i++) {
        GLfloat *pixels = new GLfloat [lightMap.vRes() * lightMap.uRes() * 3];
        unsigned i = 0;
        for (unsigned v = 0; v < lightMap.vRes(); v++)
            for (unsigned u = 0; u < lightMap.uRes(); u++) 
                if (lightMap.getValue((LightMap::MapIndex)i, u, v, color)) {
                    pixels[i++] = (GLfloat) color.x;
                    pixels[i++] = (GLfloat) color.y;
                    pixels[i++] = (GLfloat) color.z;
#if 0
                    pixels[i++] = (GLfloat) 1.0/(v+1.0);
                    pixels[i++] = (GLfloat) 1.0/(u+1.0);
                    pixels[i++] = (GLfloat) color.z;
#endif
                } else {
                    pixels[i++] = (GLfloat) 0.0;
                    pixels[i++] = (GLfloat) 0.0;
                    pixels[i++] = (GLfloat) 0.0;
                }

        GLuint textureName;
        glGenTextures(1, &textureName);
        glBindTexture(GL_TEXTURE_2D, textureName);
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
                     lightMap.uRes(), lightMap.vRes(), 0,
                     GL_RGB, GL_FLOAT, pixels);

        glEnable(GL_TEXTURE_2D);
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
        glBindTexture(GL_TEXTURE_2D, textureName);

        if ((LightMap::MapIndex) i == LightMap::NEAR_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s1);
        if ((LightMap::MapIndex) i == LightMap::FAR_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s2);
        if ((LightMap::MapIndex) i == LightMap::LEFT_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s3);
        if ((LightMap::MapIndex) i == LightMap::RIGHT_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s4);
        if ((LightMap::MapIndex) i == LightMap::TOP_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s5);
        if ((LightMap::MapIndex) i == LightMap::BOTTOM_MAP) 
            __SET_MAP_FACET(lightMap.centroid(), lightMap.extent(), s6);

        glDisable(GL_TEXTURE_2D);
        glDeleteTextures(1, &textureName);

        delete [] pixels;
    }
}

#undef __SET_MAP_FACET

void GLEnergyRender::_render_partial_energy(PolygonalEnergy& e)
{
    AutoPtr<Mesh> * pAMesh = e.getMesh();
    if (!pAMesh) return;
    
    Mesh * pMesh = pAMesh->origObject();
    if (!pMesh) return;

    glEnable(GL_COLOR_MATERIAL);
    glDisable(GL_LIGHTING);
    
    PolygonalEnergy::Regions regions = e.getRegionsDescr();
    
    if (regions == PolygonalEnergy::FACET_BASED) {
        // to do
        return;
    }

    if (regions == PolygonalEnergy::VERTEX_BASED) {
        Vector3 u,v;

        //glColor3f(_background.x,_background.y,_background.z);
        pMesh->resetActSolid();
        do {
            pMesh->resetActPlane();
            do {
                glBegin(GL_POLYGON); {
                    pMesh->resetActEdge();
                    do {
                        v.set(pMesh->getActVert1(true));
                        glVertex3f(v.x,v.y,v.z);
                    } while (pMesh->goToNextEdge());
                } glEnd();
            } while (pMesh->goToNextPlane());
        } while (pMesh->goToNextSolid());

        glColor3f(0.0,0.0,0.0);
        glBegin(GL_LINES); {
            pMesh->resetActSolid();
            do {
                pMesh->resetEdgeWalkInSolid();
                do {
                    u.set(pMesh->getActVert1(false));
                    v.set(pMesh->getActVert2(false));
                    u.scale(1.002);
                    v.scale(1.002);
                    glVertex3f(u.x,u.y,u.z);
                    glVertex3f(v.x,v.y,v.z);
                } while (pMesh->stepInEdgeWalkInSolid());
            } while (pMesh->goToNextSolid());
        } glEnd();

        GLfloat pointSize;
        GLboolean antia;
        glGetFloatv(GL_POINT_SIZE, &pointSize);
        glGetBooleanv(GL_LINE_SMOOTH, &antia);
        //glEnable(GL_LINE_SMOOTH);
        //glEnable(GL_POINT_SMOOTH);
        //glPointSize(20);
        glMatrixMode(GL_MODELVIEW);

        //      glBegin(GL_POINTS); {
            pMesh->resetActSolid();
            do {
                pMesh->resetVertWalkInSolid();
                do {
                    u.set(pMesh->getActVert());
                    e.getRegionEnergy(pMesh->getActVertID(), v);
                    glColor3f(v.x,v.y,v.z);
                    //glVertex3f(u.x,u.y,u.z);
                    glPushMatrix();
                    glTranslatef(u.x,u.y,u.z);
                    glutSolidSphere(.04, 10, 10);
                    glPopMatrix();
                } while (pMesh->stepInVertWalkInSolid());
            } while (pMesh->goToNextSolid());
            //  } glEnd();

        glPointSize(pointSize);
        if (!antia) glDisable(GL_LINE_SMOOTH);
        
        return;
    }
}

void GLEnergyRender::_render_energy(Scene& scene)
{
    ObjsExplorer explorer;
    explorer.explore(*(scene.root()));

    AutoPtr<EnergyCoat> * pAEnergy;
    EnergyCoat          * pEnergy;
    Matrix4               trMat;
    bool                  transformed;
    SceneGraphObject    * pObj = explorer.result(trMat, transformed);

    while (pObj) {
        pAEnergy = pObj->getEnergyState();
        if (pAEnergy) {
            pEnergy = pAEnergy->origObject();
            assert(pEnergy);
            PolygonalEnergy * pPE = dynamic_cast<PolygonalEnergy*>(pEnergy);
            if (pPE) 
                _render_partial_energy(*pPE);
            else {
                LightMap* pLM = dynamic_cast<LightMap*>(pEnergy);
                if (pLM) _render_light_map(*pLM);
            }
        }
        pObj = explorer.result(trMat, transformed);
    }
}

void GLEnergyRender::_render(Shader&      shader,
                             FrameBuffer& fb,
                             Camera&      camera,
                             Scene&       scene)
{
    //Vector3 viewDir(camera.getDirection());
    //viewDir.negate();
    //shader.illuminateScene(scene, &viewDir);

    /*
     * 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) {
        if (_displayList) glCallList(_displayList);
        else {
            _displayList = glGenLists(1);
            glNewList(_displayList, GL_COMPILE_AND_EXECUTE); {
                _render_energy(scene);
            } glEndList();
        }
    } else
        _render_energy(scene);
}

---