vertexbuffer.h

Go to the documentation of this file.

#ifndef LOVE_GRAPHICS_OPENGL_VERTEX_BUFFER_H
#define LOVE_GRAPHICS_OPENGL_VERTEX_BUFFER_H

// LOVE
//#include <graphics/Volatile.h>

// OpenGL
#include <ugdk/internal/opengl.h>
#include <memory>

namespace ugdk {
namespace graphic {
namespace opengl {
    class VertexBuffer
    {
    public:

        static VertexBuffer *Create(size_t size, GLenum target, GLenum usage);

        static std::shared_ptr<const VertexBuffer> CreateDefaultShared();
        static const VertexBuffer *CreateDefault();

        VertexBuffer(size_t size, GLenum target, GLenum usage);

        virtual ~VertexBuffer();

        size_t getSize() const { return size; }

        GLenum getTarget() const { return target; }

        GLenum getUsage() const { return usage; }

        virtual void *map() = 0;

        virtual void unmap() = 0;

        virtual void bind() const = 0;

        virtual void unbind() const = 0;

        virtual void fill(size_t offset, size_t size, const void *data) = 0;

        virtual const void *getPointer(size_t offset) const = 0;

        class Bind
        {
        public:

            Bind(const VertexBuffer &buf)
                : buf(buf)
            { buf.bind(); }

            ~Bind()
            { buf.unbind(); }

        private:
            void operator=(const Bind&);

            // VertexBuffer to work on.
            const VertexBuffer &buf;
        };

        class Mapper
        {
        public:
            Mapper(VertexBuffer& buffer)
                : buf(buffer)
            { elems = buf.map(); }

            ~Mapper()
            { buf.unmap(); }

            void* get()
            { return elems; }

        private:
            void operator=(const Mapper&);

            VertexBuffer &buf;
            void* elems;
        };

    private:

        // The size of the buffer, in bytes.
        size_t size;

        // The target buffer object. (GL_ARRAY_BUFFER, GL_ELEMENT_ARRAY_BUFFER).
        GLenum target;

        // Usage hint. GL_[DYNAMIC, STATIC, STREAM]_DRAW.
        GLenum usage;
    };

    class VertexArray : public VertexBuffer
    {
    public:

        VertexArray(size_t size, GLenum target, GLenum usage);

        virtual ~VertexArray();

        // Implements VertexBuffer.
        virtual void *map();
        virtual void unmap();
        virtual void bind() const;
        virtual void unbind() const;
        virtual void fill(size_t offset, size_t size, const void *data);
        virtual const void *getPointer(size_t offset) const ;

    private:
        // Holds the data.
        char *buf;
    };

#ifndef UGDK_USING_GLES

    class VBO : public VertexBuffer //TODO, public Volatile
    {
    public:

        VBO(size_t size, GLenum target, GLenum usage);

        virtual ~VBO();

        // Implements VertexBuffer.
        virtual void *map();
        virtual void unmap();
        virtual void bind() const;
        virtual void unbind() const;
        virtual void fill(size_t offset, size_t size, const void *data);
        virtual const void *getPointer(size_t offset) const ;

        // Implements Volatile.
        bool loadVolatile();
        void unloadVolatile();

    private:

        bool load(bool restore);

        void unload(bool save);

        // The VBO identifier. Assigned by OpenGL.
        GLuint vbo;

        // *May* contain data saved by 'unload'.
        char *buffer_copy;

        // A pointer to mapped memory. Zero if memory is currently
        // not mapped.
        void *mapped;
    };
#endif // UGDK_USING_GLES

} // namespace opengl
} // namespace graphic
} // namespace ugdk

#endif // LOVE_GRAPHICS_OPENGL_SPRITE_BATCH_H