AssetImporterLoader.cpp

#include "AssetImporterLoader.h"
 
#include "Context.h"
 
#include <assimp/Importer.hpp>
#include <assimp/IOSystem.hpp>
#include <assimp/IOStream.hpp>
#include <assimp/postprocess.h>
#include <assimp/mesh.h>
#include <assimp/scene.h>
 
#include "Resources/MeshManager.h"
#include "Resources/ModelManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/AnimationManager.h"
#include "Resources/ResourceStore.h"
#include "Resources/Skeleton.h"
#include "Resources/Animation.h"
 
#include "Rendering/IGraphicsDevice.h"
#include "Rendering/ITextures.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include <glm/gtx/matrix_decompose.hpp>
 
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
 
#include "Services/Variables.h"
 
using namespace Cogs::Core;
using namespace Cogs;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("AssetImporterLoader");
 
  glm::mat4 toGlm(aiMatrix4x4 matrix)
  {
    matrix.Transpose();
 
    return glm::make_mat4((float *)&(matrix));
  }
 
  glm::vec3 toGlm(aiVector3D v)
  {
    return glm::make_vec3((float *)&(v));
  }
 
  glm::quat toGlm(aiQuaternion q)
  {
    return glm::quat(q.w, q.x, q.y, q.z);
  }
 
  class InputIOStream : public Assimp::IOStream
  {
  public:
    InputIOStream(const Cogs::Core::ResourceBuffer & resourceBuffer) :
      resourceBuffer(resourceBuffer),
      buffer(resourceBuffer.data()),
      position(resourceBuffer.data()),
      size(resourceBuffer.size())
    {
 
    }
 
    size_t Read(void * destBuffer, size_t pSize, size_t pCount) override
    {
      const size_t bytesToRead = pSize * pCount;
      const size_t offset = position - buffer;
 
      if (offset < size) {
        auto bytesLeft = size - offset;
 
        auto bytesRead = std::min(bytesToRead, bytesLeft);
 
        if (bytesRead != 0) {
          ::memcpy(destBuffer, position, bytesRead);
          position += bytesRead;
        }
 
        return bytesRead;
      }
 
      return 0;
    }
 
    size_t Write(const void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override
    {
      // Write not supported for now.
      return 0;
    }
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable: 26812) // prefer enum class over enum
#endif
    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override
    {
      switch (pOrigin) {
      case aiOrigin_SET:
        position = buffer + pOffset;
        break;
      case aiOrigin_CUR:
        position += pOffset;
        break;
      case aiOrigin_END:
        position = buffer + size + pOffset;
        break;
      default:
        break;
      }
 
      return aiReturn_SUCCESS;
    }
#ifdef _WIN32
#pragma warning(pop)
#endif
 
    size_t Tell() const override
    {
      return position - buffer;
    }
 
    size_t FileSize() const override
    {
      return size;
    }
 
    void Flush() override
    {
      return;
    }
 
  private:
    Cogs::Core::ResourceBuffer resourceBuffer;
    const uint8_t * buffer;
    const uint8_t * position;
    size_t size;
  };
 
  class MmapIOStream : public Assimp::IOStream
  {
  public:
    MmapIOStream(const Cogs::StringView & path) :
      path(path)
    {
      file = IO::openFile(path, FileHandle::OpenMode::OpenAlways, FileHandle::AccessMode::Read);
      size = IO::fileSize(file);
      buffer = (const uint8_t *)IO::mapFile(file, FileHandle::ProtectionMode::ReadOnly, 0, size);
      position = buffer;
    }
 
    size_t Read(void * destBuffer, size_t pSize, size_t pCount) override
    {
      const size_t bytesToRead = pSize * pCount;
      const size_t offset = position - buffer;
 
      if (offset < size) {
        auto bytesLeft = size - offset;
 
        auto bytesRead = std::min(bytesToRead, bytesLeft);
 
        if (bytesRead != 0) {
          ::memcpy(destBuffer, position, bytesRead);
          position += bytesRead;
        }
 
        return bytesRead;
      }
 
      return 0;
    }
 
    size_t Write(const void * /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) override
    {
      // Write not supported for now.
      return 0;
    }
 
    aiReturn Seek(size_t pOffset, aiOrigin pOrigin) override
    {
      switch (pOrigin) {
      case aiOrigin_SET:
        position = buffer + pOffset;
        break;
      case aiOrigin_CUR:
        position += pOffset;
        break;
      case aiOrigin_END:
        position = buffer + size + pOffset;
        break;
      default:
        break;
      }
 
      return aiReturn_SUCCESS;
    }
 
    size_t Tell() const override
    {
      return position - buffer;
    }
 
    size_t FileSize() const override
    {
      return size;
    }
 
    void Flush() override
    {
      return;
    }
 
  private:
    Cogs::StringView path;
    Cogs::FileHandle::Ptr file;
    const uint8_t * buffer = nullptr;
    const uint8_t * position = nullptr;
    size_t size = 0;
  };
 
  class IOSystem : public Assimp::IOSystem
  {
  public:
    IOSystem(Context * context) : context(context)
    {
      useMmap = context->variables->get("resources.useMemoryMappedIO", false);
    }
 
    bool Exists(const char * pFile) const override
    {
      if (useMmap) {
        auto path = context->resourceStore->getResourcePath(pFile, ResourceStoreFlags::NoCachedContent);
        return IO::exists(path);
      } else {
        return context->resourceStore->getResourceContents(pFile).size() != 0;
      }
    }
 
    char getOsSeparator() const override
    {
      return IO::pathSeparator();
    }
 
    Assimp::IOStream * Open(const char* pFile, const char* /*pMode = "rb"*/) override
    {
      if (useMmap) {
        auto name = context->resourceStore->getResourcePath(pFile, ResourceStoreFlags::NoCachedContent);
 
        return new MmapIOStream(name.c_str());
      } else {
        auto content = context->resourceStore->getResourceContents(pFile);
 
        if (!content.size()) return nullptr;
 
        return new InputIOStream(content);
      }
    }
 
    void Close(Assimp::IOStream * pFile) override
    {
      delete pFile;
    }
 
  private:
    Context * context = nullptr;
    bool useMmap = true;
  };
 
  glm::vec3 xformPosition(const glm::mat4 & transform, const glm::vec3 & pos)
  {
    glm::vec4 c = transform * glm::vec4(pos.x, pos.y, pos.z, 1);
    if (c.w == 0) {
      c = glm::vec4(0, 0, 0, 1.0f);
    } else {
      c /= c.w;
    }
 
    return glm::vec3(c);
  }
 
  glm::vec3 xformVector(const glm::mat4 & transform, const glm::vec3 & n)
  {
    return xformPosition(transform, n) - xformPosition(transform, glm::vec3(0, 0, 0));
  }
 
  glm::vec3 calcNormal(const glm::mat4 & transform, const glm::vec3 & p1, const glm::vec3 & p2, const glm::vec3 & p3)
  {
    return glm::normalize(glm::cross(xformVector(transform, p2 - p1), xformVector(transform, p3 - p2)));
  }
 
  bool needInvertNormals(const glm::mat4 & transform,
                         const std::vector<uint32_t> &indexes,
                         const glm::vec3 * points, const glm::vec3 * normals,
                         const uint32_t count)
  {
    if (!indexes.empty()) {
      for (size_t p = 1; p < indexes.size() - 1; p += 3) {
        const auto n = calcNormal(transform, points[indexes[p - 1]], points[indexes[p]], points[indexes[p + 1]]);
        float dotProduct = glm::dot(n, glm::normalize(xformVector(transform, normals[indexes[p]])));
        if (dotProduct > 0.5f)
          return false;
        else if (dotProduct < -0.5f)
          return true;
      }
    } else {
      for (uint32_t p = 1; p < count - 1; p += 3) {
        const auto n = calcNormal(transform, points[p - 1], points[p], points[p + 1]);
        float dotProduct = glm::dot(n, glm::normalize(xformVector(transform, normals[p])));
        if (dotProduct > 0.5f)
          return false;
        else if (dotProduct < -0.5f)
          return true;
      }
    }
 
    return false;
  }
 
}
 
