resourceloader.h

Go to the documentation of this file.

#pragma once
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#include "ids/id.h"
#include "util/stringatom.h"
#include "io/stream.h"
#include "util/set.h"
#include "resource.h"
#include "threading/safequeue.h"
#include "threading/threadid.h"
#include "ids/idpool.h"
#include <tuple>
#include <functional>
 
namespace Resources
{
 
struct PartialLoadBits
{
    uint bits;
    uint64 submissionId;
};
 
class Resource;
class ResourceLoaderThread;
class ResourceLoader : public Core::RefCounted
{
    __DeclareAbstractClass(ResourceLoader);
 
public:
    ResourceLoader();
    virtual ~ResourceLoader();
 
    virtual void Setup();
    virtual void Discard();
 
    virtual void LoadFallbackResources();
 
    Resources::ResourceId CreateResource(const Resources::ResourceName& res, const void* loadInfo, SizeT loadInfoSize, const Util::StringAtom& tag, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed, bool immediate, bool stream);
    void DiscardResource(const Resources::ResourceId id);
    void DiscardByTag(const Util::StringAtom& tag);
    void CreateListener(const Resources::ResourceId res, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed);
 
    const Resources::ResourceName& GetName(const Resources::ResourceId id) const;
    const uint32_t GetUsage(const Resources::ResourceId id) const;
    const Util::StringAtom GetTag(const Resources::ResourceId id) const;
    const Resource::State GetState(const Resources::ResourceId id) const;
    const Resources::ResourceId GetId(const Resources::ResourceName& name) const;
    const Util::Dictionary<Resources::ResourceName, Ids::Id32>& GetResources() const;
    const bool HasResource(const Resources::ResourceId id) const;
 
    const int32_t& GetUniqueId() const;
 
    void ReloadResource(const Resources::ResourceName& res, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed);
    void ReloadResource(const Resources::ResourceId& id, std::function<void(const Resources::ResourceId)> success, std::function<void(const Resources::ResourceId)> failed);
 
    void SetMinLod(const Resources::ResourceId& id, const float lod, bool immediate);
 
protected:
    friend class ResourceServer;
 
    struct _PendingResourceLoad
    {
        Ids::Id32 entry;
        Util::StringAtom tag;
        bool inflight;
        bool immediate;
        bool reload;
        IndexT frame;
        float lod;
 
        enum Mode
        {
            None = 0x0,
            Create = 0x1,
            Update = 0x2
        };
        uint mode;
 
        _PendingResourceLoad() : entry(-1) {};
    };
 
    struct _PendingStreamLod
    {
        Resources::ResourceId id;
        float lod;
        bool immediate;
 
        _PendingStreamLod() : id(ResourceId::Invalid()) {};
    };
 
    struct _PendingResourceUnload
    {
        Resources::ResourceId resourceId;
    };
 
    struct _Callbacks
    {
        Resources::ResourceId id;
        std::function<void(const Resources::ResourceId)> success;
        std::function<void(const Resources::ResourceId)> failed;
    };
 
    struct _LoadMetaData
    {
        void* data;
        SizeT size;
    };
 
    enum SubresourceLoadStatus
    {
        Full,       // All requested subresources were loaded
        Partial,    // Some of the requested subresources could be loaded, but not all
        Rejected    // None of the requested subresources were loaded, loader out of budget
    };
 
    static const uint32_t ResourceIndexGrow = 512;
 
    virtual ResourceUnknownId InitializeResource(const Ids::Id32 entry, const Util::StringAtom& tag, const Ptr<IO::Stream>& stream, bool immediate = false) = 0;
    virtual uint StreamResource(const ResourceId entry, IndexT frameIndex, uint requestedBits);
    virtual Resource::State ReloadFromStream(const Resources::ResourceId id, const Ptr<IO::Stream>& stream);
    virtual SubresourceLoadStatus StreamMaxLOD(const Resources::ResourceId& id, const float lod, bool immediate);
 
    virtual uint LodMask(const Ids::Id32 entry, float lod, bool stream) const;
    virtual void RequestLOD(const Ids::Id32 entry, float lod) const;
 
