SXCore.h

#ifndef _SX_SXCORE_H_
#define _SX_SXCORE_H_

#include <AL/al.h>
#include <AL/alc.h>
#include <export/Export.h>
#include <vector>
#include <sx/SXMath.h>
#include <sx/SXParser.h>
#include <map>
#include <boost/timer.hpp>
#include <boost/unordered_map.hpp>
using namespace std;
using namespace boost;

namespace sx {

    class SXResource {
    protected:

        string id;

    public:

        EX virtual ~SXResource();

        EX const string &getID() const;

        virtual bool isLoaded() const = 0;

        virtual void load() = 0;

    };

    class EffectObject {

    public:

        virtual void execute(vector<string> &input) = 0;

    };

    enum ShaderType {
        VERTEX,
        TESSELLATION_CONTROL,
        TESSELLATION_EVALUATION,
        GEOMETRY,
        FRAGMENT
    };

    class Shader: public SXResource {
    private:

        bool loaded;

        unsigned int newTextureSlot;

        unsigned int freeTextureSlot;

        vector<unsigned int> lockedSlotsStack;

        //resources not loaded yet

        vector<string> newShaders;

        vector<string> newTransformFeedbackBuffers;

        bool newFragmentShade;

        bool newTessellate;

        vector<ShaderType> newShaderTypes;

        vector<bool> newShaderIsFile;

        //loaded resources

        unsigned int program;

        vector<unsigned int> shaders;

        vector<string> transformFeedbackBuffers;

        bool fragmentShade;

        bool tessellate;

        unordered_map<string,int> uniformLocations;

        unordered_map<string,int> targetLocations;

        unordered_map<string,int> attribLocations;

        vector<string> errorLog;

        Shader(const Shader &);

        Shader &operator = (const Shader &);

    public:

        EX Shader(const string &id);

        EX ~Shader();

        EX void load();

        EX bool isLoaded() const;

        EX vector<string> getErrorLog() const;

        EX void addShader(const string &code, ShaderType type);

        EX void addShaderFile(const string &path, ShaderType type);

        EX void addTransformFeedbackBuffer(const string &identifier);

        EX void use();

        EX bool isTessellating() const;

        EX bool isTransformFeedback() const;

        EX bool isFragmentShading() const;

        EX int getProgramID() const;

        EX const vector<string> &getTransformFeedbackBuffers() const;

        EX int getTransformFeedbackLocation(const string &identifyer);

        EX int getUniformLocation(const string &identifyer);

        EX int getTargetLocation(const string &identifyer);

        EX int Shader::getAttribLocation(const std::string &identifyer);

        EX void freeTextureSlots();

        EX unsigned int createTextureSlot();

        EX void lockTextureSlots();

        EX void unlockTextureSlots();

    };

    class Mesh: public SXResource {
    protected:

        unsigned int newFaceSize;
    
        unsigned int faceSize;

        unsigned int vertexCount;

    public:

        EX ~Mesh();

        EX void setFaceSize(unsigned int faceSize);

        EX unsigned int getFaceSize() const;

        EX unsigned int getVertexCount() const;

        virtual void render(Shader &shader) = 0;
    };

    struct VertexBuffer {

        string ID;

        string outputID;
        
        unsigned int bufferID;

        unsigned int location;

        unsigned int attributeSize;

    public:

        EX float *unlock();

        EX const float *unlockRead();
        
        EX float *unlockWrite();

        EX void lock();

    };

    class Uniform;
    class UniformFloat;
    class UniformVector;
    class UniformMatrix;

    class BufferedMesh: public Mesh, public EffectObject {
    private:

        bool loaded;

        //resources not loaded yet

        vector<vector<float>> newBuffers;

        vector<string> newAttributeIDs;

        map<string,string> newOutputIDs;

        vector<unsigned int> newAttributeSizes;

        vector<string> newMeshes;

        unsigned int newMaxVertexCount;

        vector<bool> newDiscardStandard;

        //loaded resources

        map<string,VertexBuffer *> vbos;

        map<string,VertexBuffer *> outputVBOs;

        unsigned int vao;

        map<string,UniformFloat **> uniformFloatSets;
        map<string,UniformVector **> uniformVectorSets;
        map<string,UniformMatrix **> uniformMatrixSets;

        unsigned int query_primitives_written;

        unsigned int query_primitives_generated;

        unsigned int maxVertexCount;

