BuffersGLES30.cpp

#include "../Base/ContextCommon.h"
 
#include "ContextGLES30.h"
#include "BuffersGLES30.h"
#include "CapabilitiesGLES30.h"
#include "EffectsGLES30.h"
#include "FormatsGLES30.h"
 
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("BuffersGLES30");
}
 
#if defined(COGS_WGL) && (defined(COGSRENDERING_GFX_ANNOTATE) || defined(OSOMP_EnableProfiler))
 
void  Cogs::BuffersGLES30::annotate(BufferHandle handle, const StringView& name)
{
  if (HandleIsValid(handle) && !name.empty()) {
    BufferGLES30& buffer = buffers[handle];
 
#if defined( OSOMP_EnableProfiler )
    OsoMPAttribute  attribute = { COGSMEM_NameAttribute, ATTRIBUTETYPE_String };
 
    std::string name_(name);
    attribute.mData.mText = name_.c_str();
    RegisterGPUResourceAttributes(glBufferFakeAddress(buffer.bufferId), &attribute, 1);
#endif
 
#if defined(COGSRENDERING_GFX_ANNOTATE)
    if (glObjectLabelKHR && handle && name) {
      glObjectLabelKHR(GL_BUFFER_KHR, buffer.bufferId, static_cast<GLsizei>(name.length()), name.data());
    }
#endif
 
  }
}
void  Cogs::BuffersGLES30::annotate(VertexBufferHandle handle, const StringView& name)
{
  if (HandleIsValid(handle) && !name.empty()) {
    BufferGLES30& buffer = buffers[handle];
 
#if defined( OSOMP_EnableProfiler )
    OsoMPAttribute  attribute = { COGSMEM_NameAttribute, ATTRIBUTETYPE_String };
 
    std::string name_(name);
    attribute.mData.mText = name_.c_str();
    RegisterGPUResourceAttributes(glBufferFakeAddress(buffer.bufferId), &attribute, 1);
#endif
 
#if defined(COGSRENDERING_GFX_ANNOTATE)
    if (glObjectLabelKHR && name) {
      glObjectLabelKHR(GL_BUFFER_KHR, buffer.bufferId, static_cast<GLsizei>(name.length()), name.data());
    }
#endif
 
  }
}
#endif
 
 
Cogs::VertexBufferHandle Cogs::BuffersGLES30::loadVertexBuffer(const void * vertexData, const size_t count, const VertexFormat & vertexFormat)
{
  const uint32_t stride = getSize(vertexFormat);
  const size_t size = count * stride;
 
  auto handle = loadBuffer(vertexData, size, Usage::Default, AccessMode::None, BindFlags::VertexBuffer);
 
  auto& buffer = buffers[handle];
 
  auto formatHandle = createVertexFormat(vertexFormat.elements.data(), vertexFormat.elements.size());
 
  buffer.vertexFormat = getVertexFormat(formatHandle);
  buffer.target = OpenGLES30::BufferTarget::ArrayBuffer;
 
  assert(buffer.vertexFormat);
 
  return handle;
}
 
Cogs::VertexBufferHandle Cogs::BuffersGLES30::loadVertexBuffer(const void* vertexData, const size_t count, VertexFormatHandle vertexFormatHandle)
{
  return loadVertexBuffer(vertexData, count, *VertexFormats::getVertexFormat(vertexFormatHandle));
}
 
void Cogs::BuffersGLES30::releaseVertexBuffer(VertexBufferHandle vertexBufferHandle)
{
  releaseBuffer(vertexBufferHandle);
}
 
Cogs::IndexBufferHandle Cogs::BuffersGLES30::loadIndexBuffer(const void * indexData, const size_t count, const size_t indexSize)
{
  return loadBuffer(indexData,
                    static_cast<uint32_t>(count * indexSize),
                    Usage::Default, AccessMode::Write, BindFlags::IndexBuffer,
                    static_cast<uint32_t>(indexSize));
}
 
void Cogs::BuffersGLES30::releaseIndexBuffer(IndexBufferHandle indexBufferHandle)
{
  releaseBuffer(indexBufferHandle);
}
 
Cogs::InputLayoutHandle Cogs::BuffersGLES30::loadInputLayout(const VertexFormatHandle* vertexFormats, const size_t count, EffectHandle /*effectHandle*/)
{
  InputLayoutGLES30 inputLayout = {};
  inputLayout.numFormats = count;
 
  const uint32_t maxInputs = (uint32_t)capabilities->getDeviceCapabilities().MaxVertexInputElements;
 
  for (size_t i = 0; i < count; ++i) {
    const VertexFormat* vertexFormat = VertexFormats::getVertexFormat(vertexFormats[i]);
 
    inputLayout.formats[i] = getVertexFormat(vertexFormats[i]);
 
    if (maxInputs <= vertexFormat->elements.size()) {
      LOG_ERROR(logger, "Input element count exceeds limit set by GL_MAX_VERTEX_ATTRIBS.");
      return InputLayoutHandle::InvalidHandle;
    }
  }
  return inputLayouts.addResource(inputLayout);
}
 
