checkermaterial.h

Go to the documentation of this file.

#ifndef CHECKERMATERIAL_H
#define CHECKERMATERIAL_H

#include "raytrace_defs.h"
#include "material.h"
#include "pluginfactory.h"
#include "scene.h"

Material * new_checker_material(std::map<std::string, std::string> props);
void delete_checkermaterial(Material * checker_material);

class CheckeredMaterial : public Material {

    class StaticInit {
        public:
            StaticInit() {
                MaterialFactory::get_instance()->registerPlugin("checkered", sigc::ptr_fun(new_checker_material));
            }
    };
    static StaticInit m_init;


    protected:
    Material *  m_material_one;

    Material *  m_material_two;

    // TODO: deprecate this.  There are much better approaches to scaling
    // things that could be utilized
    double      m_scale;

    int choose_material(const Point3D& intersection_point) const ;

    public:
    CheckeredMaterial(Material * one, Material * two, double scale) {
        m_material_one = one;
        m_material_two = two;
        m_scale = scale;
    }

    CheckeredMaterial(const CheckeredMaterial &other) :  m_material_one(other.m_material_one),
    m_material_two(other.m_material_two),
    m_scale(other.m_scale)

    {
    }


    virtual ~CheckeredMaterial() {
        //delete m_color;
    }

    virtual Magick::Color get_color(const Point3D& intersesction_point) const; 

    virtual bool is_light(const Point3D& intersesction_point) const; 

    virtual void set_is_light(bool v); 

    virtual double get_diffuse(const Point3D& intersesction_point) const; 

    virtual void set_diffuse(double diffuse); 

    virtual double get_reflection(const Point3D& intersesction_point) const; 

    virtual double get_reflectivity(const Point3D& intersesction_point) const; 

    virtual double get_refraction_index(const Point3D& intersesction_point) const; 

    virtual double get_opacity(const Point3D& intersesction_point) const; 

    virtual void set_opacity(double opacity); 

    public:
    static Material * createCheckeredMaterial(std::map<std::string, std::string>);
};

Material * new_checker_material(std::map<std::string, std::string> props) {
    Scene * scene  = Scene::get_instance();
    Material * one = scene->get_material(props["material1"]);
    Material * two = scene->get_material(props["material2"]);

    // TODO: this is done so many times it really needs a helper function
    double scale = props.count("scale") > 0 ?
        (double)strtod(props["scale"].c_str(), NULL)       :  1.0;

    return new CheckeredMaterial(one, two, scale);

}

#endif

---