surface_material.h

#pragma once
 
#include <complex>
#include <cgv/media/color.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace media { 
        namespace illum {
 
enum BrdfType {
    BT_LAMBERTIAN = 0, // use lambertian for diffuse part
    BT_OREN_NAYAR = 1, // use oren nayar for diffuse part
    BT_STRAUSS_DIFFUSE = 2, // use diffuse part of strauss model for diffuse part
                       // reserve one more diffuse models for future use
    BT_PHONG = 4,      // shininess in range [1,128] is computed roughness
    BT_BLINN = 8,      // shininess in range [1,128] is computed roughness
    BT_COOK_TORRANCE = 12,
    BT_STRAUSS = 16
};
 
class CGV_API surface_material
{
public:
    typedef color<float,RGB> color_type;
protected:
    BrdfType brdf_type;
    color_type diffuse_reflectance;
    float roughness;
    float metalness;
    float ambient_occlusion;
    color_type emission;
    float transparency;
    std::complex<float> propagation_slow_down;
    float roughness_anisotropy;
    float roughness_orientation;
    color_type specular_reflectance;
public: //@<
    surface_material(
        BrdfType _brdf_type = BrdfType(BT_STRAUSS_DIFFUSE + BT_STRAUSS),
        color_type _diffuse_reflectance = color_type(0.5f, 0.5f, 0.5f),
        float _roughness = 0.5f,
        float _metalness = 0.0f,
        float _ambient_occlusion = 1.0f,
        color_type _emission = color_type(0,0,0),
        float _transparency = 0.0f,
        const std::complex<float>& _propagation_slow_down = std::complex<float>(1.5f,0.0f),
        float _roughness_anisotropy = 0.0f,
        float _roughness_orientation = 0.0f,
        color_type _specular_reflectance = color_type(1,1,1)
    );
 
    void set_brdf_type(BrdfType brdf_type) { this->brdf_type = brdf_type; }
    BrdfType get_brdf_type() const { return brdf_type; }
    BrdfType& ref_brdf_type() { return brdf_type; }
 
    void set_ambient_occlusion(float ambient_occlusion) { this->ambient_occlusion = ambient_occlusion; }
    float get_ambient_occlusion() const { return ambient_occlusion; }
    float& ref_ambient_occlusion() { return ambient_occlusion; }
 
    void set_diffuse_reflectance(color_type diffuse_reflectance) { this->diffuse_reflectance = diffuse_reflectance; }
    color_type get_diffuse_reflectance() const { return diffuse_reflectance; }
    color_type& ref_diffuse_reflectance() { return diffuse_reflectance; }
 
    void set_specular_reflectance(color_type specular_reflectance) { this->specular_reflectance = specular_reflectance; }
    color_type get_specular_reflectance() const { return specular_reflectance; }
    color_type& ref_specular_reflectance() { return specular_reflectance; }
 
    void set_emission(color_type emission) { this->emission = emission; }
    color_type get_emission() const { return emission; }
    color_type& ref_emission() { return emission; }
 
    void set_transparency(float transparency) { this->transparency = transparency; }
    float get_transparency() const { return transparency; }
    float& ref_transparency() { return transparency; }
 
    void set_roughness(float roughness) { this->roughness = roughness; }
    float get_roughness() const { return roughness; }
    float& ref_roughness() { return roughness; }
 
    void set_metalness(float metalness) { this->metalness = metalness; }
    float get_metalness() const { return metalness; }
    float& ref_metalness() { return metalness; }
 
    void set_roughness_anisotropy(float roughness_anisotropy) { this->roughness_anisotropy = roughness_anisotropy; }
    float get_roughness_anisotropy() const { return roughness_anisotropy; }
    float& ref_roughness_anisotropy() { return roughness_anisotropy; }
 
    void set_roughness_orientation(float roughness_orientation) { this->roughness_orientation = roughness_orientation; }
    float get_roughness_orientation() const { return roughness_orientation; }
    float& ref_roughness_orientation() { return roughness_orientation; }
 
    void set_propagation_slow_down(std::complex<float> propagation_slow_down) { this->propagation_slow_down = propagation_slow_down; }
    std::complex<float> get_propagation_slow_down() const { return propagation_slow_down; }
    std::complex<float>& ref_propagation_slow_down() { return propagation_slow_down; }
};
 
enum StandardMaterial
{
    // transparent
    SM_WATER,
    SM_GLASS,
 
    // metals
    SM_ALUMINUM,
    SM_SILVER,
    SM_COPPER,
    SM_GOLD
};
 
extern CGV_API const surface_material& get_surface_material(StandardMaterial material_id);
 
        }
    }
}
 
#include <cgv/config/lib_end.h>