    virtual void Unload(const Resources::ResourceId id) = 0;
    virtual void Update(IndexT frameIndex);
 
    void SetupIdFromEntry(const Ids::Id32 entry, ResourceId& cacheEntry);
 
    Resource::State LoadImmediate(_PendingResourceLoad& res);
    void LoadAsync(_PendingResourceLoad res);
    void RunCallbacks(Resource::State status, const Resources::ResourceId id);
 
    friend Resource::State _LoadInternal(ResourceLoader* loader, const _PendingResourceLoad res);
 
    struct _PlaceholderResource
    {
        Resources::ResourceName placeholderName;
        Resources::ResourceId placeholderId;
    };
    Util::FixedArray<_PlaceholderResource> placeholders;
 
    Resources::ResourceId GetPlaceholder(const Resources::ResourceName& name);
 
    Util::StringAtom placeholderResourceName;
    Util::StringAtom failResourceName;
 
    Resources::ResourceId placeholderResourceId;
    Resources::ResourceId failResourceId;
 
    struct StreamData
    {
        void* data;
        Ptr<IO::Stream> stream;
    };
 
    bool async;
 
    Ptr<ResourceLoaderThread> streamerThread;
    Util::StringAtom streamerThreadName;
 
    Util::Array<IndexT> pendingLoads;
    Util::Array<_PendingResourceUnload> pendingUnloads;
    Util::Array<_PendingStreamLod> pendingStreamLods;
    Threading::SafeQueue<_PendingStreamLod> pendingStreamQueue;
 
    Util::Dictionary<Resources::ResourceName, uint32_t> ids;
    Ids::IdPool resourceInstanceIndexPool;
 
    Util::FixedArray<Resources::ResourceName> names;
    Util::FixedArray<uint32_t> usage;
    Util::FixedArray<Util::StringAtom> tags;
    Util::FixedArray<Resource::State> states;
    Util::FixedArray<uint> requestedBits;
    Util::FixedArray<uint> loadedBits;
    Util::FixedArray<ResourceId> resources;
    Util::FixedArray<Util::Array<_Callbacks>> callbacks;
    Util::FixedArray<_PendingResourceLoad> loads;
    Util::FixedArray<_LoadMetaData> metaData;
    Util::FixedArray<StreamData> streams;
    uint32_t uniqueResourceId;
 
    int32_t uniqueId;
 
    Threading::CriticalSection asyncSection;
    Threading::ThreadId creatorThread;
};
 
//------------------------------------------------------------------------------
inline const Resources::ResourceName&
ResourceLoader::GetName(const Resources::ResourceId id) const
{
    return this->names[id.loaderInstanceId];
}
 
//------------------------------------------------------------------------------
inline const uint32_t
ResourceLoader::GetUsage(const Resources::ResourceId id) const
{
    return this->usage[id.loaderInstanceId];
}
 
//------------------------------------------------------------------------------
inline const Util::StringAtom
ResourceLoader::GetTag(const Resources::ResourceId id) const
{
    return this->tags[id.loaderInstanceId];
}
 
//------------------------------------------------------------------------------
inline const Resources::Resource::State
ResourceLoader::GetState(const Resources::ResourceId id) const
{
    return this->states[id.loaderInstanceId];
}
 
//------------------------------------------------------------------------------
inline const Resources::ResourceId
ResourceLoader::GetId(const Resources::ResourceName& name) const
{
    IndexT i = this->ids.FindIndex(name);
    if (i == InvalidIndex)  return Resources::ResourceId::Invalid();
    else                    return this->resources[this->ids.ValueAtIndex(i)];
}
 
//------------------------------------------------------------------------------
inline const Util::Dictionary<Resources::ResourceName, Ids::Id32>&
ResourceLoader::GetResources() const
{
    return this->ids;
}
 
//------------------------------------------------------------------------------
inline const bool
ResourceLoader::HasResource(const Resources::ResourceId id) const
{
    return this->names.Size() > (SizeT)id.loaderInstanceId;
}
 
//------------------------------------------------------------------------------
inline const int32_t&
ResourceLoader::GetUniqueId() const
{
    return this->uniqueId;
}
 
} // namespace Resources