spatial.h

#pragma once
#include <iostream>
#include<vector>
#include <meteorutils/typehelpers.h>
#include<meteorutils/vector2d.h>
#include<entities/entity.h>
#include <SDL.h>
 
namespace meteor {
    class MSpatialEntity : public MEntity {
    public:
        inline MSpatialEntity() : MSpatialEntity(NULL) {};
        MSpatialEntity(MSpatialEntity* parent);
        ~MSpatialEntity();
 
        inline SVector2 getPosition() { return position; }
        inline SVector2 getLocalPosition() { return localPosition; }
        inline void setLocalPosition(float x, float y) { localPosition.x = x; localPosition.y = y; updatePositions(); }
        inline void setLocalPosition(SVector2 pos) { localPosition.x = pos.x; localPosition.y = pos.y; updatePositions(); }
 
        inline float getRotation() { return rotation; }
        inline float getLocalRotation() { return localRotation; }
        inline void setLocalRotation(float localRotation) { this->localRotation = localRotation; }
        SVector2 getLocalScale() { return localScale; };
        inline void setLocalScale(float x, float y) { localScale.x = x; localScale.y = y; }
        inline void setLocalScale(SVector2 scale) { localScale.x = scale.x; localScale.y = scale.y; }
 
        inline MSpatialEntity* getParent() { return parent; }
        inline std::vector<MSpatialEntity*>* getChildren() { return children; }
 
        void addChild(MSpatialEntity* entity);
        void removeChild(MSpatialEntity* entity);
 
        template<typename T>
        T* find(std::string name) {
 
            // is this node called 'name'
            if (this->name == name)
                return (T*)this;
 
            // if no more children return NULL
            if (children->size() <= 0)
                return NULL;
 
            // check recursively for each child
            for (auto child : *children) {
                if (child == NULL)
                    continue;
 
                auto res = child->find<T>(name);
                if (res == NULL)
                    continue;
 
                auto isValidInstance = instanceof<T>((T*)res);
                //if we found it, return
                if (res != NULL && isValidInstance)
                    return (T*)res;
            }
 
            // if everything fails, return NULL
            return NULL;
        }
 
        virtual void onStart();
        virtual void onUpdate(float deltaTime);
        virtual void onExit();
 
    protected:
        SVector2 localPosition;
        SVector2 localScale;
        SVector2 position;
        float rotation;
        float localRotation;
        MSpatialEntity* parent = NULL;
        std::vector<MSpatialEntity*>* children = NULL;
 
        void updatePositions();
        void updateRotations();
        void updateScale();
 
        void updateChildren(float deltaTime);
    private:
        void setParent(MSpatialEntity* entity) { parent = entity; };
    };
}