Entity.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <vector>
#include <typeindex>
#include <json/json.h>
#include <glm/gtc/quaternion.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/quaternion.hpp>
#include "../Component/SuperComponent.hpp"
#include <fstream>
 
class World;
 
class Entity {
  public:
 
    Entity(World* world, const std::string& name);
 
    ~Entity();
 
 
    Entity* GetParent() const;
 
 
    Entity* AddChild(const std::string& name = "");
 
 
    bool RemoveChild(Entity* child);
 
 
    Entity* SetParent(Entity* newParent);
 
 
    bool HasChild(const Entity* child, bool deep = true) const;
 
 
    Entity* InstantiateScene(const std::string& name);
 
 
    Entity* InstantiateScene(const std::string& name, const std::string& originScene);
 
 
    void CheckIfSceneExists(const std::string& filename, bool& error, const std::string& originScene, Json::Value root);
 
 
    const std::vector<Entity*>& GetChildren() const;
 
 
    Entity* GetChild(const std::string& name) const;
 
 
    Entity* GetChildFromIndex(int index) const;
 
 
    unsigned int GetNumChildren() const;
 
 
    bool IsScene() const;
 
 
    template <typename T> T* AddComponent();
 
 
    template <typename T> T* GetComponent() const;
 
    template <typename T> void KillComponent();
 
    void Kill();
 
 
    bool IsKilled() const;
 
 
    void Serialize(Json::Value& node, bool load);
 
 
    const glm::vec3& GetPosition() const;
 
 
    void SetPosition(const glm::vec3& position);
 
 
    glm::vec3 GetWorldPosition() const;
 
 
    void SetWorldPosition(const glm::vec3& worldPos);
 
 
    void Move(const glm::vec3& translation);
 
 
    const glm::vec3& GetScale() const;
 
 
    void SetScale(const glm::vec3& scale);
 
 
    const glm::quat& GetRotation() const;
 
 
    void SetRotation(const glm::quat& localRot);
 
 
    glm::quat GetWorldRotation() const;
 
 
    void SetWorldRotation(const glm::quat& worldRot);
 
 
    glm::vec3 GetWorldDirection() const;
 
 
    void RotateYaw(float angle);
 
 
    void RotatePitch(float angle);
 
 
    void RotateRoll(float angle);
 
 
    void RotateAroundWorldAxis(float angle, const glm::vec3& axis);
 
 
    const glm::mat4& GetLocalMatrix() const;
 
 
    const glm::mat4& GetWorldModelMatrix() const;
 
 
    void SetEnabled(bool enabled, bool recursive = false);
 
 
    bool IsEnabled() const;
 
    std::string name;
 
 
    unsigned int GetUniqueIdentifier() const;
 
 
    void SetUniqueIdentifier(unsigned int UID);
 
    bool loadPaintModeClicked = false;
    bool brushActive = false;
    bool vertsLoaded = false;
    bool painting = false;
    bool sceneChosen = false;
 
  private:
    enum DirtyFlag {
        LOCAL_MATRIX = 1,
        WORLD_MATRIX = 2
    };
 
    template <typename T> void Serialize(Json::Value& node, bool load, const std::string& name);
    Component::SuperComponent* AddComponent(std::type_index componentType);
    Component::SuperComponent* GetComponent(std::type_index componentType) const;
    void KillComponent(std::type_index componentType);
    void KillHelper();
    void SetDirty(uint32_t dirtyMask = DirtyFlag::LOCAL_MATRIX | DirtyFlag::WORLD_MATRIX);
 
    World* world;
    Entity* parent = nullptr;
    std::vector<Entity*> children;
    bool scene = false;
    std::string sceneName;
 
    std::map<std::type_index, Component::SuperComponent*> components;
 
    glm::vec3 position = glm::vec3(0.0f, 0.0f, 0.0f);
    glm::vec3 scale = glm::vec3(1.0f, 1.0f, 1.0f);
    glm::quat rotation = glm::angleAxis(0.0f, glm::vec3(0.0f, 1.0f, 0.0f));
 
    bool killed = false;
    bool enabled = true;
    unsigned int uniqueIdentifier = 0;
 
    // Cache matrices.
    mutable glm::mat4 localMatrix;
    mutable glm::mat4 worldMatrix;
    mutable uint32_t dirtyMask = DirtyFlag::LOCAL_MATRIX | DirtyFlag::WORLD_MATRIX;
};
 
template <typename T> T* Entity::AddComponent() {
    std::type_index componentType = std::type_index(typeid(T*));
    return static_cast<T*>(AddComponent(componentType));
}
 
template <typename T> T* Entity::GetComponent() const {
    return static_cast<T*>(GetComponent(std::type_index(typeid(T*))));
}
 
template <typename T> void Entity::KillComponent() {
    KillComponent(typeid(T*));
}
 
template <typename T> void Entity::Serialize(Json::Value& node, bool load, const std::string& name) {
    std::type_index componentType = std::type_index(typeid(T*));
    Component::SuperComponent* component = nullptr;
    if (load) {
        if (!node[name].isNull()) {
            component = AddComponent(componentType);
        }
    } else {
        component = GetComponent(componentType);
    }
 
    if (component != nullptr) {
        component->Serialize(node[name], load);
    }
}