buffer.hpp

Go to the documentation of this file.

#pragma once
#ifndef OGLPLUS_BUFFER_1107121519_HPP
#define OGLPLUS_BUFFER_1107121519_HPP

#include <oglplus/glfunc.hpp>
#include <oglplus/error/object.hpp>
#include <oglplus/object/wrapper.hpp>
#include <oglplus/object/sequence.hpp>
#include <oglplus/buffer_binding.hpp>
#include <oglplus/buffer_usage.hpp>
#include <oglplus/buffer_storage_bit.hpp>
#include <oglplus/buffer_target.hpp>
#include <oglplus/buffer_map.hpp>
#include <oglplus/buffer_data.hpp>
#include <oglplus/buffer_gpu_addr.hpp>
#include <oglplus/access_specifier.hpp>
#include <oglplus/data_type.hpp>
#include <oglplus/pixel_data.hpp>

#include <vector>
#include <cassert>

namespace oglplus {


template <>
class ObjGenDelOps<tag::Buffer>
{
protected:
    static void Gen(tag::Generate, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenBuffers)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenBuffers);
    }
#if GL_VERSION_4_5 || GL_ARB_direct_state_access
    static void Gen(tag::Create, GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(GenBuffers)(count, names);
        OGLPLUS_CHECK_SIMPLE(GenBuffers);
    }
#endif

    static void Delete(GLsizei count, GLuint* names)
    {
        assert(names != nullptr);
        OGLPLUS_GLFUNC(DeleteBuffers)(count, names);
        OGLPLUS_VERIFY_SIMPLE(DeleteBuffers);
    }

    static GLboolean IsA(GLuint name)
    {
        assert(name != 0);
        GLboolean result = OGLPLUS_GLFUNC(IsBuffer)(name);
        OGLPLUS_VERIFY_SIMPLE(IsBuffer);
        return result;
    }
};

template <>
class ObjBindingOps<tag::Buffer>
{
private:
    static GLenum _binding_query(BufferTarget target);
    static GLenum _binding_query(BufferIndexedTarget target);
protected:
    static GLuint _binding(BufferTarget target);
    static GLuint _binding(BufferIndexedTarget target, GLuint index);
public:
    typedef BufferTarget Target;

    typedef BufferIndexedTarget IndexedTarget;


    static BufferName Binding(Target target)
    {
        return BufferName(_binding(target));
    }


    static void Bind(
        Target target,
        BufferName buffer
    )
    {
        OGLPLUS_GLFUNC(BindBuffer)(
            GLenum(target),
            GetGLName(buffer)
        );
        OGLPLUS_VERIFY(
            BindBuffer,
            ObjectError,
            Object(buffer).
            BindTarget(target)
        );
    }


    static BufferName Binding(IndexedTarget target, GLuint idx)
    {
        return BufferName(_binding(target, idx));
    }


    static void BindBase(
        IndexedTarget target,
        GLuint index,
        BufferName buffer
    )
    {
        OGLPLUS_GLFUNC(BindBufferBase)(
            GLenum(target),
            index,
            GetGLName(buffer)
        );
        OGLPLUS_VERIFY(
            BindBufferBase,
            ObjectError,
            Object(buffer).
            BindTarget(target)
        );
    }


