LocalReflection.h

Go to the documentation of this file.

/* $Id: LocalReflection.h,v 1.1 2002/12/05 15:08:03 cvs Exp $ */

#ifndef __LOCAL_REFLECTION_H
#define __LOCAL_REFLECTION_H

#include <gra/reflection/ReflectionModel.h>
#include <esg/explorer/LightsExplorer.h>
#include <esg/Intersector.h>

/*
 * Local reflection computes only local illumination of single point.
 * Any BRDF is treated by this reflection model.
 *
 * ShadowDetection parameter determines how are a shadows tested.
 * SD_NONE               - no light source visibility test is performed
 * SD_RAY_FROM_EMITTANCE - either emittance location or direction is used
 *                         for light position estimation
 * SD_GEOMETRY_SAMPLING  - we get random samples from the geometry of light
 *                         to get its position. If no geometry is specified for
 *                         the light then SD_RAY_FROM_EMITTANCE is
 *                         automatically used.
 *
 * _lightTests determines number of illumination tests per single light.
 *   0  - Light sources are ignored
 *   1  - Single test per light source, typically used in combination with
 *        SD_NONE (= classical local illumination),
 *        SD_RAY_FROM_EMITTANCE (= Whitted ray tracing) and
 *        SD_GEOMETRY_SAMPLING (= Monte Carlo ray tracing)
 *   >1 - Ignored in combination with SD_NONE and SD_RAY_FROM_EMITTANCE,
 *        1 is used instead.
 *        Together with SD_GEOMETRY_SAMPLING we get soft shadows.
 *
 */

using namespace esg;

namespace gra {

class GRA_EXPORT LocalReflection : public ReflectionModel {
public:
    enum ShadowDetection {
        SD_NONE,
        SD_RAY_FROM_EMITTANCE,
        SD_GEOMETRY_SAMPLING
    };
    
protected:
    LightArray     * _pLights;
    ShadowDetection  _shadowDetection;
    unsigned         _lightTests; // number of illumination tests per light
    unsigned         _numCaches; // caches of bjects blocking lights
    unsigned         _useCache;  // if >= _numCaches then does not use cache
    
protected:
    bool _light_visible (unsigned, const Vector3&, double, const Vector3&,
                         SceneGraphObject::OID);

public:
    LocalReflection (DiffuseBRDF   * db /* BRDF                   */ = NULL,
                     SpecularBRDF  * sb /* BRDF                   */ = NULL,
                     Emittance     * e  /* emittance              */ = NULL,
                     ShadowDetection s                               = SD_NONE,
                     unsigned        ns /* number tests per light */ = 1,
                     unsigned        c  /* num. of caches         */ = 0,
                     unsigned        u  /* which cache to use     */ = 1);

    virtual ~LocalReflection () { if (_pLights) delete _pLights; }

    virtual void setScene (Scene *);

    /*
     * Required input parametters,
     * viwerDir() and distance() have to be defined together:
     *   PointEnv.intersection()    = point of interest (PoI)
     *   PointEnv.normal()          = surface normal at PoI
     *   PointEnv.visitableObject() = surface of interest
     * [ PointEnv.viewerDir()       = normalized direction from PoI to viewer
     *   PointEnv.distance()        = distance between PoI and viewer ]
     */
    virtual Color3f* illuminatePoint(PointEnv & /* point of interest */);

    /*
     * As above but material coefficients are set in visitor
     * instead of being inspected internally
     *
     * Required input parametters,
     * viwerDir() and distance() have to be defined together:
     *   PointEnv.intersection()    = point of interest (PoI)
     *   PointEnv.normal()          = surface normal at PoI
     * [ PointEnv.viewerDir()       = normalized direction from PoI to viewer
     *   PointEnv.distance()        = distance between PoI and viewer ]
     */
    virtual Color3f* illuminatePoint(PointEnv   & /* point of interest  */,
                                     MatVisitor & /* intialized visitor */);
    const LightArray * lights (void) const { return _pLights; }

    unsigned getBlockingObjCaches   (void) const { return _numCaches; }
    unsigned getActBlockingObjCache (void) const { return _useCache;  }
    void     setActBlockingObjCache (unsigned i) { _useCache = i;     }
    void     blockingObjCacheOff    (void)       { _useCache = _numCaches; }
};
    
} // namespace

#endif // __LOCAL_REFLECTION_H

---