gltf_import_shared_internal.h

#pragma once
 
#include "morph_mesh_internal.h"
#include "pixelbullet/assets/gltf_prefab_import.h"
#include "pixelbullet/assets/material.h"
#include "pixelbullet/filesystem/filesystem.h"
#include "pixelbullet/image/bitmap.h"
#include "pixelbullet/integration/assets/gltf_source_dependencies.h"
#include "pixelbullet/logging/log.h"
#include "pixelbullet/math/validation.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 "ozz/animation/runtime/animation.h"
#include "ozz/animation/runtime/skeleton.h"
#include "ozz/base/memory/unique_ptr.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, ozz::unique_ptr<ozz::animation::Skeleton>>> skeletons;
    std::vector<std::pair<VirtualPath, ozz::unique_ptr<ozz::animation::Animation>>> animation_clips;
    std::vector<std::pair<VirtualPath, Material>> materials;
    std::vector<std::pair<VirtualPath, Bitmap>> textures;
};
 
struct ImportedSkinAnimationData
{
    VirtualPath skeleton_path;
    std::vector<const cgltf_node*> joint_nodes_in_ozz_order;
    std::vector<EntityId> joint_entities_in_ozz_order;
    std::unordered_map<const cgltf_node*, std::size_t> joint_track_indices;
};
 
enum class PrimitiveMeshKind
{
    Static,
    Skinned,
    Morph,
    SkinnedMorph,
};
 
struct PrimitiveMeshCacheKey
{
    const cgltf_primitive* primitive = nullptr;
    const cgltf_skin* skin = nullptr;
    PrimitiveMeshKind kind = PrimitiveMeshKind::Static;
};
 
inline bool operator==(const PrimitiveMeshCacheKey& lhs, const PrimitiveMeshCacheKey& rhs) noexcept
{
    return lhs.primitive == rhs.primitive && lhs.skin == rhs.skin && lhs.kind == rhs.kind;
}
 
struct PrimitiveMeshCacheKeyHash
{
    std::size_t operator()(const PrimitiveMeshCacheKey& key) const noexcept
    {
        std::size_t hash = std::hash<const void*>{}(key.primitive);
        hash ^= std::hash<const void*>{}(key.skin) + 0x9e3779b97f4a7c15ull + (hash << 6u) + (hash >> 2u);
        hash ^= std::hash<std::size_t>{}(static_cast<std::size_t>(key.kind)) + 0x9e3779b97f4a7c15ull + (hash << 6u) + (hash >> 2u);
        return hash;
    }
};
 
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<PrimitiveMeshCacheKey, VirtualPath, PrimitiveMeshCacheKeyHash> primitive_mesh_path_cache;
    std::unordered_map<const cgltf_node*, EntityId> imported_node_entities;
    std::unordered_map<const cgltf_skin*, ImportedSkinAnimationData> imported_skins;
    std::unordered_map<const cgltf_skin*, std::vector<EntityId>> imported_skin_owner_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::unordered_map<std::string, std::size_t> skeleton_name_counts;
    std::unordered_map<std::string, std::size_t> animation_clip_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 ToLowerAscii(std::string value)
{
    std::transform(value.begin(), value.end(), value.begin(),
                   [](const unsigned char character) { return static_cast<char>(std::tolower(character)); });
    return value;
}
 
inline bool IsPathWithinRoot(const std::filesystem::path& candidate, const std::filesystem::path& root)
{
    if (candidate.empty() || root.empty())
    {
        return false;
    }
 
    const std::filesystem::path normalized_candidate = candidate.lexically_normal();
    const std::filesystem::path normalized_root = root.lexically_normal();
    auto candidate_it = normalized_candidate.begin();
    for (auto root_it = normalized_root.begin(); root_it != normalized_root.end(); ++root_it, ++candidate_it)
    {
        if (candidate_it == normalized_candidate.end() ||
            ToLowerAscii(candidate_it->generic_string()) != ToLowerAscii(root_it->generic_string()))
        {
            return false;
        }
    }
 
    return true;
}
 
