SX.h

#ifndef _SX_SX_H_
#define _SX_SX_H_

#include <export/Export.h>
#include <sx/SXCore.h>
#include <sx/SXParser.h>
#include <string>
#include <vector>
#include <map>
#include <boost/unordered_map.hpp>
#include <boost/timer.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
using boost::posix_time::ptime;
using boost::posix_time::second_clock;
using boost::posix_time::to_simple_string;
using namespace std;
using namespace boost;

namespace sx {

    enum MouseButton {
        MOUSE_LEFT,
        MOUSE_MIDDLE,
        MOUSE_RIGHT
    };

    enum KeyboardSpecial {
        SX_F1 = 0x1000000,
        SX_F2 = 0x1000001,
        SX_F3 = 0x1000002,
        SX_F4 = 0x1000003,
        SX_F5 = 0x1000004,
        SX_F6 = 0x1000005,
        SX_F7 = 0x1000006,
        SX_F8 = 0x1000007,
        SX_F9 = 0x1000008,
        SX_F10 = 0x1000009,
        SX_F11 = 0x100000a,
        SX_F12 = 0x100000b,
        SX_ESC = 0x100000c,
        SX_INSERT = 0x100000d,
        SX_PAUSE = 0x100000e,
        SX_HOME = 0x100000f,
        SX_END = 0x1000010,
        SX_DELETE = 0x1000011,
        SX_PAGEUP = 0x1000012,
        SX_PAGEDOWN = 0x1000013,
        SX_LEFT = 0x1000014,
        SX_RIGHT = 0x1000015,
        SX_DOWN = 0x1000016,
        SX_UP = 0x1000017,
        SX_NUMLOCK = 0x1000018,
        SX_CLEAR = 0x1000019,
        SX_ENTER = 0x100001a,
        SX_CTRL = 0x100001b,
        SX_SHIFT = 0x100001c,
        SX_CAPSLOCK = 0x100001d,
        SX_START = 0x100001e,
        SX_ALT = 0x100001f,
        SX_RETURN = 0x1000020,
        SX_BACKSPACE = 0x1000021
    };

    class SXRenderArea {
    public:

        virtual double getTime() const = 0;

        virtual double getDeltaTime() const = 0;

        virtual int getMouseX() const = 0;

        virtual int getMouseY() const = 0;

        virtual double getMouseDeltaX() const = 0;

        virtual double getMouseDeltaY() const = 0;

        virtual bool hasKey(int key) const = 0;

        virtual bool hasMouseKey(MouseButton key) const = 0;

        virtual int getWidth() const = 0;

        virtual int getHeight() const = 0;

        virtual void stopRendering() = 0;

        virtual void setMousePointer(int x, int y) = 0;

        virtual void setShowCursor(bool showCursor) = 0;

    };

    class SXRenderListener {
    public:

        virtual void create(SXRenderArea &area) = 0;

        virtual void reshape(SXRenderArea &area) = 0;

        virtual void render(SXRenderArea &area) = 0;

        virtual void stop(SXRenderArea &area) = 0;

    };

    class SXWindow: public SXRenderArea {
    private:

        static map<int,int> keys_glut2sx;

        static map<int,int> initKeys_glut2sx();

        static map<int,int> keys_glutnotspecial2sx;

        static map<int,int> initKeys_glutnotspecial2sx();

        double currentTimeRendering;

        double lastTimeRendered;

        int width;

        int height;

        int mouseX;

        int mouseY;

        static double mouseDeltaX;

        static double mouseDeltaY;

        unordered_map<int,int> keys;

        unordered_map<int,int> mouseKeys;

        boost::timer timeMeasurement;

        vector<SXRenderListener *> listeners;

        vector<SXRenderListener *> initListeners;

        int windowID;

        bool removedWindow;

        void listenersReshape();

        void listenersRender();

        void listenersStop();

        void updateTime();

        void setWidth(int width);

        void setHeight(int height);

        void setMouseX(int x);

        void setMouseY(int y);

        void addKey(int key);

        void removeKey(int key);

        void addMouseKey(MouseButton key);

        void removeMouseKey(MouseButton key);

        SXWindow(const SXWindow &);

        SXWindow &operator = (const SXWindow &);

        static map<int, SXWindow *> windows;

        static int argc;

        static char **argv;

        static char *argv0;

        friend void windowKeyUp(unsigned char key, int x, int y);

        friend void windowKeyDown(unsigned char key, int x, int y);

        friend void windowSpecialKeyUp(int key, int x, int y);

        friend void windowSpecialKeyDown(int key, int x, int y);

        friend void windowMouseKey(int button, int state, int x, int y);

        friend void windowMouseMotion(int x, int y);

        friend void windowPassiveMotion(int x, int y);

        friend void reshapeAll(int width, int height);

        friend void renderAll();

        friend void stopAll();

    public:

        EX SXWindow(const string &name, unsigned int width, unsigned int height);

        EX ~SXWindow();

        EX void removeWindow();

        EX void addRenderListener(SXRenderListener &l);

        EX void deleteRenderListener(SXRenderListener &l);

        EX void deleteRenderListeners();

        EX double getTime() const;

        EX double getDeltaTime() const;

        EX int getMouseX() const;

        EX int getMouseY() const;

        EX double getMouseDeltaX() const;
        
        EX double getMouseDeltaY() const;

        EX bool hasKey(int key) const;

        EX bool hasMouseKey(MouseButton key) const;

        EX int getWidth() const;