    static void BindRange(
        IndexedTarget target,
        GLuint index,
        BufferName buffer,
        BufferSize offset,
        BufferSize size
    )
    {
        OGLPLUS_GLFUNC(BindBufferRange)(
            GLenum(target),
            index,
            GetGLName(buffer),
            GLintptr(offset.Get()),
            GLsizeiptr(size.Get())
        );
        OGLPLUS_VERIFY(
            BindBufferRange,
            ObjectError,
            Object(buffer).
            BindTarget(target)
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_multi_bind
    static void BindBase(
        BufferIndexedTarget target,
        GLuint first,
        GLsizei count,
        const GLuint* names
    )
    {
        OGLPLUS_GLFUNC(BindBuffersBase)(
            GLenum(target),
            first,
            count,
            names
        );
        OGLPLUS_VERIFY(
            BindBuffersBase,
            ObjectError,
            BindTarget(target)
        );
    }


    static void BindBase(
        BufferIndexedTarget target,
        GLuint first,
        const Sequence<BufferName>& buffers
    )
    {
        BindBase(
            target,
            first,
            GLsizei(buffers.size()),
            GetGLNames(buffers)
        );
    }

    static void BindRange(
        BufferIndexedTarget target,
        GLuint first,
        GLsizei count,
        const GLuint* names,
        const GLintptr* offsets,
        const GLsizeiptr* sizes
    )
    {
        OGLPLUS_GLFUNC(BindBuffersRange)(
            GLenum(target),
            first,
            count,
            names,
            offsets,
            sizes
        );
        OGLPLUS_VERIFY(
            BindBuffersRange,
            ObjectError,
            BindTarget(target)
        );
    }

    static void BindRange(
        BufferIndexedTarget target,
        GLuint first,
        const Sequence<BufferName>& buffers,
        const GLintptr* offsets,
        const GLsizeiptr* sizes
    )
    {
        BindRange(
            target,
            first,
            GLsizei(buffers.size()),
            GetGLNames(buffers),
            offsets,
            sizes
        );
    }
#endif
};


template <>
class ObjCommonOps<tag::Buffer>
 : public BufferName
 , public ObjBindingOps<tag::Buffer>
{
protected:
    ObjCommonOps(void){ }
public:
    using ObjBindingOps<tag::Buffer>::Bind;
    using ObjBindingOps<tag::Buffer>::BindBase;
    using ObjBindingOps<tag::Buffer>::BindRange;


    void Bind(Target target) const
    {
        Bind(target, *this);
    }

    void Bind(IndexedTarget target, GLuint index) const
    {
        BindBase(target, index, *this);
    }


    void BindBase(IndexedTarget target, GLuint index) const
    {
        BindBase(target, index, *this);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback3

    void BindBaseUniform(UniformBufferBindingPoint index) const
    {
        BindBase(IndexedTarget::Uniform, GLuint(index));
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_0 || GL_ARB_transform_feedback3

    void BindBaseTransformFeedback(
        TransformFeedbackBufferBindingPoint index
    ) const
    {
        BindBase(IndexedTarget::TransformFeedback, GLuint(index));
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_2 || GL_ARB_shader_atomic_counters

    void BindBaseAtomicCounter(AtomicCounterBufferBindingPoint index) const
    {
        BindBase(IndexedTarget::AtomicCounter, GLuint(index));
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3 || GL_ARB_shader_storage_buffer_object

    void BindBaseShaderStorage(ShaderStorageBufferBindingPoint index) const
    {
        BindBase(IndexedTarget::ShaderStorage, GLuint(index));
    }
#endif


    void BindRange(
        IndexedTarget target,
        GLuint index,
        BufferSize offset,
        BufferSize size
    ) const
    {
        BindRange(target, index, *this, offset, size);
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3 || GL_ARB_invalidate_subdata

    void InvalidateData(void)
    {
        OGLPLUS_GLFUNC(InvalidateBufferData)(_name);
        OGLPLUS_CHECK(
            InvalidateBufferData,
            ObjectError,
            Object(*this)
        );
    }


    void InvalidateSubData(BufferSize offset, BufferSize size)
    {
        OGLPLUS_GLFUNC(InvalidateBufferSubData)(
            _name,
            GLintptr(offset.Get()),
            GLsizeiptr(size.Get())
        );
        OGLPLUS_CHECK(
            InvalidateBufferSubData,
            ObjectError,
            Object(*this)
        );
    }
#endif
};


template <>
class ObjectOps<tag::ExplicitSel, tag::Buffer>
 : public ObjZeroOps<tag::ExplicitSel, tag::Buffer>
{
protected:
    ObjectOps(void) { }
public:
    static GLint GetIntParam(Target target, GLenum query);

    struct Property
    {
        typedef BufferUsage Usage;

        typedef BufferMapAccess MapAccess;
    };

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0
    typedef BufferTypedMap<GLubyte> Map;


    static bool Mapped(Target target)
    {
        return GetIntParam(target, GL_BUFFER_MAPPED) == GL_TRUE;
    }
#endif // GL_VERSION_3_0


    static void Resize(
        Target target,
        BufferSize size,
        BufferUsage usage = BufferUsage::StaticDraw
    )
    {
        OGLPLUS_GLFUNC(BufferData)(
            GLenum(target),
            size.Get(),
            nullptr,
            GLenum(usage)
        );
        OGLPLUS_CHECK(
            BufferData,
            ObjectError,
            ObjectBinding(target).
            EnumParam(usage)
        );
    }


    static void Data(
        Target target,
        const BufferData& data,
        BufferUsage usage = BufferUsage::StaticDraw
    )
    {
        OGLPLUS_GLFUNC(BufferData)(
            GLenum(target),
            GLsizei(data.Size()),
            data.Data(),
            GLenum(usage)
        );
        OGLPLUS_CHECK(
            BufferData,
            ObjectError,
            ObjectBinding(target).
            EnumParam(usage)
        );
    }


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


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

    static void SubData(
        Target target,
        BufferSize offset,
        const BufferData& data
    )
    {
        OGLPLUS_GLFUNC(BufferSubData)(
            GLenum(target),
            GLintptr(offset.Get()),
            GLsizei(data.Size()),
            data.Data()
        );
        OGLPLUS_CHECK(
            BufferSubData,
            ObjectError,
            ObjectBinding(target)
        );
    }


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

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_1 || GL_ARB_copy_buffer

    static inline void CopySubData(
        BufferTarget readtarget,
        BufferTarget writetarget,
        BufferSize readoffset,
        BufferSize writeoffset,
        BufferSize size
    )
    {
        OGLPLUS_GLFUNC(CopyBufferSubData)(
            GLenum(readtarget),
            GLenum(writetarget),
            GLintptr(readoffset.Get()),
            GLintptr(writeoffset.Get()),
            GLsizeiptr(size.Get())
        );
        OGLPLUS_CHECK(
            CopyBufferSubData,
            ObjectPairError,
            SubjectBinding(readtarget).
            ObjectBinding(writetarget)
        );
    }
#endif // copy buffer

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    template <typename GLtype>
    static void ClearData(
        Target target,
        PixelDataInternalFormat internal_format,
        PixelDataFormat format,
        const GLtype* data
    )
    {
        OGLPLUS_GLFUNC(ClearBufferData)(
            GLenum(target),
            GLenum(internal_format),
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearBufferData,
            ObjectError,
            ObjectBinding(target)
        );
    }


    template <typename GLtype>
    static void ClearSubData(
        Target target,
        PixelDataInternalFormat internal_format,
        BufferSize offset,
        BufferSize size,
        PixelDataFormat format,
        const GLtype* data
    )
    {
        OGLPLUS_GLFUNC(ClearBufferSubData)(
            GLenum(target),
            GLenum(internal_format),
            GLintptr(offset.Get()),
            GLsizeiptr(size.Get()),
            GLenum(format),
            GLenum(GetDataType<GLtype>()),
            data
        );
        OGLPLUS_CHECK(
            ClearBufferSubData,
            ObjectError,
            ObjectBinding(target).
            EnumParam(internal_format)
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_buffer_storage
    static void Storage(
        Target target,
        const BufferData& data,
        Bitfield<BufferStorageBit> flags
    )
    {
        OGLPLUS_GLFUNC(BufferStorage)(
            GLenum(target),
            GLsizeiptr(data.Size()),
            data.Data(),
            GLbitfield(flags)
        );
        OGLPLUS_CHECK(
            BufferStorage,
            ObjectError,
            ObjectBinding(target)
        );
    }


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


    static bool ImmutableStorage(Target target)
    {
        return GetIntParam(
            target,
            GL_BUFFER_IMMUTABLE_STORAGE
        ) == GL_TRUE;
    }


    static Bitfield<BufferStorageBit> StorageFlags(Target target)
    {
        return Bitfield<BufferStorageBit>(GLbitfield(
            GetIntParam(target, GL_BUFFER_STORAGE_FLAGS)
        ));
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_ARB_sparse_buffer
    static void PageCommitment(
        Target target,
        BufferSize offset,
        BufferSize size,
        bool commit
    )
    {
        OGLPLUS_GLFUNC(BufferPageCommitmentARB)(
            GLenum(target),
            GLintptr(offset.Get()),
            GLsizeiptr(size.Get()),
            commit?GL_TRUE:GL_FALSE
        );
        OGLPLUS_VERIFY(
            BufferPageCommitmentARB,
            ObjectError,
            ObjectBinding(target)
        );
    }

    static GLsizei PageSize(void)
    {
        GLint value = 0;
        OGLPLUS_GLFUNC(GetIntegerv)(
            GL_SPARSE_BUFFER_PAGE_SIZE_ARB,
            &value
        );
        OGLPLUS_VERIFY_SIMPLE(GetIntegerv);
        return GLsizei(value);
    }
#endif


    static GLsizei Size(Target target)
    {
        return GLsizei(GetIntParam(target, GL_BUFFER_SIZE));
    }


    static BufferUsage Usage(Target target)
    {
        return BufferUsage(GetIntParam(target, GL_BUFFER_USAGE));
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_3_0

    static Bitfield<BufferMapAccess> Access(Target target)
    {
        return Bitfield<BufferMapAccess>(
            GLbitfield(GetIntParam(target, GL_BUFFER_ACCESS))
        );
    }
#endif

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_shader_buffer_load

    static void MakeResident(Target target, AccessSpecifier access)
    {
        OGLPLUS_GLFUNC(MakeBufferResidentNV)(
            GLenum(target),
            GLenum(access)
        );
        OGLPLUS_CHECK(
            MakeBufferResidentNV,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static void MakeNonResident(Target target)
    {
        OGLPLUS_GLFUNC(MakeBufferNonResidentNV)(GLenum(target));
        OGLPLUS_CHECK(
            MakeBufferNonResidentNV,
            ObjectError,
            ObjectBinding(target)
        );
    }


    static BufferGPUAddress GPUAddress(Target target)
    {
        GLuint64EXT value = 0;
        OGLPLUS_GLFUNC(GetBufferParameterui64vNV)(
            GLenum(target),
            GL_BUFFER_GPU_ADDRESS_NV,
            &value
        );
        OGLPLUS_CHECK(
            GetBufferParameterui64vNV,
            ObjectError,
            ObjectBinding(target)
        );
        return BufferGPUAddress(value);
    }
#endif
};

typedef ObjectOps<tag::ExplicitSel, tag::Buffer>
    BufferOps;

// Helper class for syntax sugar operators
struct BufferTargetAndUsage
{
    BufferTarget target;
    BufferUsage usage;

    BufferTargetAndUsage(BufferTarget t, BufferUsage u)
     : target(t)
     , usage(u)
    { }
};

inline BufferTargetAndUsage operator << (
    BufferTarget target,
    BufferUsage usage
)
{
    return BufferTargetAndUsage(target, usage);
}

// Helper class for syntax sugar operators
struct BufferOpsAndIdxTgt
{
    const BufferOps& buf;
    BufferIndexedTarget target;

    BufferOpsAndIdxTgt(const BufferOps& b, BufferIndexedTarget t)
     : buf(b)
     , target(t)
    { }
};

inline BufferOpsAndIdxTgt operator << (
    const BufferOps& buf,
    BufferIndexedTarget target
)
{
    return BufferOpsAndIdxTgt(buf, target);
}

// Helper class for syntax sugar operators
struct BufferTargetAndOffset
{
    BufferTarget target;
    BufferSize offset;

    BufferTargetAndOffset(BufferTarget t, BufferSize o)
     : target(t)
     , offset(o)
    { }
};

inline BufferTargetAndOffset operator + (
    BufferTarget target,
    BufferSize offset
)
{
    return BufferTargetAndOffset(target, offset);
}

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

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

// Data
inline BufferTarget operator << (
    BufferTarget target,
    const BufferData& data
)
{
    BufferOps::Data(target, data);
    return target;
}

// Data
inline BufferTarget operator << (
    BufferTargetAndUsage&& tau,
    const BufferData& data
)
{
    BufferOps::Data(tau.target, data, tau.usage);
    return tau.target;
}

// SubData
inline BufferTarget operator << (
    BufferTargetAndOffset&& tao,
    const BufferData& data
)
{
    BufferOps::SubData(tao.target, tao.offset, data);
    return tao.target;
}


typedef ObjectZero<ObjZeroOps<tag::ExplicitSel, tag::Buffer>>
    NoBuffer;


typedef Object<BufferOps> Buffer;

} // namespace oglplus

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

#endif // include guard