Buffer.h

#pragma once
 
#include "ResourceBase.h"
#include "Resources.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Reflection/Name.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
#include <OsoMemoryProfiler/CogsMemoryProfile.h>
 
namespace Cogs::Core
{
  struct BufferFlags
  {
    enum EBufferFlags : uint16_t
    {
      None = 0,
      Dirty = 1 << 0,
      Mapped = 1 << 1,
    };
  };
 
  struct BufferBindFlags
  {
    enum EBufferBindFlags : uint16_t
    {
      None = 0,
      VertexBuffer = 1 << 0,
      IndexBuffer = 1 << 1,
    };
  };
 
  struct COGSCORE_DLL_API BufferResource : public ResourceBase
  {
    BufferResource() : bytes(MemBlockType::BufferResource) {}
 
    void set(size_t offset, size_t size, const uint8_t * data);
 
    void invalidate(size_t offset, size_t size);
 
    size_t size() const { return bytes.size(); }
 
    bool empty() const { return size() == 0; }
 
    void resize(size_t size);
 
    void reset(size_t size, Memory::Allocator * allocator);
 
    void * data() { return bytes.data(); }
 
    const void * data() const { return bytes.data(); }
 
    void * map(uint32_t flags);
 
    void unmap();
 
    void clear() { bytes.clear(); setChanged(); }
 
    void setBindFlags(uint16_t flags) { bindFlags |= flags; setChanged(); }
 
    uint16_t getBufferFlags() const { return bufferFlags; }
 
    uint16_t getBindFlags() const { return bindFlags; }
 
    bool isVertexBuffer() const { return bindFlags & BufferBindFlags::VertexBuffer; }
 
    bool isIndexBuffer() const { return bindFlags & BufferBindFlags::IndexBuffer; }
 
  private:
    // \cond
    Memory::MemoryBuffer bytes;
    uint16_t bufferFlags = BufferFlags::None;
    uint16_t bindFlags = BufferBindFlags::None;
    // \endcond
  };
 
  template<typename T>
  struct BufferView : public ResourceBufferHandle
  {
    BufferView() = default;
 
    BufferView(BufferResource * b) : ResourceBufferHandle(b) {}
 
    BufferView(const ResourceBufferHandle & other) { ResourceBufferHandle::operator=(other); }
 
    size_t size() const { return resolve()->size() / sizeof(T); };
 
    bool empty() const { return resolve()->empty(); }
 
    void resize(size_t size) { resolve()->resize(size * sizeof(T)); }
 
    T * data() { return reinterpret_cast<T *>(resolve()->data()); }
    const T * data() const { return reinterpret_cast<const T *>(resolve()->data()); }
 
    T * map() { return reinterpret_cast<T *>(resolve()->map(0)); }
 
    void unmap() { resolve()->unmap(); }
 
    T * begin() { return data(); }
 
    T * end() { return data() + size(); }
 
    uint8_t getGeneration() const { auto r = resolve(); return r ? static_cast<uint8_t>(r->getGeneration()) : 0; }
 
    T & operator[](size_t index)
    {
      assert(index * sizeof(T) < resolve()->size() && "Index out of range.");
      return *(data() + index);
    }
 
    const T & operator[](size_t index) const
    {
      assert(index * sizeof(T) < resolve()->size() && "Index out of range.");
      return *(data() + index);
    }
 
  private:
    // Hidden to avoid confusion between size()/data() in buffer and buffer-view by mixing
    // the use of . and operator->().
    using ResourceBufferHandle::operator->;
  };
}
 
#if defined( _WIN32 )
#if __cplusplus < 199711L
// VS2022 build fails if including this workaround.
template<typename T>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<T> *) { return "ResourceBufferHandle"; }
#endif
#endif
 
template<>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<uint32_t> *) { return "BufferView<uint32_t>"; }
template<>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<float> *) { return "BufferView<float>"; }
template<>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<glm::vec3> *) { return "BufferView<glm::vec3>"; }
template<>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<glm::vec4> *) { return "BufferView<glm::vec4>"; }
 
#if defined( __linux__ )
template<typename T>
inline Cogs::StringView getNameImpl(Cogs::Core::BufferView<T> *) { return "ResourceBufferHandle"; }
#endif