PhotonMapShader.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __PHOTON_MAP_SHADER
#define __PHOTON_MAP_SHADER

#include <gra/shader/RTShader.h>
#include <gra/reflection/PhotonTracing.h>
#include <gra/reflection/PhotonMapping.h>
#include <gra/reflection/Caustics.h>
#include <esg/LightArray.h>
#include <esg/energy/PhotonMapEnergy.h>

using namespace esg;

namespace gra {

class GRA_EXPORT PhotonMapShader : public RTShader {
public:
        enum Mapping {
            SCENE_MAPS,    
            MAPS_PER_SHAPE 
        };

protected:
        PhotonTracing * _pPhotonTracing;
        Caustics      * _pCausticsEmittion;
        LightArray    * _pLights;
        unsigned        _photonsPerLight;
        Mapping         _mapping;
        bool            _userDefinedBehaviour;
        
protected:
        void _create_scene_maps     (List<PhotonMapEnergy>&,
                                     List<SceneGraphObject>&);
        void _create_maps_per_shape (List<PhotonMapEnergy>&,
                                     List<SceneGraphObject>&);
        PointEnv* _emit_global_photon  (const Vector3&, const Vector3&);
        PointEnv* _emit_caustic_photon (const Vector3&, const Vector3&);

public:
        PhotonMapShader(PhotonTracing * m,
                        Caustics      * c,
                        PhotonMapping * n,
                        DiffuseBRDF   * db,
                        SpecularBRDF  * sb,
                        unsigned        p,
                        Mapping         mapping,
                        bool            u)
            : RTShader(n, db, sb),
              _pPhotonTracing(m),
              _pCausticsEmittion(c),
              _pLights(NULL),
              _photonsPerLight(p),
              _mapping(mapping),
              _userDefinedBehaviour(u) {}

        virtual void setScene (Scene * o) {
            RTShader::setScene(o);
            if (_pPhotonTracing) _pPhotonTracing->setScene(o);
            if (_pCausticsEmittion) _pCausticsEmittion->setScene(o);
        }

        virtual void distributeEnergy (void);

        virtual bool setRenderedShape (SceneGraphObject * pShape,
                                       const Matrix4    * pTrMat) {
            if (!RTShader::setRenderedShape(pShape, pTrMat)) return false;
            if (!_pShape)                                    return false;
            if (!_pPhotonTracing)                            return false;
            if (!_pCausticsEmittion)                         return false;
            DiffuseBRDF * pDiffBRDF = _pShape->diffuseBRDF();
            SpecularBRDF* pSpecBRDF = _pShape->specularBRDF();
            _pPhotonTracing->setDiffuseBRDF((pDiffBRDF)
                                            ? pDiffBRDF 
                                            : _pDefaultDiffBRDF);
            _pPhotonTracing->setSpecularBRDF((pSpecBRDF)
                                             ? pSpecBRDF 
                                             : _pDefaultSpecBRDF);
            _pPhotonTracing->setEmittance(_pShape->emittance());
            _pCausticsEmittion->setDiffuseBRDF((pDiffBRDF)
                                               ? pDiffBRDF 
                                               : _pDefaultDiffBRDF);
            _pCausticsEmittion->setSpecularBRDF((pSpecBRDF)
                                                ? pSpecBRDF 
                                                : _pDefaultSpecBRDF);
            _pCausticsEmittion->setEmittance(_pShape->emittance());
            return true;
        }
};
    
} // namespace

#endif // __PHOTON_MAP_SHADER

---