gpubuffer.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "fillpolicy.h"
#include "formatutils.h"
#include "renderutils.h"
#include "bufferdata.h"
 
// External Includes
#include <nap/resourceptr.h>
#include <glm/glm.hpp>
#include <nap/logger.h>
#include <vulkan/vulkan_core.h>
#include <utility/dllexport.h>
#include <nap/signalslot.h>
#include <vector>
#include <utility/errorstate.h>
 
namespace nap
{
    class RenderService;
    class Core;
 
    enum class EMemoryUsage : uint
    {
        Static,             
        DynamicRead,        
        DynamicWrite        
    };
 
 
    // GPU Buffer
 
    class NAPAPI GPUBuffer : public Resource
    {
        friend class RenderService;
        RTTI_ENABLE(Resource)
    public:
        GPUBuffer(Core& core);
 
        GPUBuffer(Core& core, EMemoryUsage usage);
 
        // Queues buffers for destruction
        virtual ~GPUBuffer();
 
        virtual VkBuffer getBuffer() const;
 
        virtual const BufferData& getBufferData() const;
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        virtual uint getCount() const = 0;
 
        virtual size_t getSize() const = 0;
 
        virtual uint32 getElementSize() const = 0;
 
        virtual VkBufferUsageFlags getBufferUsageFlags() const      { return mUsageFlags; }
 
        void ensureUsage(VkBufferUsageFlags usage)                  { mUsageFlags |= usage; }
 
        virtual bool isInitialized() const = 0;
 
        void asyncGetData(std::function<void(const void*, size_t)> copyFunction);
 
        nap::Signal<> bufferChanged;
 
        EMemoryUsage mMemoryUsage = EMemoryUsage::Static;           
 
    protected:
        bool allocateInternal(size_t size, utility::ErrorState& errorState);
 
        bool setDataInternal(const void* data, size_t size, size_t reservedSize, utility::ErrorState& errorState);
 
        void requestClear();
 
        RenderService*              mRenderService = nullptr;                   
        std::vector<BufferData>     mRenderBuffers;                             
        std::vector<BufferData>     mStagingBuffers;                            
        uint32                      mSize = 0;                                  
 
        int                         mCurrentRenderBufferIndex = 0;              
        int                         mCurrentStagingBufferIndex = 0;             
        std::vector<int>            mDownloadStagingBufferIndices;              
 
    private:
        using BufferReadCallback = std::function<void(void* data, size_t sizeInBytes)>;
 
        // Called when usage = static
        bool setDataInternalStatic(const void* data, size_t size, utility::ErrorState& errorState);
 
        // Called when usage = dynamic write
        bool setDataInternalDynamic(const void* data, size_t size, size_t reservedSize, utility::ErrorState& errorState);
 
        // Uploads data from the staging buffer into GPU buffer. Automatically called by the render service at the appropriate time.
        // Only occurs when 'usage' = 'static'. Dynamic data shares GPU / CPU memory and is updated immediately.
        void upload(VkCommandBuffer commandBuffer);
 
        // Downloads data from GPU buffer to staging buffer
        void download(VkCommandBuffer commandBuffer);
 
        // Clears the buffer to zero
        void clear(VkCommandBuffer commandBuffer);
 
        // Called by the render service when download is ready
        void notifyDownloadReady(int frameIndex);
 
        // Clears queued texture downloads
        void clearDownloads();
 
        std::vector<BufferReadCallback> mReadCallbacks;         
        VkBufferUsageFlags mUsageFlags = 0;                     
    };
 
 
    // GPUBufferNumeric
 
    class NAPAPI GPUBufferNumeric : public GPUBuffer
    {
        RTTI_ENABLE(GPUBuffer)
    public:
        GPUBufferNumeric(Core& core, VkFormat format, uint32 elementSize) :
            GPUBuffer(core), mFormat(format), mElementSize(elementSize)
        { }
 
        GPUBufferNumeric(Core& core, VkFormat format, uint32 elementSize, EMemoryUsage usage) :
            GPUBuffer(core, usage), mFormat(format), mElementSize(elementSize)
        { }
 
        virtual uint getCount() const override                      { return mCount; }
 
        virtual uint32 getElementSize() const override              { return mElementSize; };
 
        virtual size_t getSize() const override                     { return mCount * mElementSize; };
 
        virtual VkFormat getFormat() const                          { return mFormat; }
 
        virtual void setCount(uint32 count)                         { mCount = count; }
 
        virtual bool setData(const void* data, size_t elementCount, size_t reservedElementCount, utility::ErrorState& errorState);
 
        uint32 mCount = 0;                              
 
    private:
        VkFormat mFormat = VK_FORMAT_UNDEFINED;         
        uint32 mElementSize = 0;                        
    };
 
 
    // Numeric GPU Buffer
 
    template<typename T>
    class TypedGPUBufferNumeric : public GPUBufferNumeric
    {
        RTTI_ENABLE(GPUBufferNumeric)
    public:
        TypedGPUBufferNumeric(Core& core) :
            GPUBufferNumeric(core, getVulkanFormat(RTTI_OF(T)), sizeof(T))
        { }
 
