CookTorranceBRDF.cc

Go to the documentation of this file.

#include <esg/brdf/CookTorranceBRDF.h>

using namespace esg;

BRDF::RetVal CookTorranceBRDF::reflectance(const MatVisitor& visitor,
                                           const Vector3*    L,
                                           const Vector3*    V,
                                           const Vector3*    N,
                                           Vector3&          color)
{
    static Vector3 H;
    
    /*
     * Precomputation of vectors and angles (Blinn-like)
     */
    if (!N || !L || !V) return BAD_PARAMS;

    register double nv = N->dot(*V);
    if (nv <= 0.0) return NV_NEGATIVE;
    register double nl = N->dot(*L);
    if (nl <= 0.0) return NL_NEGATIVE;
    H.set(*V);
    H.add(*L);
    H.scale(0.5);
    register double hn = H.dot(*N);

    /*
     * modelling micro-geometry (normal distribution function):
     *    D = k exp[-(alpha/m)^2]
     * where
     *    k     = any constant
     *    alpha = angle of the microfacet with respect to the normal of the
     *            (mean) surface = NH
     *    m     = standard deviation the distribution
     */
    color.set(visitor.gaussianCoef());
    color.scale(exp(-pow(acos(hn)/visitor.roughness(),2)));

    /*
     * shadowing and masking effects:
     *    Gm = 2(NH)(NV)/VH
     *    Gs = 2(NH)(NL)/VH
     *    G  = min{1, Gm, Gs}
     */
    double aux = (2 * hn) / H.dot(*V);
    double Gm  = aux * nv;
    double Gs  = aux * nl;
    double G   = 1;
    if (Gm < G) G = Gm;
    if (Gs < G) G = Gs;

#ifndef WIN32
#warning "TODO: Interpolated Fresnel term"
#endif
    /*
     * the Fresnel term:
     *    F_a = F0 + (1 - cos a)^5 (1 - F0)
     * where
     *    F0 = value of F at normal incidence, can be computed as
     *        F0 = (n-1)^2 / (n+1)^2
     *    where
     *        n = refractive index of material (zero for dielectric = plastic)
     */
    Vector3 F(visitor.fresnelTerm());
    Vector3 F0(1,1,1);
    F0.sub(F);
    F0.scale(pow(1-nl,5));
    F.add(F0);

    /*
     * Specular component:
     *    s*(DGF/(NV))
     * where
     *    NV = glare effect term (view geometry)
     *    s  = specular coefficients
     */
    F.scale(G/nv);
    //c.x *= F.x * visitor.specular().x;
    //c.y *= F.y * visitor.specular().y;
    //c.z *= F.z * visitor.specular().z;
    color.x *= F.x;
    color.y *= F.y;
    color.z *= F.z;

    /*
     * Diffuse component:
     *    well-known Lambertian reflection
     */
    Vector3 auxv(visitor.diffuse());
    auxv.scale(nl);
    color.add(auxv);

    /*
     * Final formula:
     *    BRDF = sR_s + dR_d
     * where
     *    R_s = specular component DGF/(NV)
     *    R_d = Lambertian diffuse component
     *    s   = specular coefficient
     *    d   = diffuse coefficient
     *    s+d = 1
     */
    
    return NONZERO_CONTRIB;
}

