PhotonMapShader.cc

Go to the documentation of this file.

#include <gra/shader/PhotonMapShader.h>
#include <esg/explorer/ObjsExplorer.h>
#include <esg/visitor/PhotonMapBhvVisitor.h>
#include <esg/geometry/Sphere.h>

using namespace gra;

void PhotonMapShader::_create_scene_maps(List<PhotonMapEnergy>&  maps,
                                         List<SceneGraphObject>& reflShapes)
{
    PhotonMapEnergy     * pMap  = new PhotonMapEnergy();
    AutoPtr<EnergyCoat> * pAMap = new AutoPtr<EnergyCoat>(pMap);

    pAMap->registerReferer(this);

    ObjsExplorer explorer;
    explorer.explore(*(_pScene->root()));
    
    SceneGraphObject    * pObj;
    Matrix4               trMat;
    bool                  tr;
            
    while ((pObj = explorer.result(trMat, tr))) {
        PhotonMapBhvVisitor pmbVisitor;
        MatVisitor          matVisitor;
        pObj->inspectAttributes(pmbVisitor);
        pObj->inspectMaterials(matVisitor);

        if (_userDefinedBehaviour) {
            if (pmbVisitor.behaviour() &&
                (pmbVisitor.behaviour()->acceptsGlobalPhotons() ||
                 pmbVisitor.behaviour()->acceptsCaustics()))
                pObj->setEnergyState(pAMap);
            else
                pObj->setEnergyState(NULL);
            
            if (pmbVisitor.behaviour() &&
                pmbVisitor.behaviour()->makesCaustics() &&
                (matVisitor.avgReflection() > 0. ||
                 matVisitor.avgTransparency() > 0.))
                reflShapes.append(pObj);
        } else {
            if (matVisitor.avgReflection() == 0. &&
                matVisitor.avgTransparency() == 0.)
            {
                // Set photon maps of diffuse surface
                pObj->setEnergyState(pAMap);

                // A diffuse surface should store all photons
                if (!pmbVisitor.behaviour())
                    pObj->appendPrivateAttribute(new PhotonMapBehaviour(PhotonMapBehaviour::ACCEPT_CAUSTICS|PhotonMapBehaviour::ACCEPT_GLOBAL_PHOTONS));
            } else {
                if (!pmbVisitor.behaviour())
                    pObj->appendPrivateAttribute(new PhotonMapBehaviour(PhotonMapBehaviour::MAKE_CAUSTICS));
                
                // A reflective/refractive surface should not employ
                // photon maps, but should be used for caustics generation
                // instead.
                pObj->setEnergyState(NULL);
                reflShapes.append(pObj);
            }
        }
    }

    // accept new photon map iff it is used by some shape
    if (!AutoPtr<EnergyCoat>::destroy(pAMap, this)) maps.append(pMap);
}

void PhotonMapShader::_create_maps_per_shape(List<PhotonMapEnergy>&  maps,
                                             List<SceneGraphObject>& reflShapes)
{
    ObjsExplorer explorer;
    explorer.explore(*(_pScene->root()));

    SceneGraphObject * pObj;
    Matrix4            trMat;
    bool               tr;
            
    while ((pObj = explorer.result(trMat, tr))) {
        PhotonMapBhvVisitor pmbVisitor;
        MatVisitor          matVisitor;
        pObj->inspectAttributes(pmbVisitor);
        pObj->inspectMaterials(matVisitor);
           
        if (_userDefinedBehaviour) {
            if (pmbVisitor.behaviour() &&
                (pmbVisitor.behaviour()->acceptsGlobalPhotons() ||
                 pmbVisitor.behaviour()->acceptsCaustics()))
            {
                PhotonMapEnergy * pMap = new PhotonMapEnergy();
                AutoPtr<EnergyCoat> * pAMap = new AutoPtr<EnergyCoat>(pMap);
                pObj->setEnergyState(pAMap);
                maps.append(pMap);
            } else
                pObj->setEnergyState(NULL);
            
            if (pmbVisitor.behaviour() &&
                pmbVisitor.behaviour()->makesCaustics() &&
                (matVisitor.avgReflection() > 0. ||
                 matVisitor.avgTransparency() > 0.))
                reflShapes.append(pObj);
        } else {
            PhotonMapEnergy * pMap  = new PhotonMapEnergy();
            AutoPtr<EnergyCoat> * pAMap = new AutoPtr<EnergyCoat>(pMap);
            if (matVisitor.avgReflection() == 0. &&
                matVisitor.avgTransparency() == 0.)
            {
                // Set photon maps of diffuse surface
                pObj->setEnergyState(pAMap);
                maps.append(pMap);
                // A diffuse surface should store all photons
                if (!pmbVisitor.behaviour())
                    pObj->appendPrivateAttribute(new PhotonMapBehaviour(PhotonMapBehaviour::ACCEPT_CAUSTICS|PhotonMapBehaviour::ACCEPT_GLOBAL_PHOTONS));
            } else {
                // A reflective/refractive surface should not employ
                // photon maps, but should be used for caustics generation
                // instead.
                pObj->setEnergyState(NULL);
                reflShapes.append(pObj);
            }
        }
    }
}

