Node.h

Go to the documentation of this file.

//   ____   __                  __  __
// /\__  _\/\ \                /\ \/\ \
// \/_/\ \/\ \ \___      __    \ \ \_\ \    ___   __  __    ____     __
//    \ \ \ \ \  _ `\  /'__`\   \ \  _  \  / __`\/\ \/\ \  /',__\  /'__`\
//     \ \ \ \ \ \ \ \/\  __/    \ \ \ \ \/\ \L\ \ \ \_\ \/\__, `\/\  __/
//      \ \_\ \ \_\ \_\ \____\    \ \_\ \_\ \____/\ \____/\/\____/\ \____\
//       \/_/  \/_/\/_/\/____/     \/_/\/_/\/___/  \/___/  \/___/  \/____/
 
#pragma once
 
#include "GameObject.h"
#include "ChildrenHandeler.h"
#include <cassert>
 
#include "System/Camera.h"
#include "System/Logging.h"
 
 
class Entity;

class Node final : public GameObject
{
public:
#pragma region Ctors dtors and assignments

    explicit Node(std::unique_ptr<GameObject> gamobj);
    ~Node() override = default;
 
    // private: /// @todo:: make copy ctors private in node 
    Node(const Node& other);
    auto operator=(const Node& other) -> Node&;
    Node(Node&& other) noexcept                    = delete;
    auto operator=(Node&& other) noexcept -> Node& = delete;
 
#pragma endregion
 
#pragma region overloaded functions
 
    auto clone() const -> std::unique_ptr<GameObject> override;
    auto showMenu() -> void override; // for debug ImGUI
    void dragTarget();
    auto update(float dt) -> void override;
    auto onUpdate(float dt) -> void override;
 
    auto endWindow() -> void override
    {
    }; // for debug ImGUI
    auto render() -> void override;
    auto onRender() -> void override;
    auto onEnterEngine() -> void override;
    auto for_each(std::function<void(GameObject&)> func) -> void override;
    auto for_each(std::function<void(const GameObject&)> func) const -> void override;
    auto load(Stream& stream) -> void override;
    auto save(Stream& stream) const -> void override;
    auto getParent() const -> Node* override;

    auto dragAndDrop() -> void;

    auto isDescendantOf(const Node* potentialParent) const -> bool;

    auto moveParent() -> void;

    [[nodiscard]] auto addChild(std::unique_ptr<GameObject> newChild) -> bool override;
 

    auto setShouldUpdate(const bool _shouldUpdate) -> void override;
 

    auto setShouldRender(const bool _shouldRender) -> void override;
 

    auto setShouldReceiveMessages(const bool _shouldReceiveMessages) -> void override;
 
#pragma endregion
 
#pragma region node_functions

    template <typename type>
    auto GetData(gobj::Type typeId) const -> type*
    {
        assert(data->isType(typeId));
        return static_cast<type*>(&(*data));
    }

    template <typename type>
    [[nodiscard]] auto ExtractData(gobj::Type typeId) -> std::unique_ptr<type>
    {
        assert(data->isType(typeId));
        return std::unique_ptr<type>(dynamic_cast<type*>(data.release()));
    }

    auto getDataAsGameObj() const -> GameObject*;
 

    auto add(std::unique_ptr<Node> child) -> bool;

    auto dataType() const -> gobj::Type;
 
public:
    auto find(const std::function<bool(GameObject&)>& predicate) -> GameObject*;
 

    auto findDirect(const std::function<bool(GameObject&)>& predicate) -> GameObject*;

    auto deRegisterRecursively() const -> void;

    auto pop() -> std::unique_ptr<Node>;
 
 
#pragma endregion
 
    friend auto to_json(json& j, const Node& n) -> void;
    friend auto from_json(const json& j, Node& n) -> void;
 
#pragma region GetItrFunctions
    template <typename T>
    auto dataItr() -> GameObject*
    {
 
    }
 
 
    // Later I think I need to make an iterator to find nodes
    // and whatnot, but right now it isn't used, so it is disabled with a flag
#pragma endregion
 
#pragma region NodeIterator
#define NodeIteratorImplemented 0
#if NodeIteratorImplemented
    class Itr
    {
        Node* 
        Node* node;
 
    public:
        static_assert(std::bidirectional_iterator<Itr>);
        // typedef std::iterator_traits<> std::output_iterator_tag;
        // typedef std:: GameObject;
        // typedef std::difference_type unsigned int;
        // typedef std::pointer GameObject*;
        // typedef std::reference GameObject;
        Itr(Node* node)
        {
 
        }
 
        Itr& operator++()
        {
 
        }
 
    };
#endif
 
#pragma endregion
 
protected:
    auto getChildren() const -> std::shared_ptr<std::vector<GameObject*>> override;
    auto GetChildren() const;
 
private:
    std::unique_ptr<GameObject> data;
    ChildrenHandeler<Node> children;
};