BuffersGL20.cpp

#include "BuffersGL20.h"
 
namespace {
  GLuint createBuffer(GLenum target, const void * data, size_t size, const GLenum usage = GL_STATIC_DRAW)
  {
    GLuint bufferId;
 
    glGenBuffers(1, &bufferId);
    glBindBuffer(target, bufferId);
    glBufferData(target, static_cast<GLsizeiptr>(size), data, usage);
 
    return bufferId;
  }
}
 
Cogs::VertexBufferHandle Cogs::BuffersGL20::loadVertexBuffer(const void * vertexData, const size_t count, VertexFormatHandle vertexFormat)
{
  auto format = getVertexFormat(vertexFormat);
  const size_t size = count * format->size;
 
  GLuint bufferId = createBuffer(GL_ARRAY_BUFFER, vertexData, size);
  BufferGL20 buffer = {
    bufferId,
    GL_INVALID_INDEX,
    size,
    count,
    GL_ARRAY_BUFFER,
    {format},
    std::vector<uint8_t>(),
    MapMode::Read
  };
 
  bufferMemoryConsumption += buffer.size;
  return this->buffers.addResource(std::move(buffer));
}
 
Cogs::VertexBufferHandle Cogs::BuffersGL20::loadVertexBuffer(const void * vertexData, const size_t count, const VertexFormat & vertexFormat)
{
  return loadVertexBuffer(vertexData, count, createVertexFormat(vertexFormat.elements.data(), vertexFormat.elements.size()));
}
 
void Cogs::BuffersGL20::releaseVertexBuffer(VertexBufferHandle vertexBufferHandle)
{
  this->releaseBuffer(vertexBufferHandle);
}
 
Cogs::IndexBufferHandle Cogs::BuffersGL20::loadIndexBuffer(const void * indexData, const size_t count, const size_t indexSize)
{
  assert(indexSize == sizeof(GLuint) || indexSize == sizeof(GLushort));
 
  GLuint bufferId = createBuffer(GL_ELEMENT_ARRAY_BUFFER, indexData, count * indexSize);
 
  BufferGL20 buffer = { bufferId, GL_INVALID_INDEX, count * indexSize, count, GL_ELEMENT_ARRAY_BUFFER, {}, std::vector<uint8_t>(), MapMode::Read };
  buffer.indexSize = (indexSize == sizeof(GLuint)) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT;
 
  bufferMemoryConsumption += buffer.size;
  return this->buffers.addResource(std::move(buffer));
}
 
void Cogs::BuffersGL20::releaseIndexBuffer(IndexBufferHandle indexBufferHandle)
{
  this->releaseBuffer(indexBufferHandle);
}
 
Cogs::InputLayoutHandle Cogs::BuffersGL20::loadInputLayout(const VertexFormatHandle * vertexFormats, const size_t count, EffectHandle /*effectHandle*/)
{
  InputLayoutGL20 inputLayout = {};
 
  assert(count < sizeof(inputLayout.formats)/sizeof(inputLayout.formats[0]));
  for (size_t i = 0; i < count; ++i) {
    inputLayout.formats[i] = getVertexFormat(vertexFormats[i]);
  }
  inputLayout.numFormats = count;
 
  return this->inputLayouts.addResource(std::move(inputLayout));
}
 
void Cogs::BuffersGL20::releaseInputLayout(InputLayoutHandle handle)
{
  this->inputLayouts.removeResource(handle);
}
 
