DimeLoader.cpp

#include "DimeLoader.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Resources/ResourceStore.h"
#include "Resources/ModelManager.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "Foundation/Platform/IO.h"
 
#include <dime/Input.h>
#include <dime/Output.h>
#include <dime/Model.h>
#include <dime/State.h>
#include <dime/convert/convert.h>
#include <dime/convert/layerdata.h>
#include <dime/convert/layergroup.h>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("DimeLoader");
}
 
bool Cogs::Core::DimeLoader::canLoad(Context *, const ModelLoadInfo & loadInfo)
{
  auto extension = IO::extension(loadInfo.resourcePath);
  return extension == ".dxf";
}
 
namespace Cogs
{
  namespace Core
  {
    MaterialInstanceHandle createMaterial(Context * context, int colorIndex, PrimitiveType::EPrimitiveType primitiveType)
    {
      auto materialInstanceHandle = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
      {
        dxfdouble r, g, b;
        dimeLayer::colorToRGB(colorIndex, r, g, b);
 
        auto materialInstance = materialInstanceHandle.resolve();
        materialInstance->setVariant("LightModel", "BaseColor");
        materialInstance->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(r, g, b, 1));
        materialInstance->setVec4Property(DefaultMaterial::SpecularColor, glm::vec4(0, 0, 0, 0));
        materialInstance->setBoolProperty(DefaultMaterial::EnableLighting, false);
        materialInstance->setFloatProperty(DefaultMaterial::LineWidth, 1.0f);
        materialInstance->setPermutation(primitiveType == PrimitiveType::LineList ? "Line" : "Default");
        materialInstance->options.cullMode = CullMode::None;
      }
 
      return materialInstanceHandle;
    }
 
    void createLayerModel(Context * context,
      Model & model,
      uint32_t parentIndex,
      const std::string& name,
      const std::vector<PositionNormalVertex>& vertexBuffer,
      const std::vector<uint32_t>& indexBuffer,
      PrimitiveType::EPrimitiveType primitiveType,
      int colorIndex)
    {
      auto mesh = context->meshManager->createLocked();
      mesh->setName(name);
      mesh->setVertexData(vertexBuffer.data(), vertexBuffer.size());
      mesh->setIndexes(std::move(indexBuffer));
      mesh->primitiveType = primitiveType;
      mesh->setBounds(calculateBounds(&(*mesh)));
 
      auto & modelPart = model.parts.emplace_back();
      modelPart.parentIndex = parentIndex;
      model.setPartName(modelPart, name);
      model.setPartTransform(modelPart, glm::mat4(1.0f));
      modelPart.meshIndex = (uint32_t)model.meshes.size();
      model.meshes.emplace_back(mesh.getHandle());
      modelPart.materialIndex = (uint32_t)model.materials.size();
      auto material = createMaterial(context, colorIndex, primitiveType);
      model.materials.emplace_back(material);
    }
  }
}
 
