| #include "assets.h" |
| #include "../core/core.h" |
| #include <cstdio> |
| #include <cstring> |
| #include <sstream> |
|
|
| namespace unify { |
|
|
| const char* asset_type_name(AssetType t) { |
| switch (t) { |
| case AssetType::Texture: return "texture"; |
| case AssetType::Audio: return "audio"; |
| case AssetType::Music: return "music"; |
| case AssetType::Script: return "script"; |
| case AssetType::Prefab: return "prefab"; |
| case AssetType::Map: return "map"; |
| case AssetType::Kernel: return "kernel"; |
| case AssetType::Material: return "material"; |
| case AssetType::Font: return "font"; |
| case AssetType::SaveData: return "save"; |
| } |
| return "?"; |
| } |
|
|
| bool read_file(const std::string& path, std::vector<uint8_t>& out) { |
| FILE* f = std::fopen(path.c_str(), "rb"); |
| if (!f) return false; |
| out.clear(); |
| uint8_t buf[65536]; |
| size_t n; |
| while ((n = std::fread(buf, 1, sizeof buf, f)) > 0) out.insert(out.end(), buf, buf + n); |
| std::fclose(f); |
| return true; |
| } |
|
|
| bool write_file(const std::string& path, const std::vector<uint8_t>& data) { |
| std::string tmp = path + ".tmp"; |
| FILE* f = std::fopen(tmp.c_str(), "wb"); |
| if (!f) return false; |
| bool ok = std::fwrite(data.data(), 1, data.size(), f) == data.size(); |
| ok = std::fclose(f) == 0 && ok; |
| return ok && std::rename(tmp.c_str(), path.c_str()) == 0; |
| } |
|
|
| AssetManager::AssetManager(RenderDevice& device, std::string root, size_t budget) : device_(device), root_(std::move(root)), alloc_(budget) {} |
|
|
| AssetManager::~AssetManager() { |
| for (uint32_t i = 0; i < handles_.capacity(); i++) |
| if (AssetHandle h = handles_.at(i)) free_payload(records_[i]); |
| } |
|
|
| std::string AssetManager::path_for(AssetType type, const std::string& name) const { |
| static const std::map<AssetType, const char*> ext = { |
| {AssetType::Texture, ".qoi"}, {AssetType::Audio, ".wav"}, {AssetType::Music, ".wav"}, {AssetType::Script, ".lua"}, |
| {AssetType::Prefab, ".lua"}, {AssetType::Map, ".map"}, {AssetType::Kernel, ".cu"}, {AssetType::Material, ".mat"}, |
| {AssetType::Font, ""}, {AssetType::SaveData, ".usav"}}; |
| return root_ + "/" + name + ext.at(type); |
| } |
|
|
| AssetHandle AssetManager::find(const std::string& name) const { |
| auto it = by_name_.find(name); |
| return it == by_name_.end() ? AssetHandle{} : it->second; |
| } |
|
|
| AssetHandle AssetManager::load(AssetType type, const std::string& name) { |
| auto it = by_name_.find(name); |
| if (it != by_name_.end() && handles_.valid(it->second)) { |
| AssetRecord& r = records_[it->second.index()]; |
| if (r.type != type) { UNIFY_LOG_ERROR("ASSETS", "'%s' already loaded as %s", name.c_str(), asset_type_name(r.type)); return {}; } |
| r.refs++; |
| return it->second; |
| } |
| AssetRecord rec; |
| rec.name = name; |
| rec.type = type; |
| rec.path = path_for(type, name); |
| rec.refs = 1; |
| if (!load_payload(rec)) { |
| UNIFY_LOG_ERROR("ASSETS", "failed to load %s '%s' (%s)", asset_type_name(type), name.c_str(), rec.path.c_str()); |
| return {}; |
| } |
| AssetHandle h = handles_.allocate(); |
| if (h.index() >= records_.size()) records_.resize(h.index() + 1); |
| records_[h.index()] = std::move(rec); |
| by_name_[name] = h; |
| return h; |
| } |
|
|
| bool AssetManager::acquire(AssetHandle h) { |
| if (!valid(h)) return false; |
| records_[h.index()].refs++; |
| return true; |
| } |
|
|
| bool AssetManager::release(AssetHandle h) { |
| if (!valid(h)) return false; |
| AssetRecord& r = records_[h.index()]; |
| if (--r.refs > 0) return true; |
| free_payload(r); |
| by_name_.erase(r.name); |
| r = AssetRecord{}; |
| handles_.release(h); |
| return true; |
| } |
|
|
| static bool parse_map(const std::string& text, TileMap& m) { |
| std::istringstream in(text); |
| std::string line; |
| while (std::getline(in, line)) { |
| if (!line.empty() && line.back() == '\r') line.pop_back(); |
| if (line.rfind("//", 0) == 0) continue; |
| if (line.rfind("tile_size ", 0) == 0) { m.tile_size = std::stof(line.substr(10)); continue; } |
| m.rows.push_back(line); |
| m.width = std::max(m.width, int(line.size())); |
| } |
| for (auto& r : m.rows) r.resize(size_t(m.width), ' '); |
| m.height = int(m.rows.size()); |
| return m.height > 0; |
| } |
|
|
| bool AssetManager::load_payload(AssetRecord& r) { |
| switch (r.type) { |
| case AssetType::Texture: { |
| Image img; |
| if (!load_image(r.path, img)) return false; |
| r.texture.texture = device_.create_texture(img); |
| r.texture.width = img.width; |
| r.texture.height = img.height; |
| r.texture.atlas.regions.push_back({"", {0, 0, img.width, img.height}}); |
| |
| std::vector<uint8_t> meta; |
| std::string atlas_path = r.path.substr(0, r.path.size() - 4) + ".atlas"; |
| if (read_file(atlas_path, meta)) { |
| std::istringstream in(std::string(meta.begin(), meta.end())); |
| AtlasRegion reg; |
| while (in >> reg.name >> reg.rect.x >> reg.rect.y >> reg.rect.w >> reg.rect.h) r.texture.atlas.regions.push_back(reg); |
| } |
| r.bytes = img.pixels.size(); |
| return bool(r.texture.texture); |
| } |
| case AssetType::Audio: { |
| r.clip = std::make_shared<AudioClip>(); |
| r.clip->name = r.name; |
| if (!r.clip->load_wav(r.path)) return false; |
| r.bytes = r.clip->samples.size() * sizeof(float); |
| return true; |
| } |
| case AssetType::Music: { |
| |
| WavDecoder probe; |
| if (!probe.open(r.path)) return false; |
| r.bytes = 0; |
| return true; |
| } |
| case AssetType::Font: return true; |
| case AssetType::Script: case AssetType::Prefab: case AssetType::Map: case AssetType::Kernel: case AssetType::Material: case AssetType::SaveData: { |
| std::vector<uint8_t> data; |
| if (!read_file(r.path, data)) return false; |
| r.blob = alloc_.allocate(data.size() + 1, asset_type_name(r.type)); |
| if (!r.blob) { UNIFY_LOG_ERROR("ASSETS", "asset budget exhausted loading '%s'", r.name.c_str()); return false; } |
| std::memcpy(r.blob, data.data(), data.size()); |
| r.blob[data.size()] = 0; |
| r.text.assign(reinterpret_cast<char*>(r.blob), data.size()); |
| r.bytes = data.size() + 1; |
| if (r.type == AssetType::Map && !parse_map(r.text, r.map)) return false; |
| if (r.type == AssetType::Material) { |
| std::istringstream in(r.text); |
| std::string key; |
| while (in >> key) { |
| if (key == "blend") { |
| std::string v; in >> v; |
| r.material.blend = v == "additive" ? BlendMode::Additive : v == "multiply" ? BlendMode::Multiply : v == "opaque" ? BlendMode::Opaque : BlendMode::Alpha; |
| } else if (key == "tint") { |
| int cr, cg, cb, ca; in >> cr >> cg >> cb >> ca; |
| r.material.tint = {uint8_t(cr), uint8_t(cg), uint8_t(cb), uint8_t(ca)}; |
| } |
| } |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
|
|
| void AssetManager::free_payload(AssetRecord& r) { |
| if (r.type == AssetType::Texture && r.texture.texture) device_.destroy_texture(r.texture.texture); |
| if (r.blob) { alloc_.free(r.blob); r.blob = nullptr; } |
| r.clip.reset(); |
| } |
|
|
| std::shared_ptr<StreamingSource> AssetManager::open_stream(AssetHandle h) { |
| const AssetRecord* r = get(h); |
| if (!r || r->type != AssetType::Music) return nullptr; |
| auto s = std::make_shared<StreamingSource>(); |
| s->name = r->name; |
| if (!s->open(r->path)) return nullptr; |
| return s; |
| } |
|
|
| size_t AssetManager::resident_bytes() const { |
| size_t n = 0; |
| for (uint32_t i = 0; i < handles_.capacity(); i++) if (handles_.at(i)) n += records_[i].bytes; |
| return n; |
| } |
|
|
| std::vector<std::string> AssetManager::loaded_names() const { |
| std::vector<std::string> out; |
| for (auto& kv : by_name_) out.push_back(kv.first); |
| return out; |
| } |
|
|
| } |
|
|
