engine.hpp

/*
    Entity Component System: Base Engine.
    Copyright (C) 2015 Denis BOURGE

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
    USA
*/

#ifndef HX3D_ECS_ENGINE
#define HX3D_ECS_ENGINE

#include "hx3d/ecs/system.hpp"
#include "hx3d/ecs/entity.hpp"
#include "hx3d/ecs/component.hpp"

#include "hx3d/utils/log.hpp"
#include "hx3d/utils/ptr.hpp"

#include <map>
#include <typeindex>
#include <functional>

namespace hx3d {
namespace ecs {

class Engine {

public:
  Engine();

  // ENTITY ///////////////////////

  Ptr<Entity> createEntity();

  void registerEntity(const Ptr<Entity>& entity);

  void removeEntity(const Ptr<Entity>& entity);

  // COMPONENTS /////////////////////

  template <class T>
  Ptr<T> getComponent(const Ptr<Entity>& entity);

  template <class T>
  void addComponent(const Ptr<Entity>& entity, const Ptr<Component>& component);

  template <class T, class... Args>
  void createComponent(const Ptr<Entity>& entity, Args... args);

  // SYSTEM /////////////////////////

  template <class T>
  void addSystem(const Ptr<System>& sys);

  template <class T, class... Args>
  void createSystem(Args... args);

  // UTILS //////////////////////////

  unsigned int getComponentSize(const Ptr<Entity>& entity);

  unsigned int getEntityCount();

  unsigned int getBits(const Ptr<Entity>& entity);

  template <class T>
  void registerComponentAdded(std::function<void(const Ptr<Component>&, const Ptr<Entity>&)> callback);

  template <class T>
  void registerComponentRemoved(std::function<void(const Ptr<Component>&, const Ptr<Entity>&)> callback);

  void update(const float delta);

  void clear();

private:
  std::map<unsigned int, Ptr<Entity>> _entities;
  std::map<unsigned int, std::map<std::type_index, Ptr<Component>>> _components;
  std::map<unsigned int, Bitset> _bits;

  std::map<std::type_index, Ptr<System>> _systems;
  std::map<std::type_index, std::function<void(Ptr<Component>, Ptr<Entity>)>> _onComponentAdded;
  std::map<std::type_index, std::function<void(Ptr<Component>, Ptr<Entity>)>> _onComponentRemoved;

  std::vector<unsigned int> _toRemove;

  void cleanEntities();

  unsigned int lastEntityAvailable();

  template <class T>
  void addInternalComponent(const unsigned int entityId, const Ptr<Component>& component);

  void removeComponents(const unsigned int entityId);
};

} /* ecs */
} /* hx3d */

#include "hx3d/ecs/_inline/engine.inl.hpp"

#endif