Material.h

Go to the documentation of this file.

/* $Id: Material.h,v 1.1 2002/12/05 15:02:18 cvs Exp $ */

#ifndef __MATERIAL_H
#define __MATERIAL_H

#include <esg/visitor/Visitor.h>
#include <esg/ESGObject.h>

namespace esg {

/*
 * Usefull aliases first
 */

typedef Roughness    Shininess;
typedef Transparency Transmission;

/********************************************************************/
/*                    generic material                              */
/********************************************************************/

class OGSCENE_EXPORT Material : public ESGObject{
protected:
    virtual void _duplicate_attributes (const Material&) {}
    
public:
    virtual ~Material() {}
    virtual void      acceptVisitor (Visitor&) = 0;
    virtual Material* clone         ()  const  = 0;
};


/********************************************************************/
/*                    scalar-based materials                        */
/********************************************************************/

class OGSCENE_EXPORT _ScalarMat : public Material {
protected:
    float _val;

protected:
    virtual void _duplicate_attributes (const Material& src) {
        Material::_duplicate_attributes(src);
        _val = ((_ScalarMat&)src)._val;
    }

public:
    _ScalarMat (float v = 0.0) : _val(v) {}
    
    virtual void      acceptVisitor (Visitor&) = 0;
    virtual Material* clone         () const   = 0;
    virtual float     value         () const  { return _val; }
    virtual void      setValue      (float v) { _val = v; }
};


/*
 * Roughness/shininess defined in the [0.0, 1.0] or [0, 128] extent.
 * Roughness is ususally used as an exponent in specular reflection.
 */
class OGSCENE_EXPORT Roughness : public _ScalarMat {
public:
    Roughness (float v = 0.0) : _ScalarMat(v)       {}
    Roughness (int   v)       : _ScalarMat(v/128.0) {}

    virtual void      acceptVisitor (Visitor& v) { v.visitRoughness(this); }
    virtual Material* clone    (void) const { return new Roughness(_val); }
    virtual int       intValue (void) const { return (int)(_val * 128.0); }
};

/*
 * Index of refraction.
 */
class OGSCENE_EXPORT IndexOfRefraction : public _ScalarMat {
public:
    IndexOfRefraction (float v = 0.0) : _ScalarMat(v) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitIndexOfRefraction(this); }
    virtual Material* clone (void) const { return new IndexOfRefraction(_val); }
};




/********************************************************************/
/*                    vector-based materials                        */
/********************************************************************/

class OGSCENE_EXPORT _VectorMat : public Material {
protected:
    Vector3 _val;
    double  _avgVal;

protected:
    virtual void _duplicate_attributes (const Material& src) {
        Material::_duplicate_attributes(src);
        _val.set(((_VectorMat&)src)._val);
    }

public:
    _VectorMat (Vector3 v)
        : _val(v), _avgVal((v.x+v.y+v.z)/3.) {}
    
    _VectorMat (float x=.0, float y=.0, float z=.0) :
        _val(x,y,z), _avgVal((x+y+z)/3.) {}
    
    virtual void           acceptVisitor (Visitor&)   = 0;
    virtual Material*      clone         (void) const = 0;
    virtual const Vector3& value         (void) const { return _val; }

    virtual void setValue (const Vector3& v) {
        _val.set(v);
        _avgVal = (v.x+v.y+v.z) / 3.;
    }

    virtual void setValue (float x, float y, float z) {
        _val.set(x, y, z);
        _avgVal = (x+y+z) / 3.;
    }

    double avgValue (void) const { return _avgVal; }
};
    

/*
 * Specular coefficients for view-restricted reflection
 */
class OGSCENE_EXPORT Specular : public _VectorMat {
public:
    Specular (Vector3 v)                          : _VectorMat(v)     {}
    Specular (float x=.0, float y=.0, float z=.0) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitSpecular(this);  }
    virtual Material* clone (void) const { return new Specular(_val); }
};

/*
 * Diffuse coefficients for omnidirectional reflectance.
 * Usussually controls the basic surface color
 */
class OGSCENE_EXPORT Diffuse : public _VectorMat {
public:
    Diffuse (Vector3 v)                          : _VectorMat(v)     {}
    Diffuse (float x=.8, float y=.8, float z=.8) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitDiffuse(this);     }
    virtual Material* clone (void) const { return new Diffuse(_val); }
};

/*
 * Coefficients for illumination by global ambient light
 */
class OGSCENE_EXPORT Ambient : public _VectorMat {
public:
    Ambient (Vector3 v)                          : _VectorMat(v)     {}
    Ambient (float x=.2, float y=.2, float z=.2) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitAmbient(this);     }
    virtual Material* clone (void) const { return new Ambient(_val); }
};

/*
 * Transparency/refraction
 */
class OGSCENE_EXPORT Transparency : public _VectorMat {
public:
    Transparency (Vector3 v)                          : _VectorMat(v)     {}
    Transparency (float x=.0, float y=.0, float z=.0) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitTransparency(this);     }
    virtual Material* clone (void) const { return new Transparency(_val); }
};

/*
 * Reflection
 */
class OGSCENE_EXPORT Reflection : public _VectorMat {
public:
    Reflection (Vector3 v)                          : _VectorMat(v)     {}
    Reflection (float x=.0, float y=.0, float z=.0) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitReflection(this);     }
    virtual Material* clone (void) const { return new Reflection(_val); }
};  


/*
 * Fresnel term correspond to the color fo reflected white light with orhogonal
 * incidence. For dielectrics (like plastic, porcelain etc.) these
 * values are usually 1, meaning that a specular highlight has the color
 * of the light source.In contrast to this,
 * metals change the color of a highlight, e.g. gold has a
 * goldish highlight when the light incidents orthogonally
 * to the surface. At more grazing angles all these materials
 * change their highlight color to the color of the light source
 *
 * The Fresnel term is for example used by Cook-Torrance BRDF.
 */
class OGSCENE_EXPORT FresnelTerm : public _VectorMat {
public:
    FresnelTerm (Vector3 v)                             : _VectorMat(v)     {}
    FresnelTerm (float x=1.0, float y=1.0, float z=1.0) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitFresnelTerm(this);     }
    virtual Material* clone (void) const { return new FresnelTerm(_val); }
};

/*
 * Gaussian coefficient used for description of statistical distribution
 * in physically based micro-geometry modelling.
 *
 * The gaussian coefficient is for example used by Cook-Torrance BRDF.
 */
class OGSCENE_EXPORT GaussianCoef : public _VectorMat {
public:
    GaussianCoef (Vector3 v)                             : _VectorMat(v)     {}
    GaussianCoef (float x=1.0, float y=1.0, float z=1.0) : _VectorMat(x,y,z) {}
    
    virtual void acceptVisitor (Visitor& v) { v.visitGaussianCoef(this);     }
    virtual Material* clone (void) const { return new GaussianCoef(_val); }
};
    

}; // namespace

#endif // __MATERIAL_H

---