BRDF::RetVal CookTorranceBRDF::reflectanceVNL(const MatVisitor& visitor,
                                              const Vector3*    L,
                                              const Vector3*    V,
                                              const Vector3*    N,
                                              double            NV,
                                              double            NL,
                                              Vector3&          color)
{
    static Vector3 H;
    
    /*
     * Precomputation of vectors and angles (Blinn-like)
     */
    if (!N || !L || !V) return BAD_PARAMS;

    H.set(*V);
    H.add(*L);
    H.scale(0.5);
    register double hn = H.dot(*N);

    /*
     * modelling micro-geometry (normal distribution function):
     *    D = k exp[-(alpha/m)^2]
     * where
     *    k     = any constant
     *    alpha = angle of the microfacet with respect to the normal of the
     *            (mean) surface = NH
     *    m     = standard deviation the distribution
     */
    color.set(visitor.gaussianCoef());
    color.scale(exp(-pow(acos(hn)/visitor.roughness(),2)));

    /*
     * shadowing and masking effects:
     *    Gm = 2(NH)(NV)/VH
     *    Gs = 2(NH)(NL)/VH
     *    G  = min{1, Gm, Gs}
     */
    double aux = (2 * hn) / H.dot(*V);
    double Gm  = aux * NV;
    double Gs  = aux * NL;
    double G   = 1;
    if (Gm < G) G = Gm;
    if (Gs < G) G = Gs;

#ifndef WIN32
#warning "TODO: Interpolated Fresnel term"
#endif
    /*
     * the Fresnel term:
     *    F_a = F0 + (1 - cos a)^5 (1 - F0)
     * where
     *    F0 = value of F at normal incidence, can be computed as
     *        F0 = (n-1)^2 / (n+1)^2
     *    where
     *        n = refractive index of material (zero for dielectric = plastic)
     */
    Vector3 F(visitor.fresnelTerm());
    Vector3 F0(1,1,1);
    F0.sub(F);
    F0.scale(pow(1-NL,5));
    F.add(F0);

    /*
     * Specular component:
     *    s*(DGF/(NV))
     * where
     *    NV = glare effect term (view geometry)
     *    s  = specular coefficients
     */
    F.scale(G/NV);
    color.x *= F.x * visitor.specular().x;
    color.y *= F.y * visitor.specular().y;
    color.z *= F.z * visitor.specular().z;

    /*
     * Diffuse component:
     *    well-known Lambertian reflection
     */
    Vector3 auxv(visitor.diffuse());
    auxv.scale(NL);
    color.add(auxv);

    /*
     * Final formula:
     *    BRDF = sR_s + dR_d
     * where
     *    R_s = specular component DGF/(NV)
     *    R_d = Lambertian diffuse component
     *    s   = specular coefficient
     *    d   = diffuse coefficient
     *    s+d = 1
     */
    
    return NONZERO_CONTRIB;
}

BRDF::RetVal CookTorranceBRDF::reflectanceNL(const MatVisitor& visitor,
                                             const Vector3*    L,
                                             const Vector3*    V,
                                             const Vector3*    N,
                                             double            NL,
                                             Vector3&          color)
{
    static Vector3 H;
    
    /*
     * Precomputation of vectors and angles (Blinn-like)
     */
    if (!N || !L || !V) return BAD_PARAMS;

    register double nv = N->dot(*V);
    if (nv <= 0.0) return NV_NEGATIVE;
    H.set(*V);
    H.add(*L);
    H.scale(0.5);
    register double hn = H.dot(*N);

    /*
     * modelling micro-geometry (normal distribution function):
     *    D = k exp[-(alpha/m)^2]
     * where
     *    k     = any constant
     *    alpha = angle of the microfacet with respect to the normal of the
     *            (mean) surface = NH
     *    m     = standard deviation the distribution
     */
    color.set(visitor.gaussianCoef());
    color.scale(exp(-pow(acos(hn)/visitor.roughness(),2)));

    /*
     * shadowing and masking effects:
     *    Gm = 2(NH)(NV)/VH
     *    Gs = 2(NH)(NL)/VH
     *    G  = min{1, Gm, Gs}
     */
    double aux = (2 * hn) / H.dot(*V);
    double Gm  = aux * nv;
    double Gs  = aux * NL;
    double G   = 1;
    if (Gm < G) G = Gm;
    if (Gs < G) G = Gs;

#ifndef WIN32
#warning "TODO: Interpolated Fresnel term"
#endif
    /*
     * the Fresnel term:
     *    F_a = F0 + (1 - cos a)^5 (1 - F0)
     * where
     *    F0 = value of F at normal incidence, can be computed as
     *        F0 = (n-1)^2 / (n+1)^2
     *    where
     *        n = refractive index of material (zero for dielectric = plastic)
     */
    Vector3 F(visitor.fresnelTerm());
    Vector3 F0(1,1,1);
    F0.sub(F);
    F0.scale(pow(1-NL,5));
    F.add(F0);

    /*
     * Specular component:
     *    s*(DGF/(NV))
     * where
     *    NV = glare effect term (view geometry)
     *    s  = specular coefficients
     */
    F.scale(G/nv);
    color.x *= F.x * visitor.specular().x;
    color.y *= F.y * visitor.specular().y;
    color.z *= F.z * visitor.specular().z;

    /*
     * Diffuse component:
     *    well-known Lambertian reflection
     */
    Vector3 auxv(visitor.diffuse());
    auxv.scale(NL);
    color.add(auxv);

    /*
     * Final formula:
     *    BRDF = sR_s + dR_d
     * where
     *    R_s = specular component DGF/(NV)
     *    R_d = Lambertian diffuse component
     *    s   = specular coefficient
     *    d   = diffuse coefficient
     *    s+d = 1
     */
    
    return NONZERO_CONTRIB;
}

---