RenderBuffer.cpp

#include "RenderBuffer.h"
#include "Renderer.h"
 
#include "Rendering/IBuffers.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderBuffer");
}
 
void Cogs::Core::RenderBuffer::update(Renderer * renderer)
{
  const size_t desiredSize = elementCount.getValue() ? elementCount.getValue() * elementSize.getValue() : bufferSize.getValue();
 
  if (desiredSize == size && currentCount == bufferCount) return;
 
  release(renderer);
  
  size = desiredSize;
  currentCount = bufferCount;
 
  void * data = nullptr;
  std::vector<uint32_t> fill;
  Usage::EUsage usage = Usage::Default;
  AccessMode::EAccessMode accessMode = AccessMode::None;
  BindFlags::EBindFlags bindFlags = BindFlags::None;
 
  for (auto & p : parameters) {
    if (p.key == "flags") {
      if (p.value == "Raw") {
        bindFlags = BindFlags::RawBuffer;
      } else if (p.value == "Structured") {
        bindFlags = BindFlags::StructuredBuffer;
      } else if (p.value == "StructuredWithCounter") {
        bindFlags = BindFlags::StructuredBufferWithCounter;
      }
    } else if (p.key == "fill") {
      if (p.type == ParsedDataType::UInt) {
        fill.resize(size, p.uintValue);
        data = fill.data();
      }
      else if (p.type == ParsedDataType::Int) {
        char *dat = (char*)&p.intValue;
        fill.resize(size);
        memcpy(fill.data(), dat, sizeof(int32_t));
        data = fill.data();
      }
      else if (p.type == ParsedDataType::Float) {
        char *dat = (char*)&p.floatValue;
        fill.resize(size);
        memcpy(fill.data(), dat, sizeof(float));
        data = fill.data();
      }
    } else if (p.key == "accessMode") {
      if (p.value == "Read") {
        accessMode = AccessMode::Read;
      } else if (p.value == "Write") {
        accessMode = AccessMode::Write;
      } else if (p.value == "ReadWrite") {
        accessMode = AccessMode::ReadWrite;
      }
    } else if (p.key == "usage") {
      if (p.value == "Default") {
        usage = Usage::Default;
      } else if (p.value == "Dynamic") {
        usage = Usage::Dynamic;
      } else if (p.value == "Staging") {
        usage = Usage::Staging;
      }
    }
  }
 
  auto device = renderer->getDevice();
  auto buffers = device->getBuffers();
  frames.resize(currentCount);
  if (currentCount == 1) {
    buffer = buffers->loadBuffer(data, size, usage, accessMode, bindFlags, static_cast<uint32_t>(elementSize));
    buffers->annotate(buffer, "RenderBuffer");
 
    if (!HandleIsValid(buffer)) {
      LOG_ERROR(logger, "Could not create buffer with size=%zd.", size);
    }
  } else {
    this->buffers.resize(currentCount);
    for (size_t i = 0; i < currentCount; ++i) {
      this->buffers[i] = buffers->loadBuffer(data, size, usage, accessMode, bindFlags, static_cast<uint32_t>(elementSize));
      buffers->annotate(this->buffers[i], "RenderBuffer");
 
      if (!HandleIsValid(this->buffers[i])) {
        LOG_ERROR(logger, "Could not create buffer with size=%zd.", size);
      }
    }
  }
 
  if (HandleIsValid(buffer)) {
    buffers->annotate(buffer, getName());
  }
}
 
void Cogs::Core::RenderBuffer::release(Renderer * renderer)
{
  auto device = renderer->getDevice();
  auto buffers = device->getBuffers();
 
  if (!this->buffers.size() && HandleIsValid(buffer)) {
    buffers->releaseBuffer(buffer);
  } else {
    for (size_t i = 0; i < this->buffers.size(); ++i) {
      buffers->releaseBuffer(this->buffers[i]);
    }
  }
}