mirror of
https://github.com/zoriya/Bomberman.git
synced 2025-12-20 13:25:10 +00:00
100 lines
3.1 KiB
C++
100 lines
3.1 KiB
C++
/*
|
|
** EPITECH PROJECT, 2021
|
|
** Bomberman
|
|
** File description:
|
|
** Cache
|
|
*/
|
|
|
|
#pragma once
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
#include <functional>
|
|
#include <raylib.h>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <string>
|
|
|
|
namespace RAY {
|
|
//! @brief A templated class used to cache ressources, indexed with a string
|
|
template<typename T>
|
|
class Cache {
|
|
public:
|
|
//! @brief
|
|
Cache(std::function<T(const char *)> dataLoader, std::function<void(T)> dataUnloader):
|
|
_dataLoader(dataLoader), _dataUnloader(dataUnloader)
|
|
{};
|
|
|
|
//! @brief Default destructor, will destroy ray's data
|
|
~Cache() = default;
|
|
|
|
//! @brief default copy constructor
|
|
Cache(const Cache &) = default;
|
|
|
|
//! @brief a cache is assignable
|
|
Cache &operator=(const Cache &) = default;
|
|
|
|
//! @param path path of the file
|
|
//! @param lonely: should be set to true if the loaded data must be held by no other active entites
|
|
//! @return a newly loaded ressource if it hasn't be previously loaded, or one from cache
|
|
std::shared_ptr<T>fetch(const std::string &path, bool lonely = false)
|
|
{
|
|
if (!this->_cache.contains(path))
|
|
this->_cache.emplace(path, std::vector<std::shared_ptr<T>>());
|
|
std::vector<std::shared_ptr<T>> &matchingDataVector = this->_cache.at(path);
|
|
|
|
for (std::shared_ptr<T> &i: matchingDataVector) {
|
|
if (!lonely)
|
|
return i;
|
|
if (lonely && i.use_count() == 1)
|
|
return i;
|
|
}
|
|
matchingDataVector.emplace_back(std::shared_ptr<T>(
|
|
new T(this->_dataLoader(path.c_str())), [this](T *p) {
|
|
this->_dataUnloader(*p);
|
|
delete p;
|
|
}));
|
|
return matchingDataVector.back();
|
|
};
|
|
private:
|
|
//! @brief function to call to load data
|
|
std::function<T(const char *)> _dataLoader;
|
|
|
|
//! @brief function to call when the ray data will be unloaded
|
|
std::function<void(T)> _dataUnloader;
|
|
|
|
//! @brief map storing shared ptr of caches
|
|
std::unordered_map<std::string, std::vector<std::shared_ptr<T>>> _cache;
|
|
};
|
|
|
|
template<>
|
|
class Cache<::ModelAnimation> {
|
|
public:
|
|
Cache(std::function<::ModelAnimation *(const char *, int *)> dataLoader, std::function<void(::ModelAnimation *, unsigned int)>dataUnloader):
|
|
_dataLoader(dataLoader), _dataUnloader(dataUnloader)
|
|
{};
|
|
std::shared_ptr<::ModelAnimation> fetch(const std::string &path, int *counter)
|
|
{
|
|
if (this->_cache.find(path) != this->_cache.end())
|
|
return this->_cache[path];
|
|
|
|
::ModelAnimation *animations = this->_dataLoader(path.c_str(), counter);
|
|
unsigned int animCount = *counter;
|
|
|
|
this->_cache.emplace(path, std::shared_ptr<::ModelAnimation>(
|
|
animations, [this, animCount](::ModelAnimation *p) {
|
|
this->_dataUnloader(p, animCount);
|
|
}));
|
|
return this->_cache[path];
|
|
};
|
|
private:
|
|
//! @brief function to call to load data
|
|
std::function<::ModelAnimation *(const char *, int *)> _dataLoader;
|
|
|
|
//! @brief function to call when the ray data will be unloaded
|
|
std::function<void(::ModelAnimation *, unsigned int)> _dataUnloader;
|
|
|
|
//! @brief map storing shared ptr of caches
|
|
std::unordered_map<std::string, std::shared_ptr<::ModelAnimation>> _cache;
|
|
};
|
|
}
|