void Cogs::BuffersGLES30::releaseInputLayout(InputLayoutHandle vertexFormatHandle)
{
  inputLayouts.removeResource(vertexFormatHandle);
}
 
Cogs::BufferHandle Cogs::BuffersGLES30::loadBuffer(const void* data, const size_t size, Usage::EUsage usageMode, uint32_t /*accessMode*/, uint32_t bindFlags, uint32_t stride)
{
  if constexpr (sizeof(uint32_t) < sizeof(size_t)) {
    if (std::numeric_limits<uint32_t>::max() < size) {
      LOG_ERROR(logger, "Buffer size %zu larger than 32-bits is unsupported.", size);
      return Cogs::BufferHandle::InvalidHandle;
    }
  }
 
  // FIXME: Verify these
  if (bindFlags & BindFlags::ShaderResource) { LOG_WARNING(logger, "loadBuffer: OpenGLES30 loadBuffer does not support ShaderResource flag."); }
  if (bindFlags & BindFlags::RawBuffer) { LOG_WARNING(logger, "loadBuffer: OpenGLES30 loadBuffer does not support RawBuffer flag."); }
  if (bindFlags & BindFlags::StructuredBuffer) { LOG_WARNING(logger, "loadBuffer: OpenGLES30 loadBuffer does not support StructuredBuffer flag."); }
  if (bindFlags & BindFlags::StructuredBufferWithCounter) { LOG_WARNING(logger, "loadBuffer: OpenGLES30 loadBuffer does not support StructuredBufferWithCounter flag."); }
 
  BufferGLES30 buffer = {};
  buffer.size = uint32_t(size);
  buffer.bindFlags = bindFlags;
  buffer.vertexFormat = nullptr;  // clear union
  buffer.keepMapBacking = 0;
  buffer.writeBackMap = 0;
  buffer.isMapped = 0;
  buffer.isIndexBuffer = 0;
 
  if (bindFlags & BindFlags::VertexBuffer) {
    buffer.target = OpenGLES30::BufferTarget::ArrayBuffer;
 
    if (bindFlags & BindFlags::IndexBuffer) {
#ifdef __EMSCRIPTEN__
      LOG_ERROR_ONCE(logger, "loadBuffer: Buffer with mixed vertex and index data is explicitly not supported by WebGL");
      return BufferHandle::InvalidHandle;
#else
      LOG_WARNING_ONCE(logger, "loadBuffer: Buffer with mixed vertex and index data is explicitly not supported by WebGL");
#endif
    }
 
  }
  else if (bindFlags & BindFlags::IndexBuffer) {
    buffer.target = OpenGLES30::BufferTarget::ElementArrayBuffer;
    buffer.isIndexBuffer = 1;
 
    switch (stride) {
    case 2:
      buffer.indexType = GL_UNSIGNED_SHORT;
      break;
    case 4:
      buffer.indexType = GL_UNSIGNED_INT;
      break;
    default:
      LOG_ERROR_ONCE(logger, "loadBuffer: IndexBuffer with unsupported stride %u", stride);
      return BufferHandle::InvalidHandle;
    }
 
  }
  else if (bindFlags & BindFlags::ConstantBuffer) {
    buffer.target = OpenGLES30::BufferTarget::UniformBuffer;
 
    // Round up to nearest multiple of 16 since some implementations are picky about this
    buffer.size = (buffer.size + 15) & ~15;
 
  }
  else if (bindFlags & BindFlags::StreamOutBuffer) {
    buffer.target = OpenGLES30::BufferTarget::TransformFeedbackBuffer;
  }
  else {
    buffer.target = OpenGLES30::BufferTarget::CopyReadBuffer;
  }
 
  GLenum usage = GL_STATIC_DRAW;
  switch (usageMode) {
  case Usage::Default: [[fallthrough]];
  case Usage::Static:
    usage = GL_STATIC_DRAW;
    break;
  case Usage::Dynamic:
    usage = GL_DYNAMIC_DRAW;
    buffer.keepMapBacking = 1;
    break;
  case Usage::Staging:
    usage = GL_STREAM_READ;
    buffer.keepMapBacking = 1;
    break;
  default:
    assert(false && "Illegal usage mode");
  }
 
  glGenBuffers(1, &buffer.bufferId);
  GLenum glTarget = context->bindBufferCopy(OpenGLES30::BufferTarget::CopyWriteBuffer, buffer);
  glBufferData(glTarget, static_cast<GLsizeiptr>(buffer.size), data, usage);
  if(context->uploadStatisticsEnabled) context->uploadStatisticsBufferUpload(buffer.size);
 
  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);
  }
 
  const size_t roundedSize = buffer.size;
  BufferHandle handle = buffers.addResource(std::move(buffer));
  recordBufferCreate(handle, static_cast<BindFlags::EBindFlags>(bindFlags), roundedSize);
  return handle;
}
 
