RadShader.cc

Go to the documentation of this file.

#include <gra/shader/RadShader.h>
#include <esg/explorer/ObjsExplorer.h>
#include <esg/energy/PolygonalEnergy.h>
#include <esg/mesh/Mesh.h>

using namespace gra;

void RadShader::setScene(Scene * pScene)
{
    _pScene = pScene;

    if (!_pScene || !_pScene->root()) return;

    /*
     * Triangulate geometries
     */

    ObjsExplorer     explorer;
    Matrix4          trMat;
    bool             transformed;
    PolygonalEnergy* pE;
    Mesh*            pMesh;
    Geometry*        pGeom;
    Emittance*       pEmittance;
    int              ids = 0;

    explorer.explore(*(_pScene->root()));
    
    for (SceneGraphObject * pObj = explorer.result(trMat, transformed);
         pObj;
         pObj = explorer.result(trMat, transformed))
    {
        if (!pObj->supportsEnergy()) continue;

        // inspect geometry
        pGeom = pObj->geometry();
        if (!pGeom) continue;
        pMesh = pGeom->mesh(_meshDensity);
        if (!pMesh) continue;

        pE = new PolygonalEnergy(new AutoPtr<Mesh>(pMesh),
                                 PolygonalEnergy::FACET_BASED);

        // init energy
        Color3f       emission;
        Mesh::Plane * pPlane;
        pMesh->resetActSolid();
        do {
            pMesh->resetActPlane();
            do {
                pPlane = pMesh->getActPlane();
                pPlane->jmeno_roviny = ids++;

                pEmittance = pObj->emittance();
                if (pEmittance) { // light source
                    if (pEmittance->intensity(pMesh->getActPlaneCentroid(),
                                              emission))
                        pE->setRegionEnergy(pPlane->jmeno_roviny, emission);
                    else
                        pE->setRegionEnergy(pPlane->jmeno_roviny,
                                            Color3f(0.,0.,0.));
                } else
                    pE->setRegionEnergy(pPlane->jmeno_roviny,
                                        Color3f(0.,0.,0.));
            } while (pMesh->goToNextPlane());
        } while (pMesh->goToNextSolid());
        
        pObj->setEnergyState(new AutoPtr<EnergyCoat>(pE));
    }

    /*
     * Init radiosity reflection model
     */
    if (_pReflectionModel) _pReflectionModel->setScene(_pScene);

    /*
     * Anounce local shader
     */
    if (_pLocalShader) _pLocalShader->setScene(_pScene);
}

void RadShader::distributeEnergy()
{
    PointEnv fakeEnv;
    if (_pReflectionModel)
        (void) _pReflectionModel->illuminatePoint(fakeEnv);
}

bool RadShader::setRenderedShape(SceneGraphObject * s, const Matrix4 * m)
{
    if (!_pLocalShader) return false;
    return _pLocalShader->setRenderedShape(s, m);
}

Color3f* RadShader::illuminatePoint(const Vector3& point,
                                    const Vector3& normal,
                                    const Vector3& vDir,
                                    float          dist,
                                    double*        pNV,
                                    const Matrix4* mat)
{
    if (!_pLocalShader) return NULL;
    return _pLocalShader->illuminatePoint(point,normal,vDir,dist,NULL,mat);
}

---