src/SceneBuilder.cpp

Go to the documentation of this file.

#include <stdexcept>
#include <fstream>
#include <vector>

#include "SceneBuilder.h"
#include "Scene.h"
#include "Camera.h"
#include "defines.h"
#include "SceneBuilderFactories.h"
#include "QuotedString.h"
#include "Animator.h"


// FIXME detect commas between numbers (like resolution in cameras)

// macro for throwing parse exception
#define THROW_SPE(x) {  LOG("Throwing SceneParseException\n\n"); \
                        throw SceneParseException(mFileName, mLineNr, (x)); \
                     }


SceneBuilder::SceneBuilder()
    : mFileName(),
        mLine(),
        mLineNr(-1),
        mLights(),
        mTextures(),
        mShaders(),
        mObjects(),
        mCameraParsers(),
        mLightParsers(),
        mShaderParsers(),
        mObjectParsers(),
        mTransformators(),
        mPhysicsParsers()
{
    // init all parsers
    mCameraParsers.push_back(new PerspectiveCameraFactory());
    mCameraParsers.push_back(new DepthOfFieldCameraFactory());

    mLightParsers.push_back(new PointLightFactory());
    mLightParsers.push_back(new QuadAreaLightFactory());

    mShaderParsers.push_back(new CombineShaderFactory(mShaders, mTextures));
    mShaderParsers.push_back(new CloudShaderFactory(mTextures));
    mShaderParsers.push_back(new MirrorShaderFactory(mTextures));
    mShaderParsers.push_back(new PhongShaderFactory(mTextures));
    mShaderParsers.push_back(new TransparentShaderFactory());
    mShaderParsers.push_back(new RefractiveShaderFactory(mTextures));
    mShaderParsers.push_back(new CookTorranceShaderFactory(mTextures));
    mShaderParsers.push_back(new WoodShaderFactory(mTextures));

    mObjectParsers.push_back(new OBJObjectFactory(mShaders));
    mObjectParsers.push_back(new SphereObjectFactory(mShaders));
    mObjectParsers.push_back(new CopyObjectFactory(mObjects));

    mTransformators.push_back(new Translator(mObjects));
    mTransformators.push_back(new Rotator(mObjects));
    mTransformators.push_back(new Scaler(mObjects));

    mPhysicsParsers.push_back(new PhysicsStepParser(mObjects));
}


SceneBuilder::~SceneBuilder()
{
    for (unsigned int i = 0; i < mCameraParsers.size(); i++)
        delete mCameraParsers[i];

    for (unsigned int i = 0; i < mLightParsers.size(); i++)
        delete mLightParsers[i];

    for (unsigned int i = 0; i < mShaderParsers.size(); i++)
        delete mShaderParsers[i];

    for (unsigned int i = 0; i < mObjectParsers.size(); i++)
        delete mObjectParsers[i];

    for (unsigned int i = 0; i < mTransformators.size(); i++)
        delete mTransformators[i];

    for (unsigned int i = 0; i < mPhysicsParsers.size(); i++)
        delete mPhysicsParsers[i];
}


void SceneBuilder::load(Scene &             scene,
                        Camera *&           camera,
                        const std::string & fileName,
                        bool                parseScene)
{
    if (parseScene)
    {
        clear();
    }
    mFileName   = fileName;
    mLineNr     = 0;
    camera      = NULL;
    LOG("Trying to load scene from \"" << fileName << "\"");

    // test file name extension
    if (fileName.size() < 7 || fileName.substr(fileName.size() - 6) != ".scene")
        throw std::invalid_argument("Unknown file name extension in \"" + fileName + "\"");

    // open file
    std::ifstream file(fileName.c_str());
    if (!file)
        THROW_SPE("Could not open scene file");

    // parse the file
    std::string type;

    // scene section
    type = nextOperator(file);
    if (type != "scene:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of scene: section");
    LOG("Found scene: section");
    if (parseScene)
    {
        bool foundscene = false;
        while (!file.eof())
        {
            type = nextOperator(file);
            if (type == "scene")
            {
                foundscene = true;
                makeScene(scene);
            }
            else if (type == "perspectivecamera" || type == "depthoffieldcamera")
            {
                if (camera)
                    THROW_SPE("Multiple camera definitions in scene: section");
                camera = makeCamera(type);
                LOG("Added new camera of type \"" << type << "\"");
            }
            else if (type == "include")
            {
                QuotedString includefile;
                mLine >> includefile;
                Camera *    tmpc;
                std::string tmpf = mFileName;
                int         tmpfn = mLineNr;
                LOG("Found include statement, including \"" << includefile.str() << "\"");
                load(scene, tmpc, includefile.str(), false);
                mFileName   = tmpf;
                mLineNr     = tmpfn;
            }
            else if (type == "lights:" || type == "")
                break;
            else
                THROW_SPE("Unknown statement \"" + type + "\"");
        }
        if (!foundscene)
            THROW_SPE("No \"scene\" statement in scene: section");
        if (!camera)
            THROW_SPE("No \"perspectivecamera\" or \"depthoffieldcamera\" statement in scene: section");
    }
    else
    {
        LOG("Skipping scene: section as requested");
        while (!file.eof())
        {
            type = nextOperator(file);
            if (type == "lights:" || type == "")
                break;
        }
    }

    // lights section
    if (type != "lights:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of lights: section");
    LOG("Found lights: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "textures:" || type == "")
            break;
        addLight(scene, type);
    }

    // textures section
    if (type != "textures:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of textures: section");
    LOG("Found textures: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "shaders:" || type == "")
            break;
        addTexture(scene, type);
    }

    // shaders section
    if (type != "shaders:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of shaders: section");
    LOG("Found shaders: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "objects:" || type == "")
            break;
        addShader(scene, type);
    }

    // objects section
    if (type != "objects:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of objects: section");
    LOG("Found objects: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "initialization:" || type == "")
            break;
        addObject(scene, type);
    }

    // initialization section
    if (type != "initialization:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of initialization: section");
    LOG("Found initialization: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "physics:" || type == "")
            break;
        doInit(type);
    }

    // physics section
    if (type != "physics:")
        THROW_SPE("Found unexpected token \"" + type + "\" instead of physics: section");
    LOG("Found physics: section");
    while (!file.eof())
    {
        type = nextOperator(file);
        if (type == "")
            break;
        addPhysicsStep(scene, type);
    }

    // cleanup
    if (parseScene)
        clear();
    LOG("Completed scene file parsing\n");
}


