buffer_map.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_BUFFER_MAP_1107121519_HPP
#define OGLPLUS_BUFFER_MAP_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/buffer_map_access.hpp>
#include <oglplus/buffer_target.hpp>
#include <oglplus/buffer_size.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
class BufferRawMap
{
private:
    const GLintptr _offset;
    GLsizeiptr _size;
    GLvoid* _ptr;
    const BufferTarget _target;

    static GLsizeiptr _get_size(BufferTarget target)
    {
        GLint value = 0;
        OGLPLUS_GLFUNC(GetBufferParameteriv)(
            GLenum(target),
            GL_BUFFER_SIZE,
            &value
        );
        OGLPLUS_CHECK(
            GetBufferParameteriv,
            ObjectError,
            ObjectBinding(target)
        );
        return GLsizeiptr(value);
    }

    static GLenum _translate(GLbitfield access)
    {
        switch(access)
        {
            case GL_MAP_READ_BIT:
                return GL_READ_ONLY;
            case GL_MAP_WRITE_BIT:
                return GL_WRITE_ONLY;
            case GL_MAP_READ_BIT|GL_MAP_WRITE_BIT:
                return GL_READ_WRITE;
        }
        return GL_READ_ONLY;
    }
public:

    BufferRawMap(
        BufferTarget target,
        BufferSize byte_offset,
        BufferSize size_bytes,
        Bitfield<BufferMapAccess> access
    ): _offset(GLintptr(byte_offset.Get()))
     , _size(GLsizeiptr(size_bytes.Get()))
     , _ptr(
        OGLPLUS_GLFUNC(MapBufferRange)(
            GLenum(target),
            _offset,
            _size,
            GLbitfield(access)
        )
    ), _target(target)
    {
        OGLPLUS_CHECK(
            MapBufferRange,
            Error,
            EnumParam(target)
        );
    }


    BufferRawMap(BufferTarget target, Bitfield<BufferMapAccess> access)
     : _offset(0)
     , _size(_get_size(target))
     , _ptr(
        OGLPLUS_GLFUNC(MapBuffer)(
            GLenum(target),
            _translate(GLbitfield(access))
        )
    ), _target(target)
    {
        OGLPLUS_CHECK(
            MapBuffer,
            ObjectError,
            ObjectBinding(_target)
        );
    }

#if !OGLPLUS_NO_DELETED_FUNCTIONS
    BufferRawMap(const BufferRawMap&) = delete;
#else
private:
    BufferRawMap(const BufferRawMap&);
public:
#endif
    BufferRawMap(BufferRawMap&& temp)
     : _offset(temp._offset)
     , _size(temp._size)
     , _ptr(temp._ptr)
     , _target(temp._target)
    {
        temp._ptr = nullptr;
    }

    ~BufferRawMap(void)
    {
        try { Unmap(); }
        catch(...){ }
    }


    void Unmap(void)
    {
        if(_ptr != nullptr)
        {
            OGLPLUS_GLFUNC(UnmapBuffer)(GLenum(_target));
            OGLPLUS_VERIFY(
                UnmapBuffer,
                ObjectError,
                ObjectBinding(_target)
            );
            _ptr = nullptr;
        }
    }

    bool Mapped(void) const
    {
        return _ptr != nullptr;
    }

    GLsizeiptr Size(void) const
    {
        return _size;
    }


    const GLvoid* RawData(void) const
    {
        assert(Mapped());
        return _ptr;
    }


    GLvoid* RawData(void)
    {
        assert(Mapped());
        return _ptr;
    }


    void FlushRange(BufferSize offset, BufferSize length)
    {
        OGLPLUS_GLFUNC(FlushMappedBufferRange)(
            GLenum(_target),
            GLintptr(offset.Get()),
            GLsizeiptr(length.Get())
        );
        OGLPLUS_CHECK(
            FlushMappedBufferRange,
            ObjectError,
            ObjectBinding(_target)
        );
    }
};

template <typename Type>
class BufferTypedMap
 : public BufferRawMap
{
public:

    BufferTypedMap(
        BufferTarget target,
        BufferTypedSize<Type> offset,
        BufferTypedSize<Type> size,
        Bitfield<BufferMapAccess> access
    ): BufferRawMap(target, offset, size, access)
    { }


    BufferTypedMap(BufferTarget target, Bitfield<BufferMapAccess> access)
     : BufferRawMap(target, access)
    { }

    BufferTypedMap(BufferTypedMap&& temp)
     : BufferRawMap(static_cast<BufferRawMap&&>(temp))
    { }

    GLsizeiptr Count(void) const
    {
        assert(this->Size() % sizeof(Type) == 0);
        return this->Size() / sizeof(Type);
    }

    const Type* Data(void) const
    {
        return static_cast<const Type*>(this->RawData());
    }

    Type* Data(void)
    {
        return static_cast<Type*>(this->RawData());
    }

    const Type& At(GLuint index) const
    {
        assert(Data() != nullptr);
        assert(((index+1)*sizeof(Type)) <= std::size_t(this->Size()));
        return Data()[index];
    }

    Type& At(GLuint index)
    {
        assert(Data() != nullptr);
        assert(((index+1)*sizeof(Type)) <= std::size_t(this->Size()));
        return Data()[index];
    }


    void FlushElements(
        BufferTypedSize<Type> start,
        BufferTypedSize<Type> count
    )
    {
        this->FlushRange(start, count);
    }
};
#endif // GL_VERSION_3_0

} // namespace oglplus

#endif // include guard