GltfWriter.cpp

#include "GltfWriter.h"
#include "Context.h"
#include "EntityStore.h"
#include "rapidjson/document.h"
#include "rapidjson/pointer.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/prettywriter.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/StaticModelComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Appearance/MaterialComponent.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Resources/Buffer.h"
#include "Resources/Mesh.h"
#include "Resources/Material.h"
#include "Resources/MaterialInstance.h"
#include "Resources/Texture.h"
#include "Resources/Model.h"
#include "Components/Core/SceneComponent.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include <glm/glm.hpp>
#include <glm/gtx/quaternion.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "stb_image_write.h"
 
#include <fstream>
#include <sstream>
#include <filesystem>
#include <vector>
#include <type_traits>
 
#ifndef EMSCRIPTEN
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GLTFWriter");
 
  constexpr float floatMax = std::numeric_limits<float>::max();
  constexpr float floatMin = -std::numeric_limits<float>::max();
  constexpr int32_t intMax = std::numeric_limits<int32_t>::max();
  constexpr int32_t intMin = std::numeric_limits<int32_t>::min();
 
  enum EPrimitiveMode { Points, Lines, LineLoop, LineStrip, Triangles, TriangleStrip, TriangleFan };
 
  enum EAccessorType { BYTE = 5120, UNSIGNED_BYTE = 5121, SHORT = 5122, UNSIGNED_SHORT = 5123, UNSIGNED_INT = 5125, FLOAT = 5126 };
 
  enum EBufferType { Image = 0, ArrayBuffer = 34962, ElementArrayBuffer = 34963 };
 
  enum EAccessorContainer { SCALAR, VEC2, VEC3, VEC4, MAT2, MAT3, MAT4 };
 
  struct Buffer {
    Cogs::Memory::MemoryBuffer buffer;
    bool active;
    Buffer(bool enable = false) : buffer(Cogs::MemBlockType::IOResource), active(enable)  {}
  };
 
  typedef struct {
    int last_pos;
    void* context;
  } stbi_mem_context;
 
  void stbi_write_mem(void* context, void* data, int size) {
    stbi_mem_context* c = (stbi_mem_context*)context;
    char* dst = (char*)c->context;
    char* src = (char*)data;
    int cur_pos = c->last_pos;
    for (int i = 0; i < size; i++) {
      dst[cur_pos++] = src[i];
    }
 
    c->last_pos = cur_pos;
  }
 
  void* ptrOffset(void* ptr, unsigned int offset) {
    return static_cast<char*>(ptr) + offset;
  }
 
  std::pair<glm::vec3, glm::vec3> getMinMaxVec3(Cogs::Core::DataStream& stream, unsigned int offset) {
    glm::vec3 min { floatMax, floatMax, floatMax };
    glm::vec3 max { floatMin, floatMin, floatMin };
    glm::vec3* vecs = static_cast<glm::vec3*>(ptrOffset(stream.data(), offset));
    for (size_t i = 0; i < stream.size() / 12; i++) {
      min = glm::min(vecs[i], min);
      max = glm::max(vecs[i], max);
    }
 
    return std::make_pair(min, max);
  }
 
  std::pair<glm::vec2, glm::vec2> getMinMaxVec2(Cogs::Core::DataStream& stream, unsigned int offset) {
    glm::vec2 min { floatMax, floatMax };
    glm::vec2 max { floatMin, floatMin };
    glm::vec2* vecs = static_cast<glm::vec2*>(ptrOffset(stream.data(), offset));
    for (size_t i = 0; i < stream.size() / 8; i++) {
      min = glm::min(vecs[i], min);
      max = glm::max(vecs[i], max);
    }
 
    return std::make_pair(min, max);
  }
 
  std::pair<int32_t, int32_t> getMinMaxIndex(Cogs::Core::DataStream& stream) {
 
    int32_t min = std::numeric_limits<int32_t>::max();
    int32_t max = std::numeric_limits<int32_t>::min();
    int32_t* indices = static_cast<int32_t*>(stream.data());
    for (size_t i = 0; i < stream.size() / 4; i++) {
      min = std::min(indices[i], min);
      max = std::max(indices[i], max);
    }
 
    return std::make_pair(min, max);
  }
 
  void extractMeshes(Cogs::ComponentModel::Entity* currentEntity, glm::mat4& modelMatrix, std::vector<std::pair<Cogs::ComponentModel::Entity*, glm::mat4>>& entities) {
    if (currentEntity == nullptr) return;
 
    Cogs::Core::MeshComponent* mesh = currentEntity->getComponent<Cogs::Core::MeshComponent>();
    if (mesh) {
      if (std::find_if(entities.begin(), entities.end(), [ourEntity = currentEntity](std::pair<Cogs::ComponentModel::Entity*, glm::mat4> e) { return e.first->getId() == ourEntity->getId(); }) == entities.end()) {
        Cogs::Core::TransformComponent* transform = currentEntity->getComponent<Cogs::Core::TransformComponent>();
        if (transform) {
          glm::mat4 translate = glm::translate(glm::mat4(1.0), glm::vec3(transform->position.x, transform->position.y, transform->position.z));
          glm::mat4 rotate = glm::mat4_cast(transform->rotation);
          glm::mat4 scale = glm::scale(glm::mat4(1.0), transform->scale);
 
          glm::mat4 matrix = translate * rotate * scale;
          modelMatrix = modelMatrix * matrix;
        }
        entities.push_back(std::make_pair(currentEntity, modelMatrix));
      }
    }
 
    Cogs::Core::SceneComponent* scene = currentEntity->getComponent<Cogs::Core::SceneComponent>();
    if (scene) {
      for (const auto& c : scene->children) {
        glm::mat4 childModelMatrix{ modelMatrix };
        Cogs::Core::TransformComponent* transform = c.get()->getComponent<Cogs::Core::TransformComponent>();
        if (transform) {
          glm::mat4 translate = glm::translate(glm::mat4(1.0), glm::vec3(transform->position.x, transform->position.y, transform->position.z));
          glm::mat4 rotate = glm::mat4_cast(transform->rotation);
          glm::mat4 scale = glm::scale(glm::mat4(1.0), transform->scale);
 
          glm::mat4 matrix = translate * rotate * scale;
          childModelMatrix = modelMatrix * matrix;
        }
        extractMeshes(c.get(), childModelMatrix, entities);
      }
    }
    else return;
  }
}
 