        TypedGPUBufferNumeric(Core& core, EMemoryUsage usage, bool storage) :
            GPUBufferNumeric(core, getVulkanFormat(RTTI_OF(T)), sizeof(T), usage), mStorage(storage)
        { }
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        bool setData(const std::vector<T>& data, utility::ErrorState& errorState);
 
        virtual bool isInitialized() const override                     { return mInitialized; };
 
        bool mClear = false;                                            
        ResourcePtr<FillPolicy<T>> mFillPolicy = nullptr;               
 
    private:
        bool mStorage = true;                                           
        bool mInitialized = false;                                      
    };
 
 
    // Vertex Buffers
 
    template<typename T>
    class VertexBuffer : public TypedGPUBufferNumeric<T>
    {
        RTTI_ENABLE(TypedGPUBufferNumeric<T>)
    public:
        VertexBuffer(Core& core) :
            TypedGPUBufferNumeric<T>(core)
        { }
 
        VertexBuffer(Core& core, EMemoryUsage usage, bool storage) :
            TypedGPUBufferNumeric<T>(core, usage, storage)
        { }
 
        virtual bool init(utility::ErrorState& errorState) override;
    };
 
 
    // Index Buffer
 
    class NAPAPI IndexBuffer : public TypedGPUBufferNumeric<uint>
    {
        RTTI_ENABLE(TypedGPUBufferNumeric<uint>)
    public:
        // Constructor
        IndexBuffer(Core & core) : TypedGPUBufferNumeric<uint>(core)            { }
 
        IndexBuffer(Core & core, EMemoryUsage usage, bool storage) :
            TypedGPUBufferNumeric<uint>(core, usage, storage)       { }
 
        virtual bool init(utility::ErrorState & errorState) override;
    };
 
 
    // GPU numeric buffer type definitions
 
    // General purpose GPU buffers
    using GPUBufferUInt         = TypedGPUBufferNumeric<uint>;
    using GPUBufferInt          = TypedGPUBufferNumeric<int>;
    using GPUBufferFloat        = TypedGPUBufferNumeric<float>;
    using GPUBufferVec2         = TypedGPUBufferNumeric<glm::vec2>;
    using GPUBufferVec3         = TypedGPUBufferNumeric<glm::vec3>;
    using GPUBufferVec4         = TypedGPUBufferNumeric<glm::vec4>;
    using GPUBufferMat4         = TypedGPUBufferNumeric<glm::mat4>;
 
    // Vertex GPU buffers
    using VertexBufferUInt      = VertexBuffer<uint>;
    using VertexBufferInt       = VertexBuffer<int>;
    using VertexBufferFloat     = VertexBuffer<float>;
    using VertexBufferVec2      = VertexBuffer<glm::vec2>;
    using VertexBufferVec3      = VertexBuffer<glm::vec3>;
    using VertexBufferVec4      = VertexBuffer<glm::vec4>;
 
 
    // Template Definitions
 
    template<typename T>
    bool TypedGPUBufferNumeric<T>::init(utility::ErrorState& errorState)
    {
        // Ensure storage bit is set if requested
        VkBufferUsageFlags req_usage = mStorage ? VK_BUFFER_USAGE_STORAGE_BUFFER_BIT : 0;
        this->ensureUsage(req_usage);
 
        // Initialize Base
        if (!GPUBufferNumeric::init(errorState))
            return false;
 
        if (!errorState.check(mMemoryUsage != EMemoryUsage::DynamicWrite || mCount >= 0,
            "Cannot allocate a non-DynamicWrite buffer with zero elements."))
            return false;
 
        // Calculate buffer size
        uint32 buffer_size = mCount * sizeof(T);
 
        // Allocate buffer memory
        if (!allocateInternal(buffer_size, errorState))
            return false;
 
        // Upload data when a buffer fill policy is available
        if (mFillPolicy != nullptr)
        {
            if (mMemoryUsage != EMemoryUsage::DynamicRead)
            {
                // Create a staging buffer to upload
                auto staging_buffer = std::make_unique<T[]>(mCount);
                mFillPolicy->fill(mCount, staging_buffer.get());
 
                // Prepare staging buffer upload
                if (!setDataInternal(staging_buffer.get(), buffer_size, buffer_size, errorState))
                    return false;
            }
            else
            {
                // Warn user that buffers cannot be filled when their usage is set to DynamicRead
                nap::Logger::warn(utility::stringFormat("%s: The configured fill policy was ignored as the buffer usage is DynamicRead", mID.c_str()).c_str());
            }
        }
 
        // Optionally clear - does not count as an upload
        else if (mClear)
        {
            GPUBuffer::requestClear();
        }
 
        mInitialized = true;
        return true;
    }
 
    template<typename T>
    bool TypedGPUBufferNumeric<T>::setData(const std::vector<T>& data, utility::ErrorState& errorState)
    {
        if (!setDataInternal(data.data(), data.size() * sizeof(T), data.capacity() * sizeof(T), errorState))
            return false;
 
        // Update count
        mCount = data.size();
        return true;
    }
 
    template<typename T>
    bool VertexBuffer<T>::init(utility::ErrorState& errorState)
    {
        this->ensureUsage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
        return TypedGPUBufferNumeric<T>::init(errorState);
    }
}