BuffersVK.cpp

#include "BuffersVK.h"
 
#include "GraphicsDeviceVK.h"
 
#include "EffectsVK.h"
#include "FormatsVK.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BuffersVK");
}
 
Cogs::BufferPageVK::BufferPageVK(BufferContextVK & context, size_t pageSize)
{
  VkBufferCreateInfo bufferInfo = {};
  bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  bufferInfo.pNext = nullptr;
  bufferInfo.size = context.elementSize * pageSize;
  bufferInfo.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
  bufferInfo.flags = 0;
 
  VkMemoryAllocateInfo allocateInfo = {};
  allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  allocateInfo.pNext = nullptr;
  allocateInfo.allocationSize = 0;
  allocateInfo.memoryTypeIndex = 0;
 
  auto result = vkCreateBuffer(context.device, &bufferInfo, nullptr, &buffer);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create buffer.");
    return;
  }
 
  VkMemoryRequirements memoryRequirements;
  vkGetBufferMemoryRequirements(context.device, buffer, &memoryRequirements);
  assert(!result);
 
  allocateInfo.allocationSize = memoryRequirements.size;
  auto pass = context.graphicsDevice->getMemoryType(memoryRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &allocateInfo.memoryTypeIndex);
  assert(pass);
 
  result = vkAllocateMemory(context.device, &allocateInfo, nullptr, &deviceMemory);
  assert(!result);
 
  result = vkBindBufferMemory(context.device, buffer, deviceMemory, 0);
 
  // Resize the backing store of the page to hold pageSize number of elements.
  storage.resize(sizeof(PoolBufferVK) * pageSize);
 
  auto head = reinterpret_cast<PoolBufferVK *>(storage.data());
 
  vkMapMemory(context.device, deviceMemory, 0, memoryRequirements.size, 0, ((void **)&mappedRegion));
 
  // Initialize the linked list of elements chaining all elements in the page together.
  for (size_t i = 0; i < pageSize; ++i) {
    PoolBufferVK * block = head + i;
 
    auto offset = i * context.elementSize;
    block->mappedRegion = mappedRegion + offset;
    block->pool = context.pool;
    block->offset = offset;
    block->size = context.elementSize;
    block->buffer = buffer;
 
    block->next = block + 1;
  }
 
  (head + pageSize - 1)->next = nullptr; 
}
 
#define VERTEX_BUFFER_BIND_ID 0
 
void Cogs::BuffersVK::initialize(GraphicsDeviceVK * graphicsDevice)
{
  pool256.initialize(graphicsDevice, graphicsDevice->device, 1, 256, 1024);
  pool1024.initialize(graphicsDevice, graphicsDevice->device, 1, 1024, 256);
}
 
Cogs::VertexBufferHandle Cogs::BuffersVK::loadVertexBuffer(const void * vertexData, const size_t count, const VertexFormat & vertexFormat)
{
  const uint32_t vertexSize = getSize(vertexFormat);
  const size_t size = vertexSize * count;
 
  auto handle = loadBuffer(vertexData, size, Usage::Dynamic, AccessMode::Write, BindFlags::VertexBuffer);
 
  auto & buffer = buffers[handle];
 
  auto hashCode = getHash(vertexFormat);
  assert(hashCode);
 
  auto vIt = vertexFormats.find(hashCode);
 
  if (vIt != vertexFormats.end()) {
    buffer.vertexFormat = &vIt->second;
  } else {
    buffer.vertexFormat = &(vertexFormats[hashCode] = vertexFormat);
  }
 
  return handle;
}
 
Cogs::VertexBufferHandle Cogs::BuffersVK::loadVertexBuffer(const void * vertexData, const size_t count, VertexFormatHandle vertexFormatHandle)
{
  assert(false);
  return Cogs::VertexBufferHandle::NoHandle;
}
 
void Cogs::BuffersVK::releaseVertexBuffer(VertexBufferHandle vertexBufferHandle)
{
  assert(false);
}
 
Cogs::IndexBufferHandle Cogs::BuffersVK::loadIndexBuffer(const void * indexData, const size_t count, const size_t indexSize)
{
  auto handle = loadBuffer(indexData, count * indexSize, Usage::Dynamic, AccessMode::Write, BindFlags::IndexBuffer);
 
  auto & buffer = buffers[handle];
 
  buffer.size = count;
  buffer.indexSize = indexSize;
 
  return handle;
}
 
