GltfLoader.h

#pragma once
 
#include "Serialization/JsonParser.h"
 
#include "Services/TaskManager.h"
#include "Resources/TextureManager.h"
#include "Resources/ModelManager.h"
#include "Resources/MeshManager.h"
 
#include "Foundation/Platform/Timer.h"
 
#include "Rendering/DataFormat.h"
 
#include <base64.h>
 
// NOTE: We cannot include the "stb_image.h" here as this will cause clashing symbols when linking in
// Emscripten mode. We'll therefore just predefine the needed type and include the actual header-file
// in the C++ file instead.
typedef unsigned char stbi_uc; // Used in the GltfImage struct below (line ~180).
 
#include <glm/gtx/matrix_decompose.hpp>
 
#include <ctype.h>
#include <stdint.h>
#include <string>
#include <vector>
#include <map>
#include <span>
 
namespace Cogs::Core::GltfLoader {
  using namespace rapidjson;
 
  // Bool switch to disable the loader
  static constexpr Cogs::StringView enableVariableName = "gltf.import.enable";
 
  // Integer number that controls the amount of cleanup done when reading the mesh:
  // 0 - Preserve as much as possible
  // 1 - Strip unused vertex attributes
  static const char* optimizeVariableName = "gltf.import.optimize";
 
  typedef GenericMember<UTF8<>, RAPIDJSON_DEFAULT_ALLOCATOR> Member;
  typedef GenericArray<true, Value> Array;
  typedef GenericObject<true, Value> Object;
 
  constexpr int GLTF_BYTE = 5120;
  constexpr int GLTF_UNSIGNED_BYTE = 5121;
  constexpr int GLTF_SHORT = 5122;
  constexpr int GLTF_UNSIGNED_SHORT = 5123;
  constexpr int GLTF_UNSIGNED_INT = 5125;
  constexpr int GLTF_FLOAT = 5126;
 
  constexpr unsigned GLTF_NEAREST = 9728;
  constexpr unsigned GLTF_LINEAR = 9729;
  constexpr unsigned GLTF_NEAREST_MIPMAP_NEAREST = 9984;
  constexpr unsigned GLTF_LINEAR_MIPMAP_NEAREST = 9985;
  constexpr unsigned GLTF_NEAREST_MIPMAP_LINEAR = 9986;
  constexpr unsigned GLTF_LINEAR_MIPMAP_LINEAR = 9987;
 
  //constexpr int GLTF_ARRAY_BUFFER = 34962;
  //constexpr int GLTF_ELEMENT_ARRAY_BUFFER = 34963;
 
  constexpr unsigned GLTF_CLAMP_TO_EDGE = 33071;
  constexpr unsigned GLTF_MIRRORED_REPEAT = 33648;
  constexpr unsigned GLTF_REPEAT = 10497;
 
  enum struct AccessorComponentType
  {
    None = 0,
    Byte,
    UnsignedByte,
    Short,
    UnsignedShort,
    UnsignedInt,
    Float,
    Count
  };
 
  static const char* accessorComponentTypeName[] = {
    "None",
    "Byte",
    "UnsignedByte",
    "Short",
    "UnsignedShort",
    "UnsignedInt",
    "Float"
  };
  static_assert(sizeof(accessorComponentTypeName) == sizeof(accessorComponentTypeName[0]) * size_t(AccessorComponentType::Count));
 
  static uint32_t accessorComponentTypeSize[] = {
    0,
    uint32_t(sizeof(int8_t)),
    uint32_t(sizeof(uint8_t)),
    uint32_t(sizeof(int16_t)),
    uint32_t(sizeof(uint16_t)),
    uint32_t(sizeof(uint32_t)),
    uint32_t(sizeof(float))
  };
  static_assert(sizeof(accessorComponentTypeSize) == sizeof(accessorComponentTypeSize[0]) * size_t(AccessorComponentType::Count));
 