        BufferedMesh(const BufferedMesh &);

        vector<Bone> bones;

        Matrix skeletonMatrix;

        BufferedMesh &operator = (const BufferedMesh &);

    public:

        EX BufferedMesh(const string &id);

        EX ~BufferedMesh();

        EX void unload();

        EX void load();

        EX bool isLoaded() const;

        EX void save(const string &filename);

        EX void beginCapture(Shader &shader);

        EX void endCapture(Shader &shader);

        EX unsigned int countCreatedVertices() const;

        EX void setMaxVertexCount(unsigned int count);

        EX unsigned int getMaxVertexCount() const;

        EX void setVertexCount(unsigned int count);

        EX void render(Shader &shader);

        EX void renderInstanced(Shader &shader, vector<BufferedMesh *> &instanceBuffers);

        EX void addBuffer(const string &identifier, const string &outputIdentifier, vector<float> &buffer, unsigned int attributeSize);

        EX void addBuffer(const string &identifier, vector<float> &buffer, unsigned int attributeSize);

        EX void addBuffers(const string &path);

        EX void addBuffers(const string &path, bool discardStandardBuffers);

        EX void setOutputIdentifier(const string &identifier, const string &outputIdentifier);

        EX VertexBuffer *getBuffer(const string &identifier);

        EX map<string,VertexBuffer *> &getBuffers();

        EX bool setUniforms(const vector<Uniform *> &uniforms, const vector<string> &bufferIDs, unsigned int location);

        EX bool removeUniforms(unsigned int location);

        EX void removeUniforms();

        EX void resetUniforms();

        EX void loadBuffersToUniforms();

        EX void loadBuffersToUniforms(unsigned int firstLocation, unsigned int lastLocation);

        EX void loadBufferToUniforms(const string &bufferID);

        EX void loadBufferToUniforms(const string &bufferID, unsigned int firstLocation, unsigned int lastLocation);

        EX void loadUniformsToBuffers();

        EX void loadUniformsToBuffers(unsigned int firstLocation, unsigned int lastLocation);

        EX void loadUniformsToBuffer(const string &bufferID);

        EX void loadUniformsToBuffer(const string &bufferID, unsigned int firstLocation, unsigned int lastLocation);

        EX vector<Bone> getSkeleton() const;

        EX Matrix getSkeletonMatrix() const;

        EX void setSkeleton(const vector<Bone> &bones);

        EX void setSkeletonMatrix(const Matrix &skeletonMatrix);

        EX void execute(vector<string> &input);

    };

    class Uniform: public SXResource {
    protected:

        string idToken;

        unordered_map<string,string> uniformNames;

        EX Uniform(const string &id);

    public:

        EX virtual ~Uniform();

        EX void setUniformName(const string &name, const string &id);

        EX const string &getUniformName(const string &id) const;

        virtual void use(Shader &shader, const string &id) = 0;

    };

    class UniformFloat: public Uniform {
    private:

        UniformFloat(const UniformFloat &);

        UniformFloat &operator = (const UniformFloat &);

    public:

        float value;

        EX UniformFloat(const string &id);

        EX UniformFloat &operator = (float v);

        EX UniformFloat &operator << (float v);

        EX const UniformFloat &operator >> (float &v) const;

        EX void load();

        EX bool isLoaded() const;

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

    };

    class UniformDouble: public Uniform {
    private:

        UniformDouble(const UniformDouble &);

        UniformDouble &operator = (const UniformDouble &);

    public:

        double value;

        EX UniformDouble(const string &id);

        EX UniformDouble &operator = (double v);

        EX UniformDouble &operator << (double v);

        EX const UniformDouble &operator >> (double &v) const;

        EX void load();

        EX bool isLoaded() const;

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

    };

    class UniformVector: public Uniform, public Vector {
    private:

        UniformVector(const UniformVector &);

        UniformVector &operator = (const UniformVector &);

    public:

        EX UniformVector(const string &id);

        EX Vector &operator = (const Vector &v);

        EX void load();

        EX bool isLoaded() const;

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

    };

    class UniformDVector: public Uniform, public DVector {
    private:

        UniformDVector(const UniformDVector &);

        UniformDVector &operator = (const UniformDVector &);

    public:

        EX UniformDVector(const string &id);

        EX DVector &operator = (const DVector &v);

        EX void load();

