buffer.hpp

Go to the documentation of this file.

#ifndef OGLPLUS_BOUND_BUFFER_1107121519_HPP
#define OGLPLUS_BOUND_BUFFER_1107121519_HPP

#include <oglplus/object/bound.hpp>
#include <oglplus/buffer.hpp>
#include <utility>

namespace oglplus {


template <>
class BoundObjOps<tag::Buffer>
{
private:
    typedef ObjectOps<tag::ExplicitSel, tag::Buffer> ExplicitOps;
public:
    typedef ExplicitOps::Target Target;
    Target target;

    BoundObjOps(void)
    { }

    BoundObjOps(Target init_tgt)
     : target(init_tgt)
    { }

    GLint GetIntParam(
        GLenum query
    ) const
    {
        return ExplicitOps::GetIntParam(
            this->target,
            query
        );
    }


    bool Mapped(void) const
    {
        return ExplicitOps::Mapped(
            this->target
        );
    }


    const BoundObjOps& Resize(
        BufferSize size,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        ExplicitOps::Resize(
            this->target,
            size,
            usage
        );
        return *this;
    }


    template <typename GLtype>
    const BoundObjOps& Data(
        GLsizei count,
        const GLtype * data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        ExplicitOps::Data(
            this->target,
            count,
            data,
            usage
        );
        return *this;
    }


    template <typename GLtype, std::size_t Count>
    const BoundObjOps& Data(
        const GLtype (&data)[Count],
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        ExplicitOps::Data(
            this->target,
            data,
            usage
        );
        return *this;
    }


    template <typename GLtype>
    const BoundObjOps& Data(
        const std::vector< GLtype > & data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        ExplicitOps::Data(
            this->target,
            data,
            usage
        );
        return *this;
    }


    template <typename GLtype, std::size_t N>
    const BoundObjOps& Data(
        const std::vector< Vector< GLtype, N > > & data,
        BufferUsage usage = BufferUsage::StaticDraw
    ) const
    {
        ExplicitOps::Data(
            this->target,
            data,
            usage
        );
        return *this;
    }


    template <typename GLtype>
    const BoundObjOps& SubData(
        BufferSize offset,
        GLsizei count,
        const GLtype * data
    ) const
    {
        ExplicitOps::SubData(
            this->target,
            offset,
            count,
            data
        );
        return *this;
    }


    template <typename GLtype, std::size_t Count>
    const BoundObjOps& SubData(
        BufferSize offset,
        const GLtype (&data)[Count]
    ) const
    {
        ExplicitOps::SubData(
            this->target,
            offset,
            data
        );
        return *this;
    }


    template <typename GLtype>
    const BoundObjOps& SubData(
        BufferSize offset,
        const std::vector< GLtype > & data
    ) const
    {
        ExplicitOps::SubData(
            this->target,
            offset,
            data
        );
        return *this;
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    template <typename GLtype>
    const BoundObjOps& ClearData(
        PixelDataInternalFormat internal_format,
        PixelDataFormat format,
        const GLtype * data
    ) const
    {
        ExplicitOps::ClearData(
            this->target,
            internal_format,
            format,
            data
        );
        return *this;
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_3

    template <typename GLtype>
    const BoundObjOps& ClearSubData(
        PixelDataInternalFormat internal_format,
        BufferSize offset,
        BufferSize size,
        PixelDataFormat format,
        const GLtype * data
    ) const
    {
        ExplicitOps::ClearSubData(
            this->target,
            internal_format,
            offset,
            size,
            format,
            data
        );
        return *this;
    }
#endif // GL_VERSION_4_3

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_buffer_storage

    const BoundObjOps& Storage(
        BufferSize size,
        const void * data,
        Bitfield< BufferStorageBit > flags
    ) const
    {
        ExplicitOps::Storage(
            this->target,
            size,
            data,
            flags
        );
        return *this;
    }
#endif // GL_VERSION_4_4 GL_ARB_buffer_storage

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_buffer_storage

    bool ImmutableStorage(void) const
    {
        return ExplicitOps::ImmutableStorage(
            this->target
        );
    }
#endif // GL_VERSION_4_4 GL_ARB_buffer_storage

#if OGLPLUS_DOCUMENTATION_ONLY || GL_VERSION_4_4 || GL_ARB_buffer_storage

    Bitfield< BufferStorageBit > StorageFlags(void) const
    {
        return ExplicitOps::StorageFlags(
            this->target
        );
    }
#endif // GL_VERSION_4_4 GL_ARB_buffer_storage


    GLsizei Size(void) const
    {
        return ExplicitOps::Size(
            this->target
        );
    }


    BufferUsage Usage(void) const
    {
        return ExplicitOps::Usage(
            this->target
        );
    }


    Bitfield< BufferMapAccess > Access(void) const
    {
        return ExplicitOps::Access(
            this->target
        );
    }

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_shader_buffer_load

    const BoundObjOps& MakeResident(
        AccessSpecifier access
    ) const
    {
        ExplicitOps::MakeResident(
            this->target,
            access
        );
        return *this;
    }
#endif // GL_NV_shader_buffer_load

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_shader_buffer_load

    const BoundObjOps& MakeNonResident(void) const
    {
        ExplicitOps::MakeNonResident(
            this->target
        );
        return *this;
    }
#endif // GL_NV_shader_buffer_load

#if OGLPLUS_DOCUMENTATION_ONLY || GL_NV_shader_buffer_load

    BufferGPUAddress GPUAddress(void) const
    {
        return ExplicitOps::GPUAddress(
            this->target
        );
    }
#endif // GL_NV_shader_buffer_load


}; // class BoundObjOps

} // namespace oglplus

#endif // include guard