Resource.h

浏览该文件的文档.

#pragma once
#include "common/AssetReloader.h"
#include "common/BorrowedRef.h"
#include "common/Export.h"
#include "common/Result.h"
// Cached resources are owned by a RuntimeObjectRegistry and handed out as borrows and
// keep-alive pins, so this header needs those definitions. RuntimeRegistry.h is
// deliberately Squirrel-free: the cache's consumers must not be forced to include
// <squirrel.h> just to name a resource handle.
#include "common/RuntimeRegistry.h"
 
#include <cstddef>
#include <condition_variable>
#include <map>
#include <memory>
#include <mutex>
#include <span>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve {
 
class Resource;
 
struct ResourceCacheTag;
 
using ResourcePin = script::RuntimePin<Resource, ResourceCacheTag>;
 
class Resource {
public:
    virtual ~Resource() {}
 
    Resource(const Resource&)            = delete;
    Resource& operator=(const Resource&) = delete;
 
    std::string getUri() const { return uri; }
 
    [[nodiscard]] EVENGINE_API_FOUNDATION std::vector<Resource*> getDependencies() const;
 
    [[nodiscard]] EVENGINE_API_FOUNDATION eve::Result<void> addDependency(Resource& dependency);
 
    virtual void adopt(eve::Resource& replacement) = 0;
 
protected:
    Resource(std::string uri) : uri(uri) {}
 
    void setUri(std::string value) { uri = std::move(value); }
 
    friend class ResourceManager;
 
    std::string uri;
    std::vector<ResourcePin> dependencies;
};
 
 
class EVENGINE_API_FOUNDATION ResourceManager : public eve::caps::IAssetReloader {
public:
    static ResourceManager& getInstance();
 
    static std::string normalizePath(std::string path);
 
    static std::string makeKey(const std::string& path, const std::string& query = "");
 
    static std::string pathOfKey(const std::string& key);
 
    [[nodiscard("resource lookup ownership must be retained or explicitly handled")]] Resource* get(std::string key);
 
    [[nodiscard("async resource request outcome must be checked")]] eve::Result<void> request(
        std::string key);
 
    [[nodiscard("async resource request outcome must be checked")]] eve::Result<void> requestAll(
        std::span<const std::string> keys);
 
    [[nodiscard]] OptionalRef<Resource> peek(const std::string& key);
 
    [[nodiscard]] eve::Result<ResourcePin> pin(Resource* resource);
 
    [[nodiscard("resource wait outcome must be checked")]] ResultRef<Resource> waitFor(std::string key);
 
    size_t pendingCount() const;
 
    void unload(std::string key);
 
    void unloadPath(const std::string& path);
 
    size_t count() const;
 
    void clear();
 
    // eve::caps::IAssetReloader -- the cache participates in hot reload as the
    // first listener, refreshing CPU resources before GPU/consumers re-bind.
    const char* reloadKind() const override { return "cache"; }
    bool handlesPath(const std::string& normPath) const override;
    [[nodiscard("resource reload outcome must be checked")]] eve::Result<bool> reload(
        const std::string& normPath) override;
    [[nodiscard("loaded resource ownership must be retained or explicitly handled")]] Resource* load(
        const std::string& key) override {
        return nullptr;
    }
 
protected:
    ResourceManager() = default;
 
    void ensureRegistered();
    Resource* loadReplacement(const std::string& key);
    Resource* loadUncached(const std::string& norm);
    void runLoadJob(std::string norm, uint64_t epoch);
 
    struct AsyncLoad {
        bool done = false;
        bool failed = false;
        std::string error;
        uint64_t epoch = 0;
    };
 
    using ResourceRef = script::RuntimeHandleRef<ResourceCacheTag>;
 
    [[nodiscard]] Resource* borrowLocked(const ResourceRef& reference) { return registry_.resolve(reference).get(); }
 
    script::RuntimeObjectRegistry<Resource, ResourceCacheTag>   registry_;
    std::map<std::string, ResourceRef>                          resources;
    std::unordered_map<std::string, std::shared_ptr<AsyncLoad>> pending_;
    mutable std::mutex mu_;
    std::condition_variable cv_;
    uint64_t epoch_ = 1;
    bool registered_ = false;
};
 
}  // namespace eve