void Cogs::BuffersGLES30::releaseBuffer(BufferHandle bufferHandle)
{
  if (!bufferHandle) return;
 
  BufferGLES30& buffer = buffers[bufferHandle];
  GLuint bufferId = buffer.bufferId;
 
  context->unbindBuffer(bufferId);
 
  recordBufferRelease(bufferHandle, static_cast<BindFlags::EBindFlags>(buffer.bindFlags), buffer.size);
 
  UnregisterGPUResource(glBufferFakeAddress(bufferId));
 
  glDeleteBuffers(1, &bufferId);
 
  buffers.removeResource(bufferHandle);
}
 
void Cogs::BuffersGLES30::releaseResources()
{
  {
    std::vector<BufferHandle> handles;
    for (auto& resource : buffers) {
      handles.push_back(buffers.getHandle(resource));
    }
    for (auto& handle : handles) {
      releaseBuffer(handle);
    }
  }
  {
    std::vector<InputLayoutHandle> handles;
    for (auto& resource : inputLayouts) {
      handles.push_back(inputLayouts.getHandle(resource));
    }
    for (auto& handle : handles) {
      releaseInputLayout(handle);
    }
  }
  {
    std::vector<VertexArrayObjectHandle> handles;
    for (auto& resource : vertexArrayObjects) {
      handles.push_back(vertexArrayObjects.getHandle(resource));
    }
    for (auto& handle : handles) {
      releaseVertexArrayObject(handle);
    }
  }
}
 
void Cogs::BuffersGLES30::retrieveSubBuffer(void* /*data*/, BufferHandle /*source*/, const size_t /*offset*/, const size_t /*size*/)
{
  LOG_ERROR_ONCE(logger, "retrieveSubBuffer: not implemented");
  return;
}
 