namespace Cogs::Core::GltfWriter {
  static EPrimitiveMode toGltfPrimitiveType(Cogs::PrimitiveType::EPrimitiveType type)
  {
    switch (type) {
    case Cogs::PrimitiveType::PointList: return EPrimitiveMode::Points;
    case Cogs::PrimitiveType::LineList: return EPrimitiveMode::Lines;
    case Cogs::PrimitiveType::LineStrip: return EPrimitiveMode::LineStrip;
    case Cogs::PrimitiveType::TriangleList: return EPrimitiveMode::Triangles;
    case Cogs::PrimitiveType::TriangleStrip: return EPrimitiveMode::TriangleStrip;
    default: return EPrimitiveMode::Triangles;
    }
  }
 
  rapidjson::Value generateBuffer(rapidjson::Document& doc, const std::string& name)
  {
    rapidjson::Value GLTFbuffers(rapidjson::kArrayType);
    rapidjson::Value GLTFbuffer(rapidjson::kObjectType);
    rapidjson::Value GLTFuri(rapidjson::kStringType);
 
    GLTFuri.SetString(name.c_str(), doc.GetAllocator());
 
    GLTFbuffer.AddMember("byteLength", 0, doc.GetAllocator());
    if (!name.empty()) GLTFbuffer.AddMember("uri", GLTFuri, doc.GetAllocator());
    GLTFbuffers.PushBack(GLTFbuffer, doc.GetAllocator());
 
    return GLTFbuffers;
  }
 
  unsigned int generateBufferView(rapidjson::Document& doc,
                                  const std::string& path,
                                  void* data,
                                  size_t dataSize,
                                  uint32_t byteStride,
                                  EBufferType target,
                                  Buffer& dataBuffer)
  {
    rapidjson::Value GLTFbufferView(rapidjson::kObjectType);
    if (!dataBuffer.active) {
      std::fstream bufferFile(path, std::ios::binary | std::ios::out | std::ios::app | std::ios::ate);
      if (!bufferFile.is_open()) {
        LOG_ERROR(logger, "GLTF binary data file could not be opened!");
        return 0;
      }
 
      GLTFbufferView.AddMember("buffer", 0, doc.GetAllocator());
      GLTFbufferView.AddMember("byteOffset", static_cast<int>(bufferFile.tellg()), doc.GetAllocator());
      GLTFbufferView.AddMember("byteLength", static_cast<uint64_t>(dataSize), doc.GetAllocator());
      if (byteStride > 4) GLTFbufferView.AddMember("byteStride", byteStride, doc.GetAllocator());
      if (target != EBufferType::Image) GLTFbufferView.AddMember("target", target, doc.GetAllocator());
 
      bufferFile.write(static_cast<const char*>(data), dataSize);
      
      // We need to write some empty data if the buffer is misaligned
      while (static_cast<size_t>(bufferFile.tellg()) % 4) {
        char t = 0x00;
        bufferFile.write(&t, sizeof(char));
      }
      
      doc["buffers"].GetArray()[0]["byteLength"].SetInt(static_cast<int>(bufferFile.tellg()));
      bufferFile.close();
    }
    else {
 
      GLTFbufferView.AddMember("buffer", 0, doc.GetAllocator());
      GLTFbufferView.AddMember("byteOffset", static_cast<int>(dataBuffer.buffer.size()), doc.GetAllocator());
      GLTFbufferView.AddMember("byteLength", static_cast<uint64_t>(dataSize), doc.GetAllocator());
      if (byteStride > 0) GLTFbufferView.AddMember("byteStride", byteStride, doc.GetAllocator());
      if (target != EBufferType::Image) GLTFbufferView.AddMember("target", target, doc.GetAllocator());
 
      dataBuffer.buffer.write(static_cast<const char*>(data), dataSize);
 
      // We need to write some empty data if the buffer is misaligned
      while (static_cast<size_t>(dataBuffer.buffer.size()) % 4) {
        char t = 0x00;
        dataBuffer.buffer.write(&t, sizeof(char));
      }
 
      doc["buffers"].GetArray()[0]["byteLength"].SetInt(static_cast<int>(dataBuffer.buffer.size()));
    }
 
    if (doc.HasMember("bufferViews") && doc["bufferViews"].IsArray()) {
      const auto bufferviews = doc["bufferViews"].GetArray();
      bufferviews.PushBack(GLTFbufferView, doc.GetAllocator());
 
      return bufferviews.Size() - 1;
    }
    else {
      rapidjson::Value GLTFbufferviews(rapidjson::kArrayType);
      GLTFbufferviews.PushBack(GLTFbufferView, doc.GetAllocator());
      doc.AddMember("bufferViews", GLTFbufferviews, doc.GetAllocator());
 
      return 0;
    }
  }
 
