Resources.hpp

#pragma once
 
#include "PixelBullet/Serialization/Node.hpp"
#include "PixelBullet/Threading/ThreadPool.hpp"
 
#include <chrono>
#include <map>
#include <memory>
#include <typeindex>
#include <unordered_map>
 
namespace PixelBullet
{
 
    class Resource;
 
    class Resources
    {
    public:
        Resources();
        ~Resources() = default;
 
        void Update();
 
        std::shared_ptr<Resource> Find(const std::type_index& typeIndex, const Node& node) const;
 
        template <typename T>
        std::shared_ptr<T> Find(const Node& node) const
        {
            auto it = m_Resources.find(typeid(T));
            if (it == m_Resources.end())
            {
                return nullptr;
            }
 
            for (const auto& [key, resource] : it->second)
            {
                if (key == node)
                {
                    return std::dynamic_pointer_cast<T>(resource);
                }
            }
            return nullptr;
        }
 
        void Add(const Node& node, const std::shared_ptr<Resource>& resource);
 
        void Remove(const std::shared_ptr<Resource>& resource);
 
        ThreadPool& GetThreadPool();
 
    private:
        // Resources are stored by type and then by a key (Node).
        std::unordered_map<std::type_index, std::map<Node, std::shared_ptr<Resource>>> m_Resources;
 
        // Time point for the last purge.
        std::chrono::steady_clock::time_point m_LastPurgeTime;
 
        // Purge interval (we purge every 5 seconds).
        std::chrono::seconds m_PurgeInterval = std::chrono::seconds(5);
 
        // Thread pool for resource loading.
        ThreadPool m_ThreadPool;
    };
} // namespace PixelBullet