Source: raytracer/media3d.h

/* *************************************************************************
                          media3d.h  -  description
                             -------------------
    begin                : Wed Oct 16 2002        
    copyright            : (C) 2002 by Micha Riser
    email                : mriser@gmx.net
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ************************************************************************* */

#ifndef MEDIA3D_H
#define MEDIA3D_H

#include<vector>

#include "transformatable.h"
#include "object3d.h"
#include "vector.h"
#include "ray.h"
#include "colour.h"
#include "cameraray.h"
#include "lightsource.h"
#include "statistics.h"
#include "pigment3d.h"

//class LightCache;

/**Volumetric media.
  *@author Micha Riser
  */
class Media3D: public Transformatable {

public: // Static members
    static HitStatistics evaluations;

public: // Public type definitions
    enum scattertype {
        NONE,
        ISOTROPIC,
        RAYLEIGH,
        MIE_HAZY,
        MIE_MURKY,
        HENYEY_GREENSTEIN 
    };
    
public: // Constructors and destructor
    Media3D(DBL jitteramouth, CLR tol1, CLR tol2):
      jitter(jitteramouth), coltolerance(tol1), colblocktolerance(tol2) {}

    virtual ~Media3D() {}

private:
    Media3D& operator=(const Media3D&);

public: // Public methods
    /**Integrate media contribution over ray interval.
      */
    Colour3 sample(DBL start, DBL end, const CameraRay& r, Colour3& absorb);
    
    /**Integrate absorbtion value over ray interval.
      */
    void sample(DBL start, DBL end, const LightRay& r, Colour3& absorb);

public: // Pure virtual methods
    /**Get emitting colour at location.
      */
    virtual Colour3 evaluateEmit(const Vector3& p, const CameraRay& r, CLR& maxerr, DBL precision) const = 0;

    /**Get absorbing colour at location.
      */
    virtual Colour3 evaluateAbsorb(const Vector3& p) const = 0;

    /**Copy media.
      */
    virtual Media3D* copy() const = 0;

private: // Private attributes
    DBL jitter;
    CLR coltolerance;
    CLR colblocktolerance;

private: // Private Methods
    Colour3 sampleRecursive(
      const CameraRay& ray, DBL l, DBL m, DBL r,
/*      const Colour3&, const Colour3&, const Colour3&,*/
      const Colour3&, const Colour3&, const Colour3&,
      Colour3&);
  
    void sampleRecursive(const LightRay& ray, DBL l, DBL m, DBL r,
      const Colour3&, const Colour3&, const Colour3&, Colour3& end_absorb);
  
    Colour3 simps(const Colour3& c1, const Colour3& c2, const Colour3& c3);

};

/**Single media.
  *@author Micha Riser
  */
class Media3DSingle : public Media3D  {

public: // Constructors and destructor
    Media3DSingle(const Colour3& emitting, const Colour3& absorbing,
      const Colour3& scattering, scattertype t, const Scene* s,
      DBL jitter, CLR tol1, CLR tol2);

    ~Media3DSingle();

private:
    Media3DSingle(const Media3DSingle&);

public: // Public methods (inherited from Media3D)

    void setDensity(Pigment3D* map) {delete(density); density = map;}

    Media3D* copy() const {return new Media3DSingle(*this);}
    Colour3 evaluateEmit(const Vector3& p, const CameraRay& r, CLR& maxerror, DBL precision) const;
    Colour3 evaluateAbsorb(const Vector3& p) const;

private: // Private attributes
    Colour3 emit, absorb, scatter;
    scattertype stype;
    Pigment3D* density;
    const Scene* scene;
    CLR scatternorm;

};

/**Multiple media.
  *@author Micha Riser
  */
class Media3DMultiple: public Media3D {

public: // Constructor and destructor
    Media3DMultiple(DBL jitteramouth, CLR tol1, CLR tol2);

    Media3DMultiple(const Media3D* m);

    ~Media3DMultiple();

private:
    Media3DMultiple(const Media3DMultiple& m);

public: // Public methods

    void addMedia(const Media3D* m) {
        list.push_back(m);
    }
    
    // Inherited from Media3D
    Media3D* copy() const {return new Media3DMultiple(*this);}
    Colour3 evaluateEmit(const Vector3& p, const CameraRay& r, CLR& maxerror, DBL precision) const;
    Colour3 evaluateAbsorb(const Vector3& p) const;
    

private: // Private attributes
    std::vector<const Media3D*> list;

};
  


#endif