  enum struct AccessorType {
    None = 0,
    Scalar,
    Vec2, Vec3, Vec4,
    Mat2, Mat3, Mat4,
    Count
  };
 
  static const char* accessorTypeName[] = {
    "None",
    "Scalar",
    "Vec2", "Vec3", "Vec4",
    "Mat2", "Mat3", "Mat4"
  };
  static_assert(sizeof(accessorTypeName) == sizeof(accessorTypeName[0]) * size_t(AccessorType::Count));
 
  static uint32_t accessorTypeSize[] = {
    0,
    1,
    2,   3,   4,
    2*2, 3*3, 4*4
  };
  static_assert(sizeof(accessorTypeSize) == sizeof(accessorTypeSize[0]) * size_t(AccessorType::Count));
 
  
  struct GltfBufferView
  {
    uint32_t buffer = 0;
    uint32_t byteLength = 0;
    uint32_t byteOffset = 0;
    uint32_t byteStride = 0;  // TODO
    uint32_t target = 0;     
  };
 
  struct GltfAccessor
  {
    uint32_t bufferView = 0;
    uint32_t byteOffset = 0;
    uint32_t count = 0;
 
    AccessorComponentType componentType = AccessorComponentType::None;
    AccessorType type = AccessorType::None;
 
    union {
      int32_t s_int[4 * 4] = { 0 };
      uint32_t s_uint[4 * 4];
      float s_float[4 * 4];
    } min, max;
 
    uint32_t minCount = 0;
    uint32_t maxCount = 0;
 
    bool normalized = false;
  };
 
  struct GltfTextureSampler
  {
    Cogs::SamplerState::FilterMode filterMode = Cogs::SamplerState::FilterMode::MinMagMipLinear; // Note: not exposed in cogs materialInstance, i.e. not set
    Cogs::SamplerState::AddressMode sMode = Cogs::SamplerState::AddressMode::Wrap;
    Cogs::SamplerState::AddressMode tMode = Cogs::SamplerState::AddressMode::Wrap;
    Cogs::SamplerState::AddressMode uMode = Cogs::SamplerState::AddressMode::Wrap;
    bool mipmapped = true;
  };
 
  struct GltfImage
  {
    enum {
      Unset,
      LoadFromUri,
      LoadFromMemory
    } kind = Unset;
 
    std::string uri;
    Cogs::Core::TextureHandle handle;
    struct {
      uint32_t bufferViewIndex =0;
      std::string mimeType;
    } from_memory_data;
 
    struct {
      Cogs::Core::TaskId task = Cogs::Core::NoTask;
      stbi_uc* data = nullptr;
      int width = 0;
      int height = 0;
      int comp = 0;
      bool failed = false;
    } decoded;
 
    struct {
      Cogs::Core::TextureHandle handle;
      std::unique_ptr<Cogs::Core::TextureManager::ResourceProxy> proxy;
    } cache[4];
  };
 
  struct GltfTexture
  {
    int32_t sampler = -1;
    int32_t source = -1;
  };
 
  struct GltfNode
  {
    std::string name;
    std::vector<uint32_t> children;
 
    glm::quat rot = glm::quat();
    glm::vec3 pos = glm::vec3(0);
    glm::vec3 scale = glm::vec3(1);
 
    glm::mat4 mat;
    uint32_t mesh = (uint32_t) -1;
    uint32_t skin = (uint32_t) -1;
 
    uint32_t node_index = (uint32_t) -1;
    uint32_t parent_node = (uint32_t) -1;
 
    uint32_t part_index = (uint32_t) -1;
    uint32_t bone_index = (uint32_t) -1;
  };
 
  struct GltfScene
  {
    std::string name;
    std::vector<uint32_t> nodes;
  };
 
  struct GltfSkin
  {
    uint32_t inverseBindMatrices = 0;
    std::vector<uint32_t> joints;
    uint32_t skeleton = 0;
    std::string name;  // TODO
  };
 
