View.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <limits>
#include <tuple>
#include <utility>
 
#include "Core/Ecs/ComponentPool.h"
#include "Core/Ecs/Entity.h"

 
namespace core {

template <typename... Components>
class View {
public:
    explicit View(ComponentPool<Components>&... pools) : _pools(&pools...) {}

    template <typename Function>
    void each(Function&& function) const {
        const std::vector<Entity>& driver = smallestEntities();
        for (const Entity entity : driver) {
            if (matches(entity)) {
                function(entity, componentOf<Components>(entity)...);
            }
        }
    }

    class Iterator {
    public:
        Iterator(const View* view, const std::vector<Entity>* driver, std::size_t index)
            : _view(view), _driver(driver), _index(index) {
            skipToMatch();
        }

        [[nodiscard]] bool operator!=(const Iterator& other) const {
            return _index != other._index;
        }

        Iterator& operator++() {
            ++_index;
            skipToMatch();
            return *this;
        }

        [[nodiscard]] std::tuple<Entity, Components&...> operator*() const {
            const Entity entity = (*_driver)[_index];
            return std::tuple<Entity, Components&...>(entity,
                                                      _view->componentOf<Components>(entity)...);
        }
 
    private:
        void skipToMatch() {
            while (_index < _driver->size() && !_view->matches((*_driver)[_index])) {
                ++_index;
            }
        }
 
        const View* _view;
        const std::vector<Entity>* _driver;
        std::size_t _index;
    };

    [[nodiscard]] Iterator begin() const {
        const std::vector<Entity>& driver = smallestEntities();
        return Iterator(this, &driver, 0);
    }

    [[nodiscard]] Iterator end() const {
        const std::vector<Entity>& driver = smallestEntities();
        return Iterator(this, &driver, driver.size());
    }
 
private:
    [[nodiscard]] bool matches(Entity entity) const {
        return (std::get<ComponentPool<Components>*>(_pools)->has(entity) && ...);
    }

    template <typename Component>
    [[nodiscard]] Component& componentOf(Entity entity) const {
        return std::get<ComponentPool<Component>*>(_pools)->get(entity);
    }

    [[nodiscard]] const std::vector<Entity>& smallestEntities() const {
        const std::vector<Entity>* smallest = nullptr;
        std::size_t smallestSize = (std::numeric_limits<std::size_t>::max)();
        // Retient la pool de plus faible population : elle borne le nombre
        // d'entités à filtrer (l'intersection ne peut être plus grande).
        const auto consider = [&](const auto* pool) {
            if (pool->size() < smallestSize) {
                smallestSize = pool->size();
                smallest = &pool->entities();
            }
        };
        (consider(std::get<ComponentPool<Components>*>(_pools)), ...);
        return *smallest;
    }

    std::tuple<ComponentPool<Components>*...> _pools;
};
 
}  // namespace core