src/SceneBuilderFactories.cpp

Go to the documentation of this file.

#include <stdexcept>

#include "SceneBuilderFactories.h"

#include "Primitive.h"
#include "Scene.h"
#include "PerspectiveCamera.h"
#include "DepthOfFieldCamera.h"
#include "Vec3f.h"
#include "PointLight.h"
#include "QuadAreaLight.h"
#include "CloudShader.h"
#include "MirrorShader.h"
#include "PhongShader.h"
#include "TransparentShader.h"
#include "CombineShader.h"
#include "RefractiveShader.h"
#include "RGBAColor.h"
#include "Object.h"
#include "QuotedString.h"
#include "Texture.h"
#include "Texture2D.h"
#include "OBJObject.h"
#include "SphereObject.h"
#include "CookTorranceShader.h"
#include "WoodShader.h"
#include "PhysicsStep.h"


Camera * PerspectiveCameraFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "perspectivecamera")
        return NULL;
    //<Vec3f : position> <Vec3f : direction> <Vec3f : up>
    //<float : angle in degrees> <int res x> <int res y>
    Vec3f pos, dir, up;
    float angle;
    int x, y;
    
    line.clear();
    line >> std::ws >> pos >> std::ws >> dir >> std::ws >> up;
    line.clear();
    line >> std::ws >> angle >> std::ws >> x >> std::ws >> y;
    line.clear();
    
    return new PerspectiveCamera(pos, dir, up, angle, x, y);
}


Camera * DepthOfFieldCameraFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "depthoffieldcamera")
        return NULL;
    //<Vec3f : position> <Vec3f : direction> <Vec3f : up>
    //<float : angle in degrees> <int : res x> <int : res y>
    //<int : depth samples> <float : focus distance> <float : aperture>
    Vec3f pos, dir, up;
    float angle, focus, aperture;
    int x, y, samples;
    
    line.clear();
    line >> std::ws >> pos >> std::ws >> dir >> std::ws >> up;
    line >> std::ws >> angle >> std::ws >> x >> std::ws >> y;
    line >> std::ws >> samples >> std::ws >> focus >> std::ws >> aperture;
    line.clear();
    
    DepthOfFieldCamera * cam = new DepthOfFieldCamera(pos, dir, up, angle, x, y);
    cam->setDepthSamples(samples);
    cam->setFocusDistance(focus);
    cam->setAperture(aperture);
    return cam;
}


Light * PointLightFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "pointlight")
        return NULL;
    //<RGBAColor : intensity> <Vec3f : position>
    RGBAColor intensity;
    Vec3f position;

    line.clear();
    line >> std::ws >> intensity >> std::ws >> position;
    line.clear();
    
    return new PointLight(intensity, position);
}


Light * QuadAreaLightFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "quadarealight")
        return NULL;
    //<RGBAColor : power> <Vec3f : position> <Vec3f : span vector 1> <Vec3f : span vector 2>
    //<int : number of rays>
    RGBAColor power;
    Vec3f position, v1, v2;
    int rays = 0;

    line.clear();
    line >> std::ws >> power >> std::ws >> position >> std::ws >> v1 >> std::ws >> v2 >> std::ws >> rays;
    line.clear();
    
    QuadAreaLight * ql = new QuadAreaLight(power, position, v1, v2);
    ql->setNumberOfRays(rays);
    return ql;
}


Texture * Texture2DFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "texture2d")
        return NULL;
    //<string: png file name> <Mode : wrap mode> <InterpolationMode : interpolation mode>
    std::string tmp;
    QuotedString filename;
    Mode w;
    InterpolationMode i;

    line.clear();
    line >> std::ws >> filename >> std::ws >> tmp >> std::ws;
    if (tmp == "WRAP")
        w = WRAP;
    else if (tmp == "REPEAT")
        w = REPEAT;
    else
        throw std::logic_error("Unknown wrap mode \"" + tmp + "\"");
    line >> tmp;
    if (tmp == "NEAREST")
        i = NEAREST;
    else if (tmp == "LINEAR")
        i = LINEAR;
    else
        throw std::logic_error("Unknown interpolation mode \"" + tmp + "\"");
    line.clear();
    
    Texture2D * tex = new Texture2D(filename.str());
    tex->setWrapMode(w);
    tex->setInterpolationMode(i);
    return tex;
}


