solidmaterial.h

Go to the documentation of this file.

#ifndef SOLIDMATERIAL_H
#define SOLIDMATERIAL_H

#include "material.h"
#include "pluginfactory.h"

#include <iostream>

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

class SolidMaterial : public Material
{
    class SolidMaterialStaticInit
    {
        public:
            SolidMaterialStaticInit()
            {
                MaterialFactory::get_instance()->registerPlugin("solid", sigc::ptr_fun(new_solid_material));
            }
    };

    private:
        static SolidMaterialStaticInit m_init;

    protected:
        double m_reflection_coefficient;

        double m_diffusion_factor;

        double m_reflectivity;

        Magick::Color m_color;

        bool m_is_light_source;

        double m_opacity;

        double m_refraction_index; 

        virtual void normalize_opacity() {
            m_opacity = m_opacity > TRANSPARENT ? TRANSPARENT
                      : m_opacity < OPAQUE      ? OPAQUE
                      :                           m_opacity;
        }

    public:
        // You can never have too many constructors.
        //
        // Oh wait, yes you can.  TODO: find out where and
        // how all these are used and get rid of the unnecessary ones.

        SolidMaterial(bool is_light)
                : m_reflection_coefficient(1.0),
                  m_diffusion_factor(0.25f),
                  m_color(),
                  m_is_light_source(is_light),
                  m_reflectivity(35.0),
                  m_refraction_index(1.35),
                  m_opacity(OPAQUE) {}

        SolidMaterial(Magick::Color m_color, double reflect = 1.0f, double diffuse = 0.25f, bool is_light = false, double opacity = OPAQUE)
                : m_reflection_coefficient(reflect),
                  m_diffusion_factor(diffuse),
                  m_color(m_color),
                  m_is_light_source(is_light),
                  m_reflectivity(35.0),
                  m_refraction_index(1.35),
                  m_opacity(opacity) {}

        //
        // Do not remove this constructor. Used in create... method of solidmaterial.cpp
        SolidMaterial(Magick::Color m_color, 
                bool is_light , 
                double reflection, 
                double diffuse , 
                double reflectivity,
                double refraction,
                double opacity) : 
                  m_color(m_color),
                  m_is_light_source(is_light),
                  m_reflection_coefficient(reflection),
                  m_diffusion_factor(diffuse),
                  m_reflectivity(reflectivity),
                  m_refraction_index(refraction),
                  m_opacity(opacity) {}

        SolidMaterial(const SolidMaterial &other)
                : m_reflection_coefficient(other.m_reflection_coefficient),
                  m_diffusion_factor(other.m_diffusion_factor),
                  m_color(other.m_color),
                  m_is_light_source(other.m_is_light_source),
                  m_reflectivity(other.m_reflectivity),
                  m_opacity(other.m_opacity) {}

        virtual ~SolidMaterial() {
        }

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

        virtual bool is_light(const Point3D& intersection_point) const;

        virtual void set_is_light(bool v);

        virtual double get_diffuse(const Point3D& intersection_point) const;

        virtual void set_diffuse(double diffuse);

        virtual double get_reflection(const Point3D& intersection_point) const;

        virtual double get_reflectivity(const Point3D& intersection_point) const;

        virtual double get_refraction_index(const Point3D& intersection_point) const;

        virtual double get_opacity(const Point3D& intersection_point) const;

        virtual void set_opacity(double opacity);
        
 #if 0
 Stub out specular methods.
        virtual double get_specular_coeffiecient() ;

        virtual double get_specular_power() ;
#endif

};

inline Material * new_solid_material(std::map<std::string, std::string> props) {
    bool isLight = props.count("light") > 0;
    Magick::Color color(props["color"]);

    double reflection = props.count("reflection") > 0 ?
        (double)strtod(props["reflection"    ].c_str(), NULL)   : 1.0;

    double diffusion = props.count("diffusion") > 0 ?
        (double)strtod(props["diffusion"].c_str(), NULL)        :  1.0;

    double reflectivity = props.count("reflectivity") > 0 ?
        (double)strtod(props["reflectivity"].c_str(), NULL)     :  35.0;

    double refraction = props.count("refraction") > 0 ?
        (double)strtod(props["refraction"].c_str(), NULL)       :  1.0;

    double opacity = props.count("opacity") > 0 ?
        (double)strtod(props["opacity"].c_str(), NULL)          :  OPAQUE;

    log_debug("Creating material '%s' with:", props["name"].c_str());
    log_debug("  reflection:   %2.2f", reflection  );
    log_debug("  diffusion:    %2.2f", diffusion   );
    log_debug("  reflectivity: %2.2f", reflectivity);
    log_debug("  refraction:   %2.2f", refraction  );
    log_debug("  opacity:      %2.2f", opacity     );

    return new SolidMaterial( color,
            isLight,
            reflection,
            diffusion,
            reflectivity,
            refraction,
            opacity
            );
}

#endif

---