void Cogs::BuffersVK::releaseIndexBuffer(IndexBufferHandle indexBufferHandle)
{
}
 
namespace
{
  const char * Semantics[] = {
    "POSITION",
    "NORMAL",
    "COLOR",
    "TEXCOORD",
    "TANGENT",
    "INSTANCEVECTOR",
    "INSTANCEMATRIX",
  };
 
  const uint32_t NoRegister = ~0ul;
}
 
Cogs::InputLayoutHandle Cogs::BuffersVK::loadInputLayout(const VertexFormatHandle * vertexFormats, const size_t count, EffectHandle effectHandle)
{
  if (!HandleIsValid(effectHandle)) {
    LOG_ERROR(logger, "Cannot create input layout for invalid effect.");
    return InputLayoutHandle::InvalidHandle;
  }
 
  auto handle = inputLayouts.addResource(InputLayoutVK{});
  auto & inputLayout = inputLayouts[handle];
 
  auto findSemantic = [&](const char * semantic, size_t index = 0) -> uint32_t
  {
    auto & effect = graphicsDevice->effects.effects[effectHandle];
 
    for (auto & ia : effect.vertexShader.reflection.inputAttributes) {
      if (ia.semantic == semantic && ia.index == index) return ia.reg;
    }
 
    return NoRegister;
  };
 
  size_t attribCount = 0;
  for (size_t i = 0; i < count; ++i) {
    const VertexFormat *format = getVertexFormat(vertexFormats[i]);
    for (size_t j = 0; j < format->elements.size(); ++j) {
      auto & element = format->elements[j];
 
      if (findSemantic(Semantics[(size_t)element.semantic], element.semanticIndex) == NoRegister) continue;
 
      if (format->elements[j].semantic == ElementSemantic::InstanceVector) {
        attribCount += 4;
      } else {
        ++attribCount;
      }
    }
  }
 
  inputLayout.vertexInputBinding.resize(count);
  inputLayout.vertexInputAttribs.resize(attribCount);
 
  inputLayout.vertexInputState.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
  inputLayout.vertexInputState.pNext = nullptr;
  inputLayout.vertexInputState.vertexBindingDescriptionCount = static_cast<uint32_t>(count);
  inputLayout.vertexInputState.pVertexBindingDescriptions = inputLayout.vertexInputBinding.data();
  inputLayout.vertexInputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(attribCount);
  inputLayout.vertexInputState.pVertexAttributeDescriptions = inputLayout.vertexInputAttribs.data();
 
  for (uint32_t i = 0; i < count; ++i) {
    const VertexFormat *format = getVertexFormat(vertexFormats[i]);
    inputLayout.vertexInputBinding[i].binding = i;
    inputLayout.vertexInputBinding[i].stride = getSize(*format);
    inputLayout.vertexInputBinding[i].inputRate = format->elements.front().inputType == InputType::VertexData ? VK_VERTEX_INPUT_RATE_VERTEX : VK_VERTEX_INPUT_RATE_INSTANCE;
  }
 
  uint32_t location = 0;
 
  for (uint32_t i = 0; i < count; ++i) {
    const VertexFormat &format = *getVertexFormat(vertexFormats[i]);
    for (auto & element : format.elements) {
      auto reg = findSemantic(Semantics[(size_t)element.semantic], element.semanticIndex);
 
      if (reg == NoRegister) continue;
 
      if (element.semantic == ElementSemantic::InstanceMatrix) {
        for (uint32_t j = 0; j < 4; ++j) {
          inputLayout.vertexInputAttribs[location].binding = i;
          inputLayout.vertexInputAttribs[location].location = reg + j;
          inputLayout.vertexInputAttribs[location].format = Vulkan::TextureFormats[(size_t)element.format];
          inputLayout.vertexInputAttribs[location].offset = element.offset + 16 * j;
 
          ++location;
        }
      } else {
        inputLayout.vertexInputAttribs[location].binding = i;
        inputLayout.vertexInputAttribs[location].location = reg;
        inputLayout.vertexInputAttribs[location].format = Vulkan::TextureFormats[(size_t)element.format];
        inputLayout.vertexInputAttribs[location].offset = element.offset;
 
        ++location;
      }
    }
  }
 
  return handle;
}
 
