prefab_resolution.h

#pragma once
 
#include "pixelbullet/filesystem/virtual_path.h"
#include "pixelbullet/scene/prefab_asset.h"
#include "pixelbullet/scene/prefab_asset_io.h"
#include "pixelbullet/scene/transform_resolution.h"
 
#include <glm/glm.hpp>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace pixelbullet
{
class Filesystem;
class Scene;
 
struct ResolvedPrefabInstance;
 
struct ResolvedNestedPrefabInstance
{
    EntityId wrapper_prefab_entity = EntityId::Invalid();
    VirtualPath prefab_path;
    std::shared_ptr<const PrefabAsset> prefab;
    SceneResolvedTransforms resolved_transforms;
    SceneMorphWeightOverrides resolved_morph_weights;
    glm::mat4 wrapper_world_matrix = glm::mat4(1.0f);
    std::vector<ResolvedNestedPrefabInstance> nested_instances;
 
    [[nodiscard]] bool IsValid() const noexcept
    {
        return wrapper_prefab_entity && prefab && prefab->IsValid();
    }
};
 
struct ResolvedPrefabInstance
{
    EntityId instance_entity = EntityId::Invalid();
    VirtualPath prefab_path;
    std::shared_ptr<const PrefabAsset> prefab;
    SceneResolvedTransforms resolved_transforms;
    SceneMorphWeightOverrides resolved_morph_weights;
    glm::mat4 wrapper_world_matrix = glm::mat4(1.0f);
    std::vector<ResolvedNestedPrefabInstance> nested_instances;
 
    [[nodiscard]] bool IsValid() const noexcept
    {
        return instance_entity && prefab && prefab->IsValid();
    }
};
 
struct SceneNestedPrefabOverrideKey
{
    EntityId::ValueType root_instance = EntityId::Invalid().Raw();
    std::vector<EntityId::ValueType> wrapper_path;
 
    [[nodiscard]] bool operator==(const SceneNestedPrefabOverrideKey&) const = default;
};
 
struct SceneNestedPrefabOverrideKeyHash
{
    [[nodiscard]] std::size_t operator()(const SceneNestedPrefabOverrideKey& key) const noexcept
    {
        std::size_t seed = std::hash<EntityId::ValueType>{}(key.root_instance);
        for (const EntityId::ValueType path_entity : key.wrapper_path)
        {
            seed ^= std::hash<EntityId::ValueType>{}(path_entity) + 0x9e3779b9u + (seed << 6u) + (seed >> 2u);
        }
        return seed;
    }
};
 
[[nodiscard]] inline SceneNestedPrefabOverrideKey MakeSceneNestedPrefabOverrideKey(EntityId root_instance,
                                                                                   const std::vector<EntityId>& wrapper_path)
{
    SceneNestedPrefabOverrideKey key;
    key.root_instance = root_instance.Raw();
    key.wrapper_path.reserve(wrapper_path.size());
    for (const EntityId wrapper : wrapper_path)
    {
        key.wrapper_path.push_back(wrapper.Raw());
    }
    return key;
}
 
struct ScenePrefabTransformOverrides
{
    std::unordered_map<EntityId::ValueType, SceneTransformOverrides> values;
    std::unordered_map<SceneNestedPrefabOverrideKey, SceneTransformOverrides, SceneNestedPrefabOverrideKeyHash> nested_values;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return values.empty() && nested_values.empty();
    }
 
    [[nodiscard]] const SceneTransformOverrides* Find(EntityId instance_entity) const noexcept
    {
        const auto it = values.find(instance_entity.Raw());
        return it == values.end() ? nullptr : &it->second;
    }
 
    [[nodiscard]] const SceneTransformOverrides* FindNested(EntityId root_instance, const std::vector<EntityId>& wrapper_path) const
    {
        const SceneNestedPrefabOverrideKey key = MakeSceneNestedPrefabOverrideKey(root_instance, wrapper_path);
        const auto it = nested_values.find(key);
        return it == nested_values.end() ? nullptr : &it->second;
    }
 
    [[nodiscard]] SceneTransformOverrides& EnsureNested(EntityId root_instance, const std::vector<EntityId>& wrapper_path)
    {
        return nested_values.try_emplace(MakeSceneNestedPrefabOverrideKey(root_instance, wrapper_path), SceneTransformOverrides{})
            .first->second;
    }
};
 
