336 lines
9.8 KiB
C++
336 lines
9.8 KiB
C++
#pragma once
|
||
|
||
#include <assets/handle.h>
|
||
#include <types/ptr/intrusive_ptr.h>
|
||
#include <vector>
|
||
#include <cstdint>
|
||
#include <chrono>
|
||
#include <algorithm>
|
||
#include <unordered_map>
|
||
|
||
namespace extra2d {
|
||
|
||
/**
|
||
* @brief 资源加载状态
|
||
*/
|
||
enum class AssetLoadState {
|
||
Unloaded, ///< 未加载
|
||
Loading, ///< 加载中
|
||
Loaded, ///< 已加载
|
||
Failed ///< 加载失败
|
||
};
|
||
|
||
/**
|
||
* @brief 密集存储的资源仓库
|
||
*
|
||
* 使用 Dense Vec 存储，类似 ECS 的组件存储。
|
||
* 提供 O(1) 的插入、删除、访问。
|
||
* 支持引用统计和 LRU（最近最少使用）缓存策略。
|
||
*
|
||
* @tparam T 资源类型
|
||
*/
|
||
template<typename T>
|
||
class AssetStorage {
|
||
public:
|
||
using TimePoint = std::chrono::steady_clock::time_point;
|
||
|
||
struct Slot {
|
||
Ptr<T> asset;
|
||
typename Handle<T>::Generation generation = 0;
|
||
bool active = false;
|
||
AssetLoadState loadState = AssetLoadState::Unloaded;
|
||
TimePoint lastAccessTime; ///< 最后访问时间（用于 LRU）
|
||
};
|
||
|
||
AssetStorage() = default;
|
||
~AssetStorage() = default;
|
||
|
||
AssetStorage(const AssetStorage&) = delete;
|
||
AssetStorage& operator=(const AssetStorage&) = delete;
|
||
|
||
/**
|
||
* @brief 插入资源，返回句柄
|
||
* @param asset 资源指针
|
||
* @return 资源句柄
|
||
*/
|
||
Handle<T> insert(Ptr<T> asset) {
|
||
uint32_t index;
|
||
auto now = std::chrono::steady_clock::now();
|
||
|
||
if (!freeIndices_.empty()) {
|
||
index = freeIndices_.back();
|
||
freeIndices_.pop_back();
|
||
slots_[index].asset = std::move(asset);
|
||
slots_[index].active = true;
|
||
slots_[index].loadState = AssetLoadState::Loaded;
|
||
slots_[index].lastAccessTime = now;
|
||
} else {
|
||
index = static_cast<uint32_t>(slots_.size());
|
||
Slot slot;
|
||
slot.asset = std::move(asset);
|
||
slot.generation = nextGeneration_++;
|
||
slot.active = true;
|
||
slot.loadState = AssetLoadState::Loaded;
|
||
slot.lastAccessTime = now;
|
||
slots_.push_back(std::move(slot));
|
||
}
|
||
|
||
++activeCount_;
|
||
return Handle<T>(index, slots_[index].generation);
|
||
}
|
||
|
||
/**
|
||
* @brief 移除资源
|
||
* @param handle 资源句柄
|
||
*/
|
||
void remove(Handle<T> handle) {
|
||
if (!isValid(handle)) return;
|
||
|
||
uint32_t index = handle.index();
|
||
slots_[index].asset.reset();
|
||
slots_[index].active = false;
|
||
slots_[index].generation = nextGeneration_++;
|
||
freeIndices_.push_back(index);
|
||
--activeCount_;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源（返回指针，可能为 nullptr）
|
||
* @param handle 资源句柄
|
||
* @return 资源指针
|
||
*/
|
||
T* get(Handle<T> handle) {
|
||
if (!isValid(handle)) return nullptr;
|
||
updateAccessTime(handle);
|
||
return slots_[handle.index()].asset.get();
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源（返回指针，可能为 nullptr） - 常量版本，不更新访问时间
|
||
* @param handle 资源句柄
|
||
* @return 资源指针
|
||
*/
|
||
const T* get(Handle<T> handle) const {
|
||
if (!isValid(handle)) return nullptr;
|
||
return slots_[handle.index()].asset.get();
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源（返回智能指针）
|
||
* @param handle 资源句柄
|
||
* @return 资源智能指针
|
||
*/
|
||
Ptr<T> getPtr(Handle<T> handle) {
|
||
if (!isValid(handle)) return Ptr<T>();
|
||
updateAccessTime(handle);
|
||
return slots_[handle.index()].asset;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源（返回智能指针） - 常量版本，不更新访问时间
|
||
* @param handle 资源句柄
|
||
* @return 资源智能指针
|
||
*/
|
||
Ptr<T> getPtr(Handle<T> handle) const {
|
||
if (!isValid(handle)) return Ptr<T>();
|
||
return slots_[handle.index()].asset;
|
||
}
|
||
|
||
/**
|
||
* @brief 检查句柄是否有效
|
||
* @param handle 资源句柄
|
||
* @return 是否有效
|
||
*/
|
||
bool isValid(Handle<T> handle) const {
|
||
if (!handle.isValid()) return false;
|
||
uint32_t index = handle.index();
|
||
if (index >= slots_.size()) return false;
|
||
const Slot& slot = slots_[index];
|
||
return slot.active && slot.generation == handle.generation();
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源加载状态
|
||
* @param handle 资源句柄
|
||
* @return 加载状态
|
||
*/
|
||
AssetLoadState getLoadState(Handle<T> handle) const {
|
||
if (!isValid(handle)) return AssetLoadState::Unloaded;
|
||
return slots_[handle.index()].loadState;
|
||
}
|
||
|
||
/**
|
||
* @brief 设置资源加载状态
|
||
* @param handle 资源句柄
|
||
* @param state 加载状态
|
||
*/
|
||
void setLoadState(Handle<T> handle, AssetLoadState state) {
|
||
if (!isValid(handle)) return;
|
||
slots_[handle.index()].loadState = state;
|
||
}
|
||
|
||
/**
|
||
* @brief 检查资源是否正在加载
|
||
* @param handle 资源句柄
|
||
* @return 是否正在加载
|
||
*/
|
||
bool isLoading(Handle<T> handle) const {
|
||
return getLoadState(handle) == AssetLoadState::Loading;
|
||
}
|
||
|
||
/**
|
||
* @brief 检查资源是否已加载
|
||
* @param handle 资源句柄
|
||
* @return 是否已加载
|
||
*/
|
||
bool isLoaded(Handle<T> handle) const {
|
||
return getLoadState(handle) == AssetLoadState::Loaded;
|
||
}
|
||
|
||
/**
|
||
* @brief 遍历所有资源
|
||
* @param func 回调函数，签名 void(Handle<T>, T*)
|
||
*/
|
||
template<typename Func>
|
||
void forEach(Func&& func) const {
|
||
for (size_t i = 0; i < slots_.size(); ++i) {
|
||
const Slot& slot = slots_[i];
|
||
if (slot.active && slot.asset) {
|
||
func(Handle<T>(static_cast<uint32_t>(i), slot.generation), slot.asset.get());
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @brief 清空所有资源
|
||
*/
|
||
void clear() {
|
||
slots_.clear();
|
||
freeIndices_.clear();
|
||
activeCount_ = 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取活跃资源数量
|
||
*/
|
||
size_t count() const { return activeCount_; }
|
||
|
||
/**
|
||
* @brief 获取存储容量
|
||
*/
|
||
size_t capacity() const { return slots_.size(); }
|
||
|
||
/**
|
||
* @brief 获取资源引用计数
|
||
* @param handle 资源句柄
|
||
* @return 引用计数
|
||
*/
|
||
uint32_t getRefCount(Handle<T> handle) const {
|
||
if (!isValid(handle)) return 0;
|
||
const auto& slot = slots_[handle.index()];
|
||
return slot.asset ? slot.asset.refCount() : 0;
|
||
}
|
||
|
||
/**
|
||
* @brief 获取资源最后访问时间
|
||
* @param handle 资源句柄
|
||
* @return 最后访问时间
|
||
*/
|
||
TimePoint getLastAccessTime(Handle<T> handle) const {
|
||
if (!isValid(handle)) return TimePoint();
|
||
return slots_[handle.index()].lastAccessTime;
|
||
}
|
||
|
||
/**
|
||
* @brief 更新资源访问时间
|
||
* @param handle 资源句柄
|
||
*/
|
||
void updateAccessTime(Handle<T> handle) {
|
||
if (!isValid(handle)) return;
|
||
slots_[handle.index()].lastAccessTime = std::chrono::steady_clock::now();
|
||
}
|
||
|
||
/**
|
||
* @brief 查找可以卸载的资源（引用计数为1的资源，只有AssetStorage自己持有引用）
|
||
* @param maxAgeSeconds 最大空闲时间（秒），默认300秒
|
||
* @return 可以卸载的资源句柄列表
|
||
*/
|
||
std::vector<Handle<T>> findUnloadableResources(int maxAgeSeconds = 300) const {
|
||
std::vector<Handle<T>> result;
|
||
auto now = std::chrono::steady_clock::now();
|
||
|
||
for (size_t i = 0; i < slots_.size(); ++i) {
|
||
const Slot& slot = slots_[i];
|
||
if (slot.active && slot.asset) {
|
||
// 引用计数为1表示只有 AssetStorage 自己持有引用
|
||
if (slot.asset.refCount() == 1) {
|
||
auto age = std::chrono::duration_cast<std::chrono::seconds>(
|
||
now - slot.lastAccessTime).count();
|
||
if (age >= maxAgeSeconds) {
|
||
result.emplace_back(static_cast<uint32_t>(i), slot.generation);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 按访问时间排序，最久未使用的排在前面
|
||
std::sort(result.begin(), result.end(),
|
||
[this](const Handle<T>& a, const Handle<T>& b) {
|
||
return slots_[a.index()].lastAccessTime < slots_[b.index()].lastAccessTime;
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* @brief 卸载指定资源（只有引用计数为1时才会真正卸载）
|
||
* @param handle 资源句柄
|
||
* @return 是否成功卸载
|
||
*/
|
||
bool unloadResource(Handle<T> handle) {
|
||
if (!isValid(handle)) return false;
|
||
|
||
auto& slot = slots_[handle.index()];
|
||
if (!slot.asset) return false;
|
||
|
||
// 只有引用计数为1时才可以卸载（只有AssetStorage自己持有）
|
||
if (slot.asset.refCount() > 1) {
|
||
return false;
|
||
}
|
||
|
||
slot.asset.reset();
|
||
slot.loadState = AssetLoadState::Unloaded;
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @brief 批量卸载可卸载的资源
|
||
* @param maxCount 最大卸载数量，-1表示全部卸载
|
||
* @param maxAgeSeconds 最大空闲时间（秒）
|
||
* @return 实际卸载的资源数量
|
||
*/
|
||
size_t unloadOldResources(int maxCount = -1, int maxAgeSeconds = 300) {
|
||
auto unloadable = findUnloadableResources(maxAgeSeconds);
|
||
size_t unloaded = 0;
|
||
|
||
for (const auto& handle : unloadable) {
|
||
if (maxCount >= 0 && unloaded >= static_cast<size_t>(maxCount)) {
|
||
break;
|
||
}
|
||
if (unloadResource(handle)) {
|
||
++unloaded;
|
||
}
|
||
}
|
||
|
||
return unloaded;
|
||
}
|
||
|
||
private:
|
||
std::vector<Slot> slots_;
|
||
std::vector<uint32_t> freeIndices_;
|
||
uint32_t nextGeneration_ = 1;
|
||
size_t activeCount_ = 0;
|
||
};
|
||
|
||
} // namespace extra2d
|