OpenFlightLoader.cpp

#include "OpenFlightLoader.h"
 
#include <mgapiall.h>
 
#include "Context.h"
 
Cogs::Core::Extensions::OpenFlightLoader::OpenFlightLoader()
{
  int i = 0;
  mgInit(&i, 0);
}
 
bool Cogs::Core::Extensions::OpenFlightLoader::canLoadModel(Context * context, const std::string & fileName)
{
  auto ext = fileName.substr(fileName.rfind("."), fileName.size() - 1);
 
  return ext == ".flt";
}
 
#include <unordered_map>
 
namespace
{
  struct ParseContext
  {
    ParseContext()
    {
      const size_t reserve = 100000;
 
      positions.reserve(reserve);
      normals.reserve(reserve);
      texCoords.reserve(reserve);
 
      currentIndex = -1;
    }
 
    std::vector<glm::vec3> positions;
    std::vector<glm::vec3> normals;
    std::vector<glm::vec2> texCoords;
 
    int currentIndex;
 
    std::vector<std::vector<uint32_t>> subMeshes;
    std::unordered_map<int, int> subMeshMapping;
  };
}
 
static void ParsePolygon(mgrec * rec, void * userData)
{
  auto & parseContext = *(reinterpret_cast<ParseContext *>(userData));
 
  mgrec * vertex = mgGetChild(rec);
  mgcoord3d pos;
  int count = 0;
  bool useTexture = false;
 
  glm::vec3 positions[4];
  glm::vec3 normals[4];
  glm::vec2 texCoords[4];
 
  while (vertex) {
    if (count < 4) {
      if (mgGetVtxCoord(vertex, &pos.x, &pos.y, &pos.z) == MG_TRUE) {
        positions[count] = glm::vec3(pos.x, pos.y, pos.z);
      }
 
      if (mgGetVtxNormal(vertex, &normals[count].x, &normals[count].y, &normals[count].z) == MG_TRUE) {
 
      }
 
      float u, v;
      if (mgGetAttList(vertex, fltVU, &u, fltVV, &v, MG_NULL) == 2) {
        texCoords[count] = glm::vec2(u, 1.0 - v);
        useTexture = true;
      }
    }
 
    vertex = mgGetNext(vertex);
    count++;
  }
 
  if (count == 3 || count == 4) {
    short textureIndex = -1;
    short textureMappingIndex = -1;
 
    mgGetAttList(rec, 
      fltPolyTexture, &textureIndex,
      MG_NULL);
 
    if (textureIndex > -1) {
      if (textureIndex != parseContext.currentIndex) {
        parseContext.currentIndex = parseContext.subMeshMapping[textureIndex];
      }
    } else {
      parseContext.currentIndex = 0;
    }
 
    auto & subMeshIndexes = parseContext.subMeshes[parseContext.currentIndex];
    const auto start = parseContext.positions.size();
 
    if (count == 3) {
      subMeshIndexes.push_back(start);
      subMeshIndexes.push_back(start + 1);
      subMeshIndexes.push_back(start + 2);
 
      parseContext.positions.push_back(positions[0]);
      parseContext.positions.push_back(positions[1]);
      parseContext.positions.push_back(positions[2]);
 
      parseContext.normals.push_back(normals[0]);
      parseContext.normals.push_back(normals[1]);
      parseContext.normals.push_back(normals[2]);
 
      if (useTexture) {
        parseContext.texCoords.push_back(texCoords[0]);
        parseContext.texCoords.push_back(texCoords[1]);
        parseContext.texCoords.push_back(texCoords[2]);
      }
    } else {
      subMeshIndexes.push_back(start);
      subMeshIndexes.push_back(start + 1);
      subMeshIndexes.push_back(start + 2);
 
      subMeshIndexes.push_back(start);
      subMeshIndexes.push_back(start + 2);
      subMeshIndexes.push_back(start + 3);
 
      parseContext.positions.push_back(positions[0]);
      parseContext.positions.push_back(positions[1]);
      parseContext.positions.push_back(positions[2]);
      parseContext.positions.push_back(positions[3]);
 
      parseContext.normals.push_back(normals[0]);
      parseContext.normals.push_back(normals[1]);
      parseContext.normals.push_back(normals[2]);
      parseContext.normals.push_back(normals[3]);
 
      if (useTexture) {
        parseContext.texCoords.push_back(texCoords[0]);
        parseContext.texCoords.push_back(texCoords[1]);
        parseContext.texCoords.push_back(texCoords[2]);
        parseContext.texCoords.push_back(texCoords[3]);
      }
    }
  } else {
    return;
  }
}
 
