Scene.hpp

#pragma once 
#ifndef KJY_ANIM_ENGINE_SCENE_HPP_
#define KJY_ANIM_ENGINE_SCENE_HPP_
#include <vector>
#include <iostream>
#include "util/Timeline.hpp"
#include "components/inheritable/drawable.hpp"
#include "components/inheritable/poseable.hpp"
#include "components/inheritable/camera.hpp"
#include "Entities/TypicalEntities.inl"

class Scene {
 public:

    void pauseAll() {mGlobalTime.pause(); mAnimationTime.pause(); mEffectTime.pause(); }
    void unpauseAll() {mGlobalTime.unpause(); mAnimationTime.unpause(); mEffectTime.unpause(); }
    void togglePauseAll() {mGlobalTime.togglePause(); mAnimationTime.togglePause(); mEffectTime.togglePause(); }

    void addEntity(Entity* entity);


    template<typename DynamicType = Entity*>
    DynamicType findEntityByUUID(ent_uuid_t aId);
    
    template<typename DynamicType = Entity*>
    const DynamicType findConstEntityByUUID(ent_uuid_t aId) const;

    template<typename DynamicType = Entity*>
    DynamicType findEntityByName(const std::string& aName);
    
    template<typename DynamicType = Entity*>
    const DynamicType findConstEntityByName(const std::string& aName) const;

    bool mShouldExit = false;

    std::vector<BaseCameraEntity*> cameras;
    size_t mActiveCameraIndex = 0;

    AnimatorCollection animators;

    std::unordered_map<ent_uuid_t, Entity*> entities;

    Timeline mGlobalTime = Timeline(true);
    Timeline mAnimationTime = Timeline(true);
    Timeline mEffectTime = Timeline(true);

    double mFrameTime = 0.0;

    double mStartTime = 0.0;
    double mEndTime = -1.0;

    std::string mSceneSpecialization;

    std::unordered_map<ent_uuid_t, Entity*> _all_entities;

 protected:
    void _traverse_entity_for_bookeeping(Entity* entity);
};

template<typename DynamicType>
DynamicType Scene::findEntityByUUID(ent_uuid_t aId){
    static_assert(std::is_pointer<DynamicType>::value, "Error: Type parameter given to findEntityByUUID must be a pointer to a type derived from Entity*");

    auto foundEnt = _all_entities.find(aId);
    if(foundEnt != _all_entities.end()){
        return(dynamic_cast<DynamicType>(foundEnt->second));
    }
    return(nullptr);
}

template<typename DynamicType>
const DynamicType Scene::findConstEntityByUUID(ent_uuid_t aId) const{
    static_assert(std::is_pointer<DynamicType>::value, "Error: Type parameter given to findEntityByUUID must be a pointer to a type derived from Entity*");

    auto foundEnt = _all_entities.find(aId);
    if(foundEnt != _all_entities.end()){
        return(dynamic_cast<const DynamicType>(foundEnt->second));
    }
    return(nullptr);
}

template<typename DynamicType>
DynamicType Scene::findEntityByName(const std::string& aName){
    static_assert(std::is_pointer<DynamicType>::value, "Error: Type parameter given to findEntityByName must be a pointer to a type derived from Entity*");
    for(auto& [uuid, entity] : _all_entities){
        if(entity->getName() == aName){
            return(dynamic_cast<DynamicType>(entity));
        }
    }
    return(nullptr);
}

template<typename DynamicType>
const DynamicType Scene::findConstEntityByName(const std::string& aName) const{
    static_assert(std::is_pointer<DynamicType>::value, "Error: Type parameter given to findEntityByName must be a pointer to a type derived from Entity*");
    for(auto& [uuid, entity] : _all_entities){
        if(entity->getName() == aName){
            return(dynamic_cast<const DynamicType>(entity));
        }
    }
    return(nullptr);
}

#endif