/* Clear internal structures
 */
void SceneBuilder::clear()
{
    mFileName   = "";
    mLine.str("");
    mLineNr     = -1;
    mLights.clear();
    mTextures.clear();
    mShaders.clear();
    mObjects.clear();
}


std::string SceneBuilder::nextOperator(std::istream & ifile)
{
    std::string s;
    while (!ifile.eof() && (s == "" || s == "#"))
    {
        ifile.clear();
        std::getline(ifile, s);
        mLine.clear();
        mLine.str(s);
        mLine >> std::ws >> s;
        mLine.clear();
        mLineNr++;
    }
    return s;
}


void SceneBuilder::makeScene(Scene & scene)
{
    try
    {
        RGBAColor col;
        bool b = false;

        mLine.clear();
        mLine >> col >> std::ws >> std::boolalpha >> b;
        mLine.clear();
        
        LOG("scene cast shadows: " << b);

        scene.setBgColor(col);
        scene.setCastShadows(b);
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


Camera * SceneBuilder::makeCamera(const std::string & type) // FIXME use res-x and res-y from parameters
{
    try
    {
        Camera * cam = NULL;
        for (unsigned int i = 0; i < mCameraParsers.size(); i++)
        {
            cam = mCameraParsers[i]->create(type, mLine);
            if (cam)
                return cam;
        }
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
    return NULL;
}


void SceneBuilder::addLight(Scene & scene, const std::string & type)
{
    try
    {
        std::string name;
        mLine.clear();
        mLine >> std::ws >> name >> std::ws;
        mLine.clear();

        Light * lt = NULL;
        for (unsigned int i = 0; i < mLightParsers.size(); i++)
        {
            lt = mLightParsers[i]->create(type, mLine);
            if (lt)
            {
                Light * oldLt = mLights[name];
                if (oldLt)
                {
                    delete lt;
                    THROW_SPE("Light name \"" + name + "\" is already in use");
                }
                mLights[name] = lt;
                scene.addLight(lt);
                break;
            }
        }
        if (!lt)
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)  // FIXME this doesnt work for a strange reason
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


void SceneBuilder::addTexture(Scene & scene, const std::string & type)
{
    Texture2DFactory texParser;
    try
    {
        std::string name;
        mLine.clear();
        mLine >> std::ws >> name >> std::ws;
        mLine.clear();

        Texture * tx = NULL;
        tx = texParser.create(type, mLine);
        if (tx)
        {
            Texture * oldTx = mTextures[name];
            if (oldTx)
            {
                delete tx;
                THROW_SPE("Texture name \"" + name + "\" is already in use");
            }
            mTextures[name] = tx;
            scene.addTexture(tx);
        }
        else
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


void SceneBuilder::addShader(Scene & scene, const std::string & type)
{
    try
    {
        std::string name;
        mLine.clear();
        mLine >> std::ws >> name >> std::ws;
        mLine.clear();

        Shader * sh = NULL;
        for (unsigned int i = 0; i < mShaderParsers.size(); i++)
        {
            sh = mShaderParsers[i]->create(type, mLine, &scene);
            if (sh)
            {
                Shader * oldSh = mShaders[name];
                if (oldSh)
                {
                    delete sh;
                    THROW_SPE("Shader name \"" + name + "\" is already in use");
                }
                mShaders[name] = sh;
                scene.addShader(sh);
                break;
            }
        }
        if (!sh)
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


void SceneBuilder::addObject(Scene & scene, const std::string & type)
{
    try
    {
        std::string name;
        mLine.clear();
        mLine >> std::ws >> name >> std::ws;
        mLine.clear();

        Object * obj = NULL;
        for (unsigned int i = 0; i < mObjectParsers.size(); i++)
        {
            obj = mObjectParsers[i]->create(type, mLine);
            if (obj)
            {
                Object * oldObj = mObjects[name];
                if (oldObj)
                {
                    delete obj;
                    THROW_SPE("Object name \"" + name + "\" is already in use");
                }
                mObjects[name] = obj;
                obj->setName(name);
                scene.addObject(obj);
                LOG("Added object \"" << name << "\"\n");
                break;
            }
        }
        if (!obj)
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


void SceneBuilder::doInit(const std::string & type)
{
    try
    {
        bool done = false;
        for (unsigned int i = 0; i < mTransformators.size(); i++)
        {
            done = mTransformators[i]->transform(type, mLine);
            if (done)
                break;
        }
        if (!done)
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}


void SceneBuilder::addPhysicsStep(Scene & scene, const std::string & type)
{
    try
    {
        mLine.clear();
        Animator * ps = NULL;
        for (unsigned int i = 0; i < mPhysicsParsers.size(); i++)
        {
            ps = mPhysicsParsers[i]->create(type, mLine);
            if (ps)
            {
                scene.addAnimator(ps);
                break;
            }
        }
        if (!ps)
            THROW_SPE("Unknown statement \"" + type + "\"");
    }
    catch (std::exception & e)
    {
        mLine.clear();
        THROW_SPE(e.what());
    }
}

---