D:/Visual Studio 2010/Projects/Unishader project/Unishader/include/UniShader/Buffer.h

#pragma once
#ifndef BUFFER_H
#define BUFFER_H

#include <UniShader/Config.h>
#include <UniShader/Utility.h>
#include <UniShader/ObjectBase.h>

#include <memory>
#include <vector>
#include <string>
#include <typeinfo>

UNISHADER_BEGIN


class UniShader_API BufferBase : public ObjectBase{
protected:
        BufferBase();
public:
        typedef std::shared_ptr<BufferBase> Ptr; 
        virtual const std::string& getClassName() const; 
        ~BufferBase();


        class FrequencyMode{
        public:
                enum myEnum{NONE, 
                                        STREAM, 
                                        STATIC, 
                                        DYNAMIC 
                };
        private:
                myEnum m_en;
        public:
                FrequencyMode(){}
                FrequencyMode(const FrequencyMode& ref):m_en(ref.m_en){}
                FrequencyMode(myEnum en){ m_en = en; }
                FrequencyMode& operator =(myEnum en){ m_en = en; return *this; }
                operator myEnum(){ return m_en; }
        };


        class NatureMode{
        public:
                enum myEnum{NONE, 
                                        DRAW, 
                                        READ, 
                                        COPY 
                };
        private:
                myEnum m_en;
        public:
                NatureMode(){}
                NatureMode(const NatureMode& ref):m_en(ref.m_en){}
                NatureMode(myEnum en){ m_en = en; }
                NatureMode& operator =(myEnum en){ m_en = en; return *this; }
                operator myEnum(){ return m_en; }
        };


        class SignalID{
        public:
                enum Types{CHANGED 
                }; 
        };


        bool clear();


        unsigned int getGlID() const;


        FrequencyMode getFrequencyMode() const;


        NatureMode getNatureMode() const;


        void setFrequencyMode(FrequencyMode frequencyMode);
        

        void setNatureMode(NatureMode natureMode);

protected:

        bool mapBuffer(void** mappedPtr) const;

        bool unmapBuffer() const;


        bool setPlainData(const void* data, size_t size);

        size_t m_byteSize;
private:
        FrequencyMode m_frequencyMode;
        NatureMode m_natureMode;
        unsigned int m_bufferID;
};


template <typename T>
class Buffer : public BufferBase{
private:
        Buffer();
public:
        typedef std::shared_ptr<Buffer<T>> Ptr; 
        typedef std::shared_ptr<const Buffer<T>> PtrConst; 
        virtual const std::string& getClassName() const; 
        ~Buffer();


        static Ptr create();


        bool getDataCopy(std::vector<T>& vec) const;


        bool getDataCopy(T* arr, unsigned int& size) const;


        std::string getString(unsigned int begin = 0, unsigned int count = 0, std::ostringstream& format = std::ostringstream()) const;


        bool setData(const std::vector<T>& vec);


        bool setData(const T* arr, unsigned int size);
};

UNISHADER_END

#include <UniShader/Buffer.inl>

#endif