        EX bool isLoaded() const;

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

    };

    class UniformMatrix: public Uniform, public Matrix {
    private:

        UniformMatrix(const UniformMatrix &);

        UniformMatrix &operator = (const UniformMatrix &);

    public:

        EX UniformMatrix(const string &id);

        EX Matrix &operator = (const Matrix &m);

        EX void load();

        EX bool isLoaded() const;

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

    };

    class UniformDMatrix: public Uniform, public DMatrix {
    private:

        UniformDMatrix(const UniformDMatrix &);

        UniformDMatrix &operator = (const UniformDMatrix &);

    public:

        EX UniformDMatrix(const string &id);

        EX DMatrix &operator = (const DMatrix &m);

        EX void load();

        EX bool isLoaded() const;

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

    };

    enum PixelFormat {
        BYTE_RGBA,
        FLOAT16_RGBA,
        FLOAT_RGBA
    };

    class Texture: public Uniform {
    private:

        bool loaded;

        //resources not loaded yet

        string newPath;

        int newWidth;

        int newHeight;

        PixelFormat newPixelFormat;

        vector<unsigned char> newByteBuffer;

        vector<float> newFloatBuffer;

        //loaded resources
        
        unsigned int texture;

        int width;

        int height;

        PixelFormat pixelFormat;

        Texture(const Texture &);

        Texture &operator = (const Texture &);

    public:

        EX Texture(const string &id);

        EX ~Texture();

        EX void unload();

        EX void load();

        EX bool isLoaded() const;

        EX void save(const string &filename);

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

        EX unsigned int getTextureID() const;

        EX void setPath(const string &path);

        EX void setWidth(int width);

        EX int getWidth() const;

        EX void setHeight(int height);

        EX int getHeight() const;

        EX void setPixelFormat(PixelFormat pixelFormat);

        EX PixelFormat getPixelFormat() const;

        EX void setByteBuffer(const vector<unsigned char> &buffer);

        EX void setFloatBuffer(const vector<float> &buffer);

    };

    class Volume: public Uniform {
    private:

        bool loaded;

        //resources not loaded yet

        vector<string> newPaths;

        int newWidth;

        int newHeight;

        int newDepth;

        PixelFormat newPixelFormat;

        vector<unsigned char> newByteBuffer;

        vector<float> newFloatBuffer;

        //loaded resources
        
        unsigned int texture;

        int width;

        int height;

        int depth;

        PixelFormat pixelFormat;

        Volume(const Volume &);

        Volume &operator = (const Volume &);

    public:

        EX Volume(const string &id);

        EX ~Volume();

        EX void unload();

        EX void load();

        EX bool isLoaded() const;

        EX void save(const string &filenamepart);

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

        EX unsigned int getTextureID() const;

        EX void addPath(const string &path);

        EX void setPaths(const vector<string> &paths);

        EX void setWidth(int width);

        EX int getWidth() const;

        EX void setHeight(int height);

        EX int getHeight() const;

        EX void setDepth(int depth);

        EX int getDepth();

        EX void setPixelFormat(PixelFormat pixelFormat);

        EX PixelFormat getPixelFormat() const;

        EX void setByteBuffer(const vector<unsigned char> &buffer);

        EX void setFloatBuffer(const vector<float> &buffer);

    };

    struct BoneTransform {
        
        string boneID;

        Matrix *input;

        Matrix *output;

    public:

        EX BoneTransform();

    };

    class Skeleton: public SXResource, public EffectObject {
    private:

        bool loaded;

        //resources not loaded yet

        vector<string> newPaths;

        
        vector<BufferedMesh *> newMeshes;

        vector<Bone> newBones;

        //loaded resources

        Matrix skeletonMatrix;

        vector<Bone> bones;

        unsigned int skeletonDepth;

        map<string, Bone *> boneMap;

        map<string,unsigned int> boneTransformsIndices;

        map<int,vector<BoneTransform *> > boneTransforms;

        map<int,map<string,BoneTransform *> > boneTransformMap;

        vector<string> unmatchedBones;

        void initBoneMap();

        void initBoneTransorms();

        void initBoneTransformSet(map<int,map<string,BoneTransform *> >::iterator setIter);

        Skeleton(const Skeleton &);

        Skeleton &operator = (const Skeleton &);

    public:

        EX Skeleton(const string &id);

        EX ~Skeleton();

        EX void addBones(const string &path);