bool Cogs::Core::DimeLoader::load(Context * context, const ModelLoadInfo & loadInfo)
{
  std::string data = context->resourceStore->getResourceContentString(loadInfo.resourcePath);
 
  dimeInput in;
  if (!in.setMemoryBuffer(data))
  {
    LOG_ERROR(logger, "Error opening file for reading: %s", loadInfo.resourcePath.c_str());
    return false;
  }
 
  dimeModel dimeModel;
  if (!dimeModel.read(&in))
  {
    LOG_ERROR(logger, "DXF read error in line: %d", in.getFilePosition());
    return false;
  }
 
  dxfConverter converter;
  converter.setMaxerr(0.1f);
  auto useDepthOffset = (loadInfo.modelFlags & ModelLoadFlags::CustomExtensionFlag) != ModelLoadFlags::None;
  if (!converter.doConvert(dimeModel, useDepthOffset))
  {
    LOG_ERROR(logger, "Error during conversion: %s", loadInfo.resourcePath.c_str());
    return false;
  }
 
  auto model = context->modelManager->lock(loadInfo.handle);
 
  const auto& allLayers = converter.getAllLayers();
  for (auto& itLayers : allLayers)
  {
    const auto& layerGroupName = itLayers.first;
    const auto* layerGroup = itLayers.second;
    assert(layerGroup);
 
    uint32_t index = (uint32_t)model->parts.size();
    auto & modelPart = model->parts.emplace_back();
    modelPart.parentIndex = (uint32_t)-1;
    model->setPartName(modelPart, layerGroupName);
 
    const auto& allColorLayers = layerGroup->getAllLayerData();
    for (auto& itLayerData : allColorLayers)
    {
      const auto layerColorIndex = itLayerData.first;
      const auto* layer = itLayerData.second;
      assert(layer);
 
      auto& lineIndices = layer->lineindices;
      auto& linePoints = layer->linebsp;
      auto numLineIndices = lineIndices.count();
      auto numLinePoints = linePoints.numPoints();
      if (numLineIndices > 0 || numLinePoints > 0)
      {
        std::vector<PositionNormalVertex> vertexes(numLinePoints);
        for (int i = 0; i < numLinePoints; i++)
        {
          dimeVec3f dimePoint;
          linePoints.getPoint(i, dimePoint);
 
          auto& v = vertexes[i];
          v.position = glm::vec3(dimePoint.x, dimePoint.z, dimePoint.y);
          v.normal = glm::vec3(0, 0, 1);
        }
 
        std::vector<uint32_t> indexes;
        auto prevIndex = -1;
        for (auto i = 0; i < lineIndices.count(); i++)
        {
          auto currentIndex = lineIndices[i];
          if (currentIndex != -1 && prevIndex != -1)
          {
            indexes.push_back(prevIndex);
            indexes.push_back(currentIndex);
          }
 
          prevIndex = currentIndex;
        }
 
        createLayerModel(context, *model, index, "lines " + std::to_string(layerColorIndex), vertexes, indexes, PrimitiveType::LineList, layerColorIndex);
      }
 
      auto& faceIndices = layer->faceindices;
      auto& facePoints = layer->facebsp;
      auto numFaceIndices = faceIndices.count();
      auto numFacePoints = facePoints.numPoints();
      if (numFacePoints > 0 && numFaceIndices > 0)
      {
        std::vector<PositionNormalVertex> vertexes(numFacePoints);
        for (int i = 0; i < numFacePoints; i++)
        {
          dimeVec3f dimePoint;
          facePoints.getPoint(i, dimePoint);
 
          auto& v = vertexes[i];
          v.position = glm::vec3(dimePoint.x, dimePoint.z, dimePoint.y);
          v.normal = glm::vec3(0, 0, 1);
        }
 
        std::vector<uint32_t> indexes;
        std::vector<uint32_t> temp;
        for (auto i = 0; i < faceIndices.count(); i++)
        {
          auto currentIndex = faceIndices[i];
          if (currentIndex == -1 && !temp.empty())
          {
            if (temp.size() == 3 || temp.size() == 4)
            {
              indexes.push_back(temp[0]);
              indexes.push_back(temp[1]);
              indexes.push_back(temp[2]);
            }
 
            if (temp.size() == 4)
            {
              indexes.push_back(temp[0]);
              indexes.push_back(temp[2]);
              indexes.push_back(temp[3]);
            }
 
            if (temp.size() == 3 && temp.size() == 4)
            {
              LOG_WARNING(logger, "Unknown polygon type in the DXF file: %s", loadInfo.resourcePath.c_str());
            }
 
            temp.clear();
          }
          else
          {
            temp.push_back(currentIndex);
          }
        }
 
        createLayerModel(context, *model, index, "triangles " + std::to_string(layerColorIndex), vertexes, indexes, PrimitiveType::TriangleList, layerColorIndex);
      }
    }
  }
 
  return true;
}