static mgbool Parse(mgrec * db, mgrec * parent, mgrec * rec, void * userData) 
{
  if (mgGetCode(rec) == fltPolygon) {
    ParsePolygon(rec, userData);
  } else if (mgGetCode(rec) == fltMesh) {
    return (MG_TRUE);
  }
 
  return (MG_TRUE);
}
 
Cogs::Core::ModelHandle Cogs::Core::Extensions::OpenFlightLoader::loadModel(Context * context, const std::string & fileName)
{
  auto & modelManager = context->modelManager;
 
  ParseContext parseContext;
 
  mgrec * db = mgOpenDb(fileName.c_str());
 
  auto modelHandle = modelManager.createModel();
  auto modelData = modelManager.getModel(modelHandle);
 
  SubModel subModel;
  subModel.transform = glm::mat4(1.0f);
  subModel.mesh = modelManager.createMesh();
 
  int texCount = mgGetTextureCount(db);
 
  auto defmaterialHandle = context->materialManager.createMaterialInstance(context->materialManager.getDefaultMaterial());
  auto defmaterial = context->materialManager.getMaterialInstance(defmaterialHandle);
 
  defmaterial->vectorProperties["diffuseColor"] = glm::vec4(1, 1, 1, 1);
 
  subModel.materials.push_back(defmaterialHandle);
 
  parseContext.subMeshMapping[-1] = parseContext.subMeshes.size();
  parseContext.subMeshes.push_back(std::vector<uint32_t>());
 
  int textureIndex = 0;
  char * textureName = nullptr;
  
  mgbool hasTexture = mgGetFirstTexture(db, &textureIndex, textureName);
 
  while (hasTexture) {
    auto name = mgGetTextureName(db, textureIndex);
 
    if (name) {
      auto materialHandle = context->materialManager.createMaterialInstance(context->materialManager.getDefaultMaterial());
      auto material = context->materialManager.getMaterialInstance(materialHandle);
 
      material->vectorProperties["diffuseColor"] = glm::vec4(1, 1, 1, 1);
 
      auto tName = std::string(name);
      auto ext = tName.substr(tName.rfind("."), tName.size() - 1);
 
      if (ext == ".inta" || ext == ".rgba") {
      
      } else {
        auto texture = context->textureManager.loadTexture(std::string(name));
 
        if (texture != TextureHandle::NoHandle) {
          material->textureProperties["diffuseMap"] = texture;
 
          if (!defmaterial->textureProperties.size()) {
            defmaterial->textureProperties["diffuseMap"] = material->textureProperties["diffuseMap"];
          }
        }
      }
 
      subModel.materials.push_back(materialHandle);
 
      parseContext.subMeshMapping[textureIndex] = parseContext.subMeshes.size();
      parseContext.subMeshes.push_back(std::vector<uint32_t>());
    }
 
    hasTexture = mgGetNextTexture(db, &textureIndex, textureName);
  }
 
  mgWalk(db, Parse, MG_NULL, &parseContext, MWALK_NOREADONLY);
 
  auto mesh = modelManager.getMesh(subModel.mesh);
 
  mesh->count = parseContext.positions.size();
  mesh->setPositions(std::move(parseContext.positions));
  mesh->setNormals(std::move(parseContext.normals));
  mesh->setTexCoords(std::move(parseContext.texCoords));
 
  for (auto & p : parseContext.subMeshes) {
    mesh->addSubMesh(std::move(p), false);
  }
 
  modelData->subModels.push_back(std::move(subModel));
 
  mgCloseDb(db);
 
  return modelHandle;
}