Radiosity.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __RADIOSITY_H
#define __RADIOSITY_H

#include <gra/reflection/ReflectionModel.h>
#include <esg/Intersector.h>
#include <esg/energy/PolygonalEnergy.h>
#include <esg/mesh/Mesh.h>

using namespace esg;

namespace gra {

class GRA_EXPORT Radiosity : public ReflectionModel {
public:
    struct Patch {
        PolygonalEnergy  * pEnergy;
        Mesh::Plane      * pMeshPlane;
        Vector3            reflectance;
        Vector3            emittance;
        Vector3            normal;
        Vector3            centre;
        float              area; 

        Patch (PolygonalEnergy *,
               Mesh::Plane     *,
               const Vector3   & /* reflectance */,
               const Vector3   & /* emittance   */,
               const Vector3   & /* centroid    */,
               float             /* area        */);
    };

protected:
    Intersector * _pIntersector;
    int           _quadLevel;  // Error tolerance for the differential FF
    float         _dFError;    // How accurate to make quadrature
    List<Patch>   _scenePatches;
    int           _stage;      // which illumination stage will proceed
    bool          _useAmbient;
    
protected:
    /*
     * Return energy of single edge of patche
     */
    virtual float _edge_area (const Vector3& /* v1     */,
                              const Vector3& /* v2     */,
                              const Vector3& /* normal */);

    /*
     * Form factor of single patch (cos theta * cos phi * Ap / (pi * r^2))
     */
    virtual float _est_patch_factor(Patch&         /* patch  */,
                                    const Vector3& /* point  */,
                                    const Vector3& /* normal */);

    /*
     * polygon-to-point form factor
     */
    virtual float _patch_factor(Patch&         /* patch  */,
                                const Vector3& /* point  */,
                                const Vector3& /* normal */);

    /*
     * Compute the form factor
     */
    virtual float _est_form_factor (Patch& /* from */, Patch& /* to */);

    /*
     * Compute all form factors for the given patch
     */
    virtual void _make_form_factors (Patch& /* from */, Vector3/* result */[]);

    /*
     * Vibility function
     */
    virtual float _visibility (Patch& /* from */, Patch& /* to */);
    
public:
    Radiosity (Intersector   * i = NULL,
               int             q = 0,
               float           f = 0.0,
               bool            a = true)
        : _pIntersector(i),
          _quadLevel(q),
          _dFError(f),
          _useAmbient(a) {}
    
    virtual ~Radiosity () { _scenePatches.deleteAll(); }

    /*
     * BRDF employed by radiance-based methods is reduced to diffuse
     * coefficient. Dependency of reflection ration on azimuth and elevation
     * angles becames part of geometry term (form factors).
     */
    virtual void setBRDF (BRDF *) {}

    /*
     * Emittance is set for all patches in the setScene() function
     */
    virtual void setEmittance (Emittance *) {}

    /*
     * Initialize list of patches. Set them to facets of polygonal energy
     * coats found in the scene. The coats have to be facet-based
     * (see PoygonalEnergy class) and initialized
     * propositionally to emittance function of their original object.
     */
    virtual void setScene (Scene * /* scene */);

    /*
     * Instead of single point, whole scene is computed by radiance equation
     * evaluation. And because this evaluation is view-independent then
     * no argument is really used.
     */
    virtual Color3f* illuminatePoint (PointEnv&);
};

} // namespace

#endif // __RADIOSITY_H

---