Cogs::BufferHandle Cogs::BuffersGL20::loadBuffer(const void * data, const size_t size, Usage::EUsage usage, uint32_t accessMode, uint32_t bindFlags, uint32_t /*stride*/)
{
  unsigned int bindFlagsGl = 0;
 
  if (bindFlags == 0) bindFlagsGl = GL_ARRAY_BUFFER;
  bindFlagsGl |= bindFlags & BindFlags::VertexBuffer ? GL_ARRAY_BUFFER : 0;
  bindFlagsGl |= bindFlags & BindFlags::IndexBuffer ? GL_ELEMENT_ARRAY_BUFFER : 0;
  bindFlagsGl |= bindFlags & BindFlags::ConstantBuffer ? GL_UNIFORM_BUFFER : 0;
  bindFlagsGl |= bindFlags & BindFlags::RawBuffer ? GL_SHADER_STORAGE_BUFFER : 0;
  bindFlagsGl |= bindFlags & BindFlags::StructuredBuffer ? GL_SHADER_STORAGE_BUFFER : 0;
  bindFlagsGl |= bindFlags & BindFlags::StructuredBufferWithCounter ? GL_SHADER_STORAGE_BUFFER : 0;
 
  GLenum usageMode = GL_STREAM_COPY;
  switch (usage)
  {
  case Cogs::Usage::Default:
    switch (accessMode)
    {
    case AccessMode::Read: usageMode = GL_STREAM_READ; break;
    case AccessMode::Write: usageMode = GL_STREAM_DRAW; break;
    default: usageMode = GL_STREAM_COPY; break;
    }
    break;
  case Cogs::Usage::Static:
    switch (accessMode)
    {
    case AccessMode::Read: usageMode = GL_STATIC_READ; break;
    case AccessMode::Write: usageMode = GL_STATIC_DRAW; break;
    default: usageMode = GL_STATIC_COPY; break;
    }
    break;
  case Cogs::Usage::Dynamic:
    switch (accessMode)
    {
    case AccessMode::Read: usageMode = GL_DYNAMIC_READ; break;
    case AccessMode::Write: usageMode = GL_DYNAMIC_DRAW; break;
    default: usageMode = GL_DYNAMIC_COPY; break;
    }
    break;
  case Cogs::Usage::Staging:
    switch (accessMode)
    {
    case AccessMode::Read: usageMode = GL_STREAM_READ; break;
    case AccessMode::Write: usageMode = GL_STREAM_DRAW; break;
    default: usageMode = GL_STREAM_COPY; break;
    }
    break;
  default:
    break;
  }
 
 
  BufferGL20 buffer = { GL_INVALID_INDEX, GL_INVALID_INDEX, size, 0, bindFlagsGl, {}, std::vector<uint8_t>(), MapMode::Read };
 
  buffer.bufferId = createBuffer(bindFlagsGl, data, size, usageMode);
 
  if (bindFlags & Cogs::BindFlags::StructuredBufferWithCounter) {
    buffer.counterBufferId = createBuffer(GL_COPY_WRITE_BUFFER, nullptr, sizeof(GLuint), GL_DYNAMIC_COPY);
  }
 
  if (bindFlags & BindFlags::VertexBuffer) {
    RegisterGPUResource(glBufferFakeAddress(buffer.bufferId), buffer.size, MemBlockType::GPUVertexBuffer);
  }
  else if (bindFlags & BindFlags::IndexBuffer) {
    RegisterGPUResource(glBufferFakeAddress(buffer.bufferId), buffer.size, MemBlockType::GPUIndexBuffer);
  }
  else if (bindFlags & BindFlags::ConstantBuffer) {
    RegisterGPUResource(glBufferFakeAddress(buffer.bufferId), buffer.size, MemBlockType::GPUConstantBuffer);
  }
  else {
    RegisterGPUResource(glBufferFakeAddress(buffer.bufferId), buffer.size, MemBlockType::GPUBuffer);
  }
 
  bufferMemoryConsumption += buffer.size;
  return this->buffers.addResource(std::move(buffer));
}
 
 
void Cogs::BuffersGL20::retrieveSubBuffer(void * data, BufferHandle source, const size_t offset, const size_t size)
{
  assert(HandleIsValid(source) && "Source buffer handle must be valid.");
  const auto & sourceBuffer = this->buffers[source];
  assert((offset + size <= sourceBuffer.size) && "Requested read outside source buffer.");
 
#ifndef __APPLE__
  if (glGetNamedBufferSubData) {
    glGetNamedBufferSubData(sourceBuffer.bufferId, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size), data);
  }
  else
#endif
  {
    glBindBuffer(sourceBuffer.target, sourceBuffer.bufferId);
    glGetBufferSubData(sourceBuffer.target, static_cast<GLintptr>(offset), static_cast<GLsizeiptr>(size), data);
    glBindBuffer(sourceBuffer.target, 0);
  }
}
 
void Cogs::BuffersGL20::releaseBuffer(BufferHandle bufferHandle)
{
  auto & buffer = this->buffers[bufferHandle];
 
  if (buffer.bufferId != GL_INVALID_INDEX) {
    UnregisterGPUResource(glBufferFakeAddress(buffer.bufferId));
    glDeleteBuffers(1, &buffer.bufferId);
    buffer.bufferId = GL_INVALID_INDEX;
  }
 
  if (buffer.counterBufferId != GL_INVALID_INDEX) {
    glDeleteBuffers(1, &buffer.counterBufferId);
    buffer.counterBufferId = GL_INVALID_INDEX;
  }
 
  bufferMemoryConsumption -= buffer.size;
  this->buffers.removeResource(bufferHandle);
}
 
void Cogs::BuffersGL20::releaseResources()
{
  {
    std::vector<BufferHandle> handles;
    for (auto & buffer : buffers) {
      handles.push_back(buffers.getHandle(buffer));
    }
 
    for (auto & handle : handles) {
      releaseBuffer(handle);
    }
  }
  {
    std::vector<InputLayoutHandle> handles;
    for (auto & layout : inputLayouts) {
      handles.push_back(inputLayouts.getHandle(layout));
    }
 
    for (auto & handle : handles) {
      releaseInputLayout(handle);
    }
  }
}
 
void Cogs::BuffersGL20::annotate(BufferHandle handle, const StringView& name)
{
  auto & buffer = this->buffers[handle];
#ifndef __APPLE__
  glObjectLabel(GL_BUFFER, buffer.bufferId, static_cast<GLsizei>(name.size()), name.data());
#else
  (void)buffer;
  (void)name;
#endif
}
void Cogs::BuffersGL20::annotate(VertexBufferHandle handle, const StringView& name)
{
  auto & buffer = this->buffers[handle];
#ifndef __APPLE__
  glObjectLabel(GL_BUFFER, buffer.bufferId, static_cast<GLsizei>(name.size()), name.data());
#else
  (void)buffer;
  (void)name;
#endif
}