gltf_import_shared_internal.h

#pragma once
 
#include "morph_mesh_internal.h"
#include "pixelbullet/application/log.h"
#include "pixelbullet/assets/bitmap.h"
#include "pixelbullet/assets/gltf_prefab_import.h"
#include "pixelbullet/assets/material.h"
#include "pixelbullet/filesystem/filesystem.h"
#include "pixelbullet/scene/components/transform.h"
#include "pixelbullet/scene/prefab_asset.h"
#include "skinned_mesh_internal.h"
#include "skinned_morph_mesh_internal.h"
#include "static_mesh_internal.h"
 
#include "cgltf.h"
 
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/quaternion.hpp>
 
#include <algorithm>
#include <cctype>
#include <cstring>
#include <filesystem>
#include <fmt/format.h>
#include <memory>
#include <optional>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
namespace pixelbullet::gltf_import_internal
{
inline std::shared_ptr<log::Logger> GetAssetsLogger()
{
    return logging::Get(logging::names::core_assets);
}
 
constexpr std::string_view k_assets_prefix = "@assets/";
constexpr std::string_view k_shared_prefix = "@shared/";
 
struct SourceRoot
{
    std::string logical_root;
    std::filesystem::path physical_root;
    std::filesystem::path relative_source_path;
    std::filesystem::path relative_source_stem;
};
 
struct GeneratedFiles
{
    PrefabAsset prefab;
    VirtualPath prefab_path;
    std::vector<std::pair<VirtualPath, static_mesh_internal::LoadData>> meshes;
    std::vector<std::pair<VirtualPath, morph_mesh_internal::LoadData>> morph_meshes;
    std::vector<std::pair<VirtualPath, skinned_mesh_internal::LoadData>> skinned_meshes;
    std::vector<std::pair<VirtualPath, skinned_morph_mesh_internal::LoadData>> skinned_morph_meshes;
    std::vector<std::pair<VirtualPath, Material>> materials;
    std::vector<std::pair<VirtualPath, Bitmap>> textures;
};
 
struct ImportState
{
    const Filesystem* filesystem = nullptr;
    VirtualPath source_path;
    std::filesystem::path resolved_source_path;
    SourceRoot source_root;
    cgltf_data* gltf = nullptr;
    GeneratedFiles generated;
    std::unordered_map<const cgltf_image*, VirtualPath> image_paths;
    std::unordered_map<const cgltf_material*, VirtualPath> material_paths;
    std::unordered_map<const cgltf_primitive*, VirtualPath> primitive_mesh_paths;
    std::unordered_map<const cgltf_node*, EntityId> imported_node_entities;
    std::optional<VirtualPath> default_material_path;
    std::unordered_map<std::string, std::size_t> mesh_name_counts;
    std::unordered_map<std::string, std::size_t> material_name_counts;
    std::unordered_map<std::string, std::size_t> texture_name_counts;
    std::vector<std::string> warning_messages;
    std::unordered_set<std::string> seen_warning_messages;
    std::string failure_message;
};
 
inline bool StartsWith(const std::string_view value, const std::string_view prefix) noexcept
{
    return value.size() >= prefix.size() && value.substr(0, prefix.size()) == prefix;
}
 
inline std::string SanitizeStem(const std::string_view value, const std::string_view fallback)
{
    std::string sanitized;
    sanitized.reserve(value.size());
    for (const char ch : value)
    {
        if (std::isalnum(static_cast<unsigned char>(ch)) || ch == '_' || ch == '-')
        {
            sanitized.push_back(static_cast<char>(std::tolower(static_cast<unsigned char>(ch))));
        }
        else if (ch == ' ' || ch == '.' || ch == '/' || ch == '\\')
        {
            if (sanitized.empty() || sanitized.back() != '_')
            {
                sanitized.push_back('_');
            }
        }
    }
 
    while (!sanitized.empty() && sanitized.back() == '_')
    {
        sanitized.pop_back();
    }
 
    if (sanitized.empty())
    {
        sanitized = std::string(fallback);
    }
 
    return sanitized;
}
 
inline std::string MakeUniqueStem(std::unordered_map<std::string, std::size_t>& counts, const std::string_view preferred,
                                  const std::string_view fallback)
{
    std::string stem = SanitizeStem(preferred.empty() ? fallback : preferred, fallback);
    const auto [it, inserted] = counts.emplace(stem, 0u);
    if (inserted)
    {
        return stem;
    }
 
    ++it->second;
    return stem + "_" + std::to_string(it->second);
}
 
inline void SetFailure(ImportState& state, std::string message)
{
    if (state.failure_message.empty())
    {
        state.failure_message = std::move(message);
    }
}
 
template <typename... Args>
inline void RecordWarning(ImportState& state, fmt::format_string<Args...> fmt_str, Args&&... args)
{
    std::string message = fmt::format(fmt_str, std::forward<Args>(args)...);
    if (state.seen_warning_messages.insert(message).second)
    {
        state.warning_messages.push_back(std::move(message));
        GetAssetsLogger()->Warn("{}", state.warning_messages.back());
    }
}
 
inline std::optional<SourceRoot> ResolveSourceRoot(const Filesystem& filesystem, const VirtualPath& source_path)
{
    const std::string_view logical_path = source_path.LogicalPath();
    if (StartsWith(logical_path, k_assets_prefix))
    {
        const std::filesystem::path relative = std::filesystem::path(std::string(logical_path.substr(k_assets_prefix.size())));
        std::filesystem::path stem = relative;
        stem.replace_extension();
        return SourceRoot{
            .logical_root = "@assets",
            .physical_root = filesystem.ResolveWritable(VirtualPath("@assets")),
            .relative_source_path = std::move(relative),
            .relative_source_stem = stem,
        };
    }
 
    if (StartsWith(logical_path, k_shared_prefix))
    {
        const std::filesystem::path relative = std::filesystem::path(std::string(logical_path.substr(k_shared_prefix.size())));
        std::filesystem::path stem = relative;
        stem.replace_extension();
        return SourceRoot{
            .logical_root = "@shared",
            .physical_root = filesystem.ResolveWritable(VirtualPath("@shared")),
            .relative_source_path = std::move(relative),
            .relative_source_stem = stem,
        };
    }
 
    return std::nullopt;
}
 
inline VirtualPath BuildGeneratedPath(const ImportState& state, const std::string_view type_root,
                                      const std::filesystem::path& relative_path)
{
    std::string logical = state.source_root.logical_root;
    logical.push_back('/');
    logical.append(type_root);
    logical.push_back('/');
    logical.append(relative_path.generic_string());
    return VirtualPath(std::move(logical));
}
 
inline std::filesystem::path BuildImportedNamespace(const ImportState& state)
{
    return std::filesystem::path("imported") / state.source_root.relative_source_stem;
}
 
inline VirtualPath BuildGeneratedPrefabPath(const ImportState& state)
{
    std::filesystem::path relative = BuildImportedNamespace(state);
    relative += ".prefab.yaml";
    return BuildGeneratedPath(state, "prefabs", relative);
}
 
inline VirtualPath BuildGeneratedMeshPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "models", BuildImportedNamespace(state) / (std::string(stem) + ".mesh.bin"));
}
 
