few helper functions for components extracting

headers/enduro2d/high/systems/_systems.hpp

@@ -37,3 +37,108 @@ namespace e2d::systems
     using render_system = ecs::system<render_event>;
     using post_render_system = ecs::system<post_render_event>;
 }
+
+namespace e2d::systems
+{
+    template < typename... Ts, typename Iter >
+    std::size_t extract_components(ecs::registry& owner, Iter iter) {
+        std::size_t count{0u};
+        owner.for_joined_components<Ts...>(
+        [&iter, &count](const ecs::entity& e, Ts&... cs){
+            iter++ = std::make_tuple(e, std::ref(cs)...);
+            ++count;
+        });
+        return count;
+    }
+
+    template < typename... Ts, typename Iter >
+    std::size_t extract_components(const ecs::registry& owner, Iter iter) {
+        std::size_t count{0u};
+        owner.for_joined_components<Ts...>(
+        [&iter, &count](const ecs::const_entity& e, const Ts&... cs){
+            iter++ = std::make_tuple(e, std::cref(cs)...);
+            ++count;
+        });
+        return count;
+    }
+}
+
+namespace e2d::systems
+{
+    template < typename... Ts, typename F >
+    void for_extracted_components(ecs::registry& owner, F&& f) {
+        //TODO(BlackMat): replace it to frame allocator
+        static thread_local vector<std::tuple<
+            ecs::entity,
+            std::reference_wrapper<Ts>...>> components;
+        try {
+            extract_components<Ts...>(owner, std::back_inserter(components));
+            for ( auto& t : components ) {
+                std::apply(f, t);
+            }
+        } catch (...) {
+            components.clear();
+            throw;
+        }
+        components.clear();
+    }
+
+    template < typename... Ts, typename F >
+    void for_extracted_components(const ecs::registry& owner, F&& f) {
+        //TODO(BlackMat): replace it to frame allocator
+        static thread_local vector<std::tuple<
+            ecs::const_entity,
+            std::reference_wrapper<const Ts>...>> components;
+        try {
+            extract_components<Ts...>(owner, std::back_inserter(components));
+            for ( const auto& t : components ) {
+                std::apply(f, t);
+            }
+        } catch (...) {
+            components.clear();
+            throw;
+        }
+        components.clear();
+    }
+}
+
+namespace e2d::systems
+{
+    template < typename... Ts, typename Comp, typename F >
+    void for_extracted_components(ecs::registry& owner, Comp&& comp, F&& f) {
+        //TODO(BlackMat): replace it to frame allocator
+        static thread_local vector<std::tuple<
+            ecs::entity,
+            std::reference_wrapper<Ts>...>> components;
+        try {
+            extract_components<Ts...>(owner, std::back_inserter(components));
+            std::sort(components.begin(), components.end(), comp);
+            for ( auto& t : components ) {
+                std::apply(f, t);
+            }
+        } catch (...) {
+            components.clear();
+            throw;
+        }
+        components.clear();
+    }
+
+    template < typename... Ts, typename Comp, typename F >
+    void for_extracted_components(const ecs::registry& owner, Comp&& comp, F&& f) {
+        //TODO(BlackMat): replace it to frame allocator
+        static thread_local vector<std::tuple<
+            ecs::const_entity,
+            std::reference_wrapper<const Ts>...>> components;
+        try {
+            extract_components<Ts...>(owner, std::back_inserter(components));
+            std::sort(components.begin(), components.end(), comp);
+            for ( const auto& t : components ) {
+                std::apply(f, t);
+            }
+        } catch (...) {
+            components.clear();
+            throw;
+        }
+        components.clear();
+    }
+}

sources/enduro2d/high/systems/render_system.cpp

@@ -19,57 +19,36 @@ namespace
     using namespace e2d;
     using namespace e2d::render_system_impl;
 
-    template < typename T, typename Comp, typename F >
+    void for_all_scenes(drawer::context& ctx, const ecs::registry& owner) {
-    void for_each_by_sorted_components(ecs::registry& owner, Comp&& comp, F&& f) {
+        const auto comp = [](const auto& l, const auto& r) noexcept {
-        static vector<std::pair<ecs::const_entity,T>> temp_components;
+            return std::get<1>(l).get().depth() < std::get<1>(r).get().depth();
-        try {
+        };
-            temp_components.reserve(owner.component_count<T>());
+        const auto func = [&ctx](
-            owner.for_each_component<T>([](const ecs::const_entity& e, const T& t){
+            const ecs::const_entity&,
-                temp_components.emplace_back(e, t);
+            const scene&,
+            const actor& scn_a)
+        {
+            nodes::for_extracted_nodes(scn_a.node(), [&ctx](const const_node_iptr& node){
+                ctx.draw(node);
             });
-            std::sort(
+        };
-                temp_components.begin(),
+        systems::for_extracted_components<scene, actor>(owner, comp, func);
-                temp_components.end(),
-                [&comp](const auto& l, const auto& r){
-                    return comp(l.second, r.second);
-                });
-            for ( auto& p : temp_components ) {
-                f(p.first, p.second);
-            }
-        } catch (...) {
-            temp_components.clear();
-            throw;
-        }
-        temp_components.clear();
     }
 
-    void for_all_scenes(drawer::context& ctx, ecs::registry& owner) {
+    void for_all_cameras(drawer& drawer, const ecs::registry& owner) {
-        const auto comp = [](const scene& l, const scene& r) noexcept {
+        const auto comp = [](const auto& l, const auto& r) noexcept {
-            return l.depth() < r.depth();
+            return std::get<1>(l).get().depth() < std::get<1>(r).get().depth();
         };
-        const auto func = [&ctx](const ecs::const_entity& scn_e, const scene&) {
+        const auto func = [&drawer, &owner](
-            const actor* scn_a = scn_e.find_component<actor>();
+            const ecs::const_entity&,
-            if ( scn_a && scn_a->node() ) {
+            const camera& cam,
-                nodes::for_extracted_nodes(scn_a->node(), [&ctx](const const_node_iptr& node){
+            const actor& cam_a)
-                    ctx.draw(node);
+        {
-                });
+            drawer.with(cam, cam_a.node(), [&owner](drawer::context& ctx){
-            }
-        };
-        for_each_by_sorted_components<scene>(owner, comp, func);
-    }
-
-    void for_all_cameras(drawer& drawer, ecs::registry& owner) {
-        const auto comp = [](const camera& l, const camera& r) noexcept {
-            return l.depth() < r.depth();
-        };
-        const auto func = [&drawer, &owner](const ecs::const_entity& cam_e, const camera& cam) {
-            const actor* const cam_a = cam_e.find_component<actor>();
-            const const_node_iptr cam_n = cam_a ? cam_a->node() : nullptr;
-            drawer.with(cam, cam_n, [&owner](drawer::context& ctx){
                 for_all_scenes(ctx, owner);
             });
         };
-        for_each_by_sorted_components<camera>(owner, comp, func);
+        systems::for_extracted_components<camera, actor>(owner, comp, func);
     }
 }