vertex_buffer.h

#pragma once
 
#include <cgv/render/context.h>
#include <cgv/render/element_traits.h>
 
#include "lib_begin.h"
 
namespace cgv {
namespace render {

class CGV_API vertex_buffer : public vertex_buffer_base
{
protected:
    size_t size_in_bytes = 0;
 
public:
    vertex_buffer(VertexBufferType type = VBT_VERTICES, VertexBufferUsage usage = VBU_STATIC_DRAW);
    ~vertex_buffer();
    void bind(const context& ctx, VertexBufferType type = VBT_UNDEF) const;
    void unbind(const context& ctx, VertexBufferType type = VBT_UNDEF) const;
    void unbind(const context& ctx, unsigned index) const;
    void unbind(const context& ctx, VertexBufferType type, unsigned index) const;
    void bind(const context& ctx, unsigned index) const;
    void bind(const context& ctx, VertexBufferType type, unsigned index) const;
    bool create(const context& ctx, size_t size_in_bytes);
    template <typename T>
    bool create(const context& ctx, const T& array)
    {
        size_in_bytes = array_descriptor_traits<T>::get_size(array);
        return ctx.vertex_buffer_create(*this, array_descriptor_traits<T>::get_address(array), size_in_bytes);
    }

    template <typename T>
    bool create(const context& ctx, const T* array_ptr, size_t nr_elements) {
        size_in_bytes = nr_elements * sizeof(T);
        return ctx.vertex_buffer_create(*this, array_ptr, size_in_bytes);
    }

    bool is_created() const override;
    size_t get_size_in_bytes() const;
    bool resize(const context& ctx, size_t size_in_bytes);
    template <typename T, typename = std::enable_if_t<std::is_class<T>::value, bool>>
    bool resize(const context& ctx, const T& array)
    {
        size_in_bytes = array_descriptor_traits<T>::get_size(array);
        return ctx.vertex_buffer_resize(*this, array_descriptor_traits<T>::get_address(array), size_in_bytes);
    }

    template <typename T>
    bool resize(const context& ctx, const T* array_ptr, size_t nr_elements)
    {
        size_in_bytes = nr_elements * sizeof(T);
        return ctx.vertex_buffer_resize(*this, array_ptr, size_in_bytes);
    }

    bool create_or_resize(const context& ctx, size_t size_in_bytes);
    template <typename T, typename = std::enable_if_t<std::is_class<T>::value, bool>>
    bool create_or_resize(const context& ctx, const T& array)
    {
        return !is_created() ? create(ctx, array) : resize(ctx, array);
    }

    template <typename T> bool create_or_resize(const context& ctx, const T* array_ptr, size_t nr_elements)
    {
        return !is_created() ? create(ctx, array_ptr, nr_elements) : resize(ctx, array_ptr, nr_elements);
    }

    bool clear(const context& ctx) {
        return ctx.vertex_buffer_clear(*this, 0, size_in_bytes);
    }

    template <typename T>
    bool replace(const context& ctx, size_t buffer_offset_in_bytes, const T* array_ptr, size_t nr_elements)
    {
        return ctx.vertex_buffer_replace(*this, buffer_offset_in_bytes, nr_elements* sizeof(T), array_ptr);
    }

    bool copy(const context& ctx, size_t src_offset_in_bytes, size_t size_in_bytes, vertex_buffer& dst, size_t dst_offset_in_bytes) const;
    template <typename T>
    bool copy(const context& ctx, size_t src_offset_in_bytes, T* array_ptr, size_t nr_elements) const
    {
        return ctx.vertex_buffer_copy_back(*this, src_offset_in_bytes, sizeof(T)*nr_elements, array_ptr);
    }

    template <typename T, typename = std::enable_if_t<std::is_class<T>::value, bool>>
    bool copy(const context& ctx, T& array, size_t src_offset_in_bytes = 0) const
    {
        const auto size_in_bytes = array_descriptor_traits<T>::get_size(array);
        return ctx.vertex_buffer_copy_back(*this, src_offset_in_bytes, size_in_bytes,
                                           array_descriptor_traits<T>::get_address(array));
    }

    void destruct(const context& ctx);
};
 
} // namespace render
} // namespace cgv
 
#include <cgv/config/lib_end.h>