dynamic_vertex_buffer.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_BGFX_BUFFERS_DYNAMIC_VERTEX_BUFFER_H
#define VCL_BGFX_BUFFERS_DYNAMIC_VERTEX_BUFFER_H
 
#include "generic_buffer.h"
 
namespace vcl {
 
class DynamicVertexBuffer :
        public GenericBuffer<bgfx::DynamicVertexBufferHandle>
{
    using Base = GenericBuffer<bgfx::DynamicVertexBufferHandle>;
 
    bool mCompute = false;
 
public:
    DynamicVertexBuffer() = default;
 
    void swap(DynamicVertexBuffer& other)
    {
        using std::swap;
        Base::swap(other);
        swap(mCompute, other.mCompute);
    }
 
    friend void swap(DynamicVertexBuffer& a, DynamicVertexBuffer& b)
    {
        a.swap(b);
    }
 
    bool isCompute() const { return mCompute; }
 
    void create(
        uint               vertNum,
        bgfx::Attrib::Enum attrib,
        uint               attribNumPerVertex,
        PrimitiveType      attribType,
        bool               normalize   = false,
        bool               allowResize = true)
    {
        uint64_t flags =
            allowResize ? BGFX_BUFFER_ALLOW_RESIZE : BGFX_BUFFER_NONE;
 
        bgfx::VertexLayout layout;
        layout.begin()
            .add(
                attrib,
                attribNumPerVertex,
                attributeType(attribType),
                normalize)
            .end();
 
        create(vertNum, layout, flags);
    }
 
    void create(
        const void*        bufferData,
        uint               vertNum,
        bgfx::Attrib::Enum attrib,
        uint               attribNumPerVertex,
        PrimitiveType      attribType,
        bool               normalize   = false,
        bgfx::ReleaseFn    releaseFn   = nullptr,
        bool               allowResize = true)
    {
        uint64_t flags =
            allowResize ? BGFX_BUFFER_ALLOW_RESIZE : BGFX_BUFFER_NONE;
 
        bgfx::VertexLayout layout;
        layout.begin()
            .add(
                attrib,
                attribNumPerVertex,
                attributeType(attribType),
                normalize)
            .end();
 
        create(vertNum, layout, flags);
        update(
            bufferData, vertNum, attribNumPerVertex, attribType, 0, releaseFn);
    }
 
    void create(
        uint                      vertNum,
        const bgfx::VertexLayout& layout,
        uint64_t                  flags   = BGFX_BUFFER_NONE,
        bool                      compute = false)
    {
        destroy();
 
        if (vertNum != 0)
            mHandle = bgfx::createDynamicVertexBuffer(vertNum, layout, flags);
        mCompute = compute;
    }
 
    void update(
        const void*     bufferData,
        uint            vertNum,
        uint            attribNumPerVertex,
        PrimitiveType   attribType,
        uint            startIndex = 0,
        bgfx::ReleaseFn releaseFn  = nullptr)
    {
        if (vertNum != 0) {
            const bgfx::Memory* data = bgfx::makeRef(
                bufferData,
                vertNum * attribNumPerVertex * sizeOf(attribType),
                releaseFn);
 
            update(startIndex, data);
        }
        else {
            if (releaseFn)
                releaseFn((void*) bufferData, nullptr);
        }
    }
 
    void update(uint startIndex, const bgfx::Memory* data)
    {
        if (bgfx::isValid(mHandle)) {
            bgfx::update(mHandle, startIndex, data);
        }
    }
 
    void bind(uint stream, bgfx::Access::Enum access = bgfx::Access::Read) const
    {
        if (bgfx::isValid(mHandle)) {
            if (!mCompute)
                bgfx::setVertexBuffer(stream, mHandle);
            else
                bgfx::setBuffer(stream, mHandle, access);
        }
    }
};
 
} // namespace vcl
 
#endif // VCL_BGFX_BUFFERS_DYNAMIC_VERTEX_BUFFER_H