GLShader.cc

Go to the documentation of this file.

#include <gra/shader/GLShader.h>
#include <GL/gl.h>

using namespace gra;

void GLShader::_illum_vertices(Mesh& mesh) const
{
    Vector3 v;

    glBegin(GL_POINTS); {
        mesh.resetActSolid();
        do {
            mesh.resetVertWalkInSolid();
            do {
                if (_shadingMode == SMOOTH || _shadingMode == TEXTURE) {
                    v.set(mesh.getActVertNormal());
                    glNormal3f(v.x,v.y,v.z);
                }
                if (_shadingMode == TEXTURE) {
#warning "TODO: Texture coordinates from mesh"
                }
                v.set(mesh.getActVert());
                glVertex3f(v.x,v.y,v.z);
            } while (mesh.stepInVertWalkInSolid());
        } while (mesh.goToNextSolid());
    } glEnd();
}

void GLShader::_illum_edges(Mesh& mesh) const
{
    Vector3 u,v;

    glBegin(GL_LINES); {
        mesh.resetActSolid();
        do {
            mesh.resetEdgeWalkInSolid();
            do {
                if (_shadingMode == SMOOTH || _shadingMode == TEXTURE) {
                    u.set(mesh.getActVertNormal1(false));
                    v.set(mesh.getActVertNormal2(false));
                    glNormal3f(u.x,u.y,u.z);
                    glNormal3f(v.x,v.y,v.z);
                }
                if (_shadingMode == TEXTURE) {
#warning "TODO: Texture coordinates from mesh"
                }
                u.set(mesh.getActVert1(false));
                v.set(mesh.getActVert2(false));
                glVertex3f(u.x,u.y,u.z);
                glVertex3f(v.x,v.y,v.z);

                cerr << u << "--" << v << endl;
            } while (mesh.stepInEdgeWalkInSolid());
        } while (mesh.goToNextSolid());
    } glEnd();
}

void GLShader::_illum_facets(GLenum polMode, Mesh& mesh) const
{
    Vector3 v;

    if (_shadingMode == FLAT)
        glShadeModel(GL_FLAT);
    
    if (_shadingMode == SMOOTH || _shadingMode == TEXTURE)
        glShadeModel(GL_SMOOTH);

    switch (_facetMode) {
    case FRONT:
        glCullFace(GL_BACK);
        glEnable(GL_CULL_FACE);
        glPolygonMode(GL_FRONT, polMode);
        break;
    case BACK:
        glCullFace(GL_FRONT);
        glEnable(GL_CULL_FACE);
        glPolygonMode(GL_BACK, polMode);
        break;
    case FRONT_AND_BACK:
        glDisable(GL_CULL_FACE);
        glPolygonMode(GL_FRONT_AND_BACK, polMode);
        break;
    default:
        fprintf(stderr,"GLShader::_illum_facets(): Uknown facet mode, using AUTO\n");
    case AUTO:
        if (mesh.hasOutwardNormals()) {
            glCullFace(GL_BACK);
            glEnable(GL_CULL_FACE);
            glPolygonMode(GL_FRONT, polMode);
        } else {
            glDisable(GL_CULL_FACE);
            glPolygonMode(GL_FRONT_AND_BACK,polMode);
        }
        break;
    }

    mesh.resetActSolid();
    do {
        mesh.resetActPlane();
        do {
            glBegin(GL_POLYGON); {
                if (_shadingMode == FLAT) {
                    v.set(mesh.getActPlaneNormal());
                    glNormal3f(v.x,v.y,v.z);
                }
                mesh.resetActEdge();
                do {
                    if (_shadingMode == SMOOTH || _shadingMode == TEXTURE) {
                        v.set(mesh.getActVertNormal1(true));
                        glNormal3f(v.x,v.y,v.z);
                    }
                    if (_shadingMode == TEXTURE) {
#warning "TODO: Texture coordinates from mesh"
                    }
                    v.set(mesh.getActVert1(true));
                    glVertex3f(v.x,v.y,v.z);
                } while (mesh.goToNextEdge());
            } glEnd();

        } while (mesh.goToNextPlane());
    } while (mesh.goToNextSolid());
}

