BuffersCommon.cpp

#include "Foundation/Logging/Logger.h"
#include "BuffersCommon.h"
#include "ContextCommon.h"
 
namespace {
  using namespace Cogs;
 
  Logging::Log logger = Logging::getLogger("BuffersCommon");
 
  BuffersCommon::BufferType getType(BindFlags::EBindFlags bindFlags)
  {
    if (bindFlags & BindFlags::VertexBuffer) {
      return BuffersCommon::BufferType::Vertex;
    }
    else if (bindFlags & BindFlags::IndexBuffer) {
      return BuffersCommon::BufferType::Index;
    }
    else if (bindFlags & BindFlags::ConstantBuffer) {
      return BuffersCommon::BufferType::Constant;
    }
    else {
      return BuffersCommon::BufferType::Unclassified;
    }
  }
 
}
 
Cogs::VertexFormatHandle Cogs::BuffersCommon::createVertexFormat(const VertexElement * elements, size_t count)
{
  return VertexFormats::createVertexFormat(elements, count);
}
 
const Cogs::VertexFormat *Cogs::BuffersCommon::getVertexFormat(VertexFormatHandle handle)
{
  return VertexFormats::getVertexFormat(handle);
}
 
Cogs::VertexArrayObjectHandle Cogs::BuffersCommon::loadVertexArrayObject(const EffectHandle,
                                                                         const VertexBufferHandle*, const size_t,
                                                                         const VertexFormat* const*, const uint32_t*, const uint32_t*,
                                                                         const IndexBufferHandle, uint32_t)
{
  LOG_ERROR_ONCE(logger, "loadVertexArrayObject: Rendering context does not support vertex array objects.");
  return Cogs::VertexArrayObjectHandle::InvalidHandle;
}
 
void Cogs::BuffersCommon::releaseVertexArrayObject(VertexArrayObjectHandle)
{
  LOG_ERROR_ONCE(logger, "releaseVertexArrayObject: Rendering context does not support vertex array objects.");
}
 
void Cogs::BuffersCommon::recordBufferCreate(BufferHandle handle, BindFlags::EBindFlags bindFlags, size_t bytes)
{
  assert(HandleIsValid(handle) && "recordBufferCreate requires a valid buffer handle.");
  auto& t = bufferStats[static_cast<size_t>(getType(bindFlags))];
  t.count.fetch_add(1);
  t.bytes.fetch_add(bytes);
}
 
void Cogs::BuffersCommon::recordBufferRelease(BufferHandle handle, BindFlags::EBindFlags bindFlags, size_t bytes)
{
  assert(HandleIsValid(handle) && "recordBufferRelease requires a valid buffer handle.");
  auto& t = bufferStats[static_cast<size_t>(getType(bindFlags))];
  t.count.fetch_sub(1);
  t.bytes.fetch_sub(bytes);
}
 
void Cogs::BuffersCommon::updateResourceStatistics(ResourceStatistics& stats) const
{
  stats.vertexBufferBytes = bufferStats[static_cast<size_t>(BufferType::Vertex)].bytes.load();
  stats.indexBufferBytes = bufferStats[static_cast<size_t>(BufferType::Index)].bytes.load();
  stats.constantBufferBytes = bufferStats[static_cast<size_t>(BufferType::Constant)].bytes.load();
  stats.unclassifiedBufferBytes = bufferStats[static_cast<size_t>(BufferType::Unclassified)].bytes.load();
  stats.vertexBufferCount = bufferStats[static_cast<size_t>(BufferType::Vertex)].count.load();
  stats.indexBufferCount = bufferStats[static_cast<size_t>(BufferType::Index)].count.load();
  stats.constantBufferCount = bufferStats[static_cast<size_t>(BufferType::Constant)].count.load();
  stats.unclassifiedBufferCount = bufferStats[static_cast<size_t>(BufferType::Unclassified)].count.load();
}