✨ Scene Objects Refactor

CMakeLists.txt

@@ -39,20 +39,15 @@ build_core_library(
     tests/scene.test.cpp
     tests/jolt_type_conversion.test.cpp
     tests/jolt_engine.test.cpp
-    # tests/object.test.cpp
 
     PACKAGES
     tinyobjloader
-    TinyGLTF
-    # shaderc # uncomment to use shaderc
     ${SHADERC_PACKAGE}
     watcher
     vulkan-cpp
 
     LINK_PACKAGES
     tinyobjloader::tinyobjloader
-    TinyGLTF::TinyGLTF
-    # shaderc::shaderc # uncomment to use shaderc
     ${SHADERC_LINK_PACKAGE}
     watcher::watcher
     vulkan-cpp::vulkan-cpp

atlas/core/common.hpp

@@ -2,6 +2,7 @@
 
 // core includes
 #include <core/core.hpp>
+#include <core/application.hpp>
 #include <core/engine_logger.hpp>
 #include <core/utilities/state.hpp>
 #include <core/event/event.hpp>

atlas/core/scene/exceptions.hpp

@@ -0,0 +1,23 @@
+#pragma once
+#include <exception>
+
+namespace atlas {
+    struct exception_block {
+        const char* data = nullptr;
+    };
+
+    class invalid_access_exception : public std::exception {
+    public:
+        invalid_access_exception() = default;
+        invalid_access_exception(const char* p_data)
+          : m_block(p_data) {}
+
+        //! @return message given when this exception gets triggered
+        [[nodiscard]] const char* what() const noexcept override {
+            return m_block.data;
+        }
+
+    private:
+        exception_block m_block;
+    };
+};

atlas/core/scene/game_object.hpp

@@ -0,0 +1,84 @@
+#pragma once
+#include <flecs.h>
+#include <optional>
+
+namespace atlas {
+
+    /**
+     * @brief Creates a pointer wrapper which extends capabilities of
+     * flecs::entity
+     *
+     * Provides our own construct of API's that handles any workload around some
+     * of the raw flecs API's that can still be used by other flecs API's
+     * without completely interacting touching raw flecs API
+     */
+    class game_object : public flecs::entity {
+    public:
+        //! @brief Should not construct a scene object not created through
+        //! flecs::world
+        game_object() = delete;
+
+        game_object(flecs::world_t* p_registry, flecs::entity_t p_id);
+
+        game_object(const flecs::entity& p_base);
+
+        explicit game_object(flecs::entity& p_base);
+
+        /**
+         * @brief sets the entity to be a parent of the specified entity
+         *
+         * @param p_entity is the specified entity to specify as the parent.
+         *
+         *
+         * Example Usage:
+         *
+         * ```C++
+         *
+         * atlas::game_object obj1 = entity("Parent");
+         *
+         * atlas::game_object obj2 = entity("Chlid");
+         *
+         * // obj2 is the child of obj1
+         * // As obj1 is a parent node
+         * obj2.child_of(obj1);
+         *
+         * ```
+         *
+         */
+        void child_of(const std::optional<game_object>& p_parent);
+
+        /**
+         * @brief iterates through all children entities if the given entity is
+         * a parent of any given entities
+         *
+         * Example Usage:
+         *
+         *
+         * ```C++
+         * atlas::game_object obj1 = entity("Parent Node");
+         * atlas::game_object obj2 = entity("Chlid Node");
+         *
+         * // obj1 is the parent of obj2.
+         * obj2.child_of(parent);
+         *
+         * // iteration should only include for "Child Node"
+         * obj1.children([](flecs::entity p_child){
+         *     // do stuff with the child entity
+         * });
+         *
+         * ```
+         */
+        template<typename UFunction>
+        void children(UFunction&& p_callback) {
+            children(p_callback);
+        }
+    };
+
+    /**
+     * @brief Alias to std::optional<game_object>
+     *
+     * This alias serves as a representation of game objects users can create
+     * and manage components with
+     */
+    using game_object_optional = std::optional<game_object>;
+};

atlas/core/scene/scene.hpp

@@ -1,10 +1,8 @@
 #pragma once
 #include <core/core.hpp>
-#include <core/engine_logger.hpp>
-#include <core/scene/scene_object.hpp>
 #include <string>
-#include <core/scene/types.hpp>
 #include <core/event/event_bus.hpp>
+#include <core/scene/game_object.hpp>
 
 namespace atlas {
 
@@ -23,30 +21,33 @@ namespace atlas {
      * helps manages these scenes and consider them as contexts that can be
      * switched/toggled based on users transforms.
      */
-    class scene_scope {
+    class scene {
     public:
         /**
          * @param p_name is the name given to this scene
          * @param p_bus is the globalized event bus that is given access to the
          * scene to subscribe events to it.
          */
-        scene_scope(const std::string& p_name, event::event_bus& p_bus)
-          : m_name(p_name)
-          , m_bus(&p_bus) {}
+        scene(const std::string& p_name, event::event_bus& p_bus);
 
-        virtual ~scene_scope() = default;
+        virtual ~scene() = default;
 
         /**
-         * @brief Used to creating a game object
+         * @brief Retrieves if an entity already exists within the registry,
+         * create new entity otherwise
          *
-         * @param p_name is specified when creating or searching the object
+         * @param p_name is a string to set the name of the entity
+         */
+        game_object entity(std::string_view p_name);
+
+        /**
+         * @brief Retrieves if an entity already exists within the registry,
+         * create new entity otherwise
          *
-         * @return strong_ptr<atlas::scene_object>
+         * @param p_entity_id is the ID to retrieve an entity if it exists,
+         * otherwise returns a new entity.
          */
-        strong_ref<scene_object> create_object(const std::string& p_name) {
-            return create_strong_ref<scene_object>(
-              m_allocator, &m_registry, p_name);
-        }
+        game_object entity(uint64_t p_id);
 
         /**
          * @brief subscribes an event to the event::bus to get invoked when
@@ -59,6 +60,7 @@ namespace atlas {
          * callback belongs to
          * @param p_callback is the callback that contains an arbitrary task
          * that gets invoked when incoming updates occur from the publisher
+         *
          */
         template<typename UEventType, typename UObject, typename UCallback>
         void subscribe(UObject* p_instance, const UCallback& p_callback) {
@@ -96,11 +98,38 @@ namespace atlas {
                                                   std::forward(args)...);
         }
 
+        /**
+         * @return the number of children entities
+         *
+         * Example Usage:
+         *
+         *
+         * ```C++
+         *
+         * atlas::scene scene("New Scene");
+         *
+         * // creating obj1 (parent) and obj2 (child)
+         * atlas::game_object obj1 = scene.create("Parent");
+         *
+         * atlas::game_object obj2 = scene.create("Chlid");
+         *
+         * // obj2 is the child of obj1
+         * // As obj1 is a parent node
+         *
+         * obj2.child_of(obj1);
+         *
+         * // Returns 1
+         * uint32_t obj1_children = scene.children_count(obj1);
+         *
+         * ```
+         */
+        uint32_t children_count(const game_object& p_parent);
+
         /**
          * @brief Defer operations until end of frame.
-         * When this operation is invoked while iterating, operations inbetween
-         * the defer_begin() and defer_end() operations are executed at the end
-         * of the frame.
+         * When this operation is invoked while iterating, operations
+         * inbetween the defer_begin() and defer_end() operations are executed
+         * at the end of the frame.
          *
          * This operation is thread safe.
          *
@@ -120,22 +149,20 @@ namespace atlas {
          */
         bool defer_end() { return m_registry.defer_end(); }
 
-        //! @return the name of atlas::scene_object
+        //! @return the name of the scene
         [[nodiscard]] std::string name() const { return m_name; }
 
-        //! @return the event::bus handle to do the subscription operation of
-        //! events
+        //! @return the event::bus handle for subscribing events
         [[nodiscard]] event::event_bus* event_handle() const { return m_bus; }
 
         /**
          * @brief Requires to return flecs::world is returned by reference to
          * prevent making copies of flecs::world
          */
-        operator world&() { return m_registry; }
+        operator flecs::world&() { return m_registry; }
 
     private:
-        std::pmr::polymorphic_allocator<> m_allocator;
-        world m_registry;
+        flecs::world m_registry;
         std::string m_name;
         event::event_bus* m_bus = nullptr;
     };