GlBuffer.h

// Copyright eeGeo Ltd (2012-2014), All Rights Reserved

#pragma once

#include "Types.h"
#include "Text.h"
#include "Rendering.h"
#include "Graphics.h"


#include <vector>

namespace Eegeo
{
    namespace Text
    {

#if defined(EEGEO_UNITY)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif

        class GlBufferBase : private Eegeo::NonCopyable
        {
        public:
            GlBufferBase(GLenum bufferType,
                         GLenum hint,
                         int strideSize,
                         int bufferChainCount);

            ~GlBufferBase();
            
            void Reserve(int elementCount);
            
            void Shrink(int elementCount);
            
            void Bind() const;
            
            void Unbind() const;
            
            void Swap();
            
        protected:
            
            void Upload(const void* pData, int elementOffset, int elementCount) const;

        private:
            void ResizeBuffer(int elementCount);
            
            
             
            std::vector<GLuint> m_glBuffers;
            GLenum m_bufferType;
            GLenum m_hint;
            int m_strideSize;
            int m_elementCapacity;
            int m_currentBufferIndex;
            GLuint m_currentBuffer;
        };

#if defined(EEGEO_UNITY)
#pragma clang diagnostic pop
#endif
        
        template <typename T>
        class GlBuffer : public GlBufferBase
        {
        public:
            typedef T ElementType;
            typedef GlBuffer<T> ThisType;
            typedef std::vector<ElementType> ElementVectorType;
            
            inline static GlBuffer<ElementType>* Create(GLenum bufferType, GLenum hint, int bufferChainCount = 1)
            {
                return Eegeo_NEW(GlBuffer<ElementType>)(bufferType, hint, bufferChainCount);
            }

            void Reset()
            {
                m_elementOffset = 0;
            }

            void Upload(const ElementVectorType& elements)
            {
                const void* pData = static_cast<const void*>(elements.data());
                
                GlBufferBase::Upload(pData, m_elementOffset, static_cast<int>(elements.size()));
                
                m_elementOffset += static_cast<int>(elements.size());
            }
            
            int GetElementOffset() const { return m_elementOffset; }

        private:
            GlBuffer(GLenum bufferType,
                     GLenum hint,
                     int bufferChainCount)
            : GlBufferBase(bufferType, hint, static_cast<int>(sizeof(ElementType)), bufferChainCount)
            , m_elementOffset(0)
            {
                
            }
            
            int m_elementOffset;
        };
    }
}