component.h

#pragma once
 
#include <iostream>
#include "ec.h"
#include <functional>
#include <array>
#include <utils/logger.h>
#include <core/serialize/Serializable.h>
#include <core/serialize/Inspectable.h>
 
class Transform;
class Scene;
namespace ec
{
    class RenderComponent;
    class UpdateComponent;

    class Component : public cme::Serializable, public cme::Inspectable
    {
        using Iterator = std::vector<Component*>::iterator;
    public:

        Component() {
#ifdef _DEBUG
            LOG_INFO("Creating base component");
#endif // _DEBUG
        };

        virtual ~Component() { };
 
        protected:
            std::weak_ptr<ec::Entity> _entity;
            Iterator _iterator;
 
    public:

        inline void setContext(std::weak_ptr<ec::Entity> ent)
        {
            _entity = ent;
        }
 
        inline virtual void initComponent() {}
 
        inline virtual void start() {}
        virtual ec::cmpID_t getID() const = 0;
        virtual std::string serializeID() const = 0;
 
        virtual void drawOnInspector() override {}
 
        virtual void serialize(cme::JsonSerializer& s) const override {}
        virtual void deserialize(cme::JsonSerializer& s) override {}
 
        virtual RenderComponent* getAsRender() { return nullptr; }
        virtual UpdateComponent* getAsUpdate() { return nullptr; }
    };
 

    class RenderComponent {
        using RenderIterator = std::vector<RenderComponent*>::iterator;
    protected:
        RenderIterator _renderIterator;
    public:
        virtual ~RenderComponent() {}
        virtual void render() const = 0;
    };

    class UpdateComponent {
        using UpdateIterator = std::vector<UpdateComponent*>::iterator;
    protected:
        UpdateIterator _updateIterator;
    public:
        virtual void update() =  0;
 
        inline UpdateIterator& getUpdateIterator() { return _updateIterator; } // deberia haber aqui un assert
        void setUpdateIterator(UpdateIterator it) { _updateIterator = it; }
    };
}