inline VirtualPath BuildGeneratedSkinnedMeshPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "models", BuildImportedNamespace(state) / (std::string(stem) + ".skinned_mesh.bin"));
}
 
inline VirtualPath BuildGeneratedMorphMeshPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "models", BuildImportedNamespace(state) / (std::string(stem) + ".morph_mesh.bin"));
}
 
inline VirtualPath BuildGeneratedSkinnedMorphMeshPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "models", BuildImportedNamespace(state) / (std::string(stem) + ".skinned_morph_mesh.bin"));
}
 
inline VirtualPath BuildGeneratedMaterialPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "materials", BuildImportedNamespace(state) / (std::string(stem) + ".material.yaml"));
}
 
inline VirtualPath BuildGeneratedTexturePath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "textures", BuildImportedNamespace(state) / (std::string(stem) + ".png"));
}
 
inline glm::mat4 BuildNodeLocalMatrix(const cgltf_node& node)
{
    if (node.has_matrix)
    {
        glm::mat4 matrix(1.0f);
        std::memcpy(&matrix[0][0], node.matrix, sizeof(node.matrix));
        return matrix;
    }
 
    const glm::vec3 translation =
        node.has_translation ? glm::vec3(node.translation[0], node.translation[1], node.translation[2]) : glm::vec3(0.0f);
    const glm::quat rotation =
        node.has_rotation ? glm::quat(node.rotation[3], node.rotation[0], node.rotation[1], node.rotation[2]) : glm::quat(glm::vec3(0.0f));
    const glm::vec3 scale = node.has_scale ? glm::vec3(node.scale[0], node.scale[1], node.scale[2]) : glm::vec3(1.0f);
    return glm::translate(glm::mat4(1.0f), translation) * glm::toMat4(rotation) * glm::scale(glm::mat4(1.0f), scale);
}
 
inline Transform BuildNodeTransform(const cgltf_node& node)
{
    Transform transform;
    if (!TryDecomposeTransform(BuildNodeLocalMatrix(node), transform))
    {
        return Transform{};
    }
    return transform;
}
 
