GameObject.h

Go to the documentation of this file.

 
#pragma once
#include "Globals.h"
#include "Serialization.h"
 
#include <map>
 
#define ADD_COMPONENT(str, type) if (type == #str ) return this->AddComponent<str>();
 
typedef int (*DrawCallback)(void* data);
 
class GameComponent: public Serialized {
public:
    static std::string GetType() { return "GameComponent"; }
 
    virtual void Update() {};
 
    virtual void Start() {};
 
    virtual void SetGameObject(void* go) {};
 
    virtual void* GetGameObject() { return nullptr; };
 
    virtual ~GameComponent() {};
};
 
class GameObject : public Serialized {
private:
    static int numberOfGameObjects;
 
public:
    std::map<std::string, GameComponent*> components; 
    std::string name = "new GameObject"; 
    uint32 id = 0; 
    DrawCallback _drawProc = nullptr; 
    GameObject();
 
    GameObject(const GameObject& other);
 
    ~GameObject();
 
    int Draw();
 
    void SetDrawCallback(DrawCallback callback);
 
    void DeleteComponent(std::string typeName);
 
    void DeleteComponents();
 
    int Serialize(std::fstream* data, int offset);
 
    int Deserialize(std::fstream* data, int offset);
 
    template<typename T>
    T* GetComponent() {
        T* component = nullptr;
        if (this->components.find(T::GetType()) == this->components.end()) return component;
 
        component = (T*)this->components[T::GetType()];
        return component;
    };
 
    template<typename T>
    T* AddComponent() {
        std::map<std::string, GameComponent*>::iterator temp = components.find(T::GetType());
        if (temp != components.end()) return (T*)(*&temp)->second;
        T* ptr = new T(this);
        components.insert(std::pair<std::string, GameComponent*>( T::GetType(), ptr ));
        return ptr;
    };
 
    GameComponent* AddComponent(std::string type);
    GameComponent* GetComponent(std::string type);
 
    template<typename T>
    void DeleteComponent() {
        if (components.find(T::GetType()) == components.end()) return;
        delete components[T::GetType()];
        components.erase(T::GetType());
    }
};