  template <typename MinMax>
  unsigned int generateAccessor(int id,
                                rapidjson::Document& doc,
                                uint32_t offset,
                                EAccessorType componentType,
                                uint32_t count,
                                const std::string& type,
                                const MinMax& min,
                                const MinMax& max)
  {
    rapidjson::Value GLTFaccessor(rapidjson::kObjectType);
    rapidjson::Value GLTFtype(rapidjson::kStringType);
    rapidjson::Value GLTFmin(rapidjson::kArrayType);
    rapidjson::Value GLTFmax(rapidjson::kArrayType);
 
    if constexpr (std::is_same_v<MinMax, glm::vec3>) {
      glm::vec3 minVec = static_cast<glm::vec3>(min);
      glm::vec3 maxVec = static_cast<glm::vec3>(max);
      if (minVec.x != floatMax) {
        GLTFmin.PushBack(minVec.x, doc.GetAllocator());
        GLTFmin.PushBack(minVec.y, doc.GetAllocator());
        GLTFmin.PushBack(minVec.z, doc.GetAllocator());
      }
      if (maxVec.x != floatMin) {
        GLTFmax.PushBack(maxVec.x, doc.GetAllocator());
        GLTFmax.PushBack(maxVec.y, doc.GetAllocator());
        GLTFmax.PushBack(maxVec.z, doc.GetAllocator());
      }
    } else if constexpr (std::is_same_v<MinMax, glm::vec2>) {
      glm::vec2 minVec = static_cast<glm::vec2>(min);
      glm::vec2 maxVec = static_cast<glm::vec2>(max);
      if (minVec.x != floatMax) {
        GLTFmin.PushBack(minVec.x, doc.GetAllocator());
        GLTFmin.PushBack(minVec.y, doc.GetAllocator());
      }
      if (maxVec.x != floatMin) {
        GLTFmax.PushBack(maxVec.x, doc.GetAllocator());
        GLTFmax.PushBack(maxVec.y, doc.GetAllocator());
      }
    } else {
      if (min != intMax) {
        GLTFmin.PushBack(min, doc.GetAllocator());
      }
      if (max != intMin) {
        GLTFmax.PushBack(max, doc.GetAllocator());
      }
    }
 
    GLTFtype.SetString(type.c_str(), doc.GetAllocator());
 
    GLTFaccessor.AddMember("bufferView", id, doc.GetAllocator());
    GLTFaccessor.AddMember("byteOffset", offset, doc.GetAllocator());
    GLTFaccessor.AddMember("componentType", componentType, doc.GetAllocator());
    GLTFaccessor.AddMember("count", count, doc.GetAllocator());
    GLTFaccessor.AddMember("type", GLTFtype, doc.GetAllocator());
    if (GLTFmin.Size()) GLTFaccessor.AddMember("min", GLTFmin, doc.GetAllocator());
    if (GLTFmax.Size()) GLTFaccessor.AddMember("max", GLTFmax, doc.GetAllocator());
 
    if (doc.HasMember("accessors") && doc["accessors"].IsArray()) {
      const auto accessors = doc["accessors"].GetArray();
      accessors.PushBack(GLTFaccessor, doc.GetAllocator());
 
      return accessors.Size() - 1;
    }
    else {
      rapidjson::Value accessors(rapidjson::kArrayType);
      accessors.PushBack(GLTFaccessor, doc.GetAllocator());
      doc.AddMember("accessors", accessors, doc.GetAllocator());
 
      return 0;
    }
  }
 
  unsigned int generateImage(rapidjson::Document& doc,
                             const std::string& filePath,
                             void* buffer,
                             size_t bufferSize,
                             const std::string& extension,
                             Buffer& dataBuffer)
  {
    rapidjson::Value GLTFimage(rapidjson::kObjectType);
    unsigned int bufferViewIndex = generateBufferView(doc, filePath + extension, buffer, bufferSize, 0, EBufferType::Image, dataBuffer);
 
    GLTFimage.AddMember("mimeType", "image/png", doc.GetAllocator());
    GLTFimage.AddMember("bufferView", bufferViewIndex, doc.GetAllocator());
 
    if (doc.HasMember("images") && doc["images"].IsArray()) {
      auto images = doc["images"].GetArray();
      images.PushBack(GLTFimage, doc.GetAllocator());
 
      return images.Size() - 1;
    }
    else {
      rapidjson::Value GLTFimages(rapidjson::kArrayType);
      GLTFimages.PushBack(GLTFimage, doc.GetAllocator());
      doc.AddMember("images", GLTFimages, doc.GetAllocator());
 
      return 0;
    }
  }
 
  unsigned int generateTexture(rapidjson::Document& doc,
                               const std::string& filePath,
                               void* buffer,
                               size_t bufferSize,
                               const std::string& extension,
                               Buffer& dataBuffer)
  {
    rapidjson::Value GLTFtexture(rapidjson::kObjectType);
    unsigned int imageIndex = generateImage(doc, filePath, buffer, bufferSize, extension, dataBuffer);
    GLTFtexture.AddMember("source", imageIndex, doc.GetAllocator());
 
    if (doc.HasMember("textures") && doc["textures"].IsArray()) {
      auto textures = doc["textures"].GetArray();
      textures.PushBack(GLTFtexture, doc.GetAllocator());
 
      return textures.Size() - 1;
    }
    else {
      rapidjson::Value GLTFtextures(rapidjson::kArrayType);
      GLTFtextures.PushBack(GLTFtexture, doc.GetAllocator());
      doc.AddMember("textures", GLTFtextures, doc.GetAllocator());
 
      return 0;
    }
  }
 
  rapidjson::Value generateMaterialProperty(rapidjson::Document& doc,
                                            const std::string& filePath,
                                            const Cogs::Core::TextureHandle& handle,
                                            const std::string& extension,
                                            Buffer& dataBuffer)
  {
    rapidjson::Value GLTFmaterialProperty(rapidjson::kObjectType);
 
    size_t size = handle->storage.getSize();
    unsigned char* buffer = new unsigned char[size];
    stbi_mem_context context{};
    context.last_pos = 0;
    context.context = (void*)buffer;
    int result = stbi_write_png_to_func(stbi_write_mem, &context, handle->description.width, handle->description.height, static_cast<int>(handle->storage.blockSize), handle->storage.getData(), handle->description.width * 4);
    if (result < 1) {
      LOG_ERROR(logger, "stbi failed to write image data to memory.");
      return GLTFmaterialProperty;
    }
 
    unsigned int index = generateTexture(doc, filePath, buffer, context.last_pos, extension, dataBuffer);
    GLTFmaterialProperty.AddMember("index", index, doc.GetAllocator());
    delete[] buffer;
 
    return GLTFmaterialProperty;
  }
 
