CogsBin1Loader.cpp

#include "ModelLoader.h"
#include "CogsBin1.h"
 
#include "../Context.h"
 
#include "../Resources/ResourceStore.h"
#include "../Resources/ModelManager.h"
#include "../Resources/MeshManager.h"
#include "../Resources/MaterialManager.h"
#include "../Resources/TextureManager.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include <cinttypes>
#include <span>
 
#if defined( EMSCRIPTEN )
  #include "Foundation/Platform/MemoryBufferBackedFileContents.h"
#else
  // Toggle using memory mapped IO when reading file.
  #define COGS_USE_MMAP
#endif
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("CogsBin1Loader");
 
  template<typename T>
  std::span<const T> readView(const uint8_t *& data, uint64_t num, const uint8_t * dataEnd = nullptr)
  {
    const size_t size = num * sizeof(T);
 
    auto currentAlignment = (intptr_t)data % CogsBin1::CogsSectionAlignment;
 
    if (currentAlignment) {
      data += CogsBin1::CogsSectionAlignment - currentAlignment;
    }
 
    auto begin = reinterpret_cast<const T *>(data);
 
    if (dataEnd && (data + num) > dataEnd) {
      LOG_WARNING(logger, "View outside data range.");
      return {};
    }
 
    if (reinterpret_cast<intptr_t>(begin) % alignof(T) != 0) {
      LOG_WARNING(logger, "Misaligned section data 0x%p for structure with alignment %zd.", begin, alignof(T));
    }
 
    std::span<const T> view(begin, num);
 
    data += size;
 
    return view;
  }
 
}
 
