scene.hpp

#pragma once
#include <core/core.hpp>
#include <string>
#include <core/event/event_bus.hpp>
#include <core/scene/game_object.hpp>
 
namespace atlas {
 
    class scene {
    public:
        scene(const std::string& p_name, event::event_bus& p_bus);
 
        virtual ~scene() = default;
 
        game_object entity(std::string_view p_name);
 
        game_object entity(uint64_t p_id);
 
        template<typename UEventType, typename UObject, typename UCallback>
        void subscribe(UObject* p_instance, const UCallback& p_callback) {
            m_bus->subscribe<UEventType>(p_instance, p_callback);
        }
 
        template<typename... Comps, typename... Args>
        flecs::query_builder<Comps...> query_builder(Args&&... args) const {
            return flecs::query_builder<Comps...>(m_registry,
                                                  std::forward(args)...);
        }
 
        uint32_t children_count(const game_object& p_parent);
 
        bool defer_begin() { return m_registry.defer_begin(); }
 
        bool defer_end() { return m_registry.defer_end(); }
 
        [[nodiscard]] std::string name() const { return m_name; }
 
        [[nodiscard]] event::event_bus* event_handle() const { return m_bus; }
 
        operator flecs::world&() { return m_registry; }
 
    private:
        flecs::world m_registry;
        std::string m_name;
        event::event_bus* m_bus = nullptr;
    };
}; // namespace atlas