interaction_sequence_ops.h

#pragma once
 
#include "pixelbullet/scene/interaction_sequence_types.h"
 
#include <algorithm>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
namespace pixelbullet
{
inline void NormalizeInteractionSequenceEditorGraphLayout(InteractionSequenceEditorGraphLayout& layout)
{
    std::vector<InteractionSequenceEditorGraphNodeLayout> normalized;
    normalized.reserve(layout.nodes.size());
    for (InteractionSequenceEditorGraphNodeLayout& node : layout.nodes)
    {
        if (node.node_id.empty())
        {
            continue;
        }
 
        const auto existing = std::find_if(normalized.begin(), normalized.end(),
                                           [&](const InteractionSequenceEditorGraphNodeLayout& candidate)
                                           { return candidate.node_id == node.node_id; });
        if (existing == normalized.end())
        {
            normalized.push_back(std::move(node));
        }
        else
        {
            *existing = std::move(node);
        }
    }
 
    layout.nodes = std::move(normalized);
}
 
inline void NormalizeInteractionSequenceAsset(InteractionSequenceAsset& asset)
{
    if (asset.editor_graph)
    {
        NormalizeInteractionSequenceEditorGraphLayout(*asset.editor_graph);
        if (asset.editor_graph->Empty())
        {
            asset.editor_graph.reset();
        }
    }
 
    if (asset.initial_node_id.empty() && !asset.nodes.empty())
    {
        asset.initial_node_id = asset.nodes.front().id;
    }
}
 
[[nodiscard]] inline std::optional<std::size_t> FindInteractionSequenceNodeIndex(const InteractionSequenceAsset& asset,
                                                                                  const std::string_view node_id)
{
    for (std::size_t index = 0; index < asset.nodes.size(); ++index)
    {
        if (asset.nodes[index].id == node_id)
        {
            return index;
        }
    }
 
    return std::nullopt;
}
 
[[nodiscard]] inline const InteractionSequenceNode* FindInteractionSequenceNode(const InteractionSequenceAsset& asset,
                                                                                const std::string_view node_id)
{
    const auto index = FindInteractionSequenceNodeIndex(asset, node_id);
    return index ? &asset.nodes[*index] : nullptr;
}
 
[[nodiscard]] inline InteractionSequenceNode* FindInteractionSequenceNode(InteractionSequenceAsset& asset,
                                                                          const std::string_view node_id)
{
    const auto index = FindInteractionSequenceNodeIndex(asset, node_id);
    return index ? &asset.nodes[*index] : nullptr;
}
 
[[nodiscard]] inline const InteractionSequenceEditorGraphNodeLayout*
FindInteractionSequenceEditorGraphNodeLayout(const InteractionSequenceAsset& asset, const std::string_view node_id)
{
    if (!asset.editor_graph)
    {
        return nullptr;
    }
 
    const auto it = std::find_if(asset.editor_graph->nodes.begin(), asset.editor_graph->nodes.end(),
                                 [&](const InteractionSequenceEditorGraphNodeLayout& node) { return node.node_id == node_id; });
    return it == asset.editor_graph->nodes.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline InteractionSequenceEditorGraphNodeLayout*
FindInteractionSequenceEditorGraphNodeLayout(InteractionSequenceAsset& asset, const std::string_view node_id)
{
    if (!asset.editor_graph)
    {
        return nullptr;
    }
 
    const auto it = std::find_if(asset.editor_graph->nodes.begin(), asset.editor_graph->nodes.end(),
                                 [&](const InteractionSequenceEditorGraphNodeLayout& node) { return node.node_id == node_id; });
    return it == asset.editor_graph->nodes.end() ? nullptr : &(*it);
}
 
inline InteractionSequenceEditorGraphNodeLayout& EnsureInteractionSequenceEditorGraphNodeLayout(InteractionSequenceAsset& asset,
                                                                                                 std::string node_id)
{
    if (!asset.editor_graph)
    {
        asset.editor_graph = InteractionSequenceEditorGraphLayout{};
    }
 
    if (InteractionSequenceEditorGraphNodeLayout* existing = FindInteractionSequenceEditorGraphNodeLayout(asset, node_id))
    {
        return *existing;
    }
 
    asset.editor_graph->nodes.push_back(InteractionSequenceEditorGraphNodeLayout{
        .node_id = std::move(node_id),
        .position = glm::vec2(0.0f),
    });
    return asset.editor_graph->nodes.back();
}
} // namespace pixelbullet