  struct GltfSampler
  {
    uint32_t input = 0;  // Time accessor
    std::string interpolation;
    uint32_t output = 0;  // Ineterpolant accessor
  };
 
  struct GltfChannel
  {
    uint32_t sampler = 0;
    uint32_t node = 0;
    std::string path;
  };
 
  struct GltfAnimation
  {
    std::string name;
    std::vector<GltfSampler> samplers;
    std::vector<GltfChannel> channels;
  };
 
  struct CachedModelMaterial
  {
    int32_t modelMaterialIx = -1;
 
    uint32_t texCoordSets = 0;    // max referenced texcoord set + 1
    bool needsTangents = false;
    bool needsNormals = false;
  };
 
  struct CachedModelMesh
  {
    uint32_t meshIx = 0;
    uint32_t bboxIx = 0;
    uint32_t vertexCount = (uint32_t) -1;
  };
 
  struct ModelMeshInstance {
    CachedModelMesh mesh;
    uint32_t materialIx;
  };
 
  struct TextureTransform {
    glm::vec2 offset = glm::vec2(0, 0);
    glm::vec2 scale = glm::vec2(1.0, 1.0);
    float rotation = 0.0;
  };
 
  struct GltfModelDefinition
  {
    GltfModelDefinition(Context* context, Cogs::StringView path);
    ~GltfModelDefinition();
 
    Context* context = nullptr;
    Cogs::StringView path;
    TaskId rootTask = NoTask;
    Cogs::Timer timer;
 
    int32_t version = -1;
    int32_t min_version = -1;
    int32_t load_scene = -1;  // Display at load time
 
    unsigned optimizationLevel = 1; // managed via variables
 
    std::map<std::string, uint32_t> debugMessages;
 
    std::vector<ResourceBuffer> buffer_data_store;
    std::vector<std::span<const uint8_t>> buffer_data;
    std::vector<GltfBufferView> buffer_views;
    std::vector<GltfAccessor> accessors;
 
    std::vector<GltfImage> images;
    std::vector<GltfTextureSampler> texture_samplers;
    std::vector<GltfTexture> textures;
 
    std::vector<GltfScene> scenes;
    std::vector<GltfNode> nodes;
 
    std::vector<GltfSkin> skins;
    std::vector<GltfAnimation> animations;
 
    std::vector<Object> materialsArray;
    std::vector<Object> meshesArray;
    std::vector<TextureTransform> textureTransforms;
 
    std::vector<CachedModelMaterial> modelMaterialsCache;
    std::unordered_map<size_t, CachedModelMesh> modelMeshCache;
 
    int32_t default_material = -1;
    std::vector<int32_t> materials_skinned;
 
    std::vector<Cogs::Memory::MemoryBuffer> normalsScratch;
    std::vector<Cogs::Memory::MemoryBuffer> tangentsScratch;
    std::vector<Cogs::Memory::MemoryBuffer> positionsScratch;
    std::vector<Cogs::Memory::MemoryBuffer> texCoordsScratch;
  };
 
  struct BufferDataView
  {
    const uint8_t* data = nullptr;
    uint32_t stride = 0;
    uint32_t count = 0;
  };
 
  static_assert(sizeof(BufferDataView) == (sizeof(BufferDataView::data) +
    sizeof(BufferDataView::stride) +
    sizeof(BufferDataView::count)), "Struct is not tightly packed");
 
  struct VertexStream
  {
    BufferDataView dataView;
    size_t formatSize = 0;
    size_t offset = 0;
    Cogs::DataFormat format = Cogs::DataFormat::Unknown;
    Cogs::ElementSemantic semantic = Cogs::ElementSemantic::Position;
    uint32_t semanticIndex = 0;
  };
 
  static_assert(sizeof(VertexStream) == (sizeof(VertexStream::dataView) +
    sizeof(VertexStream::formatSize) +
    sizeof(VertexStream::offset) +
    sizeof(VertexStream::format) +
    sizeof(VertexStream::semantic) +
    sizeof(VertexStream::semanticIndex)), "Struct is not tightly packed");
 
