139 lines
4.8 KiB
C++
139 lines
4.8 KiB
C++
#include "ResourceManager.hpp"
|
|
#include "Helpers/Networking/NetLibrary.hpp"
|
|
#include <include/core/SkImage.h>
|
|
#include "ResourceDisplay/SvgResourceDisplay.hpp"
|
|
#include "Server/CommandList.hpp"
|
|
#include "ResourceDisplay/ImageResourceDisplay.hpp"
|
|
#include "ResourceDisplay/FileResourceDisplay.hpp"
|
|
#include <cereal/types/string.hpp>
|
|
#include <Helpers/Logger.hpp>
|
|
#include <optional>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include "World.hpp"
|
|
#include "ResourceDisplay/FileResourceDisplay.hpp"
|
|
|
|
ResourceManager::ResourceManager(World& initWorld):
|
|
world(initWorld)
|
|
{}
|
|
|
|
void ResourceManager::init_client_callbacks() {
|
|
world.con.client_add_recv_callback(CLIENT_NEW_RESOURCE, [&](cereal::PortableBinaryInputArchive& message) {
|
|
ServerClientID resourceID;
|
|
message(resourceID);
|
|
message(resources[resourceID]);
|
|
std::cout << "Received new resource: " << resourceID.first << " " << resourceID.second << " " << resources[resourceID].data->size() << std::endl;
|
|
});
|
|
}
|
|
|
|
void ResourceManager::update() {
|
|
for(auto& [k, v] : displays)
|
|
v->update(world);
|
|
}
|
|
|
|
ServerClientID ResourceManager::add_resource_file(std::string_view fileName) {
|
|
// https://nullptr.org/cpp-read-file-into-string/
|
|
std::ifstream file(fileName.data(), std::ios::in | std::ios::binary | std::ios::ate);
|
|
if(!file.is_open()) {
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource_file] Could not open file " + std::string(fileName));
|
|
return {0, 0};
|
|
}
|
|
|
|
size_t resourcesize;
|
|
|
|
auto tellgResult = file.tellg();
|
|
|
|
if(tellgResult == -1) {
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource_file] tellg failed for file " + std::string(fileName));
|
|
return {0, 0};
|
|
}
|
|
|
|
resourcesize = static_cast<size_t>(tellgResult);
|
|
|
|
file.seekg(0, std::ios_base::beg);
|
|
|
|
ResourceData resource;
|
|
resource.data = std::make_shared<std::string>();
|
|
resource.name = std::filesystem::path(fileName).filename().string();
|
|
std::string& toPlaceIn = *resource.data;
|
|
|
|
toPlaceIn.resize(resourcesize);
|
|
|
|
file.read(toPlaceIn.data(), resourcesize);
|
|
|
|
file.close();
|
|
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource_file] Successfully read file " + std::string(fileName));
|
|
|
|
return add_resource(resource);
|
|
}
|
|
|
|
ServerClientID ResourceManager::add_resource(const ResourceData& resource) {
|
|
auto it = std::find_if(resources.begin(), resources.end(), [&](const auto& p) {
|
|
return p.second.data == resource.data || (*p.second.data) == (*resource.data);
|
|
});
|
|
if(it != resources.end()) {
|
|
Logger::get().log("INFO", "[ResourceManager::add_resource] File " + std::string(resource.name) + " is a duplicate");
|
|
return it->first;
|
|
}
|
|
ServerClientID newID = world.get_new_id();
|
|
resources[newID] = resource;
|
|
world.con.client_send_items_to_server(RELIABLE_COMMAND_CHANNEL, SERVER_RESOURCE_INIT);
|
|
world.con.client_send_items_to_server(RESOURCE_COMMAND_CHANNEL, SERVER_RESOURCE_DATA, resource);
|
|
return newID;
|
|
}
|
|
|
|
void ResourceManager::copy_resource_set_to_map(const std::unordered_set<ServerClientID>& resourceSet, std::unordered_map<ServerClientID, ResourceData>& resourceMap) const {
|
|
resourceMap.clear();
|
|
for(auto& [k, v] : resources) {
|
|
if(resourceSet.contains(k))
|
|
resourceMap[k] = v;
|
|
}
|
|
}
|
|
|
|
ClientPortionID ResourceManager::get_max_id(ServerPortionID serverID) const {
|
|
ClientPortionID maxClientID = 0;
|
|
for(auto& p : resources) {
|
|
if(p.first.first == serverID)
|
|
maxClientID = std::max(maxClientID, p.first.second);
|
|
}
|
|
return maxClientID;
|
|
}
|
|
|
|
std::optional<ResourceData> ResourceManager::get_resource(const ServerClientID& id) const {
|
|
auto it = resources.find(id);
|
|
if(it == resources.end())
|
|
return std::nullopt;
|
|
return it->second;
|
|
}
|
|
|
|
std::shared_ptr<ResourceDisplay> ResourceManager::get_display_data(const ServerClientID& fileID) {
|
|
auto loadedDisplayIt = displays.find(fileID);
|
|
if(loadedDisplayIt != displays.end())
|
|
return loadedDisplayIt->second;
|
|
|
|
auto resourceIt = resources.find(fileID);
|
|
if(resourceIt == resources.end())
|
|
return nullptr;
|
|
|
|
auto imgResource(std::make_shared<ImageResourceDisplay>());
|
|
if(imgResource->load(resourceIt->second.name, *resourceIt->second.data)) {
|
|
displays[fileID] = imgResource;
|
|
return imgResource;
|
|
}
|
|
|
|
auto svgResource(std::make_shared<SvgResourceDisplay>());
|
|
if(svgResource->load(resourceIt->second.name, *resourceIt->second.data)) {
|
|
displays[fileID] = svgResource;
|
|
return svgResource;
|
|
}
|
|
|
|
auto fileResource(std::make_shared<FileResourceDisplay>());
|
|
fileResource->load(resourceIt->second.name, *resourceIt->second.data);
|
|
displays[fileID] = fileResource;
|
|
return fileResource;
|
|
}
|
|
|
|
const std::unordered_map<ServerClientID, ResourceData>& ResourceManager::resource_list() {
|
|
return resources;
|
|
}
|