scene.hpp

Go to the documentation of this file.

#ifndef SCENE_HPP
#define SCENE_HPP

#include <map>
#include <string>
#include <memory>
#include <vector>

class Debug;
class Model;
class Light;
class Shader;
class Camera;
class Texture;
class SelectorGPU;
class SelectorQuadTree;
class SceneObject;
class SunVolumetric;
class CubeMapObject;
class LightCamera;
class MouseSemantics;
class SelectorBase;
class Legend;
class BubbleCursor;
struct GLFWwindow;


class Scene {
public:
    enum { SentinelPre = 0,
           SentinelDraw = 1000,
           SentinelDrawPickable = 1500,
           SentinelPost = 2000,
           SentinelUnordered = 3000 };

    typedef std::map<std::size_t, std::shared_ptr<SceneObject> >::const_iterator ConstIterator;

    Scene(GLFWwindow* window);
    ~Scene();

    void init(const std::string& scenePath);

    void clearRender();
    void remRender(std::shared_ptr<SceneObject>& object);
    void getRender(size_t idx, std::shared_ptr<SceneObject>& object) const;
    size_t pushRender(std::shared_ptr<SceneObject>& object, size_t idx = SentinelUnordered);
    size_t insertRender(std::shared_ptr<SceneObject>& object, size_t idx = SentinelUnordered);

    Shader* getShader(const std::string& name) const;
    void addShader(const std::string& name, std::unique_ptr<Shader>& shader);
    void changeRenderShader(const std::string& from, const std::string& to);

    GLFWwindow* getWindow() const { return window; }
    std::shared_ptr<Light> getLight() const { return light; }
    std::shared_ptr<Camera> getCamera() const { return camera; }
    std::shared_ptr<SceneObject> getRootNode() const { return rootNode; }
    std::shared_ptr<CubeMapObject> getCubeMapObject() const { return cmObject; }
    std::shared_ptr<LightCamera> getLightCam() const { return lightCam; }
    std::shared_ptr<SunVolumetric> getSunVolumetric() const { return sunVolumetric; }
    std::shared_ptr<MouseSemantics> getMouseSemantics() const { return mouseSemantics; }
    std::shared_ptr<SelectorBase> getActiveSelector() const { return activeSelector; }
    std::shared_ptr<Legend> getLegend() const { return legend; }
    std::shared_ptr<BubbleCursor> getBubbleCursor() const { return bubbleCursor; }
    bool getObject(const std::string& name, std::shared_ptr<SceneObject>& object, size_t pos = 1) const;

    void setWindow(GLFWwindow* val) { window = val; }
    void setLight(std::shared_ptr<Light> val) { light = val; }
    void setCamera(std::shared_ptr<Camera> val) { camera = val; }
    void setRootNode(std::shared_ptr<SceneObject> root) { rootNode = root; }
    void setCubeMapObject(std::shared_ptr<CubeMapObject> val)  { cmObject = val; } 
    void setLightCam(std::shared_ptr<LightCamera> val) { lightCam = val; }
    void setSunVolumetric(std::shared_ptr<SunVolumetric> val) { sunVolumetric = val; }
    void setMouseSemantics(std::shared_ptr<MouseSemantics> val) { mouseSemantics = val; }
    void setActiveSelector(std::shared_ptr<SelectorBase> val) { activeSelector = val; }
    void setLegend(std::shared_ptr<Legend> val) { legend = val; }
    void setBubbleCursor(std::shared_ptr<BubbleCursor> val) { bubbleCursor = val; }

    ConstIterator end() const { return renderList.cend(); }
    ConstIterator begin() const { return renderList.cbegin(); }
    ConstIterator end(size_t idx) const { return renderList.lower_bound(idx); }
    ConstIterator begin(size_t idx) const { return renderList.lower_bound(idx); }
    //static void draw(const ConstIterator& it) { it->second->draw(it->first); }
    static std::shared_ptr<SceneObject> get(const ConstIterator& it) { return it->second; }

private:
    friend class Debug; //direct access to textures
    friend class AssimpLoader; //direct access to models and textures

    GLFWwindow* window;
    std::shared_ptr<Light> light;
    std::shared_ptr<Camera> camera;
    std::shared_ptr<CubeMapObject> cmObject;
    std::shared_ptr<LightCamera> lightCam;
    std::shared_ptr<SunVolumetric> sunVolumetric;
    std::shared_ptr<MouseSemantics> mouseSemantics;
    std::shared_ptr<SelectorBase> activeSelector;
    std::shared_ptr<Legend> legend;
    std::shared_ptr<BubbleCursor> bubbleCursor;

    std::shared_ptr<SceneObject> rootNode;
    std::map<std::string, std::unique_ptr<Model> > models;
    std::map<std::string, std::unique_ptr<Shader> > shaders;
    std::map<std::string, std::unique_ptr<Texture> > textures;
    std::map<std::size_t, std::shared_ptr<SceneObject> > renderList;

    bool getObjectRecursive(const std::string& name, std::shared_ptr<SceneObject>& object, size_t& pos) const;
};

#endif //SCENE_HPP