void TexturedShaderFactory::readTextures(   std::stringstream &         line,
                                            std::vector<Texture *> &    texes )
{
    std::string tmp;
    texes.clear();

    // textures
    line.clear();
    line >> std::ws;
    while (!line.eof())
    {
        line >> tmp >> std::ws;
        line.clear();
        if (tmp == "endtex" || tmp == "notex")
            break;
        else if (tmp == "tex")
        {
            // read texture name
            line >> tmp >> std::ws;
            line.clear();
            Texture * tex = mTextures[tmp];
            if (!tex)
                throw std::logic_error("Undefined texture \"" + tmp + "\"");
            texes.push_back(tex);
        }
        else
            throw std::logic_error("Unknown token \"" + tmp + "\"");
    }
}


void TexturedShaderFactory::readBump(   std::stringstream &         line,
                                        Texture *&                  bump,
                                        float &                     bumppar )
{
    std::string tmp;
    bump = NULL;
    bumppar = 0;

    // bump map
    line.clear();
    line >> std::ws >> tmp >> std::ws;
    if (tmp != "nobump")
    {
        if (tmp == "bump")
        {
            // read bump texture name
            line >> tmp >> std::ws;
            line.clear();
            bump = mTextures[tmp];
            if (!bump)
                throw std::logic_error("Undefined bump texture \"" + tmp + "\"");
            line >> bumppar >> std::ws;
            line.clear();
        }
        else
            throw std::logic_error("Unknown token \"" + tmp + "\"");
    }

}


Shader * CloudShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "cloudshader")
        return NULL;
    //[nobump | bump <bump map texture name> <float bump coefficient>] <RGBAColor : color>
    Texture * bump = NULL;
    float bumppar = 0;
    RGBAColor col;

    // bump mapping
    readBump(line, bump, bumppar);

    // color
    line >> col;
    line.clear();
    
    CloudShader * sh = new CloudShader(scene, col);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }

    return sh;
}


Shader * WoodShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "woodshader")
        return NULL;
    //[nobump | bump <bump map texture name> <float bump coefficient>] <RGBAColor : color>
    Texture * bump = NULL;
    float bumppar = 0;
    RGBAColor col;

    // bump mapping
    readBump(line, bump, bumppar);

    // color
    line >> col;
    line.clear();
    
    WoodShader * sh = new WoodShader(scene, col);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }

    return sh;
}


Shader * MirrorShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "mirrorshader")
        return NULL;
    //[nobump | bump <bump map texture name> <float bump coefficient>] <RGBAColor : color>
    Texture * bump = NULL;
    float bumppar = 0;
    RGBAColor col;

    // bump mapping
    readBump(line, bump, bumppar);

    // color
    line >> col;
    line.clear();
    
    MirrorShader * sh = new MirrorShader(scene, col);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }

    return sh;
}


Shader * PhongShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "phongshader")
        return NULL;
    //[notex | tex <texture name> [tex <...> [...]] endtex]
    //[nobump | bump <bump map texture name> <float bump coefficient>] <RGBAColor : color>
    //<float : ambient coefficient ka> <float : diffuse reflection kd>
    //<float : specular reflection ks> <float : shininess exponent ke>
    std::vector<Texture *> texes;
    Texture * bump = NULL;
    float bumppar = 0;
    RGBAColor col;
    float ka, kd, ks, ke;

    readTextures(line, texes);
    readBump(line, bump, bumppar);

    // color etc
    line >> col >> std::ws >> ka >> std::ws >> kd >> std::ws >> ks >> std::ws >> ke;
    line.clear();
    
    PhongShader * sh = new PhongShader(scene, col, ka, kd, ks, ke);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }
    for (unsigned int i = 0; i < texes.size(); i++)
        sh->addTexture(texes[i]);

    return sh;
}


