graph/include/ecs.h

#pragma once

#include <cstdint>
#include <map>
#include <vector>
#include <array>
#include <string>
#include <glm/glm.hpp>
#include <type_traits>

struct InfoComponent {
    std::string name, tag;
};

struct TransformComponent {
    glm::vec3 position = glm::vec3(0);
};

struct MeshAsset;
struct MaterialAsset;

struct MeshComponent {
    MeshAsset* mesh = nullptr;
    MaterialAsset* material = nullptr;
};

enum class LightType {
    Point,
    Directional
};

struct LightComponent {
    LightType type = LightType::Point;
    glm::vec3 color = glm::vec3(1);

    glm::mat4 matrix = glm::mat4(1.0f);
};

struct CameraComponent {
    float fov = 75.0f, near = 0.1f, far = 100.0f;
    float focusDistance = 0.0f;
    float aperture = 0.0f;
    glm::vec3 target = glm::vec3(0);
};

struct ListenerComponent {

};

struct AudioAsset;

struct SpeakerComponent {
    AudioAsset* audio = nullptr;
    unsigned int source = 0;
    bool playing = false;
};

using EntityID = uint64_t;

struct World;

namespace ECS {
    // components
    inline std::map<EntityID, InfoComponent*> infos;
    inline std::map<EntityID, TransformComponent*> transforms;
    inline std::map<EntityID, MeshComponent*> meshes;
    inline std::map<EntityID, LightComponent*> lights;
    inline std::map<EntityID, CameraComponent*> cameras;
    inline std::map<EntityID, ListenerComponent*> listeners;
    inline std::map<EntityID, SpeakerComponent*> speakers;

    inline std::map<EntityID, ::World*> worlds;
    inline EntityID lastID = 1;

    static inline void destructResources() {
        for(const auto& [id, info] : infos)
            delete info;

        for(const auto& [id, transform] : transforms)
            delete transform;

        for(const auto& [id, mesh] : meshes)
            delete mesh;

        for(const auto& [id, light] : lights)
            delete light;

        for(const auto& [id, camera] : cameras)
            delete camera;

        for(const auto& [id, listener] : listeners)
            delete listener;

        for(const auto& [id, speaker] : speakers)
            delete speaker;
    }

    static inline EntityID createEntity(World* world) {
        EntityID newID = lastID++;
        worlds[newID] = world;

        return newID;
    }

    static inline void destroyEntity(const EntityID id) {

    }

    template<class T>
    static inline T* addComponent(const EntityID id) {
        T* t = new T();
        if constexpr(std::is_same<T, InfoComponent>::value) {
            infos[id] = t;
        } else if constexpr(std::is_same<T, TransformComponent>::value) {
            transforms[id] = t;
        } else if constexpr(std::is_same<T, MeshComponent>::value) {
            meshes[id] = t;
        } else if constexpr(std::is_same<T, LightComponent>::value) {
            lights[id] = t;
        } else if constexpr(std::is_same<T, CameraComponent>::value) {
            cameras[id] = t;
        } else if constexpr(std::is_same<T, ListenerComponent>::value) {
            listeners[id] = t;
        } else if constexpr(std::is_same<T, SpeakerComponent>::value) {
            speakers[id] = t;
        }

        return t;
    }

    template<class T>
    static inline T* getComponent(const EntityID id) {
        if constexpr(std::is_same<T, InfoComponent>::value) {
            return infos[id];
        } else if constexpr(std::is_same<T, TransformComponent>::value) {
            return transforms[id];
        } else if constexpr(std::is_same<T, MeshComponent>::value) {
            return meshes[id];
        } else if constexpr(std::is_same<T, LightComponent>::value) {
            return lights[id];
        } else if constexpr(std::is_same<T, CameraComponent>::value) {
            return cameras[id];
        } else if constexpr(std::is_same<T, ListenerComponent>::value) {
            return listeners[id];
        } else if constexpr(std::is_same<T, SpeakerComponent>::value) {
            return speakers[id];
        }
    }

    template<class T>
    static inline auto getWorldComponents(World* world) {
        std::vector<EntityID> entities;
        for (auto it = worlds.begin(); it != worlds.end(); ++it) {
            if(it->second == world) {
                entities.push_back(it->first);
            }
        }

        std::vector<std::tuple<EntityID, T*>> components;
        for(auto ent : entities) {
            T* t = getComponent<T>(ent);
            if(t != nullptr)
                components.push_back(std::tuple(ent, t));
        }

        return components;
    }

    static inline std::vector<EntityID> getWorldEntities(World* world) {
        std::vector<EntityID> entities;
        for (auto it = worlds.begin(); it != worlds.end(); ++it) {
            if(it->second == world)
                entities.push_back(it->first);
        }

        return entities;
    }

    template<class T>
    static inline void removeComponent(const EntityID id) {
        if constexpr(std::is_same<T, InfoComponent>::value) {
            infos.erase(infos.find(id), infos.end());
        } else if constexpr(std::is_same<T, TransformComponent>::value) {
            transforms.erase(transforms.find(id), transforms.end());
        } else if constexpr(std::is_same<T, MeshComponent>::value) {
            meshes.erase(meshes.find(id), meshes.end());
        } else if constexpr(std::is_same<T, LightComponent>::value) {
            lights.erase(lights.find(id), lights.end());
        } else if constexpr(std::is_same<T, CameraComponent>::value) {
            cameras.erase(cameras.find(id), cameras.end());
        } else if constexpr(std::is_same<T, ListenerComponent>::value) {
            listeners.erase(listeners.find(id), listeners.end());
        } else if constexpr(std::is_same<T, SpeakerComponent>::value) {
            speakers.erase(speakers.find(id), speakers.end());
        }
    }
};