  unsigned int generateMaterial(rapidjson::Document& doc,
                                const std::string& filePath,
                                const Cogs::Core::MaterialInstanceHandle& materialIns,
                                Cogs::Core::MaterialComponent*& matComp,
                                const std::string& extension,
                                Buffer& dataBuffer)
  {
    rapidjson::Value GLTFmaterial(rapidjson::kObjectType);
    rapidjson::Value GLTFpbrMetallicRoughness(rapidjson::kObjectType);
    rapidjson::Value GLTFbaseColorFactor(rapidjson::kArrayType);
    rapidjson::Value GLTFmaterialName(rapidjson::kStringType);
 
    if (matComp != nullptr) {
      for (int i = 0; i < 4; i++) {
        GLTFbaseColorFactor.PushBack(matComp->diffuseColor[i], doc.GetAllocator());
      }
      GLTFpbrMetallicRoughness.AddMember("roughnessFactor", matComp->specularPower / 100.f, doc.GetAllocator());
 
      if (matComp->diffuseMap != nullptr) {
        rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, matComp->diffuseMap, extension, dataBuffer);
        GLTFpbrMetallicRoughness.AddMember("baseColorTexture", GLTFmaterialProperty, doc.GetAllocator());
      }
      if (matComp->normalMap != nullptr) {
        rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, matComp->normalMap, extension, dataBuffer);
        GLTFmaterial.AddMember("normalTexture", GLTFmaterialProperty, doc.GetAllocator());
      }
      if (matComp->specularMap != nullptr) {
        rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, matComp->specularMap, extension, dataBuffer);
        GLTFmaterial.AddMember("specularTexture", GLTFmaterialProperty, doc.GetAllocator());
      }
    }
    else if (materialIns != nullptr) {
      Cogs::Core::TextureValue texture;
      Cogs::Core::TextureValue albedoMap = materialIns->getTextureProperty(materialIns->material->getTextureKey("albedoMap"));
      Cogs::Core::TextureValue diffuseMap = materialIns->getTextureProperty(materialIns->material->getTextureKey("diffuseMap"));
 
      if (albedoMap.property != nullptr && albedoMap.texture.handle && (albedoMap.texture.handle->description.height > 4 || albedoMap.texture.handle->description.width > 4)) {
        const Cogs::Core::TextureHandle& handle = albedoMap.texture.handle;
        rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
        GLTFpbrMetallicRoughness.AddMember("baseColorTexture", GLTFmaterialProperty, doc.GetAllocator());
      }
      else if (diffuseMap.property != nullptr && diffuseMap.texture.handle && (diffuseMap.texture.handle->description.height > 4 || diffuseMap.texture.handle->description.width > 4)) {
        const Cogs::Core::TextureHandle& handle = diffuseMap.texture.handle;
        rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
        GLTFpbrMetallicRoughness.AddMember("baseColorTexture", GLTFmaterialProperty, doc.GetAllocator());
      }
      else {
        glm::vec4 albedo = materialIns->getVec4Property(materialIns->material->getVec4Key("albedo"));
        glm::vec4 diffuse = materialIns->getVec4Property(materialIns->material->getVec4Key("diffuseColor"));
 
        glm::vec4 color = albedo == glm::vec4{ 0 } ? diffuse : albedo;
 
        GLTFbaseColorFactor.PushBack(color.x, doc.GetAllocator());
        GLTFbaseColorFactor.PushBack(color.y, doc.GetAllocator());
        GLTFbaseColorFactor.PushBack(color.z, doc.GetAllocator());
        GLTFbaseColorFactor.PushBack(color.w, doc.GetAllocator());
        GLTFpbrMetallicRoughness.AddMember("baseColorFactor", GLTFbaseColorFactor, doc.GetAllocator());
      }
 
      texture = materialIns->getTextureProperty(materialIns->material->getTextureKey("metallicRoughnessMap"));
      if (texture.property != nullptr && texture.texture.handle) {
        if (texture.texture.handle->description.height > 4 || texture.texture.handle->description.width > 4) {
          const Cogs::Core::TextureHandle& handle = texture.texture.handle;
          rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
          GLTFpbrMetallicRoughness.AddMember("metallicRoughnessTexture", GLTFmaterialProperty, doc.GetAllocator());
        }
      }
      texture = materialIns->getTextureProperty(materialIns->material->getTextureKey("normalMap"));
      if (texture.property != nullptr && texture.texture.handle) {
        if (texture.texture.handle->description.height > 4 || texture.texture.handle->description.width > 4) {
          const Cogs::Core::TextureHandle& handle = texture.texture.handle;
          rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
          GLTFmaterial.AddMember("normalTexture", GLTFmaterialProperty, doc.GetAllocator());
        }
      }
      texture = materialIns->getTextureProperty(materialIns->material->getTextureKey("emissiveMap"));
      if (texture.property != nullptr && texture.texture.handle) {
        if (texture.texture.handle->description.height > 4 || texture.texture.handle->description.width > 4) {
          const Cogs::Core::TextureHandle& handle = texture.texture.handle;
          rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
          GLTFmaterial.AddMember("emissiveTexture", GLTFmaterialProperty, doc.GetAllocator());
        }
      }
      texture = materialIns->getTextureProperty(materialIns->material->getTextureKey("occlusionMap"));
      if (texture.property != nullptr && texture.texture.handle) {
        if (texture.texture.handle->description.height > 4 || texture.texture.handle->description.width > 4) {
          const Cogs::Core::TextureHandle& handle = texture.texture.handle;
          rapidjson::Value GLTFmaterialProperty = generateMaterialProperty(doc, filePath, handle, extension, dataBuffer);
          GLTFmaterial.AddMember("occlusionTexture", GLTFmaterialProperty, doc.GetAllocator());
        }
      }
    }
 
    GLTFpbrMetallicRoughness.AddMember("metallicFactor", 0, doc.GetAllocator());
 
    GLTFmaterial.AddMember("pbrMetallicRoughness", GLTFpbrMetallicRoughness, doc.GetAllocator());
 
    if (doc.HasMember("materials") && doc["materials"].IsArray()) {
      auto materials = doc["materials"].GetArray();
      GLTFmaterialName.SetString(std::string("Material" + std::to_string(materials.Size())).c_str(), doc.GetAllocator());
      GLTFmaterial.AddMember("name", GLTFmaterialName, doc.GetAllocator());
      materials.PushBack(GLTFmaterial, doc.GetAllocator());
 
      return materials.Size() - 1;
    }
    else {
      rapidjson::Value GLTFmaterials(rapidjson::kArrayType);
      GLTFmaterialName.SetString("Material0", doc.GetAllocator());
      GLTFmaterial.AddMember("name", GLTFmaterialName, doc.GetAllocator());
      GLTFmaterials.PushBack(GLTFmaterial, doc.GetAllocator());
      doc.AddMember("materials", GLTFmaterials, doc.GetAllocator());
 
      return 0;
    }
  }
 
  template <typename MinMax>
  void generateAttribute(rapidjson::Document& doc,
                         rapidjson::Value& attr,
                         Cogs::Core::DataStream& stream,
                         EAccessorType accessorCompType,
                         const std::string& accessorType,
                         const std::string& filePath,
                         EBufferType bufferType,
                         const rapidjson::GenericStringRef<char>& attributeName,
                         const std::string& extension,
                         Buffer& dataBuffer,
                         const MinMax& min,
                         const MinMax& max)
  {
    unsigned int bufferViewIndex = generateBufferView(doc, filePath + extension, stream.data(), stream.size(), std::string("indices").compare(attributeName) ? 0 : stream.stride, bufferType, dataBuffer);
    unsigned int accesorIndex = generateAccessor<MinMax>(bufferViewIndex, doc, stream.offset, accessorCompType, stream.numElements, accessorType, min, max);
    attr.AddMember(attributeName, accesorIndex, doc.GetAllocator());
  }
 
  rapidjson::Value generatePrimitives(rapidjson::Document& doc,
                                     Cogs::Core::MeshHandle& mesh,
                                     Cogs::Core::MaterialInstanceHandle& materialIns,
                                     Cogs::Core::MaterialComponent*& matComp,
                                     const std::vector<Cogs::Core::MaterialInstanceHandle>& subMeshMaterials,
                                     const std::string& filePath,
                                     const std::string& extension,
                                     Buffer& dataBuffer)
  {
    rapidjson::Value GLTFprimitives(rapidjson::kArrayType);
    rapidjson::Value GLTFattributes(rapidjson::kObjectType);
    unsigned int indicesBufferViewIndex = 0;
    std::pair<int32_t, int32_t> indicesMinMax;
    
    for (size_t i = 0; i < mesh->streams.size(); i++) {
      if (mesh->streams[i].size() != 0) {
        if (mesh->streams[i].type != Cogs::Core::VertexDataType::Interleaved0 &&
          mesh->streams[i].type != Cogs::Core::VertexDataType::Interleaved1) {
          if (mesh->streams[i].type == Cogs::Core::VertexDataType::Indexes) {
            indicesMinMax = getMinMaxIndex(mesh->streams[i]);
            if (mesh->isMeshFlagSet(Cogs::Core::MeshFlags::ClockwiseWinding)) {
              Cogs::Memory::MemoryBuffer buffer;
              buffer.reserve(mesh->getIndexes().size_bytes());
              for (auto x = mesh->getIndexes().rbegin(); x != mesh->getIndexes().rend(); ++x) {
                buffer.write32(*x);
              }
              indicesBufferViewIndex = generateBufferView(doc, filePath + extension, buffer.data(), buffer.size(), 0, EBufferType::ElementArrayBuffer, dataBuffer);
            }
            else {
              indicesBufferViewIndex = generateBufferView(doc, filePath + extension, mesh->streams[i].data(), mesh->streams[i].size(), 0, EBufferType::ElementArrayBuffer, dataBuffer);
            }
          }
          else if (mesh->streams[i].type == Cogs::Core::VertexDataType::Positions) {
            std::pair<glm::vec3, glm::vec3> minMax = getMinMaxVec3(mesh->streams[i], 0);
            generateAttribute<glm::vec3>(doc, GLTFattributes, mesh->streams[i], EAccessorType::FLOAT,
              std::string("VEC3"), filePath, EBufferType::ArrayBuffer, rapidjson::GenericStringRef<char>("POSITION"), extension, dataBuffer, minMax.first, minMax.second);
          }
          else if (mesh->streams[i].type == Cogs::Core::VertexDataType::Normals) {
            std::pair<glm::vec3, glm::vec3> minMax = getMinMaxVec3(mesh->streams[i], 0);
            generateAttribute<glm::vec3>(doc, GLTFattributes, mesh->streams[i], EAccessorType::FLOAT,
              std::string("VEC3"), filePath, EBufferType::ArrayBuffer, rapidjson::GenericStringRef<char>("NORMAL"), extension, dataBuffer, minMax.first, minMax.second);
          }
          else if (mesh->streams[i].type == Cogs::Core::VertexDataType::TexCoords0) {
            std::pair<glm::vec2, glm::vec2> minMax = getMinMaxVec2(mesh->streams[i], 0);
            generateAttribute<glm::vec2>(doc, GLTFattributes, mesh->streams[i], EAccessorType::FLOAT,
              std::string("VEC2"), filePath, EBufferType::ArrayBuffer, rapidjson::GenericStringRef<char>("TEXCOORD_0"), extension, dataBuffer, minMax.first, minMax.second);
          }
          else if (mesh->streams[i].type == Cogs::Core::VertexDataType::TexCoords1) {
            std::pair<glm::vec2, glm::vec2> minMax = getMinMaxVec2(mesh->streams[i], 0);
            generateAttribute<glm::vec2>(doc, GLTFattributes, mesh->streams[i], EAccessorType::FLOAT,
              std::string("VEC2"), filePath, EBufferType::ArrayBuffer, rapidjson::GenericStringRef<char>("TEXCOORD_1"), extension, dataBuffer, minMax.first, minMax.second);
          }
          else if (mesh->streams[i].type == Cogs::Core::VertexDataType::TexCoords2) {
            std::pair<glm::vec2, glm::vec2> minMax = getMinMaxVec2(mesh->streams[i], 0);
            generateAttribute<glm::vec2>(doc, GLTFattributes, mesh->streams[i], EAccessorType::FLOAT,
              std::string("VEC2"), filePath, EBufferType::ArrayBuffer, rapidjson::GenericStringRef<char>("TEXCOORD_2"), extension, dataBuffer, minMax.first, minMax.second);
          }
        }
        else {
          static const Cogs::VertexFormat* vertexPrimitive = Cogs::VertexFormats::getVertexFormat(mesh->streams[i].format);
          unsigned int bufferViewIndex = generateBufferView(doc, filePath + extension, mesh->streams[i].data(), mesh->streams[i].size(), getSize(*vertexPrimitive), EBufferType::ArrayBuffer, dataBuffer);
          for (auto& data : vertexPrimitive->elements) {
            if (data.semantic == Cogs::ElementSemantic::Position) {
              std::pair<glm::vec3, glm::vec3> minMax = getMinMaxVec3(mesh->streams[i], data.offset);
              unsigned int accesorIndex = generateAccessor<glm::vec3>(bufferViewIndex, doc, data.offset, EAccessorType::FLOAT, mesh->streams[i].numElements, std::string("VEC3"), minMax.first, minMax.second);
              GLTFattributes.AddMember("POSITION", accesorIndex, doc.GetAllocator());
            }
            else if (data.semantic == Cogs::ElementSemantic::Normal) {
              std::pair<glm::vec3, glm::vec3> minMax = getMinMaxVec3(mesh->streams[i], data.offset);
              unsigned int accesorIndex = generateAccessor<glm::vec3>(bufferViewIndex, doc, data.offset, EAccessorType::FLOAT, mesh->streams[i].numElements, std::string("VEC3"), minMax.first, minMax.second);
              GLTFattributes.AddMember("NORMAL", accesorIndex, doc.GetAllocator());
            }
            else if (data.semantic == Cogs::ElementSemantic::TextureCoordinate) {
              std::pair<glm::vec2, glm::vec2> minMax = getMinMaxVec2(mesh->streams[i], data.offset);
              unsigned int accesorIndex = generateAccessor<glm::vec2>(bufferViewIndex, doc, data.offset, EAccessorType::FLOAT, mesh->streams[i].numElements, std::string("VEC2"), minMax.first, minMax.second);
              GLTFattributes.AddMember("TEXCOORD_0", accesorIndex, doc.GetAllocator());
            }
          }
        }
      }
    }
    
    std::span<Cogs::Core::SubMesh> subMeshes = mesh->getSubMeshes();
    if (subMeshes.size()) {
      size_t subMeshMaterialIndex = 0;
      for (const auto &subMesh : subMeshes) {
        rapidjson::Value GLTFprimitive(rapidjson::kObjectType);
        rapidjson::Value GLTFattributesCopy(rapidjson::kObjectType);
 
        GLTFattributesCopy.CopyFrom(GLTFattributes, doc.GetAllocator());
 
        unsigned int accesorIndex = generateAccessor<int32_t>(indicesBufferViewIndex, doc, sizeof(unsigned int) * subMesh.startIndex, EAccessorType::UNSIGNED_INT, subMesh.numIndexes, std::string("SCALAR"), indicesMinMax.first, indicesMinMax.second);
        GLTFprimitive.AddMember("indices", accesorIndex, doc.GetAllocator());
 
        GLTFprimitive.AddMember("attributes", GLTFattributesCopy, doc.GetAllocator());
        GLTFprimitive.AddMember("mode", toGltfPrimitiveType(mesh->primitiveType), doc.GetAllocator());
        
        unsigned int materialIndex;
        if (subMeshMaterialIndex < subMeshMaterials.size()) {
          materialIndex = generateMaterial(doc, filePath, subMeshMaterials[subMeshMaterialIndex], matComp, extension, dataBuffer);
          subMeshMaterialIndex++;
        }
        else {
          materialIndex = generateMaterial(doc, filePath, materialIns, matComp, extension, dataBuffer);
        }
        GLTFprimitive.AddMember("material", materialIndex, doc.GetAllocator());
 
        GLTFprimitives.PushBack(GLTFprimitive, doc.GetAllocator());
      }
    }
    else {
      rapidjson::Value GLTFprimitive(rapidjson::kObjectType);
 
      unsigned int accesorIndex = generateAccessor<int32_t>(indicesBufferViewIndex, doc, 0, EAccessorType::UNSIGNED_INT, mesh->getCount(), std::string("SCALAR"), indicesMinMax.first, indicesMinMax.second);
      GLTFprimitive.AddMember("indices", accesorIndex, doc.GetAllocator());
 
      GLTFprimitive.AddMember("attributes", GLTFattributes, doc.GetAllocator());
      GLTFprimitive.AddMember("mode", toGltfPrimitiveType(mesh->primitiveType), doc.GetAllocator());
 
      unsigned int materialIndex = generateMaterial(doc, filePath, materialIns, matComp, extension, dataBuffer);
      GLTFprimitive.AddMember("material", materialIndex, doc.GetAllocator());
 
      GLTFprimitives.PushBack(GLTFprimitive, doc.GetAllocator());
    }
 
    return GLTFprimitives;
  }
 
  unsigned int generateMesh(rapidjson::Document& doc,
                            Cogs::Core::MeshHandle& mesh,
                            Cogs::Core::MaterialInstanceHandle& materialIns,
                            Cogs::Core::MaterialComponent*& matComp,
                            const std::vector<Cogs::Core::MaterialInstanceHandle>& subMeshMaterials,
                            const std::string& filePath,
                            const std::string& extension,
                            Buffer& dataBuffer)
  {
    rapidjson::Value GLTFmesh(rapidjson::kObjectType);
 
    rapidjson::Value GLTFprimitives = generatePrimitives(doc, mesh, materialIns, matComp, subMeshMaterials, filePath, extension, dataBuffer);
    
    GLTFmesh.AddMember("primitives", GLTFprimitives, doc.GetAllocator());
 
    rapidjson::Value GLTFname(rapidjson::kStringType);
 
    if (doc.HasMember("meshes") && doc["meshes"].IsArray()) {
      auto meshes = doc["meshes"].GetArray();
      GLTFname.SetString(std::string("Mesh" + std::to_string(meshes.Size())).c_str(), doc.GetAllocator());
      GLTFmesh.AddMember("name", GLTFname, doc.GetAllocator());
      meshes.PushBack(GLTFmesh, doc.GetAllocator());
 
      return meshes.Size() - 1;
    }
    else {
      rapidjson::Value meshes(rapidjson::kArrayType);
      GLTFname.SetString("Mesh0", doc.GetAllocator());
      GLTFmesh.AddMember("name", GLTFname, doc.GetAllocator());
      meshes.PushBack(GLTFmesh, doc.GetAllocator());
      doc.AddMember("meshes", meshes, doc.GetAllocator());
 
      return 0;
    }
  }
 
  rapidjson::Value generateNode(rapidjson::Document& doc,
                                Cogs::Core::MeshHandle& mesh,
                                Cogs::Core::MaterialInstanceHandle& materialIns,
                                Cogs::Core::MaterialComponent* matComp,
                                std::vector<Cogs::Core::MaterialInstanceHandle>& subMeshMaterials,
                                glm::mat4& modelMatrix,
                                const std::string& filePath,
                                const std::string& extension,
                                Buffer& dataBuffer)
  {
    rapidjson::Value GLTFnode(rapidjson::kObjectType);
 
    unsigned int meshIndex = generateMesh(doc, mesh, materialIns, matComp, subMeshMaterials, filePath, extension, dataBuffer);
    GLTFnode.AddMember("mesh", meshIndex, doc.GetAllocator());
    
    rapidjson::Value transformation(rapidjson::kArrayType);
    for (int c = 0; c < 4; c++) {
      for (int r = 0; r < 4; r++) {
        transformation.PushBack(modelMatrix[c][r], doc.GetAllocator());
      }
    }
    GLTFnode.AddMember("matrix", transformation, doc.GetAllocator());
 
    return GLTFnode;
  }
 
  rapidjson::Value generateNodes(rapidjson::Document& doc,
                                 std::vector<ComponentModel::Entity*>& _entities,
                                 const std::string& filePath,
                                 const std::string& extension,
                                 Buffer& dataBuffer)
  {
    rapidjson::Value GLTFnodes(rapidjson::kArrayType);
    std::vector<std::pair<Cogs::ComponentModel::Entity*, glm::mat4>> meshEntities;
 
    for (unsigned int i = 0; i < _entities.size(); i++) {
 
      glm::mat4 modelMatrix{ 1 };
      extractMeshes(_entities[i], modelMatrix, meshEntities);
    
    }
 
    for (const auto& entity : meshEntities) {
      Cogs::Core::MeshComponent* mesh = entity.first->getComponent<Cogs::Core::MeshComponent>();
      if (mesh && mesh->meshHandle) {
        Cogs::Core::MaterialComponent* material = entity.first->getComponent<Cogs::Core::MaterialComponent>();
        Cogs::Core::SubMeshRenderComponent* subMeshComp = entity.first->getComponent<Cogs::Core::SubMeshRenderComponent>();
        std::vector<Cogs::Core::MaterialInstanceHandle> subMeshMaterials;
        if (subMeshComp != nullptr) {
          subMeshMaterials = subMeshComp->materials;
        }
 
        glm::mat4 modelMatrix = entity.second;
 
        if (material) {
          Cogs::Core::MaterialInstanceHandle emptyInstance = Cogs::Core::MaterialInstanceHandle();
          rapidjson::Value GLTFnode = generateNode(doc, mesh->meshHandle, emptyInstance, material, subMeshMaterials, modelMatrix, filePath, extension, dataBuffer);
          GLTFnodes.PushBack(GLTFnode, doc.GetAllocator());
        }
        else {
          Cogs::Core::MeshRenderComponent* render = entity.first->getComponent<Cogs::Core::MeshRenderComponent>();
          rapidjson::Value GLTFnode = generateNode(doc, mesh->meshHandle, render->material, nullptr, subMeshMaterials, modelMatrix, filePath, extension, dataBuffer);
          GLTFnodes.PushBack(GLTFnode, doc.GetAllocator());
        }
      }
    }
    
    return GLTFnodes;
  }
 
  rapidjson::Value generateAsset(rapidjson::Document& doc)
  {
    rapidjson::Value GLTFasset(rapidjson::kObjectType);
    GLTFasset.AddMember("generator", "COGS2GLTF", doc.GetAllocator());
    GLTFasset.AddMember("version", "2.0", doc.GetAllocator());
 
    return GLTFasset;
  }
 
  void generateSceneNodes(rapidjson::Document& doc, rapidjson::Value& GLTFfirstSceneNodes, uint32_t& nodeCount, ComponentModel::Entity* currentEntity)
  {
    if (!currentEntity) return;
 
    Cogs::Core::MeshComponent* mesh = currentEntity->getComponent<Cogs::Core::MeshComponent>();
    if (mesh && mesh->meshHandle) {
      GLTFfirstSceneNodes.PushBack(nodeCount, doc.GetAllocator());
      nodeCount++;
    }
 
    Cogs::Core::SceneComponent* scene = currentEntity->getComponent<Cogs::Core::SceneComponent>();
    if (scene) {
      for (const auto& c : scene->children) {
        generateSceneNodes(doc, GLTFfirstSceneNodes, nodeCount, c.get());
      }
    }
  }
 
  rapidjson::Value generateScenes(rapidjson::Document& doc, std::vector<ComponentModel::Entity*>& _entities)
  {
    rapidjson::Value GLTFscenes(rapidjson::kArrayType);
    rapidjson::Value GLTFfirstScene(rapidjson::kObjectType);
    rapidjson::Value GLTFfirstSceneNodes(rapidjson::kArrayType);
 
    uint32_t nodeCount = 0;
    for (unsigned int i = 0; i < _entities.size(); i++) {
      rapidjson::Value GLTFnode(rapidjson::kObjectType);
      generateSceneNodes(doc, GLTFfirstSceneNodes, nodeCount, _entities[i]);
    }
 
    GLTFfirstScene.AddMember("nodes", GLTFfirstSceneNodes, doc.GetAllocator());
    GLTFscenes.PushBack(GLTFfirstScene, doc.GetAllocator());
 
    return GLTFscenes;
  }
 
  bool writeGltf(std::vector<ComponentModel::Entity*>& entities, const std::string& filePath, const std::string& fileName)
  {
    if (entities.size() == 0 || fileName.empty() || filePath.empty()) return false;
 
    Buffer empty;
    rapidjson::Document doc;
    doc.SetObject();
 
    rapidjson::Value GLTFbuffers = generateBuffer(doc, fileName + ".bin");
    doc.AddMember("buffers", GLTFbuffers, doc.GetAllocator());
 
    rapidjson::Value GLTFasset = generateAsset(doc);
    doc.AddMember("asset", GLTFasset, doc.GetAllocator());
 
    rapidjson::Value GLTFscenes = generateScenes(doc, entities);
    doc.AddMember("scene", 0, doc.GetAllocator());
    doc.AddMember("scenes", GLTFscenes, doc.GetAllocator());
 
    rapidjson::Value GLTFnodes = generateNodes(doc, entities, Cogs::IO::combine(filePath, fileName), std::string(".bin"), empty);
    doc.AddMember("nodes", GLTFnodes, doc.GetAllocator());
 
    FILE* jsonFile = fopen(Cogs::IO::combine(filePath, fileName + std::string(".gltf")).c_str(), "wb");
    if (jsonFile == NULL) {
      LOG_ERROR(logger, "Could not create GLTF file.");
      return false;
    }
 
    char writeBuffer[65536];
    rapidjson::FileWriteStream os(jsonFile, writeBuffer, sizeof(writeBuffer));
    rapidjson::PrettyWriter<rapidjson::FileWriteStream> writer(os);
    if (!doc.Accept(writer)) {
      LOG_ERROR(logger, "GLTF - JSON serialization failed");
      return false;
    }
 
    os.Flush();
    fclose(jsonFile);
    return true;
  }
 
  bool writeGlb(std::vector<ComponentModel::Entity*>& entities, const std::string& filePath, const std::string& fileName)
  {
    if (entities.size() == 0 || fileName.empty() || filePath.empty()) return false;
 
    Buffer dataBuffer{ true };
    rapidjson::Document doc;
    doc.SetObject();
 
    rapidjson::Value GLTFbuffers = generateBuffer(doc, "");
    doc.AddMember("buffers", GLTFbuffers, doc.GetAllocator());
 
    rapidjson::Value GLTFasset = generateAsset(doc);
    doc.AddMember("asset", GLTFasset, doc.GetAllocator());
 
    rapidjson::Value GLTFscenes = generateScenes(doc, entities);
    doc.AddMember("scene", 0, doc.GetAllocator());
    doc.AddMember("scenes", GLTFscenes, doc.GetAllocator());
 
    rapidjson::Value GLTFnodes = generateNodes(doc, entities, Cogs::IO::combine(filePath, fileName), "", dataBuffer);
    doc.AddMember("nodes", GLTFnodes, doc.GetAllocator());
 
    rapidjson::StringBuffer jsonStringBuffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(jsonStringBuffer);
    if (!doc.Accept(writer)) {
      LOG_ERROR(logger, "GLTF - JSON serialization failed");
      return false;
    }
 
    // Create GLB file
    std::fstream glbFile(Cogs::IO::combine(filePath, fileName + std::string(".glb")).c_str(), std::ios::binary | std::ios::out | std::ios::app);
    if (!glbFile.is_open()) {
      LOG_ERROR(logger, "GLB file could not be created");
      return false;
    }
 
    // JSON chunk
    const char* jsonChunkData = jsonStringBuffer.GetString();
    uint32_t jsonChunkSize = static_cast<uint32_t>(jsonStringBuffer.GetSize());
    uint32_t jsonChunkType = 0x4E4F534A;
    uint32_t jsonChunkPadding = jsonChunkSize % 4;
    jsonChunkSize += jsonChunkPadding;  // Add the total length of the json with padding
 
    // Data chunk
    uint32_t dataChunkSize = static_cast<uint32_t>(dataBuffer.buffer.size());
    uint32_t dataChunkType = 0x004E4942;
    char* dataChunkData = (char*)dataBuffer.buffer.data();
 
    // Main header
    uint32_t magic = 0x46546C67;
    uint32_t version = 2;
    uint32_t length = 28 + dataChunkSize + jsonChunkSize; // Adding 28 bytes on top to accomodate for headers and such.
 
    // Write header
    glbFile.write((char*)&magic, sizeof(uint32_t));
    glbFile.write((char*)&version, sizeof(uint32_t));
    glbFile.write((char*)&length, sizeof(uint32_t));
 
    // Write JSON chunk
    glbFile.write((char*)&jsonChunkSize, sizeof(uint32_t));
    glbFile.write((char*)&jsonChunkType, sizeof(uint32_t));
    glbFile.write(jsonChunkData, static_cast<std::streamsize>(jsonChunkSize) - jsonChunkPadding);       // Substract the padding so we don't write data that's not part of the JSON
 
    // Fix JSON alignment
    while (jsonChunkPadding) {
      char space = static_cast<char>(0x20);
      glbFile.write(&space, sizeof(char));
      jsonChunkPadding--;
    }
 
    // Write data chunk
    glbFile.write((char*)&dataChunkSize, sizeof(uint32_t));
    glbFile.write((char*)&dataChunkType, sizeof(uint32_t));
    glbFile.write(dataChunkData, dataChunkSize);        // Write the raw data. Padding not needed because buffer data was already padded when it was generated
 
    // Close file
    glbFile.close();
 
    return true;
  }
}
 
#else
bool Cogs::Core::GltfWriter::writeGltf(std::vector<ComponentModel::Entity*>& /*entities*/, const std::string& /*filePath*/, const std::string& /*fileName*/)
{
  return false;
}
bool Cogs::Core::GltfWriter::writeGlb(std::vector<ComponentModel::Entity*>& /*entities*/, const std::string& /*filePath*/, const std::string& /*fileName*/)
{
  return false;
}
#endif