EntityView.hpp

Go to the documentation of this file.

#pragma once
#include "Entity.hpp"
 
namespace Cori {
    namespace World {
        template <typename... T>
        struct Exclude {};

        template <typename View>
        class StaticEntityView {
        public:
            using UnderlyingIterator = typename View::iterator;
 
            class Iterator {
            public:
                using iterator_category = std::forward_iterator_tag;
                using value_type = Entity;
                using difference_type = std::ptrdiff_t;
                using pointer = const Entity*;
                using reference = Entity;
 
                Iterator(entt::registry* registry, UnderlyingIterator it)
                    : m_Registry(registry), m_EnttIterator(it) {}
 
                reference operator*() const {
                    return Entity({*m_Registry, *m_EnttIterator});
                }
 
                Iterator& operator++() {
                    ++m_EnttIterator;
                    return *this;
                }
 
                bool operator!=(const Iterator& other) const {
                    return m_EnttIterator != other.m_EnttIterator;
                }
 
            private:
                entt::registry* m_Registry;
                UnderlyingIterator m_EnttIterator;
            };
 
            StaticEntityView(View view, entt::registry& registry)
                : m_View(view), m_Registry(&registry) {}

            template<typename... T>
            [[nodiscard]] decltype(auto) Get(Entity entity) {
                return m_View.template get<T...>(entity.GetRawEntity());
            }

            template<typename T>
            [[nodiscard]] size_t Size() {
                return m_View.template size<T>();
            }

            [[nodiscard]] size_t SizeHint() const {
                return m_View.size_hint();
            }

            [[nodiscard]] bool Contains(const Entity entity) const {
                return m_View.contains(entity.GetRawEntity());
            }
 
            auto begin() { return Iterator(m_Registry, m_View.begin()); }
            auto end() { return Iterator(m_Registry, m_View.end()); }
 
        private:
            View m_View;
            entt::registry* m_Registry;
        };

        class DynamicEntityView {
        public:

            explicit DynamicEntityView(entt::registry& registry)
                : m_Registry(&registry) {}

            template <typename... T>
            DynamicEntityView& With() & {
                (m_View.iterate(m_Registry->storage<T>()), ...);
                return *this;
            }

            template <typename... T>
            DynamicEntityView&& With() && {
                (m_View.iterate(m_Registry->storage<T>()), ...);
                return std::move(*this);
            }

            template <typename... T>
            DynamicEntityView& Without() & {
                (m_View.exclude(m_Registry->storage<T>()), ...);
                return *this;
            }

            template <typename... T>
            DynamicEntityView&& Without() && {
                (m_View.exclude(m_Registry->storage<T>()), ...);
                return std::move(*this);
            }

            [[nodiscard]] size_t SizeHint() const {
                return m_View.size_hint();
            }

            [[nodiscard]] bool Contains(const Entity entity) const {
                return m_View.contains(entity.GetRawEntity());
            }

            void Clear() {
                m_View.clear();
            }
 
            using UnderlyingIterator = entt::runtime_view::iterator;
            class Iterator {
            public:
                using iterator_category = std::forward_iterator_tag;
                using value_type = Entity;
                using difference_type = std::ptrdiff_t;
                using pointer = const Entity*;
                using reference = Entity;
 
                Iterator(entt::registry* registry, UnderlyingIterator it)
                    : m_Registry(registry), m_EnttIterator(it) {}
 
                reference operator*() const {
                    return Entity({*m_Registry, *m_EnttIterator});
                }
 
                Iterator& operator++() {
                    ++m_EnttIterator;
                    return *this;
                }
 
                bool operator!=(const Iterator& other) const {
                    return m_EnttIterator != other.m_EnttIterator;
                }
 
            private:
                entt::registry* m_Registry;
                UnderlyingIterator m_EnttIterator;
            };
 
            auto begin() { return Iterator(m_Registry, m_View.begin()); }
            auto end() { return Iterator(m_Registry, m_View.end()); }
 
        private:
            entt::registry* m_Registry;
            entt::runtime_view m_View;
        };
    }
}