PhongBRDF.h

Go to the documentation of this file.

/* $Id: $ */

#ifndef __PHONG_BRDF_H
#define __PHONG_BRDF_H

#include <esg/Definitions.h>
#include <esg/visitor/MatVisitor.h>
#include <esg/brdf/SpecularBRDF.h>
#include <esg/geometry/Hemisphere.h>

namespace esg {

class OGSCENE_EXPORT PhongBRDF : public SpecularBRDF {
protected:
        virtual void _duplicate_attributes (const BRDF& src) {
            SpecularBRDF::_duplicate_attributes(src);
        }
        
public:
        PhongBRDF (void) : SpecularBRDF(true) {}

        virtual RetVal reflectance(const MatVisitor& visitor,
                                   const Vector3*    L,
                                   const Vector3*    V,
                                   const Vector3*    N,
                                   Vector3&          color) {
            if (!N || !L || !V) return BAD_PARAMS;
                  
            register double nl = N->dot(*L);
            if (nl <= 0.0) return NL_NEGATIVE;
        
            color.set(*N);
            color.scale(2.0 * nl);
            color.sub(*L);
            register double vr = V->dot(color); // vr = V * (N*(nl*2) - L)
            
            if (vr <= 0.0) return ZERO_CONTRIB;
            color.set(visitor.specular());
            color.scale(pow(vr, (double)visitor.intRoughness()) / nl);
            return NONZERO_CONTRIB;
        }
        
        virtual RetVal reflectanceVNL(const MatVisitor& visitor,
                                      const Vector3*    L,
                                      const Vector3*    V,
                                      const Vector3*    N,
                                      double            NV,
                                      double            NL,
                                      Vector3&          color) {
            if (!N || !L || !V) return BAD_PARAMS;
            
            color.set(*N);
            color.scale(2.0 * NL);
            color.sub(*L);
            register double vr = V->dot(color); // vr = V * (N*(nl*2) - L)
            
            if (vr <= 0.0) return ZERO_CONTRIB;
            color.set(visitor.specular());
            color.scale(pow(vr, (double)visitor.intRoughness()) / NL);
            return NONZERO_CONTRIB;
        }

        virtual RetVal reflectanceNL(const MatVisitor& visitor,
                                     const Vector3*    L,
                                     const Vector3*    V,
                                     const Vector3*    N,
                                     double            NL,
                                     Vector3&          color) {
            if (!N || !L || !V) return BAD_PARAMS;
            
            color.set(*N);
            color.scale(2.0 * NL);
            color.sub(*L);
            register double vr = V->dot(color); // vr = V * (N*(nl*2) - L)
            
            if (vr <= 0.0) return ZERO_CONTRIB;
            color.set(visitor.specular());
            color.scale(pow(vr, (double)visitor.intRoughness()) / NL);
            return NONZERO_CONTRIB;
        }
        
        virtual BRDF* clone (void) const { return new PhongBRDF(); }

        virtual double albedo (const MatVisitor& visitor,
                               const Vector3&    N,
                               const Vector3*    V) const {
            return ((V) ? (2. * PI * visitor.avgSpecular() /
                           (visitor.intRoughness()+2.) *
                           V->dot(N)) : -1.);
        }

        virtual void importanceSample(const MatVisitor& visitor,
                                      const Vector3&    D,
                                      double            r1,
                                      double            r2,
                                      Vector3&          dir,
                                      double*           pPDFVal) {
            Hemisphere h(D);
            dir.set(h.samplePriorToPoweredZenith(r1, r2,
                                                 visitor.intRoughness(),
                                                 pPDFVal));
        }

        virtual Vector2 dir2uv (const MatVisitor& visitor,
                                const Vector3&    N,
                                const Vector3&    D) const {
            Hemisphere h(N);
            return Vector2(h.dir2uvPriorToPoweredZenith(D, visitor.intRoughness()));
        }
};

}; // namespace

#endif // __PHONG_BRDF_H

---