void Cogs::BuffersVK::releaseInputLayout(InputLayoutHandle inputLayoutHandle)
{
  inputLayouts.removeResource(inputLayoutHandle);
}
 
Cogs::BufferHandle Cogs::BuffersVK::loadBuffer(const void * data, const size_t size, Usage::EUsage usage, uint32_t accessMode, uint32_t bindFlags, uint32_t stride)
{
  BufferVK buffer = {};
  buffer.bindFlags = (BindFlags::EBindFlags)bindFlags;
 
  VkBufferUsageFlags usageFlags = 0;
 
  if (bindFlags == BindFlags::VertexBuffer) {
    usageFlags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
  } else if (bindFlags == BindFlags::IndexBuffer) {
    usageFlags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
  } else if (bindFlags == BindFlags::ConstantBuffer) {
    usageFlags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
  }
 
  if (usage == Usage::Staging && (accessMode & AccessMode::Read) != 0) {
    usageFlags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
  } else if (usage == Usage::Staging && (accessMode & AccessMode::Write) != 0) {
    usageFlags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
  }
 
  if (bindFlags == BindFlags::ConstantBuffer && size < 256) {
    buffer.poolBuffer = pool256.allocate();
    buffer.bufferInfo.buffer = buffer.poolBuffer->buffer;
    buffer.bufferInfo.offset = buffer.poolBuffer->offset;
    buffer.bufferInfo.range = buffer.poolBuffer->size;
 
    return buffers.addResource(buffer);
  } else if (bindFlags == BindFlags::ConstantBuffer && size < 1024) {
    buffer.poolBuffer = pool1024.allocate();
    buffer.bufferInfo.buffer = buffer.poolBuffer->buffer;
    buffer.bufferInfo.offset = buffer.poolBuffer->offset;
    buffer.bufferInfo.range = buffer.poolBuffer->size;
 
    return buffers.addResource(buffer);
  }
 
  VkBufferCreateInfo bufferInfo = {};
  bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
  bufferInfo.pNext = nullptr;
  bufferInfo.size = size;
  bufferInfo.usage = usageFlags;
  bufferInfo.flags = 0;
 
  VkMemoryAllocateInfo allocateInfo = {};
  allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
  allocateInfo.pNext = nullptr;
  allocateInfo.allocationSize = 0;
  allocateInfo.memoryTypeIndex = 0;
 
  auto result = vkCreateBuffer(graphicsDevice->device, &bufferInfo, nullptr, &buffer.buffer);
  
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not create buffer.");
    return BufferHandle::InvalidHandle;
  }
 
  VkMemoryRequirements memoryRequirements;
  vkGetBufferMemoryRequirements(graphicsDevice->device, buffer.buffer, &memoryRequirements);
  assert(!result);
 
  buffer.size = memoryRequirements.size;
 
  allocateInfo.allocationSize = memoryRequirements.size;
  auto pass = graphicsDevice->getMemoryType(memoryRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, &allocateInfo.memoryTypeIndex);
  assert(pass);
 
  result = vkAllocateMemory(graphicsDevice->device, &allocateInfo, nullptr, &buffer.deviceMemory);
  assert(!result);
 
  if (data) {
    void * mappedMemory;
    result = vkMapMemory(graphicsDevice->device, buffer.deviceMemory, 0, allocateInfo.allocationSize, 0, &mappedMemory);
 
    assert(!result);
 
    std::memcpy(mappedMemory, data, size);
 
    vkUnmapMemory(graphicsDevice->device, buffer.deviceMemory);
  }
 
  buffer.bufferInfo.buffer = buffer.buffer;
  buffer.bufferInfo.offset = 0;
  buffer.bufferInfo.range = size;
 
  result = vkBindBufferMemory(graphicsDevice->device, buffer.buffer, buffer.deviceMemory, 0);
 
  return buffers.addResource(buffer);
}
 
void Cogs::BuffersVK::retrieveSubBuffer(void * data, BufferHandle source, const size_t offset, const size_t size)
{
  assert(false);
}
 
void Cogs::BuffersVK::releaseBuffer(BufferHandle bufferHandle)
{
  assert(false);
}
 
void * Cogs::BuffersVK::getNativeHandle(BufferHandle bufferHandle)
{
  return (void*)(buffers[bufferHandle].buffer);
}
 
void Cogs::BuffersVK::releaseResources()
{
  assert(false);
}