ResourceManager.cc

#include "ResourceManager.hh"
 
#include "game/system/RaceConfig.hh"
 
namespace Kinoko::System {
 
#define ARCHIVE_COUNT 2
 
static const char *const RESOURCE_PATHS[] = {
        "/Race/Common",
        nullptr,
};

void *ResourceManager::getFile(const char *filename, size_t *size, ArchiveId id) {
    s32 idx = static_cast<s32>(id);
    return m_archives[idx]->isLoaded() ? m_archives[idx]->getFile(filename, size) : nullptr;
}

void *ResourceManager::getBsp(Vehicle vehicle, size_t *size) {
    char buffer[32];
 
    const char *name = GetVehicleName(vehicle);
    snprintf(buffer, sizeof(buffer), "/bsp/%s.bsp", name);
 
    return m_archives[0]->isLoaded() ? m_archives[0]->getFile(buffer, size) : nullptr;
}

MultiDvdArchive *ResourceManager::load(s32 idx, const char *filename) {
    // Course has a dedicated load function, so we do not want it here
    ASSERT(idx != 1);
 
    if (!filename) {
        filename = RESOURCE_PATHS[idx];
    }
 
    if (!m_archives[idx]->isLoaded() && filename) {
        m_archives[idx]->load(filename);
    }
 
    return m_archives[idx];
}

MultiDvdArchive *ResourceManager::load(Course courseId) {
    char buffer[256];
    snprintf(buffer, sizeof(buffer), "Race/Course/%s", COURSE_NAMES[static_cast<s32>(courseId)]);
    m_archives[1]->load(buffer);
    return m_archives[1];
}

void ResourceManager::unmount(MultiDvdArchive *archive) {
    archive->unmount();
}

ResourceManager *ResourceManager::CreateInstance() {
    ASSERT(!s_instance);
    s_instance = EGG::egg_new<ResourceManager>();
    return s_instance;
}

void ResourceManager::DestroyInstance() {
    ASSERT(s_instance);
    auto *instance = s_instance;
    s_instance = nullptr;
    EGG::egg_delete(instance);
}

ResourceManager::ResourceManager() {
    m_archives = static_cast<MultiDvdArchive **>(
            EGG::egg_alloc(ARCHIVE_COUNT * sizeof(MultiDvdArchive *)));
    for (u8 i = 0; i < ARCHIVE_COUNT; i++) {
        m_archives[i] = Create(i);
    }
}

ResourceManager::~ResourceManager() {
    if (s_instance) {
        s_instance = nullptr;
        WARN("ResourceManager instance not explicitly handled!");
    }
}

MultiDvdArchive *ResourceManager::Create(u8 i) {
    switch (i) {
    default:
        return EGG::egg_new<MultiDvdArchive>();
    }
}
 
ResourceManager *ResourceManager::s_instance = nullptr;
 
} // namespace Kinoko::System