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_VERTEX_BUFFER_H
#define VCL_BGFX_BUFFERS_VERTEX_BUFFER_H
 
#include "generic_buffer.h"
 
namespace vcl {
 
class VertexBuffer : public GenericBuffer<bgfx::VertexBufferHandle>
{
    using Base = GenericBuffer<bgfx::VertexBufferHandle>;
 
    bool mCompute = false;
 
public:
    VertexBuffer() = default;
 
    void swap(VertexBuffer& other)
    {
        using std::swap;
        Base::swap(other);
        swap(mCompute, other.mCompute);
    }
 
    friend void swap(VertexBuffer& a, VertexBuffer& b) { a.swap(b); }
 
    bool isCompute() const { return mCompute; }
 
    void setCompute(bool compute) { mCompute = compute; }
 
    void create(
        const void*        bufferData,
        uint               vertNum,
        bgfx::Attrib::Enum attrib,
        uint               attribNumPerVertex,
        PrimitiveType      attribType,
        bool               normalize = false,
        bgfx::ReleaseFn    releaseFn = nullptr)
    {
        if (vertNum != 0) {
            bgfx::VertexLayout layout;
            layout.begin()
                .add(
                    attrib,
                    attribNumPerVertex,
                    attributeType(attribType),
                    normalize)
                .end();
 
            create(
                bgfx::makeRef(
                    bufferData,
                    vertNum * attribNumPerVertex * sizeOf(attribType),
                    releaseFn),
                layout);
        }
        else {
            if (releaseFn)
                releaseFn((void*) bufferData, nullptr);
            destroy();
        }
    }
 
    void createForCompute(
        const void*        bufferData,
        const uint         vertNum,
        bgfx::Attrib::Enum attrib,
        uint               attribNumPerVertex,
        PrimitiveType      attribType,
        bool               normalize = false,
        bgfx::Access::Enum access    = bgfx::Access::Read,
        bgfx::ReleaseFn    releaseFn = nullptr)
    {
        if (vertNum != 0) {
            uint64_t flags = flagsForAccess(access);
 
            bgfx::VertexLayout layout;
            layout.begin()
                .add(
                    attrib,
                    attribNumPerVertex,
                    attributeType(attribType),
                    normalize)
                .end();
 
            create(
                bgfx::makeRef(
                    bufferData,
                    vertNum * attribNumPerVertex * sizeOf(attribType),
                    releaseFn),
                layout,
                flags,
                true);
        }
        else {
            if (releaseFn)
                releaseFn((void*) bufferData, nullptr);
            destroy();
        }
    }
 
    void create(
        const bgfx::Memory*       data,
        const bgfx::VertexLayout& layout,
        uint64_t                  flags   = BGFX_BUFFER_NONE,
        bool                      compute = false)
    {
        if (bgfx::isValid(mHandle))
            bgfx::destroy(mHandle);
 
        mHandle  = bgfx::createVertexBuffer(data, layout, flags);
        mCompute = compute;
    }
 
    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_VERTEX_BUFFER_H