Emittance.h

Go to the documentation of this file.

/* $Id:$ */

#ifndef __EMITTANCE_H
#define __EMITTANCE_H

#include <esg/Definitions.h>
#include <esg/ESGObject.h>
#include <esg/Export>

/*
 * Emission of energy in given direction (point)
 *
 * The _fadeDistance is used to specify the distance at which the full light
 * intensity arrives. The actual attenuation is described by the _fadePower,
 * which determines the falloff rate. For example linear or quadratic falloff
 * can be used by setting _fadePower to 1 or 2 respectively.
 * The complete formula to calculate the factor by which the light is
 * attenuated is:
 *
 * attenuation = 1.0 if _fadeDistance <= 0 or _fadePower <= 0
 *             = 1.0 if actual distance is less then _fadeDistance
 *             = 2/(1+(dist/_fadeDisstance)^_fadePower) otherwise
 *
 * You should note two important facts: First, for _fadeDistance larger than
 * one the light intensity at distances smaller than _fadeDistance actually
 * increases. This is necessary to get the light source color if the distance
 * traveled equals the _fadeDistance.
 *
 * Energy source can be either fixed, i.e. emitting photons according to
 * its fixed location/direction, or it can be transformed to fit the geometry
 * of light source.
 */

namespace esg {

class OGSCENE_EXPORT Emittance : public ESGObject {
protected:
    Vector3 _location;  
    bool    _haveLocation;
    Vector3 _direction; 
    bool    _haveDirection;
    Color3f _intensity;
    double  _fadeDistance;  // distance w/o attenuation
    double  _fadePower;     // attenuation speed (0=off, 1=linear, 2=quadratic)
    bool    _attenuate;     // whether to attenuate or not
    bool    _fitToGeometry; 

protected:
    virtual void _duplicate_attributes (const Emittance& src) {
        _intensity.set(((Emittance&)src)._intensity);
        _direction.set(((Emittance&)src)._direction);
        _location.set(((Emittance&)src)._location);
        _haveLocation  = ((Emittance&)src)._haveLocation;
        _haveDirection = ((Emittance&)src)._haveDirection;
        _fadeDistance  = ((Emittance&)src)._fadeDistance;
        _fadePower     = ((Emittance&)src)._fadePower;
        _attenuate     = ((Emittance&)src)._attenuate;
    }

    Emittance () {}

public:
    Emittance (const Vector3&  loc,
               bool            haveLoc,
               const Vector3&  dir,
               bool            haveDir,
               const Color3f&  inten = Color3f(1,1,1),
               double          fadeDist  = .0,
               double          fadePower = .0,
               bool            fitToGeom = true)
        : _location(loc), _haveLocation(haveLoc),
          _direction(dir), _haveDirection(haveDir),
          _intensity(inten),
          _fadeDistance(fadeDist),
          _fadePower(fadePower),
          _attenuate((_fadeDistance >= .0 && _fadePower > .0) ? true : false),
          _fitToGeometry(fitToGeom) {}

    virtual ~Emittance () {}

    virtual Emittance* clone () const = 0;

            bool intensity (Color3f& c) const {c.set(_intensity); return true;}
    virtual bool intensity (const Vector3& /* view point */,
                            Color3f&       /* intensity  */) const = 0;
    virtual bool intensity (const Vector3& /* emittance direction */,
                            float          /* emittance distance  */,
                            Color3f&       /* intensity           */) const=0;

    virtual bool stochasticEmission (Vector3& /* stochastic dir. */) = 0;


    bool beamDirection (Vector3& d) const {
        if (_haveDirection) d.set(_direction);
        return _haveDirection;
    }

    bool setBeamDirection (const Vector3& d) {
        if (_haveDirection) _direction.set(d);
        return _haveDirection;
    }

    bool sourceLocation (Vector3& v) const {
        if (_haveLocation) v.set(_location);
        return _haveLocation;
    }

    bool setSourceLocation (const Vector3& v) {
        if (_haveLocation) _location.set(v);
        return _haveLocation;
    }

    bool haveLocation  (void) const { return _haveLocation;  }
    bool haveDirection (void) const { return _haveDirection; }
    bool fitToGeometry (void) const { return _fitToGeometry; }

    double fadeDistance (void) const { return _fadeDistance; }
    double fadePower    (void) const { return _fadePower;    }
};


#define ESG_ATTENUATION(__d, __c) { \
   if (_attenuate && (__d > _fadeDistance)) \
      (__c).scale(2.0 / (1.0 + pow(((_fadeDistance > 0.) ? (__d) / _fadeDistance : (__d)), _fadePower))); }
    
}; // namespace

#endif // __EMITTANCE_H

---