struct ScenePrefabMorphWeightOverrides
{
    std::unordered_map<EntityId::ValueType, SceneMorphWeightOverrides> values;
    std::unordered_map<SceneNestedPrefabOverrideKey, SceneMorphWeightOverrides, SceneNestedPrefabOverrideKeyHash> nested_values;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return values.empty() && nested_values.empty();
    }
 
    [[nodiscard]] const SceneMorphWeightOverrides* Find(EntityId instance_entity) const noexcept
    {
        const auto it = values.find(instance_entity.Raw());
        return it == values.end() ? nullptr : &it->second;
    }
 
    [[nodiscard]] const SceneMorphWeightOverrides* FindNested(EntityId root_instance, const std::vector<EntityId>& wrapper_path) const
    {
        const SceneNestedPrefabOverrideKey key = MakeSceneNestedPrefabOverrideKey(root_instance, wrapper_path);
        const auto it = nested_values.find(key);
        return it == nested_values.end() ? nullptr : &it->second;
    }
 
    [[nodiscard]] SceneMorphWeightOverrides& EnsureNested(EntityId root_instance, const std::vector<EntityId>& wrapper_path)
    {
        return nested_values.try_emplace(MakeSceneNestedPrefabOverrideKey(root_instance, wrapper_path), SceneMorphWeightOverrides{})
            .first->second;
    }
};
 
struct ScenePrefabResolvedInstanceStats
{
    std::uint32_t root_instance_count = 0u;
    std::uint32_t nested_instance_count = 0u;
    std::uint32_t max_nested_depth = 0u;
    std::uint32_t source_prefab_entity_count = 0u;
    std::uint32_t transform_override_entry_count = 0u;
    std::uint32_t morph_override_entry_count = 0u;
    std::uint32_t nested_recursion_call_count = 0u;
    float morph_override_apply_milliseconds = 0.0f;
    float wrapper_world_matrix_milliseconds = 0.0f;
    float root_instance_assembly_milliseconds = 0.0f;
    float nested_instance_assembly_milliseconds = 0.0f;
    float nested_traversal_milliseconds = 0.0f;
    float nested_recursion_inclusive_milliseconds = 0.0f;
    float instance_store_milliseconds = 0.0f;
};
 
struct ScenePrefabResolutionTimings
{
    float load_prefab_assets_milliseconds = 0.0f;
    float evaluate_prefab_animation_milliseconds = 0.0f;
    float resolve_prefab_transforms_milliseconds = 0.0f;
    float build_resolved_instances_milliseconds = 0.0f;
    PrefabAssetLoadStats prefab_asset_load_stats;
    ScenePrefabResolvedInstanceStats resolved_instance_stats;
};
 
struct ScenePrefabAnimationPreview
{
    std::string skeleton_clip_name;
    float time_seconds = 0.0f;
};
 
class ScenePrefabResolver
{
public:
    [[nodiscard]] static std::vector<ResolvedPrefabInstance>
    ResolveInstances(const Scene& scene, const Filesystem& filesystem, const SceneTransformOverrides* scene_transform_overrides = nullptr,
                     const ScenePrefabTransformOverrides* prefab_transform_overrides = nullptr,
                     const ScenePrefabMorphWeightOverrides* prefab_morph_weight_overrides = nullptr,
                     std::optional<float> prefab_time_seconds = std::nullopt, ScenePrefabResolutionTimings* timings = nullptr,
                     const ScenePrefabAnimationPreview* prefab_animation_preview = nullptr);
};
} // namespace pixelbullet