media3d.h

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

    $Id: media3d_8h-source.html,v 1.1 2005/02/04 21:02:27 micha Exp $
    
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   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 "transparenttransformatable.h"
#include "vector.h"
#include "ray.h"
#include "colour.h"
#include "cameraray.h"
#include "lightsource.h"
#include "statistics.h"
#include "pigment3d.h"

class Media3D: public TransparentTransformatable {

public: // Static members
    static HitStatistics evaluations;

public: // Public type definitions
    enum scattertype {
        NONE,
        ISOTROPIC,
        RAYLEIGH,
        MIE_HAZY,
        MIE_MURKY,
        HENYEY_GREENSTEIN 
    };

    enum samplingmethod {
        LINEAR,
        RECURSIVE
    };
    
public: // Constructors and destructor
    Media3D(DBL jitteramouth, CLR tol, FLT variancekeepfactor, samplingmethod m):
      jitter(jitteramouth), coltolerance(tol), varkeep(variancekeepfactor),
      method(m) {}

    virtual ~Media3D() {}

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

public: // Public methods
    virtual Media3D* copy() const = 0;

    Colour sample(DBL start, DBL end, const CameraRay& r, Colour& absorb);
    
    void sample(DBL start, DBL end, const LightRay& r, Colour& absorb);

public: // Pure virtual methods
    virtual Colour evaluateEmit(const Vector3& p, const CameraRay& r, CLR allowederror, FLT& ilength) const = 0;

    virtual Colour evaluateAbsorb(const Vector3& p) const = 0;

protected: // Protected attributes    
    DBL jitter;
    CLR coltolerance;
    FLT varkeep;    
    samplingmethod method;    

private: // Private Methods
    Colour sampleRecursive(
      const CameraRay& ray, DBL l, DBL m, DBL r,
      const Colour&, const Colour&, const Colour&,
      Colour&, const DBL il);

    void sampleRecursive(const LightRay& ray, DBL l, DBL m, DBL r,
      const Colour&, const Colour&, const Colour&, Colour& end_absorb);

    Colour simps(const Colour& c1, const Colour& c2, const Colour& c3);
    Colour simpsExp(const Colour& c1, const Colour& c2, const Colour& c3,
                    const Colour& a1, const Colour& a2, const Colour& a3,
                    DBL h);

};

class Media3DSingle : public Media3D  {

public: // Constructors and destructor
    Media3DSingle(const Colour& emitting, const Colour& absorbing,
      const Colour& scattering, scattertype t, const Scene* s,
      DBL jitter, CLR tol, FLT variancekeep, samplingmethod m);

    ~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);}
    Colour evaluateEmit(const Vector3& p, const CameraRay& r, CLR maxerror, FLT& ilength) const;
    Colour evaluateAbsorb(const Vector3& p) const;

private: // Private attributes
    Colour emit, absorb, scatter;
    Pigment3D* density;
    const Scene* scene;
    scattertype stype;    
};


class Media3DMultiple: public Media3D {

public: // Constructor and destructor
    Media3DMultiple(DBL jitteramouth, CLR tol, FLT variancekeep, samplingmethod m);

    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);}
    Colour evaluateEmit(const Vector3& p, const CameraRay& r, CLR maxerror, FLT& ilength) const;
    Colour evaluateAbsorb(const Vector3& p) const;
    

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

};

#endif

---