buffer.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_DSA_BUFFER_1309301821_HPP
#define OGLPLUS_DSA_BUFFER_1309301821_HPP

#include <oglplus/buffer.hpp>
#include <oglplus/dsa/buffer_map.hpp>

namespace oglplus {

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_5 || GL_ARB_direct_state_access

template <>
struct ObjGenTag<tag::DirectState, tag::Buffer>
{
    typedef tag::Create Type;
};


template <>
class ObjectOps<tag::DirectState, tag::Buffer>
 : public ObjZeroOps<tag::DirectState, tag::Buffer>
{
protected:
    ObjectOps(void){ }
public:
    GLint GetIntParam(GLenum query) const;

    struct Property
    {
        typedef BufferUsage Usage;

        typedef BufferMapAccess MapAccess;
    };

    typedef DSABufferTypedMap<GLubyte> Map;


    bool Mapped(void) const
    {
        return GetIntParam(GL_BUFFER_MAPPED) == GL_TRUE;
    }


    void Resize(
        BufferSize size,
        BufferUsage usage = BufferUsage::StaticDraw
    )
    {
        OGLPLUS_GLFUNC(NamedBufferData)(
            _name,
            size.Get(),
            nullptr,
            GLenum(usage)
        );
        OGLPLUS_CHECK(
            NamedBufferData,
            ObjectError,
            Object(*this).
            EnumParam(usage)
        );
    }


    void Data(
        const BufferData& data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        OGLPLUS_GLFUNC(NamedBufferData)(
            _name,
            GLsizei(data.Size()),
            data.Data(),
            GLenum(usage)
        );
        OGLPLUS_CHECK(
            NamedBufferData,
            ObjectError,
            Object(*this).
            EnumParam(usage)
        );
    }


    void RawData(
        BufferSize size,
        const GLvoid* data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        Data(BufferData(size, data), usage);
    }


    template <typename GLtype>
    void Data(
        GLsizei count,
        const GLtype* data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        Data(BufferData(count, data), usage);
    }


    void SubData(
        BufferSize offset,
        const BufferData& data
    ) const
    {
        OGLPLUS_GLFUNC(NamedBufferSubData)(
            _name,
            GLintptr(offset.Get()),
            GLsizei(data.Size()),
            data.Data()
        );
        OGLPLUS_CHECK(
            NamedBufferSubData,
            ObjectError,
            Object(*this)
        );
    }


    template <typename GLtype>
    void SubData(
        BufferSize offset,
        GLsizei count,
        GLtype* data
    ) const
    {
        SubData(offset, BufferData(count, data));
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_1 || GL_ARB_copy_buffer

    static void CopySubData(
        BufferName readbuffer,
        BufferName writebuffer,
        BufferSize readoffset,
        BufferSize writeoffset,
        BufferSize size
    )
    {
        OGLPLUS_GLFUNC(CopyNamedBufferSubData)(
            GetGLName(readbuffer),
            GetGLName(writebuffer),
            GLintptr(readoffset.Get()),
            GLintptr(writeoffset.Get()),
            GLsizeiptr(size.Get())
        );
        OGLPLUS_CHECK(
            CopyNamedBufferSubData,
            ObjectPairError,
            Subject(readbuffer).
            Object(writebuffer)
        );
    }
#endif // copy buffer


    template <typename GLtype>
    void ClearData(
        PixelDataInternalFormat internal_format,
        PixelDataFormat format,
        const GLtype* data
    ) const
    {
        OGLPLUS_GLFUNC(ClearNamedBufferData)(
            _name,
            GLenum(internal_format),
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearNamedBufferData,
            ObjectError,
            Object(*this).
            EnumParam(internal_format)
        );
    }


    template <typename GLtype>
    void ClearSubData(
        PixelDataInternalFormat internal_format,
        BufferSize offset,
        BufferSize size,
        PixelDataFormat format,
        const GLtype* data
    ) const
    {
        OGLPLUS_GLFUNC(ClearNamedBufferSubData)(
            _name,
            GLenum(internal_format),
            GLintptr(offset.Get()),
            GLsizeiptr(size.Get()),
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearNamedBufferSubData,
            ObjectError,
            Object(*this).
            EnumParam(internal_format)
        );
    }

    void Storage(
        const BufferData& data,
        Bitfield<BufferStorageBit> flags
    ) const
    {
        OGLPLUS_GLFUNC(NamedBufferStorage)(
            _name,
            GLsizeiptr(data.Size()),
            data.Data(),
            GLbitfield(flags)
        );
        OGLPLUS_CHECK(
            NamedBufferStorage,
            ObjectError,
            Object(*this)
        );
    }

    void Storage(
        BufferSize size,
        const void* data,
        Bitfield<BufferStorageBit> flags
    ) const
    {
        Storage(BufferData(size, data), flags);
    }


    GLsizei Size(void) const
    {
        return GLsizei(GetIntParam(GL_BUFFER_SIZE));
    }


    BufferUsage Usage(void) const
    {
        return BufferUsage(GetIntParam(GL_BUFFER_USAGE));
    }


    Bitfield<BufferMapAccess> Access(void) const
    {
        return Bitfield<BufferMapAccess>(
            GLbitfield(GetIntParam(GL_BUFFER_ACCESS))
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_shader_buffer_load

    void MakeResident(AccessSpecifier access) const
    {
        OGLPLUS_GLFUNC(MakeNamedBufferResidentNV)(
            _name,
            GLenum(access)
        );
        OGLPLUS_CHECK(
            MakeNamedBufferResidentNV,
            ObjectError,
            Object(*this).
            EnumParam(access)
        );
    }


    void MakeNonResident(void) const
    {
        OGLPLUS_GLFUNC(MakeNamedBufferNonResidentNV)(_name);
        OGLPLUS_CHECK(
            MakeNamedBufferNonResidentNV,
            ObjectError,
            Object(*this)
        );
    }


    BufferGPUAddress GPUAddress(void) const
    {
        GLuint64EXT value = 0;
        OGLPLUS_GLFUNC(GetNamedBufferParameterui64vNV)(
            _name,
            GL_BUFFER_GPU_ADDRESS_NV,
            &value
        );
        OGLPLUS_CHECK(
            GetNamedBufferParameterui64vNV,
            ObjectError,
            Object(*this)
        );
        return BufferGPUAddress(value);
    }
#endif
};

typedef ObjectOps<tag::DirectState, tag::Buffer>
    DSABufferOps;

// Helper class for syntax sugar operators
struct DSABufferOpsAndUsage
{
    DSABufferOps& buf;
    BufferUsage usage;

    DSABufferOpsAndUsage(DSABufferOps& b, BufferUsage u)
     : buf(b)
     , usage(u)
    { }
};

inline DSABufferOpsAndUsage operator << (
    DSABufferOps& buf,
    BufferUsage usage
)
{
    return DSABufferOpsAndUsage(buf, usage);
}

// Helper class for syntax sugar operators
struct DSABufferOpsAndIdxTgt
{
    DSABufferOps& buf;
    BufferIndexedTarget target;

    DSABufferOpsAndIdxTgt(DSABufferOps& b, BufferIndexedTarget t)
     : buf(b)
     , target(t)
    { }
};

inline DSABufferOpsAndIdxTgt operator << (
    DSABufferOps& buf,
    BufferIndexedTarget target
)
{
    return DSABufferOpsAndIdxTgt(buf, target);
}

// Helper class for syntax sugar operators
struct DSABufferOpsAndOffset
{
    DSABufferOps& buf;
    GLintptr offset;

    DSABufferOpsAndOffset(DSABufferOps& b, GLintptr o)
     : buf(b)
     , offset(o)
    { }
};

inline DSABufferOpsAndOffset operator + (
    DSABufferOps& buf,
    GLintptr offset
)
{
    return DSABufferOpsAndOffset(buf, offset);
}

// syntax-sugar operators

// Bind
inline DSABufferOps& operator << (
    DSABufferOps& buf,
    BufferTarget target
)
{
    buf.Bind(target);
    return buf;
}

// BindBase
inline DSABufferOps& operator << (
    const DSABufferOpsAndIdxTgt& bat,
    GLuint index
)
{
    bat.buf.BindBase(bat.target, index);
    return bat.buf;
}

// Data
template <typename GLtype>
inline DSABufferOps& operator << (
    DSABufferOps& buf,
    const std::vector<GLtype>& data
)
{
    buf.Data(data);
    return buf;
}

// Data
template <typename GLtype>
inline DSABufferOps& operator << (
    DSABufferOpsAndUsage&& bau,
    const std::vector<GLtype>& data
)
{
    bau.buf.Data(data, bau.usage);
    return bau.buf;
}

// Data
template <typename GLtype, std::size_t Count>
inline DSABufferOps& operator << (
    DSABufferOps& buf,
    const GLtype (&data)[Count]
)
{
    buf.Data(data);
    return buf;
}

// Data
template <typename GLtype, std::size_t Count>
inline DSABufferOps& operator << (
    DSABufferOpsAndUsage&& bau,
    const GLtype (&data)[Count]
)
{
    bau.buf.Data(data, bau.usage);
    return bau.buf;
}

// SubData
template <typename GLtype>
inline DSABufferOps& operator << (
    DSABufferOpsAndOffset&& bao,
    const std::vector<GLtype>& data
)
{
    bao.buf.SubData(bao.offset, data);
    return bao.buf;
}

// SubData
template <typename GLtype, std::size_t Count>
inline DSABufferOps& operator << (
    DSABufferOpsAndOffset&& bao,
    const GLtype (&data)[Count]
)
{
    bao.buf.SubData(bao.offset, data);
    return bao.buf;
}


typedef Object<DSABufferOps> DSABuffer;

#endif // GL_ARB_direct_state_access

} // namespace oglplus

#if !OGLPLUS_LINK_LIBRARY || defined(OGLPLUS_IMPLEMENTING_LIBRARY)
#include <oglplus/dsa/buffer.ipp>
#endif // OGLPLUS_LINK_LIBRARY

#endif // include guard