        EX void addBones(BufferedMesh &mesh);

        EX void setSkeletonMatrix(const Matrix &transform);

        EX const Matrix &getSkeletonMatrix() const;

        EX void addRootBone(Bone &bone);

        EX const Bone &getBone(const string &id) const;

        EX vector<const Bone> getRootBones() const;

        EX void load();

        EX void unload();

        EX bool isLoaded() const;

        EX vector<string> getUnmatchedBones() const;

        EX void addBoneTransform(int setID, const BoneTransform &transform);

        EX BoneTransform &getBoneTransform(int setID, const string &boneID);

        EX void removeBoneTransform(int setID, const string &boneID);

        EX void removeBoneTransforms(int setID);

        EX void removeBoneTransforms();

        EX void updateBoneTransforms();

        EX void execute(vector<string> &input);
        
    };

    enum BlendFactor {
        ZERO,                       //Blendfactor = 0
        ONE,                        //Bendfactor = 1
        FRAGMENTCOLOR,              //Blendfactor = color of the fragment, which will be rendered
        FRAMEBUFFERCOLOR,           //Blendfactor = color of framebufferfragment
        FRAGMENTALPHA,              //Blendfactor = alphavalue of the fragment, which will be rendered
        FRAMEBUFFERALPHA,           //Blendfactor = alphavalue of the framebufferfragment
        ONE_MINUS_FRAGMENTCOLOR,    //Blendfactor = 1 - color of the fragment, which will be rendered
        ONE_MINUS_FRAMEBUFFERCOLOR, //Blendfactor = 1 - color of the framebufferfragment
        ONE_MINUS_FRAGMENTALPHA,    //Blendfactor = 1 - alphavalue of the fragment, which will be rendered
        ONE_MINUS_FRAMEBUFFERALPHA  //Blendfactor = 1 - alphavalue of the framebufferfragment
    };

    enum DepthTest {
        ACCEPT_NEVER,           //fails always
        ACCEPT_ALWAYS,          //succeeds always
        ACCEPT_LESS,            //succeeds, if the fragment, which is about to be rendered, has a smaller depthvalue than the depthvalue in the framebuffer
        ACCEPT_LESS_EQUAL,      //succeeds, if the fragment, which is about to be rendered, has a smaller depthvalue than, or a depthvalue equal to the depthvalue in the framebuffer
        ACCEPT_GREATER,         //succeeds, if the fragment, which is about to be rendered, has a bigger depthvalue than the depthvalue in th framebuffer
        ACCEPT_GREATER_EQUAL,   //succeeds, if the fragment, which is about to be rendered, has a bigger depthvalue than, or a depthvalue equal to the depthvalue in the framebuffer
        ACCEPT_EQUAL,           //succeeds, if the fragment, which is about to be rendered, has a depthvalue equal to the depthvalue in the framebuffer
        ACCEPT_NOT_EQUAL        //succeeds, if the fragment, which is about to be rendered, has a depthvalue different from the depthvalue in the framebuffer
    };

    class RenderTarget: public SXResource {
    private:

        string idToken;

        bool loaded;

        //resources not loaded yet

        int newWidth;

        int newHeight;

        bool newRenderToDisplay;

        //loaded resources

        int width;

        int height;

        unsigned int target;

        unsigned int renderbuffer;

        bool renderToDisplay;

        static unordered_map<int,int> depthTest2GL;

        static unordered_map<int,int> blendFactor2GL;

        static unordered_map<int,int> initDepthTest2GL();

        static unordered_map<int,int> initBlendFactor2GL();

        RenderTarget(const RenderTarget &);

        RenderTarget &operator = (const RenderTarget &);

    public:

        EX RenderTarget(const string &id);
        
        EX ~RenderTarget();

        EX static void clearTarget();

        EX static void clearDepthBuffer();

        EX static void clearColorBuffer();

        EX static void applyDepthTest(DepthTest test);

        EX static void applyWriteDepthBuffer(bool write);

        EX static void applyBlendFactors(BlendFactor fragmentBlendFactor, BlendFactor targetBlendFactor);

        EX static void setViewport(int x, int y, int width, int height);

        EX void setViewport();

        EX void setViewport(float xFactor, float yFactor, float widthFactor, float heightFactor);

        EX void unload();

        EX void load();

        EX bool isLoaded() const;