Cogs::VertexArrayObjectHandle Cogs::BuffersGLES30::loadVertexArrayObject(const EffectHandle effectHandle,
                                                                         const VertexBufferHandle* vertexBufferHandles, const size_t vertexBufferCount,
                                                                         const VertexFormat* const* vertexFormats, const uint32_t* vertexStrides, const uint32_t* vertexOffsets,
                                                                         const IndexBufferHandle indexBufferHandle, uint32_t indexStride)
{
  if (!HandleIsValid(effectHandle)) {
    LOG_ERROR_ONCE(logger, "loadVertexArrayObject: needs valid effect");
    return Cogs::VertexArrayObjectHandle::NoHandle;
  }
  const EffectGLES30& effect = effects->effects[effectHandle];
 
  for (size_t i = 0; i < vertexBufferCount; i++) {
    if (!HandleIsValid(vertexBufferHandles[i])) {
      LOG_ERROR_ONCE(logger, "loadVertexArrayObject: vertex buffer handle %zu (of %zu) is invalid", i, vertexBufferCount);
      return Cogs::VertexArrayObjectHandle::NoHandle;
    }
  }
 
  // Resolve index buffer before we create a vertex array object
  GLenum indexType = GL_INVALID_ENUM;
  if (HandleIsValid(indexBufferHandle)) {
    const BufferGLES30* buffer = &buffers[IndexBufferHandle(indexBufferHandle)];
    if (buffer->isIndexBuffer == 0) {
      LOG_ERROR_ONCE(logger, "loadVertexArrayObject: Cannot bind non-index buffer as index buffer");
      return VertexArrayObjectHandle::InvalidHandle;
    }
 
    switch (indexStride) {
    case 0:
      indexType = buffer->indexType;
      assert((indexType == GL_UNSIGNED_SHORT) || (indexType == GL_UNSIGNED_INT));
      break;
    case 2:
      indexType = GL_UNSIGNED_SHORT;
      break;
    case 4:
      indexType = GL_UNSIGNED_INT;
      break;
    default:
      LOG_ERROR_ONCE(logger, "loadVertexArrayObject: invalid index stride %u", indexStride);
      return VertexArrayObjectHandle::InvalidHandle;
    }
  }
 
 
  VertexArrayObjectGLES30 vao;
  glGenVertexArrays(1, &vao.glName);
  glBindVertexArray(vao.glName);
 
  for (size_t b = 0; b < vertexBufferCount; b++) {
 
    const BufferGLES30& buffer = buffers[VertexBufferHandle(vertexBufferHandles[b])];
    const VertexFormat* vertexFormat = buffer.vertexFormat;
    if (vertexFormats && vertexFormats[b]) {
      vertexFormat = vertexFormats[b];
    }
    const GLsizei stride = vertexStrides && vertexStrides[b] ? vertexStrides[b] : static_cast<GLsizei>(getSize(*vertexFormat));
    const GLsizei bufferOffset = vertexOffsets ? vertexOffsets[b] : 0;
 
    // Don't let context track this because it is part of VAO state.
    glBindBuffer(GL_ARRAY_BUFFER, buffer.bufferId);
 
    for (const VertexElement& element : vertexFormat->elements) {
 
      // Search for effect attribute location for this semantic/slot pair
      GLint attributeLocation = -1;
      for (size_t i = 0; i < effect.activeAttributes; i++) {
        if (effect.attributeSemantic[i].semantic == uint32_t(element.semantic) &&
            effect.attributeSemantic[i].slot == element.semanticIndex)
        {
          attributeLocation = effect.attributeLocation[i];
          break;
        }
      }
      if (attributeLocation == -1) { continue; }  // Attribute not active
 
      const OpenGLES30::DataFormatInfo format = OpenGLES30::DataFormats[size_t(element.format)];
      if (format.isVertexFormat == 0) {
        LOG_WARNING_ONCE(logger, "Encountered unsupported vertex format");
        continue;
      }
 
      const GLvoid* attribOffset = reinterpret_cast<const GLvoid*>((size_t)element.offset + bufferOffset);
      if (element.semantic == ElementSemantic::InstanceMatrix) {
        if (format.type == GL_FLOAT && format.components == 4 && format.columns == 4) {
          for (GLuint a = 0; a < 4; a++) {
            GLuint ix = attributeLocation + a;
            glVertexAttribPointer(ix, 4, format.type, GL_TRUE, stride, reinterpret_cast<const GLvoid*>(sizeof(GLfloat) * a * 4));
            glEnableVertexAttribArray(ix);
            glVertexAttribDivisor(ix, element.instanceStep);
          }
        }
      }
      else {
        if (format.columns == 1) {
          if (format.isInteger) {
            glVertexAttribIPointer(attributeLocation, format.components, format.type, stride, attribOffset);
          }
          else {
            glVertexAttribPointer(attributeLocation, format.components, format.type, format.isNormalized ? GL_TRUE : GL_FALSE, stride, attribOffset);
          }
          glEnableVertexAttribArray(attributeLocation);
          glVertexAttribDivisor(attributeLocation, element.instanceStep);
        }
      }
    }
  }
  
  if (HandleIsValid(indexBufferHandle)) {
    const BufferGLES30& buffer = buffers[IndexBufferHandle(indexBufferHandle)];
 
    // Don't let context track this because it is part of VAO state.
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer.bufferId);
 
    vao.indexType = indexType;
    switch (vao.indexType) {
    case GL_UNSIGNED_SHORT:
      vao.indexCount = GLsizei(buffer.size / 2);
      vao.indexStride = indexStride;
      break;
    case GL_UNSIGNED_INT:
      vao.indexCount = GLsizei(buffer.size / 4);
      vao.indexStride = indexStride;
      break;
    default:
      assert(false && "Illegal index type");
      break;
    }
  }
 
  glBindVertexArray(0);
  context->vertexArrayObject.prevHandle = VertexArrayObjectHandle::NoHandle;
  context->vertexArrayObject.currHandle = VertexArrayObjectHandle::NoHandle;
  context->vertexArrayObject.indexType = GL_INVALID_ENUM;
  context->vertexArrayObject.indexCount = 0;
  context->vertexArrayObject.indexStride = 0;
  return vertexArrayObjects.addResource(std::move(vao));
}
 
void Cogs::BuffersGLES30::releaseVertexArrayObject(VertexArrayObjectHandle vertexArrayObjectHandle)
{
  VertexArrayObjectGLES30& vao = vertexArrayObjects[vertexArrayObjectHandle];
  glDeleteVertexArrays(1, &vao.glName);
  vertexArrayObjects.removeResource(vertexArrayObjectHandle);
}