        EX int getHeight() const;
        
        EX static void run();

        EX void stopRendering();

        EX void setMousePointer(int x, int y);

        EX void setShowCursor(bool showCursor);

    };

    struct BufferUniforms {
        
        map<unsigned int,vector<string> > attributeNames;

        map<unsigned int,vector<Uniform *> > uniforms;

    };

    class ShadeX {
    private:

        unordered_map<string,SXResource *> resources;
        unordered_map<string,Shader *> shaders;
        unordered_map<string,BufferedMesh *> bufferedMeshes;
        unordered_map<string,Skeleton *> skeletons;
        unordered_map<string,UniformFloat *> uniformFloats;
        unordered_map<string,UniformDouble *> uniformDoubles;
        unordered_map<string,UniformVector *> uniformVectors;
        unordered_map<string,UniformDVector *> uniformDVectors;
        unordered_map<string,UniformMatrix *> uniformMatrices;
        unordered_map<string,UniformDMatrix *> uniformDMatrices;
        unordered_map<string,Texture *> textures;
        unordered_map<string,Volume *> volumes;
        unordered_map<string,RenderTarget *> renderTargets;
        unordered_map<string,RenderObject *> renderObjects;
        unordered_map<string,Pass *> passes;
        unordered_map<string,Effect *> effects;
        unordered_map<string,AudioBuffer *> audioBuffers;
        unordered_map<string,AudioObject *> audioObjects;
        unordered_map<string,AudioListener *> audioListeners;
        unordered_map<string,AudioPass *> audioPasses;

        unordered_map<string,BufferUniforms> bufferUniforms;

        ShadeX(const ShadeX &);

        ShadeX &operator = (const ShadeX &);

        void INTERNAL_LOAD_SHADER(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_MATRIXCONTENT(Matrix &matrix, const string &id, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_DMATRIXCONTENT(DMatrix &matrix, const string &id, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_VECTORCONTENT(Vector &vec, const string &id, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_DVECTORCONTENT(DVector &vec, const string &id, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_BUFFEREDMESH(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_SKELETON(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMFLOAT(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMDOUBLE(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMVECTOR(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMDVECTOR(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMMATRIX(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_UNIFORMDMATRIX(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_TEXTURE(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_VOLUME(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_RENDERTARGET(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_RENDEROBJECT(XTag *rNode, XTag *data);

        void INTERNAL_RENDEROBJECT_COLLECT_UNIFORMS(RenderObject &obj, const string &id, const string &uType, bool isUniformSet, int uniformSetID, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_PASS(XTag *rNode, XTag *data);

        void INTERNAL_PASS_COLLECT_UNIFORMS(Pass &pass, const string &id, const string &uType, XTag *rNode, XTag *data);

        void INTERNAL_LOAD_EFFECT(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_AUDIOBUFFER(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_AUDIOOBJECT(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_AUDIOLISTENER(XTag *rNode, XTag *data);

        void INTERNAL_LOAD_AUDIOPASS(XTag *rNode, XTag *data);

    public:

        EX ShadeX();
        
        EX ~ShadeX();

        EX void clear(const string &id);

        EX void clear();

        EX void addResourcesFromString(const string &resources);

        EX void addResources(const string &path);

        EX void load();

        EX Shader &getShader(const string &id);

        EX void addResource(const string &id, Shader &shader);

        EX BufferedMesh &getBufferedMesh(const string &id);

        EX void addResource(const string &id, BufferedMesh &mesh);

        EX Skeleton &getSkeleton(const string &id);

        EX void addResource(const string &id, Skeleton &skeleton);

        EX UniformFloat &getUniformFloat(const string &id);

        EX void addResource(const string &id, UniformFloat &uFloat);

        EX UniformDouble &getUniformDouble(const string &id);

        EX void addResource(const string &id, UniformDouble &uDouble);

        EX UniformVector &getUniformVector(const string &id);

        EX void addResource(const string &id, UniformVector &uVector);

        EX UniformDVector &getUniformDVector(const string &id);

        EX void addResource(const string &id, UniformDVector &uDVector);

        EX UniformMatrix &getUniformMatrix(const string &id);

        EX void addResource(const string &id, UniformMatrix &uMatrix);

        EX UniformDMatrix &getUniformDMatrix(const string &id);

        EX void addResource(const string &id, UniformDMatrix &uDMatrix);

        EX Texture &getTexture(const string &id);

        EX void addResource(const string &id, Texture &texture);

        EX Volume &getVolume(const string &id);

        EX void addResource(const string &id, Volume &volume);

        EX RenderTarget &getRenderTarget(const string &id);

        EX void addResource(const string &id, RenderTarget &target);

        EX RenderObject &getRenderObject(const string &id);

        EX void addResource(const string &id, RenderObject &object);

        EX Pass &getPass(const string &id);

        EX void addResource(const string &id, Pass &pass);

        EX Effect &getEffect(const string &id);

        EX void addResource(const string &id, Effect &effect);

        EX AudioBuffer &getAudioBuffer(const string &id);

        EX void addResource(const string &id, AudioBuffer &buffer);

        EX AudioObject &getAudioObject(const string &id);

        EX void addResource(const string &id, AudioObject &object);

        EX AudioListener &getAudioListener(const string &id);

        EX void addResource(const string &id, AudioListener &object);

        EX AudioPass &getAudioPass(const string &id);

        EX void addResource(const string &id, AudioPass &object);

    };

}

#endif