Shader * CookTorranceShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "cooktorranceshader")
        return NULL;
    //[notex | tex <texture name> [tex <...> [...]] endtex]
    //[nobump | bump <bump map texture name> <float bump coefficient>] <RGBAColor : color>
    //<float : ambient coefficient ka> <float : diffuse reflection kd>
    //<float : specular reflection ks> <float : slope> <float : lambda>
    std::vector<Texture *> texes;
    Texture * bump = NULL;
    float bumppar = 0;
    RGBAColor col;
    float ka, kd, ks, slope, lambda;

    readTextures(line, texes);
    readBump(line, bump, bumppar);

    // color etc
    line >> col >> std::ws >> ka >> std::ws >> kd >> std::ws >> ks >> std::ws >> slope >> std::ws >> lambda;
    line.clear();
    
    CookTorranceShader * sh = new CookTorranceShader(scene, col, ka, kd, ks, slope, lambda);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }
    for (unsigned int i = 0; i < texes.size(); i++)
        sh->addTexture(texes[i]);

    return sh;
}


Shader * TransparentShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "transparentshader")
        return NULL;
    //<RGBAColor : color>
    RGBAColor col;

    // color
    line >> col;
    line.clear();
    
    TransparentShader * sh = new TransparentShader(scene, col);

    return sh;
}


Shader * CombineShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "combineshader")
        return NULL;
    //[notex | tex <texture name> [tex <...> [...]] endtex] <bool : add shaders>
    //[nosh | sh <lighting shader name> <float : alpha>] [nosh | sh <transparency shader name> <float : alpha>]
    std::vector<Texture *> texes;
    std::pair<Shader *, float> lsh;
    std::pair<Shader *, float> tsh;
    bool b = false;
    std::string tmp;

    readTextures(line, texes);

    // add shaders bool
    line.clear();
    line >> std::ws >> std::boolalpha >> b >> std::ws;
    line.clear();

    // lighting shader
    line.clear();
    line >> std::ws >> tmp >> std::ws;
    line.clear();
    if (tmp == "nosh")
    {
        lsh = std::make_pair(static_cast<Shader *>(NULL), 0.0f);
    }
    else if (tmp == "sh")
    {
        float alpha = 0;
        // read shader name
        line >> tmp >> std::ws >> alpha >> std::ws;
        line.clear();
        Shader * sh = mShaders[tmp];
        if (!sh)
            throw std::logic_error("Undefined shader \"" + tmp + "\"");
        lsh = std::make_pair(sh, alpha);
    }
    else
        throw std::logic_error("Unknown token \"" + tmp + "\"");

    // texture shader
    line.clear();
    line >> std::ws >> tmp >> std::ws;
    line.clear();
    if (tmp == "nosh")
    {
        tsh = std::make_pair(static_cast<Shader *>(NULL), 0.0f);
    }
    else if (tmp == "sh")
    {
        float alpha = 0;
        // read shader name
        line >> tmp >> std::ws >> alpha >> std::ws;
        line.clear();
        Shader * sh = mShaders[tmp];
        if (!sh)
            throw std::logic_error("Undefined shader \"" + tmp + "\"");
        tsh = std::make_pair(sh, alpha);
    }
    else
        throw std::logic_error("Unknown token \"" + tmp + "\"");

    CombineShader * csh = new CombineShader(scene, b);
    csh->setLightingShader(lsh.first, lsh.second);
    csh->setTransparentShader(tsh.first, tsh.second);
    for (unsigned int i = 0; i < texes.size(); i++)
        csh->addTexture(texes[i]);

    return csh;
}


Shader * RefractiveShaderFactory::create(const std::string & type, std::stringstream & line, Scene * scene)
{
    if (type != "refractiveshader")
        return NULL;
    //[nobump | bump <bump map texture name> <float bump coefficient>]
    //<RGBAColor : color> <float : refraction index>
    Texture * bump = NULL;
    float bumppar = 0.0f;
    RGBAColor col;
    float ridx = 1.0f;

    // bump mapping
    readBump(line, bump, bumppar);

    // color
    line >> col >> std::ws >> ridx >> std::ws;
    line.clear();
    
    RefractiveShader * sh = new RefractiveShader(scene, col, ridx);
    if (bump)
    {
        sh->setBumpTexture(bump);
        sh->setBumpCoefficient(bumppar);
    }

    return sh;
}


