BufferAllocator.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <vector>
#include <map>
#include "Buffer.hpp"
 
// There are two different strategies for temporary buffer allocation.
// HYMN_BUFFER_STRATEGY_WHOLE:
//  Buffers are allocated of the requested size (eg. a 128B request results in a 128B buffer).
// HYMN_BUFFER_STRATEGY_SUBALLOCATE
//  1 MB large buffers are allocated and requests are satisfied by sub-allocating from these (eg. a 128B request results in an offset into a 1MB buffer).
 
#define HYMN_BUFFER_STRATEGY_SUBALLOCATE 0
#define HYMN_BUFFER_STRATEGY_WHOLE 1
#define HYMN_BUFFER_STRATEGY HYMN_BUFFER_STRATEGY_SUBALLOCATE
 
namespace Video {
 
class RawBuffer {
    public:
    virtual ~RawBuffer() {};
 
 
    virtual void Write(uint32_t offset, uint32_t size, const void* data) = 0;
};
 
struct BufferAllocation {
    RawBuffer* buffer;
 
    uint32_t offset;
 
    uint32_t size;
 
    bool temporaryAllocation;
};
 
class BufferAllocator {
  public:
 
    explicit BufferAllocator(uint32_t frames);
 
    virtual ~BufferAllocator();
 
    void BeginFrame();
 
 
    Buffer* CreateBuffer(Buffer::BufferUsage bufferUsage, uint32_t size, const void* data);
 
 
    Buffer* CreateTemporaryBuffer(Buffer::BufferUsage bufferUsage, uint32_t size, const void* data);
 
  protected:
    static const uint32_t poolSize = 1024 * 1024;
 
  private:
    BufferAllocator(const BufferAllocator& other) = delete;
 
    virtual uint32_t GetAlignment(Buffer::BufferUsage bufferUsage) = 0;
 
    virtual RawBuffer* Allocate(Buffer::BufferUsage bufferUsage, bool temporary, unsigned int size) = 0;
    BufferAllocation AllocateTemporary(Buffer::BufferUsage bufferUsage, unsigned int size);
 
    virtual Buffer* CreateBufferObject(Buffer::BufferUsage bufferUsage, const BufferAllocation& allocation) = 0;
    Buffer* CreateTemporaryBufferObject(Buffer::BufferUsage bufferUsage, const BufferAllocation& allocation);
 
    uint32_t frame = 0;
    uint32_t frames;
 
    std::vector<Buffer*>* freeBufferObjects;
    std::vector<Buffer*>* usedBufferObjects;
 
    struct SubPool {
        std::vector<RawBuffer*> rawBuffers;
        uint32_t currentRawBuffer = 0;
#if HYMN_BUFFER_STRATEGY == HYMN_BUFFER_STRATEGY_SUBALLOCATE
        uint32_t currentOffset;
#endif
    };
 
#if HYMN_BUFFER_STRATEGY == HYMN_BUFFER_STRATEGY_SUBALLOCATE
    struct Pool {
        SubPool subPools[static_cast<uint32_t>(Buffer::BufferUsage::COUNT)];
    };
#elif HYMN_BUFFER_STRATEGY == HYMN_BUFFER_STRATEGY_WHOLE
    struct Pool {
        std::map<uint32_t, SubPool> subPools[static_cast<uint32_t>(Buffer::BufferUsage::COUNT)];
    };
#endif
 
    Pool* pools;
};
 
}