        EX void beginRender(Shader &shader, vector<Texture *> &textures, const string &resourceID);

        EX void beginRender(Shader &shader, vector<Volume *> &textures, unsigned int layer, const string &resourceID);

        EX void endRender();

        EX void setRenderToDisplay(bool renderToDisplay);

        EX bool isRenderingToDisplay() const;

        EX void setWidth(int width);

        EX int getWidth() const;

        EX void setHeight(int height);

        EX int getHeight() const;

    };

    class RenderObject: public SXResource {
    private:

        bool visible;

        Mesh *mesh;

        Shader *shader;

        unordered_map<string,Uniform *> uniforms;

        vector<BufferedMesh *> instanceBuffers;

        unordered_map<int,unordered_map<string,Uniform *>> uniformSets;

        RenderObject(const RenderObject &);

        RenderObject &operator = (const RenderObject &);

    public:

        EX RenderObject(const string &id);

        EX ~RenderObject();

        EX void load();

        EX bool isLoaded() const;

        EX void setVisible(bool visible);

        EX bool isVisible() const;

        EX void setMesh(Mesh &mesh);

        EX Mesh *getMesh();

        EX void setShader(Shader *shader);

        EX Shader *getShader();

        EX void addUniform(Uniform &uniform);

        EX void removeUniform(const string &name);

        EX void removeUniforms();

        EX void setInstanceBuffers(const vector<BufferedMesh *> &instanceBuffers);

        EX void removeInstanceBuffers();

        EX unordered_map<string, Uniform *> &getUniformSet(const int id);

        EX void removeUniformSet(const int id);

        EX void removeUniformSets();

        EX void render(Shader *passShader);

    };

    class Pass: public SXResource, public EffectObject {
    private:

        bool visible;

        Shader *shader;

        unordered_map<string,RenderObject *> renderObjects;

        vector<vector<RenderObject *>> tempRenderObjects;

        BufferedMesh *backgroundQuadMesh;
        RenderObject *backgroundQuad;

        unordered_map<string,Uniform *> uniforms;

        bool clearColorbuffer;

        bool clearDepthbuffer;

        bool wireframe;

        BlendFactor fragmentBlendFactor;
        BlendFactor targetBlendFactor;
        DepthTest depthTest;
        bool writeDepthBuffer;

        RenderTarget *renderTarget;

        vector<Texture *> targets;

        vector<Volume *> volumeTargets;

        BufferedMesh *geometryTarget;

        UniformFloat *layerCoordinate;

        UniformFloat *startLayer;
        
        UniformFloat *endLayer;

        Pass(const Pass &);

        Pass &operator = (const Pass &);

    public:

        EX static void applyWireframe(bool wireframe);

        EX Pass(const string &id);

        EX ~Pass();

        EX void load();

        EX bool isLoaded() const;

        EX void setVisible(bool visible);

        EX bool isVisible() const;

        EX void setShader(Shader *shader);

        EX Shader *getShader();

        EX void addRenderObject(RenderObject &object);

        EX void removeRenderObject(const string &id);

        EX void removeRenderObjects();

        EX void useBackgroundQuad(bool use);

        EX void addTempRenderObjects(const vector<RenderObject *> &temp);

        EX vector<RenderObject *> &getTempRenderObjects();

        EX void addUniform(Uniform &uniform);

        EX void removeUniform(const string &name);

        EX void removeUniforms();

        EX void setWireframe(bool wireframe);

        EX bool isWireframe() const;

        EX void setClearColorBuffer(bool clear);

        EX bool isClearingColorBuffer() const;

        EX void setClearDepthBuffer(bool clear);

        EX bool isClearingDepthBuffer() const;

        EX void setFragmentBlendFactor(BlendFactor factor);

        EX BlendFactor getFragmentBlendFactor() const;

        EX void setTargetBlendFactor(BlendFactor factor);

        EX BlendFactor getTargetBlendFactor() const;

        EX void setDepthTest(DepthTest test);

        EX DepthTest getDepthTest();

        EX void setWriteDepthBuffer(bool write);

        EX bool isWritingDepthBuffer();

        EX void setOutput(RenderTarget &target, vector<Texture *> targets);

        EX void setOutput(RenderTarget &target, vector<Volume *> targets);

        EX void setOutput(BufferedMesh *target);

        EX void setLayerCoordinate(UniformFloat *layerCoordinate);

