AssetReloader.h

浏览该文件的文档.

#pragma once
 
// Asset ownership interface, shared by two consumers:
//
// 1. Hot reload: let each module react to its own asset files. The filesystem
//    watcher knows a path changed but nothing about what lives at that path,
//    so every module that owns an asset kind registers a reloader and the
//    watcher just dispatches. Modules the build does not contain simply are
//    not registered.
// 2. Unified resource cache (common/Resource.h): on a cache miss the
//    ResourceManager asks the same registered providers to `load()` the CPU
//    resource for a key, so the engine-common layer still knows nothing about
//    graphics / particles / map / font / model / sound.
//
// Ordering matters when several reloaders react to one file: the cached CPU
// resource must refresh before the GPU texture is re-uploaded, and the GPU
// texture before the emitters / tile layers that sample it re-bind. Register
// with a priority to express that.
 
#include "common/Export.h"
#include "common/Result.h"
 
#include <string>
 
namespace eve {
class Resource;
}
 
namespace eve::caps {
 
class EVENGINE_API_FOUNDATION IAssetReloader {
public:
    enum Priority {
        kCache = 0,    // refresh cached CPU resources (ResourceManager)
        kTexture = 10,   // refresh GPU resources before their consumers re-bind
        kConsumer = 20,  // things that reference a reloaded resource
    };
 
    static constexpr const char* capabilityName = "IAssetReloader";
    virtual ~IAssetReloader() = default;
 
    virtual const char* reloadKind() const = 0;
 
    virtual bool handlesPath(const std::string& normPath) const = 0;
 
    [[nodiscard("loaded resource ownership must be retained or explicitly handled")]] virtual Resource* load(
        const std::string& key) {
        return nullptr;
    }
 
    [[nodiscard("asset reload outcome must be checked")]] virtual eve::Result<bool> reload(
        const std::string& normPath) = 0;
};
 
}  // namespace eve::caps