buffer_map.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_DSA_BUFFER_MAP_1309301821_HPP
#define OGLPLUS_DSA_BUFFER_MAP_1309301821_HPP

#include <oglplus/buffer.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_5 || GL_ARB_direct_state_access

class DSABufferRawMap
{
private:
    const GLintptr _offset;
    GLsizeiptr _size;
    GLvoid* _ptr;
    const GLuint _name;

    static GLsizeiptr _get_size(GLuint name)
    {
        GLint value = 0;
        OGLPLUS_GLFUNC(GetNamedBufferParameteriv)(
            name,
            GL_BUFFER_SIZE,
            &value
        );
        OGLPLUS_CHECK(
            GetNamedBufferParameteriv,
            ObjectError,
            Object(BufferName(name))
        );
        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:

    DSABufferRawMap(
        BufferName buffer,
        BufferSize offset,
        BufferSize size,
        Bitfield<BufferMapAccess> access
    ): _offset(GLintptr(offset.Get()))
     , _size(GLsizeiptr(size.Get()))
     , _ptr(
        OGLPLUS_GLFUNC(MapNamedBufferRange)(
            GetGLName(buffer),
            _offset,
            _size,
            GLbitfield(access)
        )
    ), _name(GetGLName(buffer))
    {
        OGLPLUS_CHECK(
            MapNamedBufferRange,
            ObjectError,
            Object(buffer)
        );
    }


    DSABufferRawMap(
        BufferName buffer,
        Bitfield<BufferMapAccess> access
    ): _offset(0)
     , _size(_get_size(GetGLName(buffer)))
     , _ptr(
        OGLPLUS_GLFUNC(MapNamedBuffer)(
            GetGLName(buffer),
            _translate(GLbitfield(access))
        )
    ), _name(GetGLName(buffer))
    {
        OGLPLUS_CHECK(
            MapNamedBuffer,
            ObjectError,
            Object(buffer)
        );
    }

#if !OGLPLUS_NO_DELETED_FUNCTIONS
    DSABufferRawMap(const DSABufferRawMap&) = delete;
#else
private:
    DSABufferRawMap(const DSABufferRawMap&);
public:
#endif

    DSABufferRawMap(DSABufferRawMap&& temp)
     : _offset(temp._offset)
     , _size(temp._size)
     , _ptr(temp._ptr)
     , _name(temp._name)
    {
        temp._ptr = nullptr;
    }

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


    void Unmap(void)
    {
        if(_ptr != nullptr)
        {
            OGLPLUS_GLFUNC(UnmapNamedBuffer)(_name);
            OGLPLUS_IGNORE(UnmapNamedBuffer);
            _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(FlushMappedNamedBufferRange)(
            _name,
            GLintptr(offset.Get()),
            GLsizeiptr(length.Get())
        );
        OGLPLUS_CHECK(
            FlushMappedNamedBufferRange,
            ObjectError,
            Object(BufferName(_name))
        );
    }
};

template <typename Type>
class DSABufferTypedMap
 : public DSABufferRawMap
{
public:

    DSABufferTypedMap(
        BufferName buffer,
        BufferTypedSize<Type> offset,
        BufferTypedSize<Type> size,
        Bitfield<BufferMapAccess> access
    ): DSABufferRawMap(buffer, offset, size, access)
    { }


    DSABufferTypedMap(
        BufferName buffer,
        Bitfield<BufferMapAccess> access
    ): DSABufferRawMap(buffer, access)
    { }

    DSABufferTypedMap(DSABufferTypedMap&& temp)
     : DSABufferRawMap(static_cast<DSABufferRawMap&&>(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];
    }
};

#endif // GL_ARB_direct_state_access

} // namespace oglplus

#endif // include guard