bool GLShader::_use_precomputed_energy(PolygonalEnergy& energy) const
{
    Vector3 v;
    AutoPtr<Mesh> * pAMesh = energy.getMesh();
    if (!pAMesh) return false;
    Mesh* pMesh = pAMesh->origObject();
    if (!pMesh) return false;

    PolygonalEnergy::Regions regions = energy.getRegionsDescr();
    if (regions != PolygonalEnergy::VERTEX_BASED &&
        regions != PolygonalEnergy::FACET_BASED) return false;

    pMesh->resetActSolid();
    do {
        pMesh->resetActPlane();
        do {
            glBegin(GL_POLYGON); {
                if (regions == PolygonalEnergy::FACET_BASED) {
                    (void) energy.getRegionEnergy(pMesh->getActPlaneID(), v);
                    glColor3f(v.x,v.y,v.z);
                }
                pMesh->resetActEdge();
                do {
                    if (regions == PolygonalEnergy::VERTEX_BASED) {
                        (void) energy.getRegionEnergy(pMesh->getActVertID1(true), v);
                        glColor3f(v.x,v.y,v.z);
                    }
                    v.set(pMesh->getActVert1(true));
                    glVertex3f(v.x,v.y,v.z);
                } while (pMesh->goToNextEdge());
            } glEnd();
        } while (pMesh->goToNextPlane());
    } while (pMesh->goToNextSolid());

    return true;
}



bool GLShader::setRenderedShape(SceneGraphObject * pShape,
                                const Matrix4    * pTrMat)
{
    _pShape = pShape;

    if (!_pShape || !_pShape->supportsEnergy()) return false;

    /*
     * Render energy coat instead of shape itself
     */
    if (_exploitEnergy) {
        AutoPtr<EnergyCoat>* pAE = pShape->getEnergyState();
        if (pAE) {
            EnergyCoat * pCoat = pAE->origObject();
            if (pCoat) {
                PolygonalEnergy* pE = dynamic_cast<PolygonalEnergy*>(pCoat);
                if (pE) return _use_precomputed_energy(*pE);
            }
        }
    }

    GLint renderMode;
    glGetIntegerv(GL_RENDER_MODE, &renderMode);

    /*
     * Illuminate the shape
     */
    (_shadingMode == COLOR) ? glDisable(GL_LIGHTING) : glEnable(GL_LIGHTING);

    // We have primitive but we need polygons. Therefore
    // get geometry of primitive and than get its polygonial mesh
    Geometry* pGeom = pShape->geometry();
    if (!pGeom) return false;
    Mesh * pMesh = pGeom->mesh(_meshDensity);
    if (!pMesh) return false;

    MatVisitor matVisitor;
    pShape->inspectMaterials(matVisitor);

    float alpha = 1.0 - matVisitor.avgTransparency();

    if (_shadingMode == COLOR) {
        glEnable(GL_COLOR_MATERIAL);
        glColor4f(matVisitor.diffuse().x,
                  matVisitor.diffuse().y,
                  matVisitor.diffuse().z,
                  alpha);
    } else { // another shading mode than COLOR => use Phong material
        float ambient[4]  = { matVisitor.ambient().x,
                              matVisitor.ambient().y,
                              matVisitor.ambient().z,
                              alpha };
        float diffuse[4]  = { matVisitor.diffuse().x,
                              matVisitor.diffuse().y,
                              matVisitor.diffuse().z,
                              alpha };
        float specular[4] = { matVisitor.specular().x,
                              matVisitor.specular().y,
                              matVisitor.specular().z,
                              alpha };
        glDisable(GL_COLOR_MATERIAL);
        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT,   ambient);
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE,   diffuse);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR,  specular);
        glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, matVisitor.intRoughness());
    }

    glMatrixMode(GL_MODELVIEW);
    if (pTrMat) {
        float   m[16];
        Matrix4 trMat(*pTrMat);
        trMat.transpose();
        trMat.get(m);
        glPushMatrix();
        glMultMatrixf(m);
    }

    switch (_meshMode) {
    case VERTICES:
        _illum_vertices(*pMesh);
        break;
    case EDGES:
        _illum_edges(*pMesh);
        break;
    case FACETS:
        _illum_facets(GL_FILL, *pMesh);
        break;
    case FACET_EDGES:
        _illum_facets(GL_LINE, *pMesh);
        break;
    case FACET_CORNERS:
        _illum_facets(GL_POINT, *pMesh);
        break;
    default:
        fprintf(stderr,"GLShader Error: Unsuported mesh mode\n");
    };

    if (pTrMat) glPopMatrix();

    delete pMesh;
    return true;
}

---