  constexpr size_t hash(const VertexStream& stream, size_t hashValue = Cogs::hash()) {
    return Cogs::hash(&stream, sizeof(stream), hashValue);
  }
 
  struct VertexStreamsState
  {
    Cogs::Geometry::BoundingBox bbox = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
    BufferDataView positionData;
    BufferDataView normalData;
    BufferDataView texcoordData;
    BufferDataView indexData;
    AccessorComponentType indexType = AccessorComponentType::None;
    bool positionPresent = false;
    bool normalPresent = false;
    bool tangentPresent = false;
    uint32_t indexSize = 0;
    uint32_t texcoordStreamCount = 0;
    uint32_t colorStreamCount = 0;
    uint32_t jointsStreamCount = 0;
    uint32_t weightsStreamCount = 0;
    uint32_t positionCount = 0;
  };
 
  // Converts a non-float-vec(n) bufferview (ie. byte or short) to a regular float-vec(n) bufferview.
  // T is the GLM vector type for the target, ie. glm::vec2, glm::vec3 or glm::vec4
  template<typename T>
  BufferDataView convertVecBufferToFloats(const BufferDataView& srcBuf, AccessorComponentType srcType, Memory::MemoryBuffer* workspace, bool normalize=false)
  {
    assert(workspace->size() == 0 &&  "Cannot reuse MemoryBuffer");
    assert(srcType != AccessorComponentType::Float && "Buffer is already of type float!");
 
    size_t stride = sizeof(T);
    workspace->resize(stride * srcBuf.count);
    
    T* buf = static_cast<T*>(workspace->data());
    const uint8_t* src = srcBuf.data;
 
    size_t c = 0;
    for (uint32_t i = 0; i < srcBuf.count; ++i) {
      T v;
      constexpr int n = v.length();
      for (int j = 0; j < n; ++j) {
        const uint8_t* ptr = src + c;
        switch (srcType) {
        case AccessorComponentType::Byte:
          v[j] = float(normalize ? std::fmax(float(reinterpret_cast<const int8_t*>(ptr)[j]) / 127.0, -1.0) : float(reinterpret_cast<const int8_t*>(ptr)[j]));
          break;
        case AccessorComponentType::UnsignedByte:
          v[j] = float(normalize ? (float(reinterpret_cast<const uint8_t*>(ptr)[j])) / 255.0f : float(reinterpret_cast<const int8_t*>(ptr)[j]));
          break;
        case AccessorComponentType::Short:
          v[j] = float(normalize ? std::fmax(float(reinterpret_cast<const int16_t*>(ptr)[j]) / 32767.0f, -1.0) : float(reinterpret_cast<const int16_t*>(ptr)[j]));
          break;
        case AccessorComponentType::UnsignedShort:
          v[j] = float(normalize ? float(reinterpret_cast<const uint16_t*>(ptr)[j]) / 65535.0f : float(reinterpret_cast<const uint16_t*>(ptr)[j]));
          break;
        default:
          assert(false && "Unhandled component type");
        }
      }
 
      buf[i] = v;
      c += srcBuf.stride;
    }
 
    BufferDataView target{
      .data = reinterpret_cast<uint8_t*>(buf),
      .stride = (uint32_t) stride,
      .count = srcBuf.count
    };
 
    return target;
  }
 
  class GltfLoader : public IModelLoader, public ILoadedModelLoader
  {
  public:
    bool canLoad(Context*, const ModelLoadInfo& loadInfo);
    size_t getPotentialB3DMOffset(uint8_t* content, size_t size);
    bool load(Context* context, const ModelLoadInfo& loadInfo, std::unique_ptr<Cogs::FileContents> contents);
    bool load(Context* context, const ModelLoadInfo& loadInfo);
  };
}