Mesh.cpp

#include "Mesh.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "MeshManager.h"
#include "Buffer.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("Mesh");
}
 
Cogs::Core::Mesh::Mesh()
{
  streamIndexes.fill(NoStream);
}
 
void Cogs::Core::Mesh::clearStream(DataStream & stream)
{
  stream.buffer->clear();
  stream.numElements = 0;
 
  streamsUpdated |= toFlag(stream.type);
 
  setMeshFlag(MeshFlags::StreamsChanged);
}
 
void Cogs::Core::Mesh::clear()
{
  submeshCount = 0;
  instanceCount = 0;
  count = 0;
 
  unsetMeshFlag(MeshFlags::Indexed);
  unsetMeshFlag(MeshFlags::Instanced);
 
  for (auto & si : streamIndexes) {
    if (si != NoStream) {
      clearStream(streams[si]);
    }
  }
 
  boundingBox = Geometry::BoundingBox();
  unsetMeshFlag(MeshFlags::BoundingBoxSet);
}
 
uint8_t * Cogs::Core::Mesh::mapStream(const VertexDataType::EVertexDataType type,
                                      VertexFormatHandle format,
                                      const size_t start,
                                      const size_t count,
                                      const size_t elementSize,
                                      bool resize)
{
  auto & stream = getStream(type);
  stream.format = format;
 
  //assert(elementSize == getSize(*format) && "Vertex format and element size must match.");
 
  return mapStream(type, start, count, elementSize, resize);
}
 
uint8_t * Cogs::Core::Mesh::mapStream(const VertexDataType::EVertexDataType type,
                                      const size_t start,
                                      const size_t count,
                                      const size_t stride,
                                      bool resize)
{
  auto & stream = getStream(type);
 
  const size_t neededCapacity = size_t(start + count) * stride;
 
  if (stream.size() < neededCapacity || (resize && stream.size() != neededCapacity)) {
    stream.buffer->resize(neededCapacity);    
  }
 
  stream.numElements = static_cast<uint32_t>(start + count);
  stream.stride = static_cast<uint32_t>(stride);
 
  if (type == VertexDataType::Positions && !isIndexed()) {
    setCount(start + count);
  }
 
  return static_cast<uint8_t *>(stream.data()) + (start * stride);
}
 
Cogs::Core::DataStream & Cogs::Core::Mesh::getStream(const VertexDataType::EVertexDataType dataType)
{
  assert(streams.size() < MaxStreams && "Vertex stream limit reached.");
 
  if (streamIndexes[dataType] == NoStream) {
    streamIndexes[dataType] = static_cast<int8_t>(streams.size());
    
    auto & stream = streams.emplace_back();
    stream.type = dataType;
 
    //TODO: Supply projected size & bind flags to buffer getter to facilitate e.g reuse of existing buffer
    // resources with same configuration.
    stream.buffer = getManager()->createBuffer();
    
    if (dataType < VertexDataType::LastVertexType) {
      stream.buffer->setBindFlags(BufferBindFlags::VertexBuffer);
    } else if (dataType == VertexDataType::Indexes) {
      stream.buffer->setBindFlags(BufferBindFlags::IndexBuffer);
    }
 
    return stream;
  }
 
  return streams[streamIndexes[dataType]];
}
 
const Cogs::Core::DataStream & Cogs::Core::Mesh::getStream(const VertexDataType::EVertexDataType dataType) const
{
  assert(streamIndexes[dataType] != NoStream && "Invalid stream type.");
 
  return streams[streamIndexes[dataType]];
}
 
const Cogs::Core::DataStream * Cogs::Core::Mesh::getAllocatedStream(const VertexDataType::EVertexDataType dataType) const
{
  if (streamIndexes[dataType] != NoStream) {
    return &streams[streamIndexes[dataType]];
  } else {
    return nullptr;
  }
}
 
Cogs::Core::DataStream * Cogs::Core::Mesh::getAllocatedStream(const VertexDataType::EVertexDataType dataType)
{
  if (streamIndexes[dataType] != NoStream) {
    return &streams[streamIndexes[dataType]];
  } else {
    return nullptr;
  }
}
 
Cogs::Core::Mesh::StreamReference Cogs::Core::Mesh::getPositionStream()
{
  auto vec3Ref = getSemanticStream(ElementSemantic::Position, DataFormat::X32Y32Z32_FLOAT);
  if (vec3Ref.ptr) return vec3Ref;
  
  return getSemanticStream(ElementSemantic::Position, DataFormat::X32Y32Z32W32_FLOAT);
}
 
Cogs::Core::Mesh::StreamReference Cogs::Core::Mesh::getSemanticStream(ElementSemantic semantic, DataFormat format)
{
  for (auto & stream : streams) {
    if (!stream.format) continue;
 
    auto vertexFormat = Cogs::VertexFormats::getVertexFormat(stream.format);
 
    auto & elements = vertexFormat->elements;
 
    auto found = std::find_if(elements.begin(), elements.end(), [semantic, format](const VertexElement & element) {
      return element.semantic == semantic && element.format == format;
    });
 
    if (found != elements.end()) {
      auto offset = (*found).offset;
 
      return { static_cast<uint8_t*>(stream.data()) + offset, stream.numElements, Cogs::getSize(*vertexFormat) };
    }
  }
 
  return StreamReference{ nullptr, 0, 0 };
}
 
Cogs::Core::MeshManager* Cogs::Core::Mesh::getManager() const
{
  return static_cast<MeshManager *>(getOwner());
}
 