PointEnv* PhotonMapShader::_emit_global_photon(const Vector3& phOrigin,
                                               const Vector3& phDir)
{
    Color3f        intensity;
    RayIntExplorer riExplorer(Vector3(0,0,0), Vector3(0,0,0), NULL);
    Intersector    intersector;

    // get first intersection of photon
    riExplorer.reinit(phOrigin, phDir, &intersector);
    intersector.init(ENV_WANT_INTERSECTION | ENV_WANT_NORMAL | 
                     ENV_WANT_ASOC_PRIMITIVE | ENV_WANT_DISTANCE | 
                     ENV_WANT_N_DOT_D);
    riExplorer.explore(*(_pScene->root()));
    PointEnv * pE = riExplorer.result();
    if (!pE || !(pE->mask & (ENV_HAVE_ASOC_PRIMITIVE | 
                             ENV_HAVE_INTERSECTION | 
                             ENV_HAVE_NORMAL)))
    { // no intersection
        if (pE) { 
            pE->pVisitableObj = NULL; 
            delete pE;
        }
        return NULL;
    }

    pE->viewerDir.set(phDir);
    pE->viewerDir.negate();
    pE->mask |= ENV_HAVE_VIEWER_DIR;

    return pE;
}

PointEnv* PhotonMapShader::_emit_caustic_photon(const Vector3& phOrigin,
                                                const Vector3& phDir)
{
    RayIntExplorer riExplorer(Vector3(0,0,0), Vector3(0,0,0), NULL);
    Intersector    intersector;

    // get first intersection of photon
    riExplorer.reinit(phOrigin, phDir, &intersector);
    intersector.init(ENV_WANT_INTERSECTION | ENV_WANT_NORMAL | 
                     ENV_WANT_ASOC_PRIMITIVE | ENV_WANT_DISTANCE | 
                     ENV_WANT_N_DOT_D);
    riExplorer.explore(*(_pScene->root()));
    PointEnv * pE = riExplorer.result();
    if (!pE || !(pE->mask & (ENV_HAVE_ASOC_PRIMITIVE | 
                             ENV_HAVE_INTERSECTION | 
                             ENV_HAVE_NORMAL)))
    { // no intersection
        if (pE) { 
            pE->pVisitableObj = NULL; 
            delete pE;
        }
        return NULL;
    }

    pE->viewerDir.set(phDir);
    pE->viewerDir.negate();
    pE->mask |= ENV_HAVE_ENERGY | ENV_HAVE_VIEWER_DIR;

    return pE;
}

//--------------- public ---------------

