1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
#include "core/pch.hh"
#include "core/resource/resource.hh"
struct ResourceLoader final {
ResourceLoadFunc load_func;
ResourceFreeFunc free_func;
emhash8::HashMap<std::string, std::shared_ptr<const void>> resources;
std::vector<std::shared_ptr<const void>> cache;
std::string class_name;
};
namespace
{
emhash8::HashMap<std::type_index, std::unique_ptr<ResourceLoader>> loaders;
} // namespace
void resource::detail::register_loader(const std::type_info& type, ResourceLoadFunc load_func, ResourceFreeFunc free_func)
{
assert(load_func);
assert(free_func);
auto type_index = std::type_index(type);
auto loader = std::make_unique<ResourceLoader>();
loader->class_name = type.name();
loader->load_func = load_func;
loader->free_func = free_func;
assert(!loaders.contains(type_index));
loaders.insert_or_assign(type_index, std::move(loader));
}
std::shared_ptr<const void> resource::detail::load_resource(const std::type_info& type, std::string_view name, std::uint32_t flags)
{
auto name_str = std::string(name);
auto type_index = std::type_index(type);
auto loader = loaders.find(type_index);
if(loader == loaders.cend()) {
spdlog::error("resource: no loader registered for type [{}]", type.name());
return nullptr;
}
auto resource_it = loader->second->resources.find(name_str);
if(resource_it == loader->second->resources.cend()) {
auto resource_raw = loader->second->load_func(name_str.c_str(), flags);
if(resource_raw == nullptr) {
spdlog::error("resource: {} [{}]: load failed", loader->second->class_name, name);
return nullptr;
}
std::shared_ptr<const void> resource_ptr(resource_raw, [](const void* ptr) { /* empty */ });
auto loaded_it = loader->second->resources.insert_or_assign(name_str, std::move(resource_ptr));
if(flags & RESOURCE_CACHE) {
loader->second->cache.push_back(loaded_it.first->second);
}
return loaded_it.first->second;
}
return resource_it->second;
}
std::shared_ptr<const void> resource::detail::find_resource(const std::type_info& type, std::string_view name)
{
auto name_str = std::string(name);
auto type_index = std::type_index(type);
auto loader = loaders.find(type_index);
if(loader == loaders.cend()) {
spdlog::error("resource: no loader registered for type [{}]", type.name());
return nullptr;
}
auto resource_it = loader->second->resources.find(name_str);
if(resource_it == loader->second->resources.cend()) {
spdlog::error("resource: {} [{}]: not found", loader->second->class_name, name);
return nullptr;
}
return resource_it->second;
}
void resource::hard_cleanup(void)
{
for(auto& [type_index, loader] : loaders) {
loader->cache.clear();
for(auto& [name, resource_ptr] : loader->resources) {
if(resource_ptr.use_count() > 1) {
spdlog::warn("resource: zombie resource: {} [{}] [use_count={}]", name, loader->class_name, resource_ptr.use_count());
}
else {
spdlog::debug("resource: releasing {} [{}]", name, loader->class_name);
}
loader->free_func(resource_ptr.get());
}
loader->resources.clear();
}
loaders.clear();
}
void resource::soft_cleanup(void)
{
for(auto& [type_index, loader] : loaders) {
auto resource_it = loader->resources.begin();
while(resource_it != loader->resources.end()) {
if(resource_it->second.use_count() <= 1) {
spdlog::debug("resource: releasing {} [{}]", resource_it->first, loader->class_name);
loader->free_func(resource_it->second.get());
resource_it = loader->resources.erase(resource_it);
continue;
}
resource_it = std::next(resource_it);
}
}
}
|