std::span<uint32_t> Cogs::Core::Mesh::mapPoseIndexes(uint32_t count)
{
  void* poseData = mapStream(VertexDataType::PoseIndexes, 0, count, sizeof(uint32_t), true);
  return std::span(static_cast<uint32_t *>(poseData), count);
}
 
std::span<const uint32_t> Cogs::Core::Mesh::getPoseIndexes() const
{
  auto stream = getAllocatedStream(VertexDataType::PoseIndexes);
 
  if (stream) {
    return std::span(static_cast<const uint32_t *>(stream->data()), stream->numElements);
  } else {
    return {};
  }
}
 
void Cogs::Core::Mesh::addSubMesh(std::span<uint32_t> collection, PrimitiveType::EPrimitiveType primitiveType)
{
  assert(submeshCount != uint16_t{ 0xffff });
  uint32_t indexCount = static_cast<uint32_t>(getIndexes().size());
  if (submeshCount == 0 && isIndexed() && !getIndexes().empty()) {
    // Inject current geometry as submesh
    auto subMeshes = mapSubMeshes(submeshCount + 1);
    auto & indexStream = getStream(VertexDataType::Indexes);
    subMeshes[0] = { 0, indexStream.numElements, this->primitiveType };
    indexCount = indexStream.numElements;
  }
 
  auto subMeshes = mapSubMeshes(submeshCount + 1);
 
  subMeshes[submeshCount - 1] = { indexCount, static_cast<uint32_t>(collection.size()), primitiveType };
 
  auto indexData = mapStream(VertexDataType::Indexes, 0, indexCount + collection.size(), sizeof(uint32_t));
 
  memcpy(indexData + indexCount * sizeof(uint32_t), collection.data(), sizeof(uint32_t) * collection.size());
 
  count = static_cast<uint32_t>(indexCount + collection.size());
 
  setMeshFlag(MeshFlags::Indexed);
  setMeshFlag(MeshFlags::IndexesChanged);
}
 
void Cogs::Core::Mesh::setBufferStream(VertexDataType::EVertexDataType type,
                                       ResourceBufferHandle buffer,
                                       VertexFormatHandle format,
                                       uint32_t numElements,
                                       uint32_t offset,
                                       uint32_t stride)
{
 
  if (streamIndexes[type] == NoStream) {
    streams.emplace_back();
    streamIndexes[type] = (uint8_t)streams.size() - 1;
  }
 
  auto & stream = streams[streamIndexes[type]];
 
  stream.buffer = buffer;
  stream.format = format;
  stream.numElements = numElements;
  stream.offset = offset;
  stream.stride = stride;
  stream.type = type;
 
  streamsUpdated |= toFlag(type);
  setMeshFlag(MeshFlags::StreamsChanged);
}
 
std::span<Cogs::Core::SubMesh> Cogs::Core::Mesh::mapSubMeshes(uint32_t count)
{
  assert(count < uint16_t{ 0xffff });
  void* data = mapStream(VertexDataType::SubMeshes, 0, count, sizeof(SubMesh));
  submeshCount = (uint16_t)count;
 
  return std::span(static_cast<SubMesh *>(data), count);
}
 
std::span<Cogs::Core::SubMesh> Cogs::Core::Mesh::getSubMeshes()
{
  if (submeshCount) {
    auto & stream = getStream(VertexDataType::SubMeshes);
    return std::span(static_cast<SubMesh *>(stream.data()), stream.numElements);
  } else {
    return {};
  }
}
 
std::span<const uint32_t> Cogs::Core::Mesh::getIndexes() const
{
  if (!isIndexed()) return {};
 
  auto & indexStream = getStream(VertexDataType::Indexes);
 
  if (indexStream.stride != sizeof(uint32_t)) return {};
 
  return std::span(static_cast<const uint32_t *>(indexStream.data()), indexStream.numElements);
}
 
std::span<const uint16_t> Cogs::Core::Mesh::getIndexesU16() const
{
  if (!hasIndexesU16()) return {};
 
  auto & indexStream = getStream(VertexDataType::Indexes);
 
  if (indexStream.stride != sizeof(uint16_t)) return {};
 
  return std::span(static_cast<const uint16_t *>(indexStream.data()), indexStream.numElements);
}
 
bool Cogs::Core::Mesh::hasIndexesU16() const
{
  return isIndexed() && getStream(VertexDataType::Indexes).stride == sizeof(uint16_t);
}
 
void* Cogs::Core::DataStream::data() { return buffer ? static_cast<uint8_t*>(buffer->data()) + offset : nullptr; }
const void* Cogs::Core::DataStream::data() const { return buffer ? static_cast<const uint8_t*>(buffer->data()) + offset : nullptr; }
size_t Cogs::Core::DataStream::size() const { return buffer ? buffer->size() : 0; }
 
 
Cogs::Core::MeshStreamsLayout Cogs::Core::Mesh::getStreamsLayout() const
{
  MeshStreamsLayout streamsLayout;
  streamsLayout.numStreams = 0;
  for (size_t i = 0; i < VertexDataType::LastVertexType; ++i) {
    VertexDataType::EVertexDataType type = VertexDataType::EVertexDataType(i);
    if (hasStream(type)) {
      const DataStream& stream = getStream(type);
      streamsLayout.vertexFormats[streamsLayout.numStreams++] = stream.format;
    }
  }
  streamsLayout.updateHash();
  return streamsLayout;
}