src/SceneBuilderFactories.h

Go to the documentation of this file.

#ifndef SCENEBUILDERFACTORIES_H
#define SCENEBUILDERFACTORIES_H


#include <string>
#include <sstream>
#include <map>
#include <vector>


class Camera;
class Light;
class Texture;
class Shader;
class Object;
class Scene;
class Animator;


class SceneBuilderFactory
{
public:
    SceneBuilderFactory()
    {
    }

    virtual ~SceneBuilderFactory()
    {
    }
};


class CameraFactory : public SceneBuilderFactory
{
public:
    CameraFactory()
    {
    }

    virtual Camera * create(const std::string & type, std::stringstream & line) = 0;
};


class PerspectiveCameraFactory : public CameraFactory
{
public:
    PerspectiveCameraFactory()
    {
    }

    virtual Camera * create(const std::string & type, std::stringstream & line);
};


class DepthOfFieldCameraFactory : public CameraFactory
{
public:
    DepthOfFieldCameraFactory()
    {
    }

    virtual Camera * create(const std::string & type, std::stringstream & line);
};


class LightFactory : public SceneBuilderFactory
{
public:
    LightFactory()
    {
    }

    virtual Light * create(const std::string & type, std::stringstream & line) = 0;
};


class PointLightFactory : public LightFactory
{
public:
    PointLightFactory()
    {
    }

    virtual Light * create(const std::string & type, std::stringstream & line);
};


class QuadAreaLightFactory : public LightFactory
{
public:
    QuadAreaLightFactory()
    {
    }

    virtual Light * create(const std::string & type, std::stringstream & line);
};


class TextureFactory : public SceneBuilderFactory
{
public:
    TextureFactory()
    {
    }

    virtual Texture * create(const std::string & type, std::stringstream & line) = 0;
};


class Texture2DFactory : public TextureFactory
{
public:
    Texture2DFactory()
    {
    }

    virtual Texture * create(const std::string & type, std::stringstream & line);
};


class ShaderFactory : public SceneBuilderFactory
{
public:
    ShaderFactory()
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene) = 0;
};


class TexturedShaderFactory : public ShaderFactory
{
public:
    TexturedShaderFactory(std::map<std::string, Texture *> & textures)
        : mTextures(textures)
    {
    }

protected:
    std::map<std::string, Texture *> &  mTextures;

    Scene *                             mScene;


    void readTextures(  std::stringstream &         line,
                        std::vector<Texture *> &    texes );
    void readBump(  std::stringstream &         line,
                    Texture *&                  bump,
                    float &                     bumppar );
};


class CloudShaderFactory : public TexturedShaderFactory
{
public:
    CloudShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class WoodShaderFactory : public TexturedShaderFactory
{
public:
    WoodShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class MirrorShaderFactory : public TexturedShaderFactory
{
public:
    MirrorShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class PhongShaderFactory : public TexturedShaderFactory
{
public:
    PhongShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class TransparentShaderFactory : public ShaderFactory
{
public:
    TransparentShaderFactory()
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class CombineShaderFactory : public TexturedShaderFactory
{
public:
    CombineShaderFactory(   std::map<std::string, Shader *> &   shaders,
                            std::map<std::string, Texture *> &  textures )
        : TexturedShaderFactory(textures),
            mShaders(shaders)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);

private:
    std::map<std::string, Shader *> & mShaders;
};


class RefractiveShaderFactory : public TexturedShaderFactory
{
public:
    RefractiveShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class CookTorranceShaderFactory : public TexturedShaderFactory
{
public:
    CookTorranceShaderFactory(std::map<std::string, Texture *> & textures)
        : TexturedShaderFactory(textures)
    {
    }

    virtual Shader * create(const std::string & type, std::stringstream & line, Scene * scene);
};


class ObjectFactory : public SceneBuilderFactory
{
public:
    ObjectFactory()
    {
    }

    virtual Object * create(const std::string & type, std::stringstream & line) = 0;
};


class ShadedObjectFactory : public ObjectFactory
{
public:
    ShadedObjectFactory(std::map<std::string, Shader *> & shaders)
        : ObjectFactory(),
            mShaders(shaders)
    {
    }

protected:
    std::map<std::string, Shader *> &   mShaders;
};


class OBJObjectFactory : public ShadedObjectFactory
{
public:
    OBJObjectFactory(std::map<std::string, Shader *> & shaders)
        : ShadedObjectFactory(shaders)
    {
    }

    virtual Object * create(const std::string & type, std::stringstream & line);
};


class SphereObjectFactory : public ShadedObjectFactory
{
public:
    SphereObjectFactory(std::map<std::string, Shader *> & shaders)
        : ShadedObjectFactory(shaders)
    {
    }

    virtual Object * create(const std::string & type, std::stringstream & line);
};


class CopyObjectFactory : public ObjectFactory
{
public:
    CopyObjectFactory(std::map<std::string, Object *> & objects)
        : ObjectFactory(),
            mObjects(objects)
    {
    }

    virtual Object * create(const std::string & type, std::stringstream & line);

protected:
    std::map<std::string, Object *> &   mObjects;
};


class Transformator : public SceneBuilderFactory
{
public:
    Transformator(std::map<std::string, Object *> & objects)
        : mObjects(objects)
    {
    }

    virtual bool transform(const std::string & type, std::stringstream & line) = 0;

protected:
    std::map<std::string, Object *> &   mObjects;
};


class Translator : public Transformator
{
public:
    Translator(std::map<std::string, Object *> & objects)
        : Transformator(objects)
    {
    }

    virtual bool transform(const std::string & type, std::stringstream & line);
};


class Rotator : public Transformator
{
public:
    Rotator(std::map<std::string, Object *> & objects)
        : Transformator(objects)
    {
    }

    virtual bool transform(const std::string & type, std::stringstream & line);
};


class Scaler : public Transformator
{
public:
    Scaler(std::map<std::string, Object *> & objects)
        : Transformator(objects)
    {
    }

    virtual bool transform(const std::string & type, std::stringstream & line);
};


class AnimatorParser : public SceneBuilderFactory
{
public:
    AnimatorParser(std::map<std::string, Object *> & objects)
        : mObjects(objects)
    {
    }

    virtual Animator * create(const std::string & type, std::stringstream & line) = 0;

protected:
    std::map<std::string, Object *> &   mObjects;
};


class PhysicsStepParser : public AnimatorParser
{
public:
    PhysicsStepParser(std::map<std::string, Object *> & objects)
        : AnimatorParser(objects)
    {
    }

    virtual Animator * create(const std::string & type, std::stringstream & line);
};


#endif

---