RenderMesh.cpp

#include "RenderMesh.h"
#include "RenderEffect.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/IContext.h"
#include "Rendering/IBuffers.h"
#include "Rendering/ICapabilities.h"
#include "Rendering/VertexFormat.h"
 
#include "Resources/VertexFormats.h"
#include "Resources/Mesh.h"
#include "Resources/Buffer.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Renderer.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("RenderMesh");
 
 
  Cogs::BufferHandle updateStream(Cogs::IBuffers* buffers, Mesh* mesh, Cogs::Core::DataStream& stream, Cogs::BindFlags::EBindFlags bindflags, bool doSet)
  {
    // Note: Here the stream more or less owns the buffer, this won't work
    // if buffers are shared across streams. But then we need something else
    // like a RenderBufferManager to manage lifetime. But for now, it looks
    // like there is always only one stream per buffer
 
    // It is BufferManager that actually determines whether this is resident or not, which doesn't mean
    // much when we update buffers here. So we don't trust or update the resident flag here and just
    // check if the buffer exist.
    Cogs::Core::ResourceBufferHandle& buffer = stream.buffer;
 
    if (Cogs::BufferHandle handle = Cogs::BufferHandle(intptr_t(buffer->getAttachedResource())); handle) {
      buffers->releaseBuffer(handle);
      buffer->unsetFlag(ResourceFlags::Resident);
      buffer->attachResource(nullptr);
    }
 
    if (doSet && !buffer->empty()) {
      Cogs::BufferHandle handle = buffers->loadBuffer((const uint8_t*)buffer->data(), buffer->size(), Cogs::Usage::Static, Cogs::AccessMode::None, bindflags, stream.stride);
      if (Cogs::StringView name = mesh->getName(); !name.empty()) {
        buffers->annotate(handle, name);
      }
      else {
        buffers->annotate(handle, "RenderMesh");
      }
      buffer->setResident();
      buffer->attachResource((RenderResource*)(intptr_t)handle.handle);
      return handle;
    }
 
    return Cogs::BufferHandle::NoHandle;
  }
 
}
 
 
Cogs::Core::RenderMesh::RenderMesh()
{
  type = RenderResourceType::RenderMesh;
 
  for (size_t i = 0; i < MeshStreamsLayout::maxStreams; ++i) {
    streamsLayout.vertexFormats[i] = VertexFormatHandle::NoHandle;
    vertexBuffers[i] = VertexBufferHandle::NoHandle;
    vertexOffsets[i] = 0;
    vertexStrides[i] = 0;
  }
}
 
 
Cogs::VertexArrayObjectHandle Cogs::Core::RenderMesh::getVertexArrayObject(IGraphicsDevice* device, const RenderEffect* renderEffect) const
{
  Cogs::IBuffers* buffers = device->getBuffers();
  if (!renderEffect || !HandleIsValid(renderEffect->effectHandle)) {
    LOG_ERROR(logger, "Trying to get a VAO for an invalid effect");
    return Cogs::VertexArrayObjectHandle::NoHandle;
  }
 
  RenderResource::Id effectId = renderEffect->getIdentity();
  if (auto it = vaos.find(effectId); it != vaos.end()) {
    return it->second;
  }
 
  std::array<const VertexFormat*, MeshStreamsLayout::maxStreams> formats;
  for (size_t i = 0; i < streamsLayout.numStreams; i++) {
    formats[i] = Cogs::VertexFormats::getVertexFormat(streamsLayout.vertexFormats[i]);
  }
 
  Cogs::VertexArrayObjectHandle vao = buffers->loadVertexArrayObject(renderEffect->effectHandle,
                                                                     vertexBuffers, streamsLayout.numStreams, formats.data(), vertexStrides, vertexOffsets,
                                                                     indexBuffer, indexStride);
  vaos.insert(std::make_pair(effectId, vao));
  return vao;
}
 
 
Cogs::Core::ActivationResult Cogs::Core::RenderMesh::update(Mesh * mesh, IGraphicsDevice * device, RenderResources * /*resources*/)
{
  bool changed = false;
  auto buffers = device->getBuffers();
  bool supportUint32Indices = device->getCapabilities()->getDeviceCapabilities().UnsignedIntIndexes;
 
  if (mesh->isMeshFlagSet(MeshFlags::StreamsChanged)) {
    streamsLayout.numStreams = 0;
    numVertexes = mesh->getCount();
 
    for (size_t i = 0; i < VertexDataType::LastVertexType; ++i) {
      VertexDataType::EVertexDataType type = VertexDataType::EVertexDataType(i);
 
      if (mesh->hasStream(type)) {
        Cogs::Core::DataStream& stream = mesh->getStream(type);
        Cogs::BufferHandle handle = Cogs::BufferHandle::NoHandle;
        if (mesh->streamsUpdated & uint16_t(1 << i)) {
          handle = updateStream(buffers, mesh, stream, Cogs::BindFlags::VertexBuffer, true);
        }
        else /*if (stream.buffer->isResident())*/ {
          // See note above, we cannot trust isResident and just check if the resource exist.
          handle = Cogs::BufferHandle(intptr_t(stream.buffer->getAttachedResource()));
        }
 
        if (HandleIsValid(handle)) {
          vertexBuffers[streamsLayout.numStreams] = handle;
          vertexOffsets[streamsLayout.numStreams] = stream.offset;
          vertexStrides[streamsLayout.numStreams] = stream.stride;
          streamsLayout.vertexFormats[streamsLayout.numStreams] = stream.format;
          streamsLayout.numStreams++;
        }
      }
    }
 
    mesh->streamsUpdated = 0;
    mesh->unsetMeshFlag(MeshFlags::StreamsChanged);
    changed = true;
  }
 
  if (mesh->isMeshFlagSet(MeshFlags::IndexesChanged)) {
    if (mesh->hasStream(VertexDataType::Indexes)) {
      DataStream& stream = mesh->getStream(VertexDataType::Indexes);
      if (!supportUint32Indices && indexStride == 4) {
        LOG_ERROR_ONCE(logger, "Mesh indices are uint32 which is not supported by graphics device");
        indexBuffer = IndexBufferHandle::NoHandle;
      }
      else {
        indexBuffer = updateStream(buffers, mesh, stream, Cogs::BindFlags::IndexBuffer, mesh->isIndexed());
        indexOffset = stream.offset;
        indexStride = stream.stride;
      }
    }
    else {
      indexBuffer = IndexBufferHandle::NoHandle;
    }
    mesh->unsetMeshFlag(MeshFlags::IndexesChanged);
    changed = true;
  }
 
  if (changed) {
    streamsLayout.updateHash();
 
    for (auto& it : vaos) {
      buffers->releaseVertexArrayObject(it.second);
    }
    vaos.clear();
  }
 
  numVertexes = mesh->getCount();
 
  setActive();
 
  return ActivationResult::Success;
}
 
void Cogs::Core::RenderMesh::release(Renderer * renderer)
{
  Cogs::IBuffers* buffers = renderer->getDevice()->getBuffers();
 
  for (auto& it : vaos) {
    buffers->releaseVertexArrayObject(it.second);
  }
  vaos.clear();
 
  setReleased();
}