VertexFormat.cpp

#include "VertexFormat.h"
 
#include <algorithm>
#include <unordered_map>
 
#include "Foundation/HashFunctions.h"
#include "Base/ResourceMap.h"
 
namespace
{
  uint32_t calculateSize(const Cogs::VertexFormat & vertexFormat)
  {
    uint32_t size = 0;
    for (size_t i = 0; i < vertexFormat.elements.size(); ++i) {
      auto & element = vertexFormat.elements[i];
      size = std::max(element.offset + (uint32_t)Cogs::getFormatInfo(element.format)->blockSize, size);
    }
    return size;
  }
}
 
namespace Cogs
{
  struct VertexFormatStorage
  {
    SafeResourceMap<VertexFormatHandle, VertexFormat> vertexFormats;
    std::mutex vertexFormatsByHashMutex;
    std::unordered_map<size_t, VertexFormatHandle> vertexFormatsByHash;
  };
 
  VertexFormatStorage& getStorage()
  {
    static Cogs::VertexFormatStorage storage;
    return storage;
  }
 
  VertexFormatHandle VertexFormats::createVertexFormat(const VertexElement * elements, size_t count)
  {
    VertexFormat vertexFormat;
    vertexFormat.elements.assign(elements, elements + count);
 
    size_t formatHash = Cogs::hash(vertexFormat);
 
    auto& storage = getStorage();
    std::lock_guard<std::mutex> lock(storage.vertexFormatsByHashMutex);
 
    auto foundIt = storage.vertexFormatsByHash.find(formatHash);
 
    if (foundIt != storage.vertexFormatsByHash.end()) {
      return foundIt->second;
    } else {
      vertexFormat.hash = formatHash;
      vertexFormat.size = calculateSize(vertexFormat);
      auto handle = storage.vertexFormats.addResource(std::move(vertexFormat));
      storage.vertexFormatsByHash[formatHash] = handle;
      return handle;
    }
  }
 
  VertexFormatHandle VertexFormats::createVertexFormat(const PackedVertexElement * packedElements, size_t count)
  {
    VertexFormat vertexFormat;
    uint16_t offset = 0;
    for (size_t i = 0; i < count; ++i) {
      auto & packedElement = packedElements[i];
 
      VertexElement element = {
        offset,
        packedElement.format,
        packedElement.semantic,
        packedElement.semanticIndex,
        packedElement.inputType,
        packedElement.instanceStep
      };
 
      offset += getFormatInfo(packedElement.format)->blockSize;
 
      vertexFormat.elements.emplace_back(element);
    }
 
    size_t formatHash = Cogs::hash(vertexFormat);
 
    auto& storage = getStorage();
    std::lock_guard<std::mutex> lock(storage.vertexFormatsByHashMutex);
 
    auto foundIt = storage.vertexFormatsByHash.find(formatHash);
 
    if (foundIt != storage.vertexFormatsByHash.end()) {
      return foundIt->second;
    } else {
      vertexFormat.hash = formatHash;
      vertexFormat.size = calculateSize(vertexFormat);
      auto handle = storage.vertexFormats.addResource(std::move(vertexFormat));
      storage.vertexFormatsByHash[formatHash] = handle;
      return handle;
    }
  }
 
  const VertexFormat * VertexFormats::getVertexFormat(VertexFormatHandle handle)
  {
    return &getStorage().vertexFormats[handle];
  }
}
 
Cogs::StringView Cogs::getElementSemanticName(ElementSemantic semantic)
{
  switch (semantic) {
  case ElementSemantic::Position:
    return "Position";
  case ElementSemantic::Normal:
    return "Normal";
  case ElementSemantic::Color:
    return "Color";
  case ElementSemantic::TextureCoordinate:
    return "TextureCoordinate";
  case ElementSemantic::Tangent:
    return "Tangent";
  case ElementSemantic::InstanceVector:
    return "InstanceVector";
  case ElementSemantic::InstanceMatrix:
    return "InstanceMatrix";
  case ElementSemantic::Semantic_Size:
  default:
    return "Illegal";
  }
}