index_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_INDEX_BUFFER_H
#define VCL_BGFX_BUFFERS_INDEX_BUFFER_H
 
#include "generic_buffer.h"
 
namespace vcl {
 
class IndexBuffer : public GenericBuffer<bgfx::IndexBufferHandle>
{
    using Base = GenericBuffer<bgfx::IndexBufferHandle>;
 
    bool mCompute = false;
 
public:
    IndexBuffer() = default;
 
    void swap(IndexBuffer& other)
    {
        using std::swap;
        Base::swap(other);
        swap(mCompute, other.mCompute);
    }
 
    friend void swap(IndexBuffer& a, IndexBuffer& b) { a.swap(b); }
 
    bool isCompute() const { return mCompute; }
 
    void setCompute(bool compute) { mCompute = compute; }
 
    void create(
        const void*     bufferIndices,
        const uint      bufferSize,
        bool            is32Bit   = true,
        bgfx::ReleaseFn releaseFn = nullptr)
    {
        if (bufferSize != 0) {
            uint64_t flags = is32Bit ? BGFX_BUFFER_INDEX32 : BGFX_BUFFER_NONE;
            uint     size  = is32Bit ? 4 : 2;
            create(
                bgfx::makeRef(bufferIndices, bufferSize * size, releaseFn),
                flags);
        }
        else {
            if (releaseFn)
                releaseFn((void*) bufferIndices, nullptr);
            destroy();
        }
    }
 
    void createForCompute(
        const void*        bufferIndices,
        const uint         bufferSize,
        PrimitiveType      type,
        bgfx::Access::Enum access    = bgfx::Access::Read,
        bgfx::ReleaseFn    releaseFn = nullptr)
    {
        if (bufferSize != 0) {
            uint64_t flags = flagsForType(type);
            flags |= flagsForAccess(access);
            create(
                bgfx::makeRef(
                    bufferIndices, bufferSize * sizeOf(type), releaseFn),
                flags,
                true);
        }
        else {
            if (releaseFn)
                releaseFn((void*) bufferIndices, nullptr);
            destroy();
        }
    }
 
    void create(
        const bgfx::Memory* indices,
        uint64_t            flags   = BGFX_BUFFER_NONE,
        bool                compute = false)
    {
        mHandle  = bgfx::createIndexBuffer(indices, flags);
        mCompute = compute;
    }
 
    void bind(
        uint               stage  = UINT_NULL,
        bgfx::Access::Enum access = bgfx::Access::Read) const
    {
        if (bgfx::isValid(mHandle)) {
            if (stage == UINT_NULL) {
                bgfx::setIndexBuffer(mHandle);
            }
            else {
                bgfx::setBuffer(stage, mHandle, access);
            }
        }
    }
};
 
} // namespace vcl
 
#endif // VCL_BGFX_BUFFERS_INDEX_BUFFER_H