Layer.cpp

Go to the documentation of this file.

#include "Layer.hpp"
 
namespace MayaFlux::Portal::Forma {
 
// =============================================================================
// Element registration
// =============================================================================
 
Layer::Slot Layer::add(Element element)
{
    element.id = m_next_id++;
    m_index[element.id] = m_elements.size();
    m_elements.push_back(std::move(element));
    return Slot(*this, m_elements.back().id);
}
 
bool Layer::remove(uint32_t id)
{
    if (!get(id))
        return false;
 
    const std::vector<uint32_t> ids = closure(id);
 
    for (uint32_t cid : ids) {
        if (auto* el = get(cid); el && el->buffer)
            el->buffer.retire();
        std::erase_if(m_elements, [cid](const Element& e) { return e.id == cid; });
        m_index_stale = true;
    }
 
    for (uint32_t cid : ids)
        m_relations.erase(cid);
 
    for (auto& [primary_id, related] : m_relations) {
        for (uint32_t cid : ids)
            std::erase(related, cid);
    }
    std::erase_if(m_relations, [](const auto& kv) { return kv.second.empty(); });
 
    return true;
}
 
void Layer::clear()
{
    m_elements.clear();
    m_index.clear();
    m_index_stale = false;
    m_relations.clear();
}
 
// =============================================================================
// Element mutation
// =============================================================================
 
bool Layer::set_bounds(uint32_t id, Kinesis::AABB2D bounds)
{
    if (auto* el = get(id)) {
        el->bounds_hint = bounds;
        return true;
    }
    return false;
}
 
bool Layer::set_contains(uint32_t id, std::function<bool(glm::vec2)> fn)
{
    if (auto* el = get(id)) {
        el->contains = std::move(fn);
        return true;
    }
    return false;
}
 
bool Layer::set_clip(uint32_t id, std::optional<Kinesis::AABB2D> clip)
{
    if (auto* el = get(id)) {
        el->clip = clip;
        return true;
    }
    return false;
}
 
bool Layer::set_interactive(uint32_t id, bool interactive)
{
    if (auto* el = get(id)) {
        el->interactive = interactive;
        return true;
    }
    return false;
}
 
bool Layer::set_visible(uint32_t id, bool visible)
{
    if (!get(id))
        return false;
 
    for (uint32_t member : closure(id)) {
        auto* el = get(member);
        if (!el)
            continue;
 
        el->visible = visible;
        el->buffer.set_visible(visible);
    }
    return true;
}
 
void Layer::set_all_visible(bool visible)
{
    for (const auto& el : m_elements) {
        set_visible(el.id, visible);
    }
}
 
bool Layer::bring_to_front(uint32_t id)
{
    if (!get(id))
        return false;
 
    const std::vector<uint32_t> ids = closure(id);
 
    auto raise = [this](uint32_t target) {
        auto it = std::ranges::find_if(m_elements,
            [target](const Element& e) { return e.id == target; });
        if (it == m_elements.end())
            return;
        std::rotate(it, it + 1, m_elements.end());
        m_index_stale = true;
 
        if (it = m_elements.end() - 1; it->buffer)
            it->buffer.bring_to_front(++m_next_front_priority);
    };
 
    for (size_t i = 1; i < ids.size(); ++i)
        raise(ids[i]);
    raise(ids.front());
 
    return true;
}
 
bool Layer::send_to_back(uint32_t id)
{
    if (!get(id))
        return false;
 
    const std::vector<uint32_t> ids = closure(id);
 
    auto lower = [this](uint32_t target) {
        auto it = std::ranges::find_if(m_elements,
            [target](const Element& e) { return e.id == target; });
        if (it == m_elements.end())
            return;
        std::rotate(m_elements.begin(), it, it + 1);
        m_index_stale = true;
 
        if (auto& el = m_elements.front(); el.buffer)
            el.buffer.send_to_back(--m_next_back_priority);
    };
 
    for (size_t i = 1; i < ids.size(); ++i)
        lower(ids[i]);
    lower(ids.front());
 
    return true;
}
 
// =============================================================================
// Spatial queries
// =============================================================================
 
std::optional<uint32_t> Layer::hit_test(glm::vec2 ndc) const
{
    for (const auto& m_element : std::views::reverse(m_elements)) {
        if (test_element(m_element, ndc))
            return m_element.id;
    }
    return std::nullopt;
}
 
std::vector<uint32_t> Layer::hit_test_all(glm::vec2 ndc) const
{
    std::vector<uint32_t> result;
    for (const auto& m_element : std::views::reverse(m_elements)) {
        if (test_element(m_element, ndc))
            result.push_back(m_element.id);
    }
    return result;
}
 
std::optional<uint32_t> Layer::hit_test(
    double px, double py, uint32_t win_w, uint32_t win_h) const
{
    return hit_test(to_ndc(px, py, win_w, win_h));
}
 
std::vector<uint32_t> Layer::hit_test_all(
    double px, double py, uint32_t win_w, uint32_t win_h) const
{
    return hit_test_all(to_ndc(px, py, win_w, win_h));
}
 
// =========================================================================
// Relations
// =========================================================================
 
bool Layer::relate(uint32_t primary_id, uint32_t related_id)
{
    auto* p = get(primary_id);
    auto* r = get(related_id);
    if (!p || !r || primary_id == related_id)
        return false;
 
    auto& rel = m_relations[primary_id];
    if (std::ranges::find(rel, related_id) == rel.end())
        rel.push_back(related_id);
 
    r->visible = p->visible;
    r->buffer.set_visible(p->visible);
 
    return true;
}
 
bool Layer::unrelate(uint32_t primary_id, uint32_t related_id)
{
    auto it = m_relations.find(primary_id);
    if (it == m_relations.end())
        return false;
    auto& rel = it->second;
    auto rit = std::ranges::find(rel, related_id);
    if (rit == rel.end())
        return false;
    rel.erase(rit);
    if (rel.empty())
        m_relations.erase(it);
    return true;
}
 
std::vector<uint32_t> Layer::related_ids(uint32_t primary_id) const
{
    auto it = m_relations.find(primary_id);
    return it != m_relations.end() ? it->second : std::vector<uint32_t> {};
}
 
std::vector<uint32_t> Layer::closure(uint32_t id) const
{
    std::vector<uint32_t> result { id };
 
    for (size_t i = 0; i < result.size(); ++i) {
        auto it = m_relations.find(result[i]);
        if (it == m_relations.end())
            continue;
        for (uint32_t rel_id : it->second) {
            if (std::ranges::find(result, rel_id) == result.end())
                result.push_back(rel_id);
        }
    }
 
    return result;
}
 
// =============================================================================
// Introspection
// =============================================================================
 
void Layer::reindex() const
{
    m_index.clear();
    for (size_t i = 0; i < m_elements.size(); ++i)
        m_index[m_elements[i].id] = i;
    m_index_stale = false;
}
 
const Element* Layer::get(uint32_t id) const
{
    if (m_index_stale)
        reindex();
    const auto it = m_index.find(id);
    return it != m_index.end() ? &m_elements[it->second] : nullptr;
}
 
Element* Layer::get(uint32_t id)
{
    return const_cast<Element*>(std::as_const(*this).get(id));
}
 
// =============================================================================
// Internal
// =============================================================================
 
glm::vec2 Layer::to_ndc(double px, double py, uint32_t w, uint32_t h) noexcept
{
    auto ndc3 = Kinesis::to_ndc(px, py, w, h);
    return { ndc3.x, ndc3.y };
}
 
bool Layer::test_element(const Element& el, glm::vec2 ndc) noexcept
{
    if (!el.interactive || !el.visible)
        return false;
    if (el.clip && !el.clip->contains(ndc))
        return false;
    if (el.bounds_hint && !el.bounds_hint->contains(ndc))
        return false;
    if (el.contains)
        return el.contains(ndc);
    return el.bounds_hint.has_value();
}
 
} // namespace MayaFlux::Portal::Forma