RayTracing.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __RAY_TRACING_H
#define __RAY_TRACING_H

#include <gra/reflection/ReflectionModel.h>
#include <gra/reflection/LocalReflection.h>
#include <esg/Intersector.h>
#include <esg/RefrCoefs.h>
#include <esg/visitor/MatVisitor.h>
#include <esg/explorer/RayIntExplorer.h>
#include <esg/texture/Texture.h>


/*
 * Global reflection model solving the rendering equation employing
 * the classical Whitted ray-tracing.
 *
 * Default medium refraction is refraction of surrounding environment.
 * This is the refraction of air by default (RERF_AIR) but arbitrary value can
 * be used, e.g. refraction of water for underwater scenes (REFR_WATER_20C).
 */

using namespace esg;

namespace gra {

class GRA_EXPORT RayTracing : public ReflectionModel {
#ifdef ESG_STATISTICS
protected:
    unsigned long _numReflections;
    unsigned long _numRefractions;
#endif // ESG_STATISTICS
    
protected:
    AutoPtr<LocalReflection> * _pAReflection;
    Color3f                    _background;
    Intersector              * _pIntersector;
    unsigned                   _maxDepth;     // Maximal depth for recursion
    float                      _minRayWeight; // Min. treshold for refl rays
    float                      _defaultMediumRefraction;
    LocalReflection          * _pLocalReflection;
    RayIntExplorer             _riExplorer;
    Texture                  * _pTexture;

    Sgi::hash_map<SceneGraphObject::OID, MatVisitor*> _matCache;

    enum RefrDir {
        REFR_DIR_REFLECTION,  // reflection inside medium
        REFR_DIR_REFRACTION   // refraction into another medium
    };

protected:
    void _check_point_of_intersection (PointEnv&) const;
    MatVisitor* _check_material       (SceneGraphObject*, bool);
    PointEnv*   _cast_ray             (const Vector3&, const Vector3&);
    void        _apply_texture        (PointEnv&, Color3f&);
    void        _apply_texture        (PointEnv&, Vector3&);
    void        _direct_illumination  (PointEnv&, MatVisitor&,
                                       unsigned,Color3f&);
    
    RefrDir _refraction_dir (PointEnv&, MatVisitor&, bool, Vector3&);
    void    _reflection_dir (PointEnv&, Vector3&);

    virtual void _cast_secondary_rays (PointEnv&, unsigned, bool, Color3f&,
                                       MatVisitor&);
    virtual void _illuminate (PointEnv&, unsigned, bool, Color3f&);

public:
    RayTracing (AutoPtr<LocalReflection> * r = NULL,
                const Color3f            & bg= Color3f(0,0,0), /*Background  */
                Intersector              * i = NULL,
                unsigned                   d = 1,   /*Max depth of recursion */
                float                      w = .001,/*Minimal weight of rays */
                float                      f = REFR_AIR/* default refraction*/)
        : _pAReflection(r),
          _background(bg),
          _pIntersector(i),
          _maxDepth(d),
          _minRayWeight(w),
          _defaultMediumRefraction(f),
          _riExplorer(Vector3(0,0,0), Vector3(0,0,0), NULL),
          _pTexture(NULL)
    {
        if (_pAReflection) {
            _pAReflection->registerReferer(this);
            _pLocalReflection = _pAReflection->origObject();
        } else
            _pLocalReflection = NULL;
    }

    virtual ~RayTracing () {
        if (_pAReflection)
            AutoPtr<LocalReflection>::destroy(_pAReflection, this);
        // TO DO: _matCache !!!
    }

    virtual void setDiffuseBRDF (DiffuseBRDF * b)
    {
        ReflectionModel::setDiffuseBRDF(b);
        if (_pLocalReflection) _pLocalReflection->setDiffuseBRDF(b);
    }

    virtual void setSpecularBRDF (SpecularBRDF * b)
    {
        ReflectionModel::setSpecularBRDF(b);
        if (_pLocalReflection) _pLocalReflection->setSpecularBRDF(b);
    }
    
    virtual void setEmittance (Emittance * e)
    {
        ReflectionModel::setEmittance(e);
        if (_pLocalReflection) _pLocalReflection->setEmittance(e);
    }
    
    virtual void setScene (Scene * s)
    {
        ReflectionModel::setScene(s);
        if (_pLocalReflection) _pLocalReflection->setScene(s);
    }

    /*
     * Required input parametters:
     *   PointEnv.intersection  = point of interest (PoI)
     *   PointEnv.pVisitableObj = object of interest
     *   PointEnv.normal        = surface normal at PoI
     *   PointEnv.viewerDir     = normalized direction from PoI to viewer
     *   PointEnv.distance      = distance between PoI and viewer 
     * [ PointEnv.trMat         = possible transformation ]
     * [ PointEnv.energy        = initial ray energy, default = (1,1,1) ]
     */
    virtual Color3f* illuminatePoint(PointEnv & /* point of interest */);

    void setIntersector (Intersector * i) { _pIntersector = i; }
};


} // namespace

#endif // __RAY_TRACING_H

---