188 lines
8.9 KiB
C++
188 lines
8.9 KiB
C++
#include "ResourceManager.hpp"
|
|
#include <Helpers/Networking/NetLibrary.hpp>
|
|
#include <include/core/SkImage.h>
|
|
#include <Helpers/NetworkingObjects/NetObjID.hpp>
|
|
#include "ResourceDisplay/SvgResourceDisplay.hpp"
|
|
#include "CommandList.hpp"
|
|
#include "ResourceDisplay/ImageResourceDisplay.hpp"
|
|
#include "ResourceDisplay/FileResourceDisplay.hpp"
|
|
#include <cereal/types/string.hpp>
|
|
#include <Helpers/Logger.hpp>
|
|
#include <fstream>
|
|
#include "World.hpp"
|
|
#include "ResourceDisplay/FileResourceDisplay.hpp"
|
|
#include <cereal/archives/portable_binary.hpp>
|
|
#include <cereal/types/unordered_map.hpp>
|
|
|
|
ResourceManager::ResourceManager(World& initWorld):
|
|
world(initWorld)
|
|
{}
|
|
|
|
void ResourceManager::init_client_callbacks() {
|
|
world.netClient->add_recv_callback(SERVER_NEW_RESOURCE_ID, [&](cereal::PortableBinaryInputArchive& message) {
|
|
NetworkingObjects::NetObjID idBeingRetrieved;
|
|
message(idBeingRetrieved);
|
|
// There is a scenario where the resource id and data messages can be sent twice for the same resource (a resource can be sent early before CLIENT_INITIAL_DATA is sent, and then resent with CLIENT_INITIAL_DATA), so check if resource already exists, and only keep track of the ID if the resource doesn't exist yet
|
|
if(!world.netObjMan.get_obj_temporary_ref_from_id<ResourceData>(idBeingRetrieved))
|
|
resourcesBeingRetrieved.emplace(idBeingRetrieved, std::weak_ptr<NetServer::ClientData>());
|
|
});
|
|
world.netClient->add_recv_callback(SERVER_NEW_RESOURCE_DATA, [&](cereal::PortableBinaryInputArchive& message) {
|
|
if(!resourcesBeingRetrieved.empty()) { // If the resource was sent for the second time, this will be empty, so we can ignore the message
|
|
ResourceData newResource;
|
|
message(newResource);
|
|
resourceList.emplace_back(world.netObjMan.make_obj_direct_with_specific_id<ResourceData>(resourcesBeingRetrieved.begin()->first, newResource));
|
|
resourcesBeingRetrieved.clear();
|
|
}
|
|
});
|
|
}
|
|
|
|
void ResourceManager::init_server_callbacks() {
|
|
world.netServer->add_recv_callback(CLIENT_NEW_RESOURCE_ID, [&](std::shared_ptr<NetServer::ClientData> client, cereal::PortableBinaryInputArchive& message) {
|
|
NetworkingObjects::NetObjID idBeingRetrieved;
|
|
message(idBeingRetrieved);
|
|
resourcesBeingRetrieved.emplace(idBeingRetrieved, client);
|
|
});
|
|
world.netServer->add_recv_callback(CLIENT_NEW_RESOURCE_DATA, [&](std::shared_ptr<NetServer::ClientData> client, cereal::PortableBinaryInputArchive& message) {
|
|
ResourceData newResource;
|
|
message(newResource);
|
|
auto it = std::find_if(resourcesBeingRetrieved.begin(), resourcesBeingRetrieved.end(), [&client](auto& p) {
|
|
return (!p.second.expired() && p.second.lock() == client);
|
|
});
|
|
resourceList.emplace_back(world.netObjMan.make_obj_direct_with_specific_id<ResourceData>(it->first, newResource));
|
|
world.netServer->send_items_to_all_clients_except(client, RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_ID, resourceList.back().get_net_id());
|
|
world.netServer->send_items_to_all_clients_except(client, RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_DATA, newResource);
|
|
resourcesBeingRetrieved.erase(it);
|
|
});
|
|
}
|
|
|
|
float ResourceManager::get_resource_retrieval_progress(const NetworkingObjects::NetObjID& id) {
|
|
auto resourceClientID = resourcesBeingRetrieved.find(id);
|
|
if(resourceClientID == resourcesBeingRetrieved.end())
|
|
return 0.0f;
|
|
if(world.netServer) {
|
|
std::weak_ptr<NetServer::ClientData> clientIDToLookFor = resourceClientID->second;
|
|
if(clientIDToLookFor.expired()) {
|
|
resourcesBeingRetrieved.erase(resourceClientID);
|
|
return 0.0f;
|
|
}
|
|
auto progressBytes = clientIDToLookFor.lock()->get_progress_into_fragmented_message(RESOURCE_COMMAND_CHANNEL);
|
|
if(progressBytes.totalBytes == 0)
|
|
return 0.0f;
|
|
return static_cast<float>(progressBytes.downloadedBytes) / static_cast<float>(progressBytes.totalBytes);
|
|
}
|
|
else if(world.netClient) {
|
|
NetLibrary::DownloadProgress progressBytes = world.netClient->get_progress_into_fragmented_message(RESOURCE_COMMAND_CHANNEL);
|
|
if(progressBytes.totalBytes == 0)
|
|
return 0.0f;
|
|
return static_cast<float>(progressBytes.downloadedBytes) / static_cast<float>(progressBytes.totalBytes);
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
void ResourceManager::update() {
|
|
for(auto& [k, v] : displays)
|
|
v->update(world);
|
|
}
|
|
|
|
NetworkingObjects::NetObjTemporaryPtr<ResourceData> ResourceManager::add_resource_file(const std::filesystem::path& filePath) {
|
|
ResourceData resource;
|
|
resource.data = std::make_shared<std::string>();
|
|
resource.name = std::filesystem::path(filePath).filename().string();
|
|
|
|
try {
|
|
*resource.data = read_file_to_string(filePath);
|
|
}
|
|
catch(...) {
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource_file] Could not open file " + filePath.string());
|
|
return {};
|
|
}
|
|
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource_file] Successfully read file " + filePath.string());
|
|
|
|
return add_resource(resource);
|
|
}
|
|
|
|
const NetworkingObjects::NetObjOwnerPtr<ResourceData>& ResourceManager::add_resource(const ResourceData& resource) {
|
|
auto it = std::find_if(resourceList.begin(), resourceList.end(), [&](const auto& p) {
|
|
return p->data == resource.data || (*p->data) == (*resource.data);
|
|
});
|
|
if(it != resourceList.end()) {
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource] File " + std::string(resource.name) + " is a duplicate");
|
|
return *it;
|
|
}
|
|
auto& resourceInsert = resourceList.emplace_back(world.netObjMan.make_obj_direct<ResourceData>(resource));
|
|
if(world.netServer) {
|
|
world.netServer->send_items_to_all_clients(RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_ID, resourceInsert.get_net_id());
|
|
world.netServer->send_items_to_all_clients(RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_DATA, resource);
|
|
}
|
|
else if(world.netClient) {
|
|
world.netClient->send_items_to_server(RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_ID, resourceInsert.get_net_id());
|
|
world.netClient->send_items_to_server(RESOURCE_COMMAND_CHANNEL, SERVER_NEW_RESOURCE_DATA, resource);
|
|
}
|
|
return resourceInsert;
|
|
}
|
|
|
|
ResourceDisplay* ResourceManager::get_display_data(const NetworkingObjects::NetObjID& fileID) {
|
|
auto loadedDisplayIt = displays.find(fileID);
|
|
if(loadedDisplayIt != displays.end())
|
|
return loadedDisplayIt->second.get();
|
|
|
|
NetworkingObjects::NetObjTemporaryPtr<ResourceData> resourceData = world.netObjMan.get_obj_temporary_ref_from_id<ResourceData>(fileID);
|
|
if(resourceData == NetworkingObjects::NetObjTemporaryPtr<ResourceData>())
|
|
return nullptr;
|
|
|
|
auto imgResource(std::make_unique<ImageResourceDisplay>());
|
|
if(imgResource->load(*this, resourceData->name, resourceData->data)) {
|
|
displays.emplace(fileID, std::move(imgResource));
|
|
return displays[fileID].get();
|
|
}
|
|
|
|
auto svgResource(std::make_unique<SvgResourceDisplay>());
|
|
if(svgResource->load(*this, resourceData->name, resourceData->data)) {
|
|
displays.emplace(fileID, std::move(svgResource));
|
|
return displays[fileID].get();
|
|
}
|
|
|
|
auto fileResource(std::make_unique<FileResourceDisplay>());
|
|
fileResource->load(*this, resourceData->name, resourceData->data);
|
|
displays.emplace(fileID, std::move(fileResource));
|
|
return displays[fileID].get();
|
|
}
|
|
|
|
std::unordered_map<NetworkingObjects::NetObjID, ResourceData> ResourceManager::copy_resource_set_to_map(const std::unordered_set<NetworkingObjects::NetObjID>& resourceSet) const {
|
|
std::unordered_map<NetworkingObjects::NetObjID, ResourceData> toRet;
|
|
for(auto& netID : resourceSet) {
|
|
auto tempPtr = world.netObjMan.get_obj_temporary_ref_from_id<ResourceData>(netID);
|
|
if(tempPtr)
|
|
toRet.emplace(netID, *tempPtr);
|
|
}
|
|
return toRet;
|
|
}
|
|
|
|
const std::vector<NetworkingObjects::NetObjOwnerPtr<ResourceData>>& ResourceManager::resource_list() {
|
|
return resourceList;
|
|
}
|
|
|
|
void ResourceManager::load_file(cereal::PortableBinaryInputArchive& a, VersionNumber version) {
|
|
std::unordered_map<NetworkingObjects::NetObjID, ResourceData> loadedResources;
|
|
a(loadedResources);
|
|
for(auto& [netID, rData] : loadedResources)
|
|
resourceList.emplace_back(world.netObjMan.make_obj_direct_with_specific_id<ResourceData>(netID, rData));
|
|
}
|
|
|
|
void ResourceManager::save_file(cereal::PortableBinaryOutputArchive& a) const {
|
|
std::unordered_set<NetworkingObjects::NetObjID> usedResources;
|
|
world.drawProg.get_used_resources(usedResources);
|
|
std::unordered_map<NetworkingObjects::NetObjID, ResourceData> strippedResources;
|
|
for(auto& n : resourceList)
|
|
strippedResources.emplace(n.get_net_id(), *n);
|
|
std::erase_if(strippedResources, [&](const auto& p) {
|
|
return !usedResources.contains(p.first);
|
|
});
|
|
a(strippedResources);
|
|
}
|
|
|
|
void ResourceManager::clear_display_cache() {
|
|
for(auto& [id, display] : displays)
|
|
display->clear_cache();
|
|
}
|