noisematerial.h

Go to the documentation of this file.

#ifndef NOISEMATERIAL_H
#define NOISEMATERIAL_H

#include "raytrace_defs.h"
#include "material.h"
#include "pluginfactory.h"
#include "noise.h"
#include "color.h"

Material * make_noise_material(std::map<std::string, std::string> props);


class NoiseMaterial : public Material{
    class StaticInit
    {
        public:
            StaticInit()
            {
                log_info("Registering as \"noise\" and \"cloud\"");
                MaterialFactory::get_instance()->registerPlugin("noise", sigc::ptr_fun(make_noise_material));
                MaterialFactory::get_instance()->registerPlugin("cloud", sigc::ptr_fun(make_noise_material));
            }
    };

    protected:


        Noise m_noise;
        
        static StaticInit m_init;

        Material * m_material_one;
        Material * m_material_two;

        // Amount to scale noise by
        double m_scale;
        double choose_material(const Point3D& intersection_point) const ;

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

        NoiseMaterial(const NoiseMaterial &other)
                :  m_material_one(other.m_material_one),
                    m_material_two(other.m_material_two)
        {
            // TODO: this should really just be a straight copy..
        }


        virtual ~NoiseMaterial() {
            //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 * createNoiseMaterial(std::map<std::string, std::string>);
};

Material * make_noise_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"]);
    double noise_scale = 1.0;
    if(props.find("noise_scale") != props.end())
    {
        noise_scale = (double)strtod(props["noise_scale"].c_str(), NULL);
    }
    return new NoiseMaterial(one, two,noise_scale);
}

#endif

---