staging.h

Go to the documentation of this file.

#ifndef NNGN_GRAPHICS_VULKAN_STAGING_H
#define NNGN_GRAPHICS_VULKAN_STAGING_H
 
#include <limits>
 
#include "graphics/stats.h"
#include "utils/log.h"
 
#include "instance.h"
#include "resource.h"
#include "vulkan.h"
 
namespace nngn {
 
class StagingBuffer {
public:
    using Stats = GraphicsStats::Staging;
    NNGN_MOVE_ONLY(StagingBuffer)
    StagingBuffer(void) = default;
    ~StagingBuffer(void);
    void init(
        const Instance &inst, VkDevice dev, DeviceMemory *dev_mem,
        VkDeviceSize default_size);
    Stats stats(std::size_t i) const;
    void resize(std::size_t n);
    bool write(std::size_t i, VkDeviceSize n, VkDeviceSize size, auto &&f);
    void destroy(std::size_t i);
private:
    struct FreeBuffer : DedicatedBuffer { u8 age = {}; };
    struct Frame {
        void release(VkDevice dev, std::vector<FreeBuffer> *free);
        void destroy(VkDevice dev, DeviceMemory *dev_mem);
        std::vector<DedicatedBuffer> blocks = {};
        void *mapped = {};
        u32 n_reused = 0, n_alloc = 0, n_req_alloc = 0;
        u64 req_mem = 0;
    };
    struct Allocation {
        DedicatedBuffer *block = {};
        VkDeviceSize offset = {}, n = {};
    };
    struct MappedRegion {
        VkDeviceMemory mem = {};
        VkDeviceSize offset = {}, n = {};
    };
    const DedicatedBuffer *cur_block(std::size_t i) const;
    DedicatedBuffer *cur_block(std::size_t i);
    Allocation alloc(std::size_t i, VkDeviceSize n, VkDeviceSize size);
    MappedRegion map(std::size_t i, VkDeviceSize n, VkDeviceSize size);
    void retire_free();
    std::vector<Frame> frames = {};
    std::vector<FreeBuffer> free = {};
    const Instance *inst = {};
    VkDevice dev = {};
    DeviceMemory *dev_mem = {};
    VkDeviceSize default_size = {};
};
 
inline void StagingBuffer::init(
    const Instance &inst_, VkDevice dev_, DeviceMemory *dev_mem_,
    VkDeviceSize default_size_
) {
    this->inst = &inst_;
    this->dev = dev_;
    this->dev_mem = dev_mem_;
    this->default_size = default_size_;
}
 
inline void StagingBuffer::resize(std::size_t n) {
    for(std::size_t i = n, old = this->frames.size(); i < old; ++i)
        this->destroy(i);
    this->frames.resize(n);
}
 
inline const DedicatedBuffer *StagingBuffer::cur_block(
    std::size_t i
) const {
    assert(i < this->frames.size());
    auto &f = this->frames[i];
    return f.blocks.empty() ? nullptr : &f.blocks.back();
}
 
inline DedicatedBuffer *StagingBuffer::cur_block(std::size_t i) {
    return const_cast<DedicatedBuffer*>(
        static_cast<const StagingBuffer*>(this)->cur_block(i));
}
 
inline bool StagingBuffer::write(
    std::size_t i, VkDeviceSize n, VkDeviceSize size, auto &&f
) {
    NNGN_LOG_CONTEXT_CF(StagingBuffer);
    for(std::size_t bi = 0; n;) {
        auto [mem, off, nw] = this->map(i, n, size);
        if(!mem)
            return false;
        void *const p = static_cast<char*>(this->frames[i].mapped) + off;
        if(!f(this->cur_block(i)->id(), p, off, bi, nw))
            return false;
        bi += static_cast<std::size_t>(nw);
        n -= static_cast<std::size_t>(nw);
    }
    return true;
}
 
}
 
#endif