src/rcrt/loaders/MaterialLoader.cpp

Go to the documentation of this file.

#include "MaterialLoader.h"
#include <stdexcept>
#include "../bxdf/BSDF.h"
#include "../bxdf/CookTorrance.h"
#include "../bxdf/Phong.h"
#include "../bxdf/Lambertian.h"
#include "conversion.hpp"
#include "../materials/BSDFMaterial.h"
#include "../materials/DielectricMaterial.h"
#include "../materials/MirrorMaterial.h"
#include "../materials/ImageMaterial.h"
#include "../materials/WoodMaterial.h"
#include "../materials/WallMaterial.h"

using namespace std;

namespace rcrt
{

MaterialLoader::MaterialLoader(string matFile):XMLLoader(matFile),initialised(false)
{
}

MaterialLoader::~MaterialLoader()
{
}

void MaterialLoader::init()
{
        initialised = true;
        
        nextStartTag("materials");
        nextStartTag("");
        std::string tagName = parser.getName();
        while(tagName == "mat"){
                string name = parser.getAttributeValue("","name");
                string type = parser.getAttributeValue("","type");
                
                cout << "loading " << type << " material " << name << endl;
                
                nextStartTag("ior");
                complex<float> ior(convertTo<float>(parser.getAttributeValue("","r")),
                                convertTo<float>(parser.getAttributeValue("","i")));
                
                if(type == "bsdf"){
                        tagName = initBSDF(name,ior);
                } else if (type == "wood"){
                        tagName = initWood(name,ior);
                } else if (type == "wall"){
                        tagName = initWall(name,ior);
                } else if (type == "floor"){
                        tagName = initFloor(name,ior);
                } else if (type == "dielectric"){
                        tagName = initDielectric(name,ior);
                } else if (type == "water"){
                        tagName = initWater(name,ior);
                } else if (type == "mirror"){
                        tagName = initMirror(name,ior);
                } else if (type == "tex"){
                        tagName = initImg(name,ior);
                }
        }
        
}

string MaterialLoader::initBSDF(std::string name, std::complex<float> ior)
{
        bool found = nextStartTag("bxdf");
        if(!found){
                throw runtime_error("[MaterialLoader] Defined a BSDFMaterial, but no bxdf tag found.");
        }
        BSDF bsdf;
        string tagName = parser.getName();
        while(tagName == "bxdf"){
                string type = parser.getAttributeValue("","t");
                if(type == "cookt"){
                        loadCookT(&bsdf, ior);
                } else if(type == "phong"){
                        loadPhong(&bsdf);
                } else if(type == "lambert"){
                        loadLambert(&bsdf);
                }
                
                eof = !nextStartTag("");
                if(eof)
                        break;
                tagName = parser.getName();
        }
        materials.insert(make_pair(name,new BSDFMaterial(bsdf, ior)));
        return tagName;
}

string MaterialLoader::initWood(std::string name, std::complex<float> ior)
{
        //TODO
        std::cout << "init wood material" << std::endl;
        nextStartTag("org");
        Point3D org(convertTo<float>(parser.getAttributeValue("","x")),
                                convertTo<float>(parser.getAttributeValue("","y")),
                                convertTo<float>(parser.getAttributeValue("","z")));
        nextStartTag("dir");
        Vec3D dir(convertTo<float>(parser.getAttributeValue("","x")),
                                convertTo<float>(parser.getAttributeValue("","y")),
                                convertTo<float>(parser.getAttributeValue("","z")));
        nextStartTag("light");
        RGBColor light(convertTo<float>(parser.getAttributeValue("","r")),
                        convertTo<float>(parser.getAttributeValue("","g")),
                        convertTo<float>(parser.getAttributeValue("","b")));
        nextStartTag("dark");
        RGBColor dark(convertTo<float>(parser.getAttributeValue("","r")),
                        convertTo<float>(parser.getAttributeValue("","g")),
                        convertTo<float>(parser.getAttributeValue("","b")));
        materials.insert(make_pair(name,new WoodMaterial(org, dir.normalize(), light, dark)));
        nextStartTag("");
        return parser.getName();
        
}

string MaterialLoader::initWall(std::string name, std::complex<float> ior)
{
        BSDF b;
        //b.addBXDF(new CookTorrance(RGBColor(0.5,0.5,0.5),RGBColor(0.5,0.5,0.5),0.15,complex<float>(1.5,0)));
        b.addBXDF(new Lambertian(RGBColor(0.960784314,0.901960784,0.803921569)));
        std::cout << "init wall material" << std::endl;
        materials.insert(make_pair(name,new WallMaterial(b,14)));
        nextStartTag("");
        return parser.getName();
        
}

string MaterialLoader::initFloor(std::string name, std::complex<float> ior)
{
        BSDF b;
        //b.addBXDF(new CookTorrance(RGBColor(0.5,0.5,0.5),RGBColor(0.5,0.5,0.5),0.15,complex<float>(1.5,0)));
        b.addBXDF(new Lambertian(RGBColor(0.647058824,0.254901961,0.117647059)));
        std::cout << "init floor material" << std::endl;
        materials.insert(make_pair(name,new WallMaterial(b,12)));
        nextStartTag("");
        return parser.getName();
        
}

string MaterialLoader::initDielectric(std::string name, std::complex<float> ior)
{
        nextStartTag("absorb");
        RGBColor absorb(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        materials.insert(make_pair(name,new DielectricMaterial(ior.real(), absorb)));
        nextStartTag("");
        return parser.getName();
}

string MaterialLoader::initWater(std::string name, std::complex<float> ior)
{
        nextStartTag("absorb");
        RGBColor absorb(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        DielectricMaterial* mat = new DielectricMaterial(ior.real(), absorb);
        //mat->setBumpFactor(2);
        //mat->setBumpMap(new WaterTexture());
        materials.insert(make_pair(name,mat));
        nextStartTag("");
        return parser.getName();
}

string MaterialLoader::initMirror(std::string name, std::complex<float> ior)
{
        //TODO
        //materials.insert(make_pair(name,mat));
}

string MaterialLoader::initImg(std::string name, std::complex<float> ior)
{
        nextStartTag("tex");
        string file = parser.getAttributeValue("","file");
        int resX = convertTo<int>(parser.getAttributeValue("","resX"));
        int resY = convertTo<int>(parser.getAttributeValue("","resY"));
        Image* img = new Image(resX, resY);
        img->LoadImage(file.c_str());
        ImageTexture* imgTex = new ImageTexture(img);
        materials.insert(make_pair(name,new ImageMaterial(imgTex, ior)));
        
        nextStartTag("");
        return parser.getName();
}
        
void MaterialLoader::loadCookT(BSDF* bsdf, complex<float> ior)
{
        nextStartTag("diff");
        RGBColor diff(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        nextStartTag("spec");
        RGBColor spec(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        nextStartTag("rough");
        float rms = convertTo<float>(parser.getAttributeValue("","val"));
        bsdf->addBXDF(new CookTorrance(diff, spec, rms, ior));
}

void MaterialLoader::loadPhong(BSDF* bsdf)
{
        nextStartTag("diff");
        RGBColor diff(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        nextStartTag("spec");
        RGBColor spec(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        nextStartTag("n");
        float n = convertTo<float>(parser.getAttributeValue("","val"));
        bsdf->addBXDF(new Phong(diff, spec, n));
}

void MaterialLoader::loadLambert(BSDF* bsdf)
{
        nextStartTag("col");
        RGBColor col(convertTo<float>(parser.getAttributeValue("","r")),
                convertTo<float>(parser.getAttributeValue("","g")),
                convertTo<float>(parser.getAttributeValue("","b")));
        
        bsdf->addBXDF(new Lambertian(col));
}

Material* MaterialLoader::getMaterial(std::string name)
{
        map<string, Material*>::iterator iter = materials.find(name);
        if( iter != materials.end() ) {
                return iter->second;
        }
        return 0;
}

bool MaterialLoader::nextFrame()
{
        if(!initialised)
                init();
        //animated procedural/movies?
        return true;
}

bool MaterialLoader::goToFrame(const int& n)
{
        if(!initialised)
                init();
        
        return true;
}


}

---