Object * OBJObjectFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "object")
        return NULL;
    //<string : object file name> <shader name> <bool : cast shadows>
    QuotedString objfile;
    std::string shadername;
    bool shadows = true;

    line.clear();
    line >> std::ws >> objfile >> std::ws >> shadername >> std::ws >> std::boolalpha >> shadows;
    line.clear();
    
    Object * obj = new OBJObject(objfile.str());
    obj->setCastShadows(shadows);
    Shader * sh = mShaders[shadername];
    if (!sh)
        throw std::logic_error("Undefined shader \"" + shadername + "\"");
    obj->setShader(sh);
    return obj;
}


Object * SphereObjectFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "sphere")
        return NULL;
    //<shader name> <bool : cast shadows>
    std::string shadername;
    bool shadows = true;

    line.clear();
    line >> std::ws >> shadername >> std::ws >> std::boolalpha >> shadows;
    line.clear();

    Object * obj = new SphereObject();
    obj->setCastShadows(shadows);
    Shader * sh = mShaders[shadername];
    if (!sh)
        throw std::logic_error("Undefined shader \"" + shadername + "\"");
    obj->setShader(sh);
    return obj;
}


Object * CopyObjectFactory::create(const std::string & type, std::stringstream & line)
{
    if (type != "copyobject")
        return NULL;
    //<another object name> <bool : cast shadows>
    std::string objname;
    bool shadows = true;

    line.clear();
    line >> std::ws >> objname >> std::ws >> std::boolalpha >> shadows;
    line.clear();
    
    Object * otherobj = mObjects[objname];
    if (!otherobj)
        throw std::logic_error("Undefined object \"" + objname + "\"");
    Object * obj = otherobj->createCopy();
    obj->setCastShadows(shadows);
    return obj;
}


bool Translator::transform(const std::string & type, std::stringstream & line)
{
    if (type != "translate")
        return false;
    //<object name> <Vec3f : translation vector>
    std::string objname;
    Vec3f v;

    line.clear();
    line >> std::ws >> objname >> std::ws >> v;
    line.clear();

    Object * obj = mObjects[objname];
    if (!obj)
        throw std::logic_error("Undefined object \"" + objname + "\"");
    obj->translate(v);
    return true;
}


bool Rotator::transform(const std::string & type, std::stringstream & line)
{
    if (type != "rotate")
        return false;
    //<object name> <float : angle in degree> <Vec3f : axis>
    std::string objname;
    float angle;
    Vec3f axis;

    line.clear();
    line >> std::ws >> objname >> std::ws >> angle >> std::ws >> axis;
    line.clear();

    Object * obj = mObjects[objname];
    if (!obj)
        throw std::logic_error("Undefined object \"" + objname + "\"");
    obj->rotate(angle / 180.0 * M_PI, axis);
    return true;
}


bool Scaler::transform(const std::string & type, std::stringstream & line)
{
    if (type != "scale")
        return false;
    //<object name> <float : x scaling factor> <float : y scaling factor> <float : z scaling factor>
    std::string objname;
    float x, y, z;

    line.clear();
    line >> std::ws >> objname >> std::ws >> x >> std::ws >> y >> std::ws >> z;
    line.clear();

    Object * obj = mObjects[objname];
    if (!obj)
        throw std::logic_error("Undefined object \"" + objname + "\"");
    obj->scale(x, y, z);
    return true;
}


Animator * PhysicsStepParser::create(const std::string & type, std::stringstream & line)
{
    if (type != "shot")
        return false;
    //<object name> <int : frame nr> <Vec3f : velocity> <Vec3f : angular velocity>
    std::string objname;
    unsigned int framenr;
    Vec3f v, w;

    line.clear();
    line >> std::ws >> objname >> std::ws >> framenr >> std::ws >> v >> std::ws >> w;
    line.clear();

    Object * obj = mObjects[objname];
    if (!obj)
        throw std::logic_error("Undefined object \"" + objname + "\"");
    PhysicsStep * ps = new PhysicsStep(obj, framenr, v, w);

    return ps;
}

---