Shipwright/libultraship/libultraship/ResourceMgr.cpp
2022-06-16 20:35:52 -04:00

362 lines
9.9 KiB
C++

#include "ResourceMgr.h"
#include "Factories/ResourceLoader.h"
#include "spdlog/spdlog.h"
#include "File.h"
#include "Archive.h"
#include "GameVersions.h"
#include <Utils/StringHelper.h>
#include "StormLib.h"
namespace Ship {
ResourceMgr::ResourceMgr(std::shared_ptr<GlobalCtx2> Context, const std::string& MainPath, const std::string& PatchesPath) : Context(Context), bIsRunning(false), FileLoadThread(nullptr) {
OTR = std::make_shared<Archive>(MainPath, PatchesPath, false);
gameVersion = OOT_UNKNOWN;
if (OTR->IsMainMPQValid())
Start();
}
ResourceMgr::~ResourceMgr() {
SPDLOG_INFO("destruct ResourceMgr");
Stop();
FileCache.clear();
ResourceCache.clear();
}
void ResourceMgr::Start() {
const std::lock_guard<std::mutex> FileLock(FileLoadMutex);
const std::lock_guard<std::mutex> ResLock(ResourceLoadMutex);
if (!IsRunning()) {
bIsRunning = true;
FileLoadThread = std::make_shared<std::thread>(&ResourceMgr::LoadFileThread, this);
ResourceLoadThread = std::make_shared<std::thread>(&ResourceMgr::LoadResourceThread, this);
}
}
void ResourceMgr::Stop() {
if (IsRunning()) {
{
const std::lock_guard<std::mutex> FileLock(FileLoadMutex);
const std::lock_guard<std::mutex> ResLock(ResourceLoadMutex);
bIsRunning = false;
}
FileLoadNotifier.notify_all();
ResourceLoadNotifier.notify_all();
FileLoadThread->join();
ResourceLoadThread->join();
if (!FileLoadQueue.empty()) {
SPDLOG_INFO("Resource manager stopped, but has {} Files left to load.", FileLoadQueue.size());
}
if (!ResourceLoadQueue.empty()) {
SPDLOG_INFO("Resource manager stopped, but has {} Resources left to load.", FileLoadQueue.size());
}
}
}
bool ResourceMgr::IsRunning() {
return bIsRunning && FileLoadThread != nullptr;
}
bool ResourceMgr::DidLoadSuccessfully()
{
return OTR != nullptr && OTR->IsMainMPQValid();
}
void ResourceMgr::LoadFileThread() {
SPDLOG_INFO("Resource Manager LoadFileThread started");
while (true) {
std::unique_lock<std::mutex> Lock(FileLoadMutex);
while (bIsRunning && FileLoadQueue.empty()) {
FileLoadNotifier.wait(Lock);
}
if (!bIsRunning) {
break;
}
//Lock.lock();
std::shared_ptr<File> ToLoad = FileLoadQueue.front();
FileLoadQueue.pop();
//Lock.unlock();
OTR->LoadFile(ToLoad->path, true, ToLoad);
//Lock.lock();
if (!ToLoad->bHasLoadError)
FileCache[ToLoad->path] = ToLoad->bIsLoaded && !ToLoad->bHasLoadError ? ToLoad : nullptr;
//Lock.unlock();
SPDLOG_DEBUG("Loaded File {} on ResourceMgr thread", ToLoad->path);
ToLoad->FileLoadNotifier.notify_all();
}
SPDLOG_INFO("Resource Manager LoadFileThread ended");
}
void ResourceMgr::LoadResourceThread() {
SPDLOG_INFO("Resource Manager LoadResourceThread started");
while (true) {
std::unique_lock<std::mutex> ResLock(ResourceLoadMutex);
while (bIsRunning && ResourceLoadQueue.empty()) {
ResourceLoadNotifier.wait(ResLock);
}
if (!bIsRunning) {
break;
}
std::shared_ptr<ResourcePromise> ToLoad = nullptr;
//ResLock.lock();
ToLoad = ResourceLoadQueue.front();
ResourceLoadQueue.pop();
//ResLock.unlock();
// Wait for the underlying File to complete loading
{
std::unique_lock<std::mutex> FileLock(ToLoad->file->FileLoadMutex);
while (!ToLoad->file->bIsLoaded && !ToLoad->file->bHasLoadError) {
ToLoad->file->FileLoadNotifier.wait(FileLock);
}
}
if (!ToLoad->file->bHasLoadError)
{
auto UnmanagedRes = ResourceLoader::LoadResource(ToLoad->file);
if (UnmanagedRes != nullptr)
{
UnmanagedRes->resMgr = this;
auto Res = std::shared_ptr<Resource>(UnmanagedRes);
if (Res != nullptr) {
std::unique_lock<std::mutex> Lock(ToLoad->resourceLoadMutex);
ToLoad->bHasResourceLoaded = true;
ToLoad->resource = Res;
ResourceCache[Res->file->path] = Res;
SPDLOG_DEBUG("Loaded Resource {} on ResourceMgr thread", ToLoad->file->path);
// Disabled for now because it can cause random crashes
//FileCache[Res->File->path] = nullptr;
//FileCache.erase(FileCache.find(Res->File->path));
Res->file = nullptr;
}
else {
ToLoad->bHasResourceLoaded = false;
ToLoad->resource = nullptr;
SPDLOG_ERROR("Resource load FAILED {} on ResourceMgr thread", ToLoad->file->path);
}
//ResLock.lock();
//ResLock.unlock();
}
}
else
{
ToLoad->bHasResourceLoaded = false;
ToLoad->resource = nullptr;
}
ToLoad->resourceLoadNotifier.notify_all();
}
SPDLOG_INFO("Resource Manager LoadResourceThread ended");
}
uint32_t ResourceMgr::GetGameVersion()
{
return gameVersion;
}
void ResourceMgr::SetGameVersion(uint32_t newGameVersion)
{
gameVersion = newGameVersion;
}
std::shared_ptr<File> ResourceMgr::LoadFileAsync(const std::string& FilePath) {
const std::lock_guard<std::mutex> Lock(FileLoadMutex);
// File NOT already loaded...?
auto fileCacheFind = FileCache.find(FilePath);
if (fileCacheFind == FileCache.end()) {
SPDLOG_TRACE("Cache miss on File load: {}", FilePath.c_str());
std::shared_ptr<File> ToLoad = std::make_shared<File>();
ToLoad->path = FilePath;
FileLoadQueue.push(ToLoad);
FileLoadNotifier.notify_all();
return ToLoad;
}
return fileCacheFind->second;
}
std::shared_ptr<File> ResourceMgr::LoadFile(const std::string& FilePath) {
auto ToLoad = LoadFileAsync(FilePath);
// Wait for the File to actually be loaded if we are told to block.
std::unique_lock<std::mutex> Lock(ToLoad->FileLoadMutex);
while (!ToLoad->bIsLoaded && !ToLoad->bHasLoadError) {
ToLoad->FileLoadNotifier.wait(Lock);
}
return ToLoad;
}
std::shared_ptr<Ship::Resource> ResourceMgr::GetCachedFile(const char* FilePath) const {
auto resCacheFind = ResourceCache.find(FilePath);
if (resCacheFind != ResourceCache.end() &&
resCacheFind->second.use_count() > 0)
{
return resCacheFind->second;
}
else
return nullptr;
}
std::shared_ptr<Resource> ResourceMgr::LoadResource(const char* FilePath) {
auto Res = LoadResourceAsync(FilePath);
if (std::holds_alternative<std::shared_ptr<Resource>>(Res))
return std::get<std::shared_ptr<Resource>>(Res);
auto& Promise = std::get<std::shared_ptr<ResourcePromise>>(Res);
if (!Promise->bHasResourceLoaded)
{
std::unique_lock<std::mutex> Lock(Promise->resourceLoadMutex);
while (!Promise->bHasResourceLoaded) {
Promise->resourceLoadNotifier.wait(Lock);
}
}
return Promise->resource;
}
std::variant<std::shared_ptr<Resource>, std::shared_ptr<ResourcePromise>> ResourceMgr::LoadResourceAsync(const char* FilePath) {
if (FilePath[0] == '_' && FilePath[1] == '_' && FilePath[2] == 'O' && FilePath[3] == 'T' && FilePath[4] == 'R' && FilePath[5] == '_' && FilePath[6] == '_')
FilePath += 7;
const std::lock_guard<std::mutex> ResLock(ResourceLoadMutex);
auto resCacheFind = ResourceCache.find(FilePath);
if (resCacheFind == ResourceCache.end() || resCacheFind->second->isDirty/* || !FileData->bIsLoaded*/) {
if (resCacheFind == ResourceCache.end()) {
SPDLOG_TRACE("Cache miss on Resource load: {}", FilePath);
}
std::shared_ptr<ResourcePromise> Promise = std::make_shared<ResourcePromise>();
std::shared_ptr<File> FileData = LoadFile(FilePath);
Promise->file = FileData;
if (Promise->file->bHasLoadError)
{
Promise->bHasResourceLoaded = true;
}
else
{
Promise->bHasResourceLoaded = false;
ResourceLoadQueue.push(Promise);
ResourceLoadNotifier.notify_all();
}
return Promise;
}
else
{
return resCacheFind->second;
}
}
std::shared_ptr<std::vector<std::shared_ptr<ResourcePromise>>> ResourceMgr::CacheDirectoryAsync(const std::string& SearchMask) {
auto loadedList = std::make_shared<std::vector<std::shared_ptr<ResourcePromise>>>();
auto fileList = OTR->ListFiles(SearchMask);
for (DWORD i = 0; i < fileList.size(); i++) {
auto resource = LoadResourceAsync(fileList.operator[](i).cFileName);
if (std::holds_alternative<std::shared_ptr<Resource>>(resource))
{
auto promise = std::make_shared<ResourcePromise>();
promise->bHasResourceLoaded = true;
promise->resource = std::get<std::shared_ptr<Resource>>(resource);
resource = promise;
}
loadedList->push_back(std::get<std::shared_ptr<ResourcePromise>>(resource));
}
return loadedList;
}
std::shared_ptr<std::vector<std::shared_ptr<Resource>>> ResourceMgr::CacheDirectory(const std::string& SearchMask) {
auto PromiseList = CacheDirectoryAsync(SearchMask);
auto LoadedList = std::make_shared<std::vector<std::shared_ptr<Resource>>>();
for (size_t i = 0; i < PromiseList->size(); i++) {
auto Promise = PromiseList->at(i);
std::unique_lock<std::mutex> Lock(Promise->resourceLoadMutex);
while (!Promise->bHasResourceLoaded) {
Promise->resourceLoadNotifier.wait(Lock);
}
LoadedList->push_back(Promise->resource);
}
return LoadedList;
}
std::shared_ptr<std::vector<std::shared_ptr<Resource>>> ResourceMgr::DirtyDirectory(std::string SearchMask)
{
auto PromiseList = CacheDirectoryAsync(SearchMask);
auto LoadedList = std::make_shared<std::vector<std::shared_ptr<Resource>>>();
for (size_t i = 0; i < PromiseList->size(); i++) {
auto Promise = PromiseList->at(i);
std::unique_lock<std::mutex> Lock(Promise->resourceLoadMutex);
while (!Promise->bHasResourceLoaded) {
Promise->resourceLoadNotifier.wait(Lock);
}
if (Promise->resource != nullptr)
Promise->resource->isDirty = true;
LoadedList->push_back(Promise->resource);
}
return LoadedList;
}
std::shared_ptr<std::vector<std::string>> ResourceMgr::ListFiles(std::string SearchMask)
{
auto result = std::make_shared<std::vector<std::string>>();
auto fileList = OTR->ListFiles(SearchMask);
for (DWORD i = 0; i < fileList.size(); i++) {
result->push_back(fileList[i].cFileName);
}
return result;
}
void ResourceMgr::InvalidateResourceCache() {
ResourceCache.clear();
}
const std::string* ResourceMgr::HashToString(uint64_t Hash) const {
return OTR->HashToString(Hash);
}
}