inline std::optional<std::filesystem::path> ResolveGltfLocalDependencyPath(const SourceRoot& source_root,
                                                                           const std::filesystem::path& source_directory,
                                                                           const std::string_view uri, std::string* error_message)
{
    if (error_message != nullptr)
    {
        error_message->clear();
    }
 
    const integration::assets::GltfDependencyUri dependency_uri = integration::assets::ClassifyGltfDependencyUri(uri);
    if (!dependency_uri)
    {
        if (error_message != nullptr)
        {
            *error_message = dependency_uri.error_message;
        }
        return std::nullopt;
    }
 
    if (!dependency_uri.is_local_file())
    {
        return std::nullopt;
    }
 
    const std::filesystem::path dependency_path = (source_directory / dependency_uri.relative_path).lexically_normal();
    if (!IsPathWithinRoot(dependency_path, source_root.physical_root))
    {
        if (error_message != nullptr)
        {
            *error_message = fmt::format("glTF dependency URI '{}' resolves outside the source asset root.", uri);
        }
        return std::nullopt;
    }
 
    return dependency_path;
}
 
inline bool ValidateGltfDependencyUris(const cgltf_data& gltf, const SourceRoot& source_root, const std::filesystem::path& source_directory,
                                       std::string* error_message)
{
    const auto validate_uri = [&](const char* const uri, const std::string_view label, const std::size_t index) -> bool
    {
        std::string dependency_error;
        ResolveGltfLocalDependencyPath(source_root, source_directory, uri != nullptr ? std::string_view(uri) : std::string_view{},
                                       &dependency_error);
        if (!dependency_error.empty())
        {
            if (error_message != nullptr)
            {
                *error_message = fmt::format("Invalid glTF {} dependency URI at index {}: {}", label, index, dependency_error);
            }
            return false;
        }
        return true;
    };
 
    for (cgltf_size index = 0u; index < gltf.buffers_count; ++index)
    {
        if (!validate_uri(gltf.buffers[index].uri, "buffer", static_cast<std::size_t>(index)))
        {
            return false;
        }
    }
 
    for (cgltf_size index = 0u; index < gltf.images_count; ++index)
    {
        if (!validate_uri(gltf.images[index].uri, "image", static_cast<std::size_t>(index)))
        {
            return false;
        }
    }
 
    return true;
}
 
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);
    }
}
 
inline bool ValidateGltfFiniteComponents(const float* values, const std::size_t count, const std::string_view label,
                                         std::string* error_message)
{
    for (std::size_t index = 0u; index < count; ++index)
    {
        if (!math::is_finite(values[index]))
        {
            if (error_message)
            {
                *error_message = fmt::format("glTF {} contains non-finite values.", label);
            }
            return false;
        }
    }
 
    return true;
}
 
template <typename T>
inline bool ValidateGltfFiniteValue(const T& value, const std::string_view label, std::string* error_message)
{
    if (math::is_finite(value))
    {
        return true;
    }
 
    if (error_message)
    {
        *error_message = fmt::format("glTF {} contains non-finite values.", label);
    }
    return false;
}
 
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.logical_path();
    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.resolve_writable(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.resolve_writable(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 BuildGeneratedSkeletonPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "animations", BuildImportedNamespace(state) / (std::string(stem) + ".skeleton.bin"));
}
 
inline VirtualPath BuildGeneratedAnimationClipPath(const ImportState& state, const std::string_view stem)
{
    return BuildGeneratedPath(state, "animations", BuildImportedNamespace(state) / (std::string(stem) + ".animation_clip.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 std::optional<glm::mat4> BuildNodeLocalMatrix(const cgltf_node& node, std::string* error_message)
{
    if (node.has_matrix)
    {
        if (!ValidateGltfFiniteComponents(node.matrix, 16u, "node matrix transform", error_message))
        {
            return std::nullopt;
        }
 
        glm::mat4 matrix(1.0f);
        std::memcpy(&matrix[0][0], node.matrix, sizeof(node.matrix));
        return matrix;
    }
 
    if (node.has_translation && !ValidateGltfFiniteComponents(node.translation, 3u, "node translation transform", error_message))
    {
        return std::nullopt;
    }
    if (node.has_rotation && !ValidateGltfFiniteComponents(node.rotation, 4u, "node rotation transform", error_message))
    {
        return std::nullopt;
    }
    if (node.has_scale && !ValidateGltfFiniteComponents(node.scale, 3u, "node scale transform", error_message))
    {
        return std::nullopt;
    }
 
    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 std::optional<Transform> BuildNodeTransform(const cgltf_node& node, std::string* error_message)
{
    const std::optional<glm::mat4> local_matrix = BuildNodeLocalMatrix(node, error_message);
    if (!local_matrix.has_value())
    {
        return std::nullopt;
    }
 
    Transform transform;
    if (!TryDecomposeTransform(*local_matrix, 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);
[[nodiscard]] const ImportedSkinAnimationData* GetOrCreateImportedSkinAnimationData(ImportState& state, const cgltf_skin& skin,
                                                                                    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