Seele/src/Engine/Graphics/Metal/Buffer.mm

#include "Buffer.h"
#include "Graphics.h"
#include "Graphics/Buffer.h"
#include "Graphics/Enums.h"
#include "Graphics/Initializer.h"
#include "Graphics/Metal/Resources.h"
#include "Metal/MTLResource.hpp"
#include <iostream>

using namespace Seele;
using namespace Seele::Metal;

BufferAllocation::BufferAllocation(PGraphics graphics)
  : CommandBoundResource(graphics)
{}

BufferAllocation::~BufferAllocation()
{
  if(buffer != nullptr)
  {
    buffer->release();
  }
}

Buffer::Buffer(PGraphics graphics, uint64 size, void* data, bool dynamic, const std::string& name)
 : graphics(graphics) 
 , dynamic(dynamic)
 , name(name) {
  createBuffer(size, data);
}

Buffer::~Buffer() {
  for (size_t i = 0; i < buffers.size(); ++i) {
    //TODO
  }
}

void* Buffer::map(bool) { return getHandle()->contents(); }

void* Buffer::mapRegion(uint64 regionOffset, uint64, bool) { return (char*)getHandle()->contents() + regionOffset; }

void Buffer::unmap() {}

void Buffer::rotateBuffer(uint64 size)
{
  size = std::max(getSize(), size);
  for(size_t i = 0; i < buffers.size(); ++i)
  {
    if(buffers[i]->isCurrentlyBound())
    {
      continue;
    }
    if(buffers[i]->size < size)
    {
      buffers[i]->buffer->release();
      buffers[i]->buffer = graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
      buffers[i]->size = size;
    }
    currentBuffer = i;
    return;
  }
  createBuffer(size, nullptr);
  currentBuffer = buffers.size() - 1;
}

void Buffer::createBuffer(uint64 size, void* data)
{
  buffers.add(new BufferAllocation(graphics));
  if (data != nullptr) {
    buffers.back()->buffer = graphics->getDevice()->newBuffer(data, size, MTL::StorageModeShared);
  } else {
    buffers.back()->buffer = graphics->getDevice()->newBuffer(size, MTL::StorageModeShared);
  }
  buffers.back()->buffer->setLabel(NS::String::string(name.c_str(), NS::ASCIIStringEncoding));
}

VertexBuffer::VertexBuffer(PGraphics graphics, const VertexBufferCreateInfo& createInfo)
    : Gfx::VertexBuffer(graphics->getFamilyMapping(), createInfo.numVertices, createInfo.vertexSize,
                        createInfo.sourceData.owner),
      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}

VertexBuffer::~VertexBuffer() {}

void VertexBuffer::updateRegion(DataSource update) {
  void* data = getHandle()->contents();
  std::memcpy((char*)data + update.offset, update.data, update.size);
}

void VertexBuffer::download(Array<uint8>& buffer) {
  void* data = getHandle()->contents();
  buffer.resize(getSize());
  std::memcpy(buffer.data(), data, getSize());
}

void VertexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }

void VertexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {
  
}

IndexBuffer::IndexBuffer(PGraphics graphics, const IndexBufferCreateInfo& createInfo)
    : Gfx::IndexBuffer(graphics->getFamilyMapping(), createInfo.sourceData.size, createInfo.indexType,
                       createInfo.sourceData.owner),
      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, false, createInfo.name) {}

IndexBuffer::~IndexBuffer() {}

void IndexBuffer::download(Array<uint8>& buffer) {
  void* data = getHandle()->contents();
  buffer.resize(getSize());
  std::memcpy(buffer.data(), data, getSize());
}
void IndexBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }

void IndexBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}

UniformBuffer::UniformBuffer(PGraphics graphics, const UniformBufferCreateInfo& createInfo)
    : Gfx::UniformBuffer(graphics->getFamilyMapping(), createInfo.sourceData),
      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}

UniformBuffer::~UniformBuffer() {}

bool UniformBuffer::updateContents(const DataSource& sourceData) {
  void* data = getHandle()->contents();
  std::memcpy((char*)data + sourceData.offset, sourceData.data, sourceData.size);
  return true;
}

void UniformBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }

void UniformBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}

ShaderBuffer::ShaderBuffer(PGraphics graphics, const ShaderBufferCreateInfo& createInfo)
    : Gfx::ShaderBuffer(graphics->getFamilyMapping(), createInfo.numElements, createInfo.sourceData),
      Seele::Metal::Buffer(graphics, createInfo.sourceData.size, createInfo.sourceData.data, createInfo.dynamic, createInfo.name) {}

ShaderBuffer::~ShaderBuffer() {}

void ShaderBuffer::rotateBuffer(uint64 size) {
  Metal::Buffer::rotateBuffer(size);
}

void ShaderBuffer::updateContents(const ShaderBufferCreateInfo& createInfo) {
  Gfx::ShaderBuffer::updateContents(createInfo);
  if(createInfo.sourceData.data == nullptr)
  {
    return;
  }
  void* data = map();
  std::memcpy((char*)data + createInfo.sourceData.offset, createInfo.sourceData.data, createInfo.sourceData.size);
  unmap();
}

void* ShaderBuffer::mapRegion(uint64 offset, uint64 size, bool writeOnly)
{
  return Metal::Buffer::mapRegion(offset, size, writeOnly);
}

void ShaderBuffer::unmap()
{
  Metal::Buffer::unmap();
}

void ShaderBuffer::executeOwnershipBarrier(Gfx::QueueType newOwner) { currentOwner = newOwner; }


void ShaderBuffer::executePipelineBarrier(Gfx::SeAccessFlags srcAccess, Gfx::SePipelineStageFlags srcStage,
                                          Gfx::SeAccessFlags dstAccess, Gfx::SePipelineStageFlags dstStage) {}