        EX void setStartLayer(UniformFloat *startLayer);

        EX void setEndLayer(UniformFloat *endLayer);

        EX void render();

        EX void execute(vector<string> &input);

    };

    struct EffectCommand {
        vector<string> input;
        EffectObject *object;
    };

    class Effect: public SXResource {
    private:

        bool visible;

        vector<EffectCommand> objects;

        Effect(const Effect &);

        Effect &operator = (const Effect &);

    public:

        EX Effect(const string &id);

        EX ~Effect();

        EX void load();

        EX bool isLoaded() const;

        EX void setVisible(bool visible);

        EX bool isVisible() const;

        EX vector<EffectCommand> &getObjects();

        EX void render();

    };

    class AudioBuffer: public SXResource {
    private:

        //resource requests

        string newPath;

        //loaded resources

        bool loaded;

        ALuint buffer;

        AudioBuffer(const AudioBuffer &);

        AudioBuffer &operator = (const AudioBuffer &);

    public:

        EX AudioBuffer(const string &id);

        EX ~AudioBuffer();

        EX void load();

        EX void unload();

        EX bool isLoaded() const;

        EX void setPath(const string &path);

        EX unsigned int getBufferID() const;

    };

    class AudioObject: public SXResource {
    private:

        static bool initialized;

        static ALCdevice *device;

        static ALCcontext *context;

        //loaded resources

        bool loaded;

        ALuint audio;

        bool playing;

        //state

        AudioBuffer *buffer;

        const UniformVector *position;

        const UniformFloat *referenceRadius;

        const UniformFloat *maxRadius;

        const UniformFloat *distanceExponent;

        const UniformVector *velocity;

        const UniformFloat *volume;

        const UniformFloat *pitch;

        bool looping;

        bool locked;

        double lockTime;

        timer timedLock;

        AudioObject(const AudioObject &);

        AudioObject &operator = (const AudioObject &);

    public:

        EX static void initAudio();

        EX static void closeAudio();

        EX static bool isInitialized();

        EX AudioObject(const string &id);

        EX ~AudioObject();

        EX void load();

        EX void unload();

        EX bool isLoaded() const;

        EX void setAudioBuffer(AudioBuffer &buffer);

        EX void setPosition(const UniformVector *pos);

        EX void setReferenceRadius(const UniformFloat *radius);

        EX void setMaxRadius(const UniformFloat *maxRadius);

        EX void setDistanceExponent(const UniformFloat *exponent);

        EX void setVelocity(const UniformVector *vel);

        EX void setVolume(const UniformFloat *v);

        EX void setPitch(const UniformFloat *pitch);

        EX void setLooping(bool looping);

        EX void start();

        EX void start(double time);

        EX void stop();

        EX void pause();

        EX bool isPlaying();

        EX double getLength() const;

        EX double getPlaybackPosition() const;

        EX void lock(double time);

        EX void unlock();

        EX void update();

    };

    class AudioListener: public SXResource {
    private:

        const UniformVector *position;

        const UniformVector *view;

        const UniformVector *up;

        const UniformVector *velocity;

        const UniformFloat *volume;

        AudioListener(const AudioListener &);

        AudioListener &operator = (const AudioListener &);

    public:

        EX AudioListener(const string &id);

        EX ~AudioListener();

        EX void load();

        EX void unload();

        EX bool isLoaded() const;

        EX void setPosition(const UniformVector *pos);

        EX void setView(const UniformVector *view);

        EX void setUp(const UniformVector *up);

        EX void setVelocity(const UniformVector *vel);

        EX void setVolume(const UniformFloat *v);

        EX void update();

    };

    class AudioPass: public SXResource {
    private :

        AudioListener *listener;

        unordered_map<string,AudioObject *> objects;

        vector<AudioObject *> pausedObjects;

        vector<AudioObject *> unpausedObjects;

        bool paused;

        AudioPass(const AudioPass &);

        AudioPass &operator = (const AudioPass &);
    public:

        EX AudioPass(const string &id);

        EX ~AudioPass();

        EX void setPause(bool pause);

        EX bool isPaused() const;

        EX void load();

        EX void unload();

        EX bool isLoaded() const;

        EX void setAudioListener(AudioListener &listener);

        EX void addAudioObject(AudioObject &object);

        EX void removeAudioObject(const string &id);

        EX void removeAudioObjects();

        EX void update();

    };

}

#endif