inline bool ReadFloatAccessorElement(const cgltf_accessor& accessor, const cgltf_size index, const cgltf_size expected_components,
                                     float* values)
{
    std::fill(values, values + expected_components, 0.0f);
    return cgltf_accessor_read_float(&accessor, index, values, expected_components) != 0;
}
 
inline bool ReadUintAccessorElement(const cgltf_accessor& accessor, const cgltf_size index, const cgltf_size expected_components,
                                    uint32_t* values)
{
    std::fill(values, values + expected_components, 0u);
    return cgltf_accessor_read_uint(&accessor, index, values, expected_components) != 0;
}
 
inline std::size_t FindMaterialIndex(const ImportState& state, const cgltf_material& material) noexcept
{
    return static_cast<std::size_t>(&material - state.gltf->materials);
}
 
inline std::size_t FindImageIndex(const ImportState& state, const cgltf_image& image) noexcept
{
    return static_cast<std::size_t>(&image - state.gltf->images);
}
 
inline std::size_t FindMeshIndex(const ImportState& state, const cgltf_mesh& mesh) noexcept
{
    return static_cast<std::size_t>(&mesh - state.gltf->meshes);
}
 
inline std::size_t FindNodeIndex(const ImportState& state, const cgltf_node& node) noexcept
{
    return static_cast<std::size_t>(&node - state.gltf->nodes);
}
 
inline std::optional<uint32_t> ResolveTextureCoordinateIndex(const cgltf_texture_view& view, std::string* error_message)
{
    if (error_message)
    {
        error_message->clear();
    }
 
    if (view.texture == nullptr)
    {
        return 0u;
    }
 
    const cgltf_int texcoord = view.has_transform && view.transform.has_texcoord ? view.transform.texcoord : view.texcoord;
    if (texcoord == 0)
    {
        return 0u;
    }
    if (texcoord == 1)
    {
        return 1u;
    }
 
    if (error_message)
    {
        *error_message = "glTF textures that reference TEXCOORD_2+ are not supported.";
    }
    return std::nullopt;
}
 
inline MaterialTextureUvSet ResolveTextureUvSet(const cgltf_texture_view& view, std::string* error_message)
{
    const std::optional<uint32_t> texcoord_index = ResolveTextureCoordinateIndex(view, error_message);
    if (!texcoord_index.has_value())
    {
        return MaterialTextureUvSet::Uv0;
    }
 
    return *texcoord_index == 1u ? MaterialTextureUvSet::Uv1 : MaterialTextureUvSet::Uv0;
}
 
inline MaterialTextureTransform ResolveTextureUvTransform(const cgltf_texture_view& view) noexcept
{
    MaterialTextureTransform transform;
    if (!view.has_transform)
    {
        return transform;
    }
 
    transform.offset = glm::vec2(view.transform.offset[0], view.transform.offset[1]);
    transform.scale = glm::vec2(view.transform.scale[0], view.transform.scale[1]);
    transform.rotation_degrees = glm::degrees(view.transform.rotation);
    return transform;
}
 
[[nodiscard]] std::optional<VirtualPath> GetOrCreateMaterialPath(ImportState& state, const cgltf_material* material);
[[nodiscard]] std::optional<VirtualPath> GetOrCreatePrimitiveMeshPath(ImportState& state, const cgltf_mesh& mesh,
                                                                      const cgltf_primitive& primitive, std::size_t primitive_index);
[[nodiscard]] std::optional<VirtualPath> GetOrCreatePrimitiveSkinnedMeshPath(ImportState& state, const cgltf_mesh& mesh,
                                                                             const cgltf_primitive& primitive, const cgltf_skin& skin,
                                                                             std::size_t primitive_index);
[[nodiscard]] std::optional<VirtualPath> GetOrCreatePrimitiveMorphMeshPath(ImportState& state, const cgltf_mesh& mesh,
                                                                           const cgltf_primitive& primitive, std::size_t primitive_index);
[[nodiscard]] std::optional<VirtualPath> GetOrCreatePrimitiveSkinnedMorphMeshPath(ImportState& state, const cgltf_mesh& mesh,
                                                                                  const cgltf_primitive& primitive, const cgltf_skin& skin,
                                                                                  std::size_t primitive_index);
[[nodiscard]] std::optional<std::vector<float>> ResolveNodeMorphWeights(const cgltf_node& node, const cgltf_mesh& mesh,
                                                                        std::string* error_message);
bool ImportNodeAnimations(ImportState& state, PrefabAsset& prefab, std::string* error_message);
bool BuildImportedPrefab(ImportState& state, std::string* error_message);
bool CommitGeneratedFiles(ImportState& state, GltfPrefabImportResult& result);
} // namespace pixelbullet::gltf_import_internal