void Cogs::Core::AssetImporterLoader::handleBones(const aiMesh * mesh, Model & root, const glm::mat4 & globalTransform, Mesh * meshData)
{
  const size_t numBones = mesh->mNumBones;
 
  std::vector<int> numBoneWeights(mesh->mNumVertices);
  std::vector<glm::ivec4> boneIndexes(mesh->mNumVertices);
  std::vector<glm::vec4> boneWeights(mesh->mNumVertices);
 
  bool weightsOutOfBounds = false;
 
  auto & skeleton = root.skeleton;
  skeleton.bindPose = glm::inverse(globalTransform);
 
  auto poseIndexes = meshData->mapPoseIndexes((uint32_t)numBones);
 
  if (numBones > kMaxBones) {
    LOG_WARNING(logger, "Mesh bone count %zd exceeds max limit %zd.", numBones, kMaxBones);
  }
 
  for (size_t i = 0; i < numBones; ++i) {
    auto aBone = mesh->mBones[i];
 
    std::string name = aBone->mName.C_Str();
 
    auto fIt = skeleton.bonesByName.find(name);
    if (fIt == skeleton.bonesByName.end()) continue;
 
    auto boneIndex = fIt->second;
    auto & bone = skeleton.bones[boneIndex];
 
    poseIndexes[i] = (uint32_t)boneIndex;
 
    bone.used = true;
 
    if (!bone.hasOffset) {
      bone.inverseBindPose = toGlm(aBone->mOffsetMatrix);
      bone.hasOffset = true;
    }
 
    auto numWeights = aBone->mNumWeights;
 
    for (size_t j = 0; j < numWeights; ++j) {
      auto & weight = aBone->mWeights[j];
 
      const int weightIndex = numBoneWeights[weight.mVertexId]++;
 
      if (weightIndex > 3) {
        if (!weightsOutOfBounds) {
          LOG_WARNING(logger, "Too many bone weights for vertex %d, extra weights will be dropped.", weight.mVertexId);
          weightsOutOfBounds = true;
        }
        continue;
      }
 
      glm::value_ptr(boneIndexes[weight.mVertexId])[weightIndex] = static_cast<int>(i);
      glm::value_ptr(boneWeights[weight.mVertexId])[weightIndex] = weight.mWeight;
    }
  }
 
  //TODO: If weights are out of bounds, we may renormalize the weights to avoid strange artifacts.
 
  meshData->set(VertexDataType::Colors2, VertexFormats::BoneIndex4i, boneIndexes);
  meshData->set(VertexDataType::Colors3, VertexFormats::BoneWeight4f, boneWeights);
 
  meshData->setMeshFlag(MeshFlags::Skinned);
}
 
