Component.hpp

#pragma once
#include "utilities/ID.hpp"
#include "utilities/Matrix4.hpp"
#include "utilities/Stream.hpp"
 
#include <sys/types.h>
#include <functional>
#include <unordered_map>
 
namespace StevEngine {
    class GameObject;
    class Scene;

    class Component {
        friend class StevEngine::GameObject;
        //Properties
        private:
            Utilities::ID gameObject = Utilities::ID::empty;

            std::string scene;

            static const bool unique = false;
 
        //Functions
        public:
            Component();

            virtual ~Component();

            GameObject& GetParent() const;

            Scene& GetScene() const;

            virtual std::string GetType() const = 0;

            virtual Utilities::Stream Export(Utilities::StreamType stream) const = 0;

            virtual void Start() {};
 
        private:
            virtual void Deactivate() {};

            virtual void Update(double deltaTime) {};
 
            #ifdef StevEngine_SHOW_WINDOW
            virtual void Draw(const Utilities::Matrix4& transform) {};
            #endif

            void SetObject(GameObject& object, std::string scene);
 
        //Events
        protected:
            std::vector<std::pair<Utilities::ID, std::string>> handlers;
    };

    class CreateComponents {
        static inline std::unordered_map<std::string, std::function<Component*(Utilities::Stream& stream)>> factories = std::unordered_map<std::string, std::function<Component*(Utilities::Stream& stream)>>();
 
        public:
            static Component* Create(const std::string& type, Utilities::Stream& stream);

            template <class T> static bool RegisterComponentType(std::string type) {
                if(factories.contains(type)) return false;
                factories.insert({type, [](Utilities::Stream& stream) -> Component*  {
                    return (Component*) (new T(stream));
                }});
                return true;
            }
    };
}