void PhotonMapShader::distributeEnergy(void)
{
    if (!_pPhotonTracing)             return;
    if (!_pScene || !_pScene->root()) return;

    _pPhotonTracing->setDiffuseBRDF(_pDefaultDiffBRDF);
    _pPhotonTracing->setSpecularBRDF(_pDefaultSpecBRDF);
    _pPhotonTracing->setScene(_pScene);

    if (_pCausticsEmittion) {
        _pCausticsEmittion->setDiffuseBRDF(_pDefaultDiffBRDF);
        _pCausticsEmittion->setSpecularBRDF(_pDefaultSpecBRDF);
        _pCausticsEmittion->setScene(_pScene);
    }

    if (_pLights) delete _pLights;
    LightsExplorer explorer(0);
    explorer.explore(*(_pScene->root()));
    _pLights = explorer.result();
    
    Emittance * pEmittance;
    PointEnv  * pE;

    /*
     * create photon maps
     */

    List<PhotonMapEnergy>  maps;
    List<SceneGraphObject> reflShapes;
    switch (_mapping) {
    case SCENE_MAPS:     _create_scene_maps(maps, reflShapes);     break;
    case MAPS_PER_SHAPE: _create_maps_per_shape(maps, reflShapes); break;
    default: break;
    }

    if (maps.empty()) return; // nothing to do

    Color3f  intensity, phPower;
    unsigned phPerL;
    Vector3  phOrigin, phDir;
    for (ESGint i = 0; i < LightArray::MAX_LIGHTS; i++) 
    {
        if (!_pLights->isOn(i)) continue;

        // get number of emitted photons proportionally to the light brightness
        if (!(pEmittance = _pLights->light(i).pEmittance)) continue;
        if (!pEmittance->intensity(intensity)) continue;
        phPerL = (unsigned) (_photonsPerLight *
                             (intensity.x+intensity.y+intensity.z) /
                             3.);

        /*
         * store global energy in the global photon map(s)
         */
        for (unsigned j = 0; j < phPerL; j++) {
            if (!_pLights->emitPhoton(phOrigin, phDir, phPower, i)) continue;
            if (!(pE = _emit_global_photon(phOrigin, phDir))) continue;
            pE->energy.set(phPower);
            pE->energy.scale(1./phPerL);
            pE->mask |= ENV_HAVE_ENERGY;
            _pPhotonTracing->illuminatePoint(*pE);
            delete pE;
        }

        if (!_pCausticsEmittion) continue;

        /*
         * Generate caustics photon map(s)
         */
        Geometry * pGeom;
        Geometry * pLightGeom = _pLights->getGeometry(i);
        Sphere   * pBoundingSphere;
        unsigned   phPerObj;
        double     bsR, bsDist;
        Vector3    bsVec;
        for (SceneGraphObject * pObj = reflShapes.firstItem();
             pObj;
             pObj = reflShapes.nextItem())
        {
            if (!(pGeom = pObj->geometry())) continue;
            pBoundingSphere = new Sphere(*pGeom);

            // phPerObj = photons per object = number of photons
            // casted towards the caustics object, which is relative
            // to the space angle (from ohOrigin) occupied by
            // the object relatively to the whole halfspace (180 degrees)
            bsVec.set(pBoundingSphere->centre());
            bsVec.sub(phOrigin);
            bsDist   = bsVec.length();
            bsR      = pBoundingSphere->radius() / bsDist;
            phPerObj = (unsigned)(phPerL * (acos(sqrt(1.-bsR*bsR))/(M_PI/2))); 

            for (unsigned j = 0; j < phPerObj; j++) {
                // stochasticly sample the light source
                if (pLightGeom) { 
                    PointEnv auxEnv;
                    pLightGeom->randomSample(ENV_WANT_SURFACE_POINT,
                                             auxEnv, NULL);
                    if (! (auxEnv.mask & ENV_HAVE_SURFACE_POINT)) continue;
                    phOrigin.set(auxEnv.intersection);
                } else {
                    if (!pEmittance->sourceLocation(phOrigin)) {
                        if (!pEmittance->beamDirection(phDir)) continue;
                        phOrigin.set(phDir); // set origin to "infinity"
                        phOrigin.negate();
                        phOrigin.scale(FLT_MAX/3.);
                        phOrigin.add(pGeom->centroid());
                    }
                }

                // stochasticly sample object that produces caustics
                if (!pBoundingSphere->randomDirection(phOrigin, phDir, NULL))
                    continue;

                if (!(pE = _emit_caustic_photon(phOrigin, phDir))) continue;
                pE->energy.set(intensity);
                pE->energy.scale(1./phPerL);
                pE->mask |= ENV_HAVE_ENERGY;
                _pCausticsEmittion->illuminatePoint(*pE);
                delete pE;
            }

            delete pBoundingSphere;
        }
    }

    /*
     * build photon maps storing global energy
     */
    
    for (PhotonMapEnergy* pMap = maps.firstItem();
         pMap;
         pMap = maps.nextItem())
    {
        pMap->buildGlobalMap();
        pMap->buildCausticsMap();
    }
}

---