bool Cogs::Core::loadCogsBin1(Context * context, const ModelLoadInfo & loadInfo, std::unique_ptr<FileContents> contents)
{
  if (!contents) return false;
 
#ifdef EMSCRIPTEN
  if (size_t(contents->ptr) & 0xF) {
 
    auto other = std::make_unique<MemoryBufferBackedFileContents>(contents->size + 0xF, contents->origin().to_string(), Cogs::FileContentsHints::None);
 
    auto alignedData = (uint8_t *)((size_t(other->bytes.data()) + 15) & ~size_t(0xF));
    std::memcpy(alignedData, contents->ptr, contents->size);
 
    other->ptr = alignedData;
    other->size = contents->size;
    contents = std::move(other);
  }
#endif
  assert(!((uintptr_t)contents->ptr % 16) && "Cogsbin data misaligned.");
 
  const auto * data = contents->ptr;
  const auto fileSize = contents->size;
  auto & header = *(CogsBin1::CogsHeader *)data;
  data += sizeof(CogsBin1::CogsHeader);
 
  if (header.magic != CogsBin1::CogsHeaderMagic) {
    LOG_ERROR(logger, "Model %s contains invalid header signature. File will not be loaded.", loadInfo.resourcePath.c_str());
    return false;
  }
 
  if (header.version > 1) {
    LOG_ERROR(logger, "Invalid or unsupported model version %d.", header.version);
    return false;
  }
 
  if (header.length != fileSize) {
    LOG_ERROR(logger, "Mismatch between file size (%zd) and expected content length (%" PRIu64 ")", fileSize, header.length);
  }
 
  auto & descriptor = *(CogsBin1::CogsDescriptor *)data;
  data += sizeof(CogsBin1::CogsDescriptor);
 
  auto dataSize = descriptor.dataSize;
  if (header.version == 1) {
    // In version 1, mesh data size is stored in this field.
    dataSize = fileSize - sizeof(CogsBin1::CogsHeader);
  }
 
  const auto dataEnd = data + dataSize;
 
  const auto stringData = readView<uint8_t>(data, descriptor.numStringBytes, dataEnd);
  const auto strings = readView<CogsBin1::CogsString>(data, descriptor.numStrings, dataEnd);
  const auto propertyData = readView<uint8_t>(data, descriptor.numPropertyBytes, dataEnd);
  const auto properties = readView<CogsBin1::CogsProperty>(data, descriptor.numProperties, dataEnd);
  const auto streams = readView<CogsBin1::CogsStream>(data, descriptor.numStreams, dataEnd);
  const auto meshes = readView<CogsBin1::CogsMesh>(data, descriptor.numMeshes, dataEnd);
  const auto materials = readView<CogsBin1::CogsMaterial>(data, descriptor.numMaterials, dataEnd);
  const auto nodeBounds = readView<Geometry::BoundingBox>(data, descriptor.numNodes, dataEnd);
  const auto nodes = readView<CogsBin1::CogsNode>(data, descriptor.numNodes, dataEnd);
 
  // Remainder of file is mesh data.
  const uint8_t * meshData = data;
 
  // FIXME: 2018-06-12 chrisdy: Is this correct?
  const uint8_t * meshDataEnd = meshData + descriptor.dataSize;
 
  std::vector<StringView> stringViews(strings.size());
  for (size_t i = 0; i < stringViews.size(); ++i) {
    auto & str = strings[i];
    const char * begin = (const char *)stringData.data() + str.start;
 
    if (str.start + str.length > stringData.size()) {
      LOG_ERROR(logger, "String data out of bounds.");
      return false;
    }
 
    stringViews[i] = StringView(begin, str.length);
  }
 
  if (descriptor.numMetadataProperties) {
    LOG_TRACE(logger, "Model metadata:");
 
    for (size_t i = 0; i < descriptor.numMetadataProperties; ++i) {
      auto & cprop = properties[descriptor.firstMetadataProperty + i];
 
      auto & ckey = stringViews[cprop.key];
      auto & cvalue = stringViews[cprop.value];
 
      LOG_TRACE(logger, "  %.*s: %.*s", StringViewFormat(ckey), StringViewFormat(cvalue));
    }
  }
 
  auto modelResource = context->modelManager->lock(loadInfo.handle);
  modelResource->meshes.resize(meshes.size());
 
  auto & modelMeshes = modelResource->meshes;
 
  for (size_t i = 0; i < meshes.size(); ++i) {
    modelMeshes[i] = context->meshManager->create();
  }
 
  std::shared_ptr<FileContents> contents_shared = std::move(contents);  // share ownership between this function and the mesh builder task
 
  context->taskManager->enqueue(TaskManager::ResourceQueue, [=]() {
    auto f = contents_shared;
 
    for (size_t i = 0; i < meshes.size(); ++i) {
      auto & cmesh = meshes[i];
 
      auto mesh = context->meshManager->lock(modelMeshes[i]);
 
      for (size_t j = cmesh.firstStream; j < cmesh.lastStream + 1; ++j) {
        if (j >= streams.size()) {
          LOG_ERROR(logger, "Stream index out of range.");
          return;
        }
 
        const auto & cstream = streams[j];
 
        auto begin = meshData + cstream.offset;
        auto end = meshData + cstream.offset + cstream.size;
 
        if (cstream.size == 0) {
          LOG_WARNING(logger, "Skipping empty stream %zu for mesh %zu.", j, i);
          continue;
        }
 
        if (begin >= meshDataEnd || end > meshDataEnd) {
          LOG_ERROR(logger, "Mesh stream data out of range.");
          return;
        }
 
        if (cstream.format == CogsBin1::CogsVertexFormat::Position3f) {
          mesh->setPositions((const glm::vec3 *)begin, (const glm::vec3 *)end);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::Normals3f) {
          mesh->setNormals((const glm::vec3 *)begin, (const glm::vec3 *)end);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::Tangent3f) {
          mesh->setTangents((const glm::vec3 *)begin, (const glm::vec3 *)end);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::TexCoord2f) {
          mesh->setTexCoords((const glm::vec2 *)begin, (const glm::vec2 *)end);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::Color4f) {
          mesh->set(VertexDataType::Colors0, VertexFormats::Color4f, (const glm::vec4 *)begin, (const glm::vec4 *)end);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::Pos3fNorm3fTex2f) {
          struct float8 { float v[8]; };
          mesh->setVertexData((float8 *)begin, cstream.size / sizeof(float8), VertexFormats::Pos3fNorm3fTex2f);
        }
        else if (cstream.format == CogsBin1::CogsVertexFormat::Indexes32) {
          mesh->setIndexData((uint32_t *)begin, cstream.size / sizeof(uint32_t));
        }
        else {
          LOG_ERROR(logger, "Unsupported stream format %d.", cstream.format);
        }
      }
 
      if (cmesh.flags & CogsBin1::CogsMeshFlags::ClockwiseWinding) {
        mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
      }
 
      Geometry::BoundingBox bounds;
      bounds.min = cmesh.boundsMin;
      bounds.max = cmesh.boundsMax;
 
      mesh->setBounds(bounds);
    }
  });
 
  const bool skipMaterials = ((ModelLoadFlags)loadInfo.loadFlags & ModelLoadFlags::SkipMaterials) != 0;
 
  if (!skipMaterials) {
    modelResource->materials.resize(materials.size());
 
    auto & modelMaterials = modelResource->materials;
 
    for (size_t i = 0; i < materials.size(); ++i) {
      auto & cmat = materials[i];
 
      if (cmat.type >= stringViews.size()) {
        LOG_ERROR(logger, "String index out of range.");
        return false;
      }
 
      auto & typeName = stringViews[cmat.type];
 
      if (typeName.empty()) {
        LOG_ERROR(logger, "Empty material name.");
        continue;
      }
 
#ifdef EMSCRIPTEN
      auto materialTemplate = context->materialManager->getDefaultMaterial();
#else
      auto materialTemplate = context->materialManager->getMaterial(typeName);
 
      if (!materialTemplate) {
        LOG_ERROR(logger, "Invalid material template. Skipping material instance.");
        continue;
      }
#endif
 
      auto material = context->materialInstanceManager->createMaterialInstance(materialTemplate);
 
      if (cmat.firstProperty != CogsBin1::CogsNoIndex) {
        for (size_t j = cmat.firstProperty; j < cmat.lastProperty + 1; ++j) {
          if (j >= properties.size()) {
            LOG_ERROR(logger, "Material property index out of range.");
            continue;
          }
 
          auto & cprop = properties[j];
 
          if (cprop.keyType != CogsBin1::CogsPropertyKeyType::String) {
            LOG_ERROR(logger, "Only string keys supported for material properties.");
            continue;
          }
 
          if (cprop.key >= stringViews.size()) {
            LOG_ERROR(logger, "Material property key index out of range.");
            continue;
          }
 
          if (cprop.valueType == CogsBin1::CogsPropertyFormat::Float4) {
            auto key = materialTemplate->getVec4Key(stringViews[cprop.key]);
            material->setVec4Property(key, *reinterpret_cast<const glm::vec4 *>(propertyData.data() + cprop.value));
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::Float3) {
            auto key = materialTemplate->getVec3Key(stringViews[cprop.key]);
            material->setVec3Property(key, *reinterpret_cast<const glm::vec3 *>(propertyData.data() + cprop.value));
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::Float2) {
            auto key = materialTemplate->getVec2Key(stringViews[cprop.key]);
            material->setVec2Property(key, *reinterpret_cast<const glm::vec3 *>(propertyData.data() + cprop.value));
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::Float) {
            auto key = materialTemplate->getFloatKey(stringViews[cprop.key]);
            material->setFloatProperty(key, *reinterpret_cast<const float *>(propertyData.data() + cprop.value));
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::String) {
            auto key = materialTemplate->getTextureKey(stringViews[cprop.key]);
            auto & source = stringViews[cprop.value];
 
            //TODO:
            // Get existing if present
            // Check if texture should be linear/sRGB
            auto & prop = materialTemplate->textureProperties[key];
 
            auto textureFlags = TextureLoadFlags::None;
 
            if (((int)prop.flags & (int)MaterialPropertyFlags::sRGB) == 0) {
              textureFlags |= TextureLoadFlags::LinearColorSpace;
            }
 
            std::string sourcePath = source.to_string();
            if (IO::isRelative(sourcePath)) {
              sourcePath = IO::combine(IO::parentPath(loadInfo.resourcePath), sourcePath);
            }
 
            auto texture = context->textureManager->loadTexture(sourcePath, NoResourceId, textureFlags);
 
            material->setTextureProperty(key, texture);
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::Variant) {
            material->setVariant(stringViews[cprop.key], stringViews[cprop.value]);
          }
          else if (cprop.valueType == CogsBin1::CogsPropertyFormat::Permutation) {
            material->setPermutation(stringViews[cprop.value]);
          }
        }
      }
 
      modelMaterials[i] = material;
    }
  }
 
  modelResource->bounds.resize(nodes.size());
  modelResource->parts.resize(nodes.size());
 
  for (size_t i = 0; i < nodes.size(); ++i) {
    modelResource->bounds[i] = nodeBounds[i];
  }
 
  for (size_t i = 0; i < nodes.size(); ++i) {
    auto & cnode = nodes[i];
 
    auto & child = modelResource->parts[i];
 
    child.parentIndex = cnode.parent;
    child.startIndex = cnode.startIndex;
    child.vertexCount = cnode.vertexCount;
 
    if (cnode.meshIndex != CogsBin1::CogsNoIndex) {
      child.meshIndex = cnode.meshIndex;
 
      if (!skipMaterials && cnode.materialIndex != CogsBin1::CogsNoMaterialIndex && cnode.materialIndex >= modelResource->materials.size()) {
        LOG_ERROR(logger, "Invalid material index in part %zu", i);
        child.materialIndex = NoIndex;
      }
      else {
        child.materialIndex = skipMaterials ? NoIndex : cnode.materialIndex;
      }
    }
 
    modelResource->setPartTransform(child, glm::translate(glm::mat4(), glm::vec3(cnode.translation)) * glm::mat4_cast(cnode.rotation) * glm::scale(glm::mat4(), glm::vec3(cnode.scale)));
 
    if (cnode.nameIndex != CogsBin1::CogsNoIndex) {
      modelResource->setPartName(child, stringViews[cnode.nameIndex]);
    }
  }
 
  return true;
}