void Cogs::Core::AssetImporterLoader::handleAssImpMesh(Context * context, Model & root, ModelPart & modelPart, const aiMesh * mesh, const glm::mat4 & localTransform, const glm::mat4 & globalTransform)
{
  // Decompose matrix, check scaling. Only invert normals if negative scaling.
  // Should work for all cases, but...
  glm::vec3 scale;
  glm::quat rotation;
  glm::vec3 translation;
  glm::vec3 skew;
  glm::vec4 perspective;
  glm::decompose(localTransform, scale, rotation, translation, skew, perspective);
  const bool positiveScale = scale.x >= 0 && scale.y >= 0 && scale.z >= 0;
 
  root.setPartTransform(modelPart, localTransform);
 
  auto meshData = context->meshManager->createLocked();
 
  modelPart.meshIndex = (uint32_t)root.meshes.size();
  root.meshes.emplace_back(meshData.getHandle());
 
  if (mesh->mName.length) {
    meshData->setName(mesh->mName.data);
  }
 
  std::vector<uint32_t> indexes;
 
  if (mesh->mPrimitiveTypes == aiPrimitiveType_LINE || mesh->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) {
    size_t numIndices = 0;
    for (uint32_t f = 0; f < mesh->mNumFaces; f++) {
      const aiFace & face = mesh->mFaces[f];
      numIndices += face.mNumIndices;
    }
 
    indexes.reserve(numIndices);
    for (uint32_t f = 0; f < mesh->mNumFaces; f++) {
      const aiFace & face = mesh->mFaces[f];
 
      assert((mesh->mPrimitiveTypes == aiPrimitiveType_LINE) || face.mNumIndices == 3);
 
      for (uint32_t i = 0; i < face.mNumIndices; i++) {
        indexes.push_back(face.mIndices[i]);
      }
    }
  } else {
    LOG_WARNING(logger, "Skipped geometry of type %x.", mesh->mPrimitiveTypes);
  }
 
  auto pPositions = reinterpret_cast<const glm::vec3 *>(mesh->mVertices);
  meshData->setPositions(pPositions, pPositions + mesh->mNumVertices);
 
  if (mesh->mNormals != nullptr) {
    auto pNormals = reinterpret_cast<const glm::vec3 *>(mesh->mNormals);
 
    bool needInvert = false;
    if (!positiveScale && mesh->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) {
      needInvert = needInvertNormals(localTransform, indexes, pPositions, pNormals, mesh->mNumVertices);
    }
 
    if (needInvert) {
      meshData->setMeshFlag(MeshFlags::ClockwiseWinding);
    }
 
    meshData->setNormals(pNormals, pNormals + mesh->mNumVertices);
  }
 
  meshData->setIndexes(std::move(indexes));
 
  if (mesh->mTangents) {
    auto pTangents = reinterpret_cast<glm::vec3 *>(mesh->mTangents);
    meshData->setTangents(pTangents, pTangents + mesh->mNumVertices);
  }
 
  if (mesh->mTextureCoords[0] != nullptr) {
    std::vector<glm::vec2> texCoords(mesh->mNumVertices);
 
    for (size_t i = 0; i < mesh->mNumVertices; ++i) {
      texCoords[i] = glm::vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y);
    }
 
    meshData->setTexCoords(std::move(texCoords));
  }
 
  if (mesh->HasBones()) {
    handleBones(mesh, root, globalTransform, meshData.operator->());
  }
 
  meshData->setMeshFlag(MeshFlags::ClockwiseWinding);
  meshData->primitiveType = (mesh->mPrimitiveTypes == aiPrimitiveType_LINE) ? Cogs::PrimitiveType::LineList : Cogs::PrimitiveType::TriangleList;
 
  Geometry::BoundingBox bounds = calculateBounds(&*meshData);
  meshData->setBounds(bounds);
 
  modelPart.boundsIndex = static_cast<uint32_t>(root.bounds.size());
  root.bounds.push_back(bounds);
 
  modelPart.materialIndex = mesh->mMaterialIndex;
}
 
void Cogs::Core::AssetImporterLoader::handleAssImpNode(Context * context, Model & root, size_t parent, const aiScene * scene, const aiNode * node, const glm::mat4 & parentTransform)
{
  const glm::mat4 localTransform = toGlm(node->mTransformation);
  const glm::mat4 globalTransform = parentTransform * localTransform;
 
  const size_t index = root.parts.size();
  root.parts.emplace_back();
  auto & modelNode = root.parts.back();
  root.setPartTransform(modelNode, localTransform);
  root.setPartName(modelNode, node->mName.C_Str());
  modelNode.parentIndex = (uint32_t)parent;
 
  if (node->mNumMeshes == 1) {
    handleAssImpMesh(context, root, modelNode, scene->mMeshes[node->mMeshes[0]], localTransform, globalTransform);
  } else {
    for (uint32_t m = 0; m < node->mNumMeshes; m++) {
      aiMesh * mesh = scene->mMeshes[node->mMeshes[m]];
 
      root.parts.emplace_back();
      auto & modelPart = root.parts.back();
      modelPart.parentIndex = (uint32_t)index;
      handleAssImpMesh(context, root, modelPart, mesh, localTransform, globalTransform);
    }
  }
 
  for (uint32_t c = 0; c < node->mNumChildren; c++) {
    aiNode * child = node->mChildren[c];
 
    handleAssImpNode(context, root, index, scene, child, globalTransform);
  }
}
 
Cogs::SamplerState::AddressMode getAddressMode(aiTextureMapMode aiMode)
{
  switch (aiMode) {
  case aiTextureMapMode_Wrap:
    return Cogs::SamplerState::Wrap;
  case aiTextureMapMode_Clamp:
    return Cogs::SamplerState::Clamp;
  case aiTextureMapMode_Decal:
    return Cogs::SamplerState::Border;
  case aiTextureMapMode_Mirror:
    return Cogs::SamplerState::Mirror;
  default:
    return Cogs::SamplerState::Wrap;
  }
}
 
bool loadTexture(Cogs::Core::Context * context,
                 const aiScene * scene,
                 const aiMaterial * aiMaterial,
                 Cogs::Core::MaterialInstance & material,
                 std::string texturePath,
                 aiTextureType textureType,
                 const Cogs::Core::VariableKey key)
{
  aiString textureresourceName;
  aiTextureMapMode mode[2] = {};  //separate modes for U and V axis
  if (aiMaterial->GetTexture(textureType, 0, &textureresourceName, 0, 0, 0, 0, mode) == aiReturn_SUCCESS) {
 
#ifdef _WIN32
    std::string textureFullPath = texturePath == "#" ?
      //If texturePath is # it means we have a .fbm folder and all textures should be fetched from there:
      Cogs::IO::fileName(textureresourceName.C_Str()) :
      Cogs::IO::combine(texturePath, textureresourceName.C_Str());
#else
    std::string textureresourceNameStr(textureresourceName.C_Str());
    std::replace(textureresourceNameStr.begin(), textureresourceNameStr.end(), '\\', '/');
    std::string textureFullPath = texturePath == "#" ?
      Cogs::IO::fileName(textureresourceNameStr) :
      Cogs::IO::combine(texturePath, textureresourceNameStr);
#endif
 
    auto textureFilename = IO::fileName(textureFullPath);
 
    auto flags = (textureType == aiTextureType_DIFFUSE) ? TextureLoadFlags::None : TextureLoadFlags::LinearColorSpace;
 
    Cogs::Core::TextureHandle textureHandle;
    if (textureFilename.size() > 0 && textureFilename[0] == '*') {
      unsigned int textureIndex;
#ifdef _WIN32
      if (sscanf_s(textureFilename.c_str(), "*%u", &textureIndex) != 1) {
#else
      if (sscanf(textureFilename.c_str(), "*%u", &textureIndex) != 1) {
#endif
        LOG_WARNING(logger, "Invalid embedded texture name '%s'.", textureFilename.c_str());
        return false;
      }
 
      if (textureIndex >= scene->mNumTextures) {
        LOG_WARNING(logger, "Texture index to big: %u out of %u.", textureIndex, scene->mNumTextures);
        return false;
      }
 
      auto textureData = scene->mTextures[textureIndex];
      if (textureData->mHeight == 0) {
        static size_t counter = 0;
        std::string resourceName = "Assimp_embedded_resource_" + std::to_string(counter++) + "." + textureData->achFormatHint;
 
        LOG_DEBUG(logger, "Loading embedded, compressed texture. Name: '%s'", resourceName.c_str());
 
        context->resourceStore->addResource(resourceName, std::string(reinterpret_cast<const char*>(textureData->pcData), textureData->mWidth));
 
        textureHandle = context->textureManager->loadTexture(resourceName, NoResourceId, flags);
      } else {
        LOG_DEBUG(logger, "Loading embedded, un-compressed texture. Hint: '%s'", textureData->achFormatHint);
        // TODO: Hint can in theory specify different formats other than RGBA8. May need fixing.
        textureHandle = context->textureManager->loadTexture2D(textureData->pcData, textureData->mWidth, textureData->mHeight, Cogs::TextureFormat::R8G8B8A8_UNORM, 0, NoResourceId, flags);
      }
    } else {
      textureHandle = context->textureManager->loadTexture(textureFullPath, NoResourceId, flags);
    }
 
    if (key != Cogs::Core::NoProperty) {
      material.setTextureProperty(key, textureHandle);
      material.setTextureAddressMode(key, getAddressMode(mode[0]));
    }
 
    return true;
  }
 
  return false;
}
 
void Cogs::Core::AssetImporterLoader::handleAssImpMaterial(Context * context, ModelLoadFlags flags, const aiScene * scene, const aiMaterial * aiMaterial, MaterialInstance & material, std::string texturePath)
{
  aiString materialName;
  aiMaterial->Get(AI_MATKEY_NAME, materialName);
 
  if (materialName.length) {
    material.setName(materialName.C_Str());
  }
 
  float opacity = 1;
  if (aiMaterial->Get(AI_MATKEY_OPACITY, opacity) != aiReturn_SUCCESS) {
    opacity = 1;
  }
 
  float specularPower;
  if (aiMaterial->Get(AI_MATKEY_SHININESS, specularPower) == aiReturn_SUCCESS && specularPower != 0) {
    material.setFloatProperty(DefaultMaterial::SpecularPower, specularPower);
  }
 
  int twoSided = 0;
  if ((aiMaterial->Get(AI_MATKEY_TWOSIDED, twoSided) == aiReturn_SUCCESS && twoSided != 0) ||
    (flags & ModelLoadFlags::ForceTwoSidedMaterial) != 0) {
    material.options.cullMode = CullMode::None;
  }
 
  int lightModel = 0;
  if (aiMaterial->Get(AI_MATKEY_SHADING_MODEL, lightModel) == aiReturn_SUCCESS && lightModel == aiShadingMode_NoShading) {
    material.setVariant("LightModel", "BaseColor");
  }
  if (opacity < 1) {
    material.setTransparent();
  } else if ((flags & ModelLoadFlags::AutomaticTransparency) != 0) {
    material.options.transparencyMode = TransparencyMode::Auto;
  } else {
    material.options.transparencyMode = TransparencyMode::Off;
  }
 
  auto checkColor = [&](const char * key, int type, int index, const VariableKey & name, float opacity, bool is4Component = false)
  {
    aiColor3D checkedColor;
    if (aiMaterial->Get(key, type, index, checkedColor) == aiReturn_SUCCESS) {
      // We only want to register the property if it is actually present, if not fall back to default.
      if (is4Component) {
        material.setVec4Property(name, glm::vec4(checkedColor.r, checkedColor.g, checkedColor.b, opacity));
      } else {
        material.setVec3Property(name, glm::vec3(checkedColor.r, checkedColor.g, checkedColor.b));
      }
    }
  };
 
  checkColor(AI_MATKEY_COLOR_DIFFUSE, DefaultMaterial::DiffuseColor, opacity, true);
  checkColor(AI_MATKEY_COLOR_SPECULAR, DefaultMaterial::SpecularColor, 1);
  checkColor(AI_MATKEY_COLOR_EMISSIVE, DefaultMaterial::EmissiveColor, 1);
 
  bool hasDiffuse = loadTexture(context, scene, aiMaterial, material, texturePath, aiTextureType_DIFFUSE, DefaultMaterial::DiffuseMap);
  bool hasSpecular = loadTexture(context, scene, aiMaterial, material, texturePath, aiTextureType_SPECULAR, DefaultMaterial::SpecularMap);
  bool hasNormal = loadTexture(context, scene, aiMaterial, material, texturePath, aiTextureType_NORMALS, DefaultMaterial::NormalMap);
  bool hasOpacity = loadTexture(context, scene, aiMaterial, material, texturePath, aiTextureType_OPACITY, DefaultMaterial::OpacityMap);
 
  if (hasOpacity && hasDiffuse) {
    material.options.transparencyMode = TransparencyMode::Alpha;
    material.setVariant("AlphaTest", "Discard");
  }
 
  material.setPermutation("Default");
  material.setVariant("EnableLighting", "true");
 
  if (hasSpecular || hasNormal || hasDiffuse) {
    material.setVariant("Textured", "true");
 
    if (hasNormal) {
      material.setVariant("TangentSpaceNormalMap", "true");
    }
 
    if (hasSpecular) {
      material.setVariant("SpecularMap", "true");
    }
  }
 
  if (hasBones(scene, scene->mRootNode)) {
      material.setVariant("Skinned", true);
  }
}
 
bool Cogs::Core::AssetImporterLoader::canLoad(Context * /*context*/, const ModelLoadInfo & loadInfo)
{
  auto extension = IO::extension(loadInfo.resourcePath);
#ifdef COGS_EXTENSIONS_TINYOBJLOADER
  if (extension == ".obj") return false;
#endif
  if (extension == ".gltf") return false;
  if (extension == ".glb") return false;
  if (extension == ".rvm") return false;
  if (extension == ".rvmdump") return false;
 
  //TODO: This is probably a little slow. Work around using a static thread local
  // instance or smth.
  Assimp::Importer importer;
  return importer.IsExtensionSupported(extension);
}
 
void addBones(Skeleton & skeleton, const aiNode * node, size_t parentIndex)
{
  auto localTransform = toGlm(node->mTransformation);
 
  std::string name = node->mName.C_Str();
 
  auto bone = Bone{ name, parentIndex, glm::vec3(0.0), glm::vec3(1.0), glm::quat(), localTransform, glm::mat4(), glm::mat4(), false, false, false };
 
  skeleton.bones.emplace_back(bone);
 
  const uint32_t index = static_cast<uint32_t>(skeleton.bones.size()) - 1;
 
  skeleton.bonesByName[name] = index;
 
  for (size_t i = 0; i < node->mNumChildren; ++i) {
    addBones(skeleton, node->mChildren[i], index);
  }
}
 
void buildSkeleton(Model & model, const aiNode * node)
{
  auto & skeleton = model.skeleton;
 
  addBones(skeleton, node, (size_t)-1);
}
 
void updateSkeleton(Skeleton & skeleton)
{
  if (skeleton.bones.empty()) return;
 
  for (auto & bone : skeleton.bones) {
    bool isRoot = bone.parentBone == (size_t)-1;
 
    if (isRoot) {
      bone.absolute = bone.relative;
    } else {
      auto & parent = skeleton.bones[bone.parentBone];
 
      bone.absolute = parent.absolute * bone.relative;
    }
  }
}
 
void handleAnimations(Context * context, Model & model, const aiScene * scene)
{
  model.animation = context->animationManager->create();
 
  auto & animation = *model.animation.resolve();
 
  auto & skeleton = model.skeleton;
 
  auto numAnims = scene->mNumAnimations;
 
  for (size_t i = 0; i < numAnims; ++i) {
    auto & aAnim = scene->mAnimations[i];
 
    animation.clips.emplace_back();
    auto & clip = animation.clips.back();
 
    clip.name = aAnim->mName.C_Str();
    clip.duration = static_cast<float>(aAnim->mDuration);
    clip.resolution = static_cast<float>(aAnim->mTicksPerSecond);
 
    auto numChannels = aAnim->mNumChannels;
 
    clip.tracks.resize(numChannels);
 
    for (size_t j = 0; j < numChannels; ++j) {
      auto & aChannel = aAnim->mChannels[j];
      std::string channelName = aChannel->mNodeName.C_Str();
 
      auto & track = clip.tracks[j];
      track.boneIndex = (uint32_t)-1;
 
      if (skeleton.bonesByName.find(channelName) == model.skeleton.bonesByName.end()) {
 
      } else {
        auto boneIndex = model.skeleton.bonesByName[channelName];
 
        track.boneIndex = boneIndex;
        model.skeleton.bones[boneIndex].animated = true;
 
        for (size_t k = 0; k < aChannel->mNumPositionKeys; ++k) {
          const float time = static_cast<float>(aChannel->mPositionKeys[k].mTime);
          const glm::vec3 translation = toGlm(aChannel->mPositionKeys[k].mValue);
 
          track.translations.emplace_back(TranslationKey{ time, translation });
        }
 
        for (size_t k = 0; k < aChannel->mNumRotationKeys; ++k) {
          const float time = static_cast<float>(aChannel->mRotationKeys[k].mTime);
          const glm::quat rotation = toGlm(aChannel->mRotationKeys[k].mValue);
 
          track.rotations.emplace_back(RotationKey{ time, rotation });
        }
 
        for (size_t k = 0; k < aChannel->mNumScalingKeys; ++k) {
          const float time = static_cast<float>(aChannel->mScalingKeys[k].mTime);
          const glm::vec3 scale = toGlm(aChannel->mScalingKeys[k].mValue);
 
          track.scales.emplace_back(ScaleKey{ time, scale });
        }
      }
    }
  }
}
 
inline bool isFolder(std::string path)
{
  struct stat sb;
  if (stat(path.c_str(), &sb) != 0) return false;
 
  auto dirMode = sb.st_mode & S_IFDIR;
  return dirMode != 0;
}
 
inline std::string toLower(std::string const & str)
{
  std::string ret(str);
  for (auto& c : ret) {
    c = static_cast<decltype(ret)::value_type>(std::tolower(c));
  }
  return ret;
}
 
inline bool endsWith(std::string const & value, std::string const & ending)
{
  if (ending.size() > value.size()) return false;
  return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
}
 
bool Cogs::Core::AssetImporterLoader::load(Context * context, const ModelLoadInfo & loadInfo)
{
  auto timer = Timer::startNew();
 
  LOG_DEBUG(logger, "Loading model: %s", loadInfo.resourceName.c_str());
 
  auto & modelManager = *context->modelManager;
  auto & materialManager = *context->materialManager;
  auto & materialInstanceManager = *context->materialInstanceManager;
 
  if (!loadInfo.resourcePath.size() && !loadInfo.resourceData.size()) return false;
 
  Assimp::Importer importer;
 
  importer.SetIOHandler(new IOSystem(context));
 
  const bool optimize = (loadInfo.modelFlags & ModelLoadFlags::DisableOptimization) == ModelLoadFlags::None;
  const bool tangents = (loadInfo.modelFlags & ModelLoadFlags::NeedsTangents) != ModelLoadFlags::None;
 
  int flags =
    aiProcess_RemoveRedundantMaterials |
    aiProcess_GenNormals |
    aiProcess_FlipWindingOrder |
    aiProcess_Triangulate;
 
 
  if ((loadInfo.modelFlags & ModelLoadFlags::NoFlipTexcoords) == ModelLoadFlags::None) {
    flags |= aiProcess_FlipUVs;
  }
 
  if (optimize) {
    flags |= aiProcess_ImproveCacheLocality |
      aiProcess_SortByPType |
      aiProcess_GenUVCoords |
      aiProcess_OptimizeMeshes;
  }
 
  if (tangents) {
    flags |= aiProcess_CalcTangentSpace;
  }
 
  const aiScene * scene = nullptr;
  bool hasMatLib = false;
 
  if (loadInfo.resourceData.size()) {
    scene = importer.ReadFileFromMemory(
      loadInfo.resourceData.data(),
      loadInfo.resourceData.size(),
      flags,
      loadInfo.resourcePath.size() ? loadInfo.resourcePath.c_str() : "");
    if (!scene)
      LOG_ERROR(logger, "Data load size: %zu", loadInfo.resourceData.size());
  } else {
 
    //check if FBX...
    if (endsWith(toLower(loadInfo.resourcePath), ".fbx")) {
      //Check if matching .fbm folder exists...
      auto path = context->resourceStore->getResourcePath(loadInfo.resourcePath);
      auto pos = path.find_last_of(".");
      auto base = path.substr(0, pos); //path up to .fbx
      auto materialFolder = base + ".fbm";
      if (isFolder(materialFolder)) {
        context->resourceStore->addSearchPath(materialFolder + IO::pathSeparator());
        hasMatLib = true;
      }
    }
 
    scene = importer.ReadFile(loadInfo.resourcePath, flags);
    if (!scene) {
      auto data = context->resourceStore->getResourceContents(loadInfo.resourcePath);
      if (data.size()) {
        scene = importer.ReadFileFromMemory(data.data(),
                                            data.size(),
                                            flags,
                                            loadInfo.resourcePath.size() ? loadInfo.resourcePath.c_str() : "");
      }
    }
  }
 
  if (!scene) {
    LOG_ERROR(logger, "Error loading model: %s", importer.GetErrorString());
    return false;
  }
 
  auto model = modelManager.lock(loadInfo.handle);
 
  bool needsTangents = false;
 
  //FIXME: Should use a cleaner way of indicating that we should strip path from texture filenames
  const std::string texturePath = hasMatLib ? "#" : IO::parentPath(loadInfo.resourcePath);
 
  for (uint32_t m = 0; m < scene->mNumMaterials; m++) {
    const aiMaterial * aiMat = scene->mMaterials[m];
 
    MaterialInstanceHandle materialHandle = materialInstanceManager.createMaterialInstance(materialManager.getDefaultMaterial());
    MaterialInstance* material = materialInstanceManager.get(materialHandle);
 
    handleAssImpMaterial(context, loadInfo.modelFlags, scene, aiMat, *material, texturePath);
 
 
    if (material->getVariant("TangentSpaceNormalMap") == "true") {
      needsTangents = true;
    }
 
    model->materials.push_back(materialHandle);
  }
 
  if (needsTangents || (!tangents && optimize)) {
    importer.ApplyPostProcessing(aiProcess_CalcTangentSpace);
  }
 
  if (hasBones(scene, scene->mRootNode)) {
    buildSkeleton(*model, scene->mRootNode);
    updateSkeleton(model->skeleton);
  }
 
  if (scene->HasAnimations()) {
    handleAnimations(context, *model, scene);
  }
 
  glm::mat4 rootTransform(1.0f);
  handleAssImpNode(context, *model, NoParentPart, scene, scene->mRootNode, rootTransform);
 
  if (model->animation) {
    model->animation->skeleton = model->skeleton;
  }
 
  LOG_TRACE(logger, "Assimp elapsed: %f.", timer.elapsedSeconds());
 
  return true;
}
 
// Check recursively for any mesh with bones:
bool Cogs::Core::AssetImporterLoader::hasBones(const aiScene * scene, const aiNode * node)
{
  for (uint32_t m = 0; m < node->mNumMeshes; m++) {
    aiMesh * mesh = scene->mMeshes[node->mMeshes[m]];
    if (mesh->HasBones()) {
      return true;
    }
  }
 
  for (uint32_t c = 0; c < node->mNumChildren; c++) {
    aiNode * child = node->mChildren[c];
    if (hasBones(scene, child))
      return true;
  }
 
  return false;
}