Component.hpp

#pragma once
 
#include <memory>
 
#include "ComponentType.hpp"
 
// forward declaration to set up circular reference.
// should NOT include the file otherwise we end up with include "infinite loop"
struct GameObject;
 
// Components must know about the GameObject associated with
// Components must have a type
 
struct Component {
  Component() {}
 
  virtual ~Component() {}
 
  virtual void Input() {}
 
  virtual void Update(float deltaTime) {}
 
  virtual void Render() {}
 
  // Must be implemented - how to do 'abstract' in C++
  static ComponentType GetType() { return ComponentType::DEFAULT; }
 
  inline void SetGameObject(std::weak_ptr<GameObject> ent) {
    mGameObject = ent;
  }
 
  inline std::shared_ptr<GameObject> GetGameObject() {
    return mGameObject.lock();
  }
 
  template <typename T> std::shared_ptr<T> GetComponent();
 
  // to think about:
  // sending/receiving messages? (does godot do something like this?)
 
protected:
  // Each component must be associated with a single game entity.
  // non-owning, so should be a weak ptr. could possibly be a raw pointer, unless
  // components end up being reused across entity boundaries.
  std::weak_ptr<GameObject> mGameObject;
};
 
#include "GameObject.hpp"
template <typename T> std::shared_ptr<T> Component::GetComponent() {
  return mGameObject.lock()->GetComponent<T>();
}