ResourceManager.h

#pragma once
 
#include <Core/ResourceManager/Implementation/WorkerTasks.h>
#include <Core/ResourceManager/Resource.h>
#include <Core/ResourceManager/ResourceHandle.h>
#include <Core/ResourceManager/ResourceTypeLoader.h>
#include <Foundation/Configuration/Plugin.h>
#include <Foundation/Containers/HashTable.h>
#include <Foundation/Threading/LockedObject.h>
#include <Foundation/Types/UniquePtr.h>
 
class plResourceManagerState;
 
class PL_CORE_DLL plResourceManager
{
  friend class plResourceManagerState;
  static plUniquePtr<plResourceManagerState> s_pState;
 
 
public:
  static const plEvent<const plResourceEvent&, plMutex>& GetResourceEvents();
 
  static const plEvent<const plResourceManagerEvent&, plMutex>& GetManagerEvents();
 
  static void BroadcastExistsEvent();
 
 
public:
  template <typename ResourceType>
  static plTypedResourceHandle<ResourceType> LoadResource(plStringView sResourceID);
 
  template <typename ResourceType>
  static plTypedResourceHandle<ResourceType> LoadResource(plStringView sResourceID, plTypedResourceHandle<ResourceType> hLoadingFallback);
 
 
  static plTypelessResourceHandle LoadResourceByType(const plRTTI* pResourceType, plStringView sResourceID);
 
  static bool IsAnyLoadingInProgress();
 
  static plString GenerateUniqueResourceID(plStringView sResourceIDPrefix);
 
  template <typename ResourceType, typename DescriptorType>
  static plTypedResourceHandle<ResourceType> CreateResource(plStringView sResourceID, DescriptorType&& descriptor, plStringView sResourceDescription = nullptr);
 
  template <typename ResourceType, typename DescriptorType>
  static plTypedResourceHandle<ResourceType> GetOrCreateResource(plStringView sResourceID, DescriptorType&& descriptor, plStringView sResourceDescription = nullptr);
 
  template <typename ResourceType>
  static plTypedResourceHandle<ResourceType> GetExistingResource(plStringView sResourceID);
 
  static plTypelessResourceHandle GetExistingResourceByType(const plRTTI* pResourceType, plStringView sResourceID);
 
  template <typename ResourceType>
  static plTypedResourceHandle<ResourceType> GetExistingResourceOrCreateAsync(plStringView sResourceID, plUniquePtr<plResourceTypeLoader>&& pLoader, plTypedResourceHandle<ResourceType> hLoadingFallback = {})
  {
    plTypelessResourceHandle hTypeless = GetExistingResourceOrCreateAsync(plGetStaticRTTI<ResourceType>(), sResourceID, std::move(pLoader));
 
    auto hTyped = plTypedResourceHandle<ResourceType>((ResourceType*)hTypeless.m_pResource);
 
    if (hLoadingFallback.IsValid())
    {
      ((ResourceType*)hTypeless.m_pResource)->SetLoadingFallbackResource(hLoadingFallback);
    }
 
    return hTyped;
  }
 
  static plTypelessResourceHandle GetExistingResourceOrCreateAsync(const plRTTI* pResourceType, plStringView sResourceID, plUniquePtr<plResourceTypeLoader>&& pLoader);
 
  static void PreloadResource(const plTypelessResourceHandle& hResource);
 
  static void ForceLoadResourceNow(const plTypelessResourceHandle& hResource);
 
  static plResourceState GetLoadingState(const plTypelessResourceHandle& hResource);
 
 
public:
  static plUInt32 ReloadAllResources(bool bForce);
 
  template <typename ResourceType>
  static plUInt32 ReloadResourcesOfType(bool bForce);
 
  static plUInt32 ReloadResourcesOfType(const plRTTI* pType, bool bForce);
 
  template <typename ResourceType>
  static bool ReloadResource(const plTypedResourceHandle<ResourceType>& hResource, bool bForce);
 
  static bool ReloadResource(const plRTTI* pType, const plTypelessResourceHandle& hResource, bool bForce);
 
 
  static void UpdateResourceWithCustomLoader(const plTypelessResourceHandle& hResource, plUniquePtr<plResourceTypeLoader>&& pLoader);
 
  static void RestoreResource(const plTypelessResourceHandle& hResource);
 
 
public:
  template <typename ResourceType>
  static ResourceType* BeginAcquireResource(const plTypedResourceHandle<ResourceType>& hResource, plResourceAcquireMode mode,
    const plTypedResourceHandle<ResourceType>& hLoadingFallback = plTypedResourceHandle<ResourceType>(),
    plResourceAcquireResult* out_pAcquireResult = nullptr);
 
  static plResource* BeginAcquireResourcePointer(const plRTTI* pType, const plTypelessResourceHandle& hResource);
 
  template <typename ResourceType>
  static void EndAcquireResource(ResourceType* pResource);
 
  static void EndAcquireResourcePointer(plResource* pResource);
 
  static void ForceNoFallbackAcquisition(plUInt32 uiNumFrames = 0xFFFFFFFF);
 
  static plUInt32 GetForceNoFallbackAcquisition();
 
  template <typename ResourceType>
  static plLockedObject<plMutex, plDynamicArray<plResource*>> GetAllResourcesOfType();
 
 
public:
  static plUInt32 FreeAllUnusedResources();
 
  static plUInt32 FreeUnusedResources(plTime timeout, plTime lastAcquireThreshold);
 
  static void SetAutoFreeUnused(plTime timeout, plTime lastAcquireThreshold);
 
  template <typename ResourceType>
  static void SetIncrementalUnloadForResourceType(bool bActive);
 
  template <typename TypeBeingUpdated, typename TypeItWantsToAcquire>
  static void AllowResourceTypeAcquireDuringUpdateContent()
  {
    AllowResourceTypeAcquireDuringUpdateContent(plGetStaticRTTI<TypeBeingUpdated>(), plGetStaticRTTI<TypeItWantsToAcquire>());
  }
 
  static void AllowResourceTypeAcquireDuringUpdateContent(const plRTTI* pTypeBeingUpdated, const plRTTI* pTypeItWantsToAcquire);
 
  static bool IsResourceTypeAcquireDuringUpdateContentAllowed(const plRTTI* pTypeBeingUpdated, const plRTTI* pTypeItWantsToAcquire);
 
private:
  static plResult DeallocateResource(plResource* pResource);
 
 
public:
  static plMutex& GetMutex() { return s_ResourceMutex; }
 
  static void PerFrameUpdate();
 
  static void EngineAboutToShutdown();
 
  static void ResetAllResources();
 
  static void SetResourceLowResData(const plTypelessResourceHandle& hResource, plStreamReader* pStream);
 
 
public:
  static void SetDefaultResourceLoader(plResourceTypeLoader* pDefaultLoader);
 
  static plResourceTypeLoader* GetDefaultResourceLoader();
 
  template <typename ResourceType>
  static void SetResourceTypeLoader(plResourceTypeLoader* pCreator);
 
 
public:
  static void RegisterNamedResource(plStringView sLookupName, plStringView sRedirectionResource);
 
  static void UnregisterNamedResource(plStringView sLookupName);
 
 
 
public:
  static void RegisterResourceForAssetType(plStringView sAssetTypeName, const plRTTI* pResourceType);
 
  static const plRTTI* FindResourceForAssetType(plStringView sAssetTypeName);
 
 
public:
  static void EnableExportMode(bool bEnable);
 
  static bool IsExportModeEnabled();
 
  template <typename ResourceType>
  static plTypedResourceHandle<ResourceType> GetResourceHandleForExport(plStringView sResourceID);
 
 
 
public:
  static void RegisterResourceOverrideType(const plRTTI* pDerivedTypeToUse, plDelegate<bool(const plStringBuilder&)> overrideDecider);
 
  static void UnregisterResourceOverrideType(const plRTTI* pDerivedTypeToUse);
 
 
public:
  template <typename RESOURCE_TYPE>
  static void SetResourceTypeLoadingFallback(const plTypedResourceHandle<RESOURCE_TYPE>& hResource)
  {
    RESOURCE_TYPE::SetResourceTypeLoadingFallback(hResource);
  }
 
  template <typename RESOURCE_TYPE>
  static inline const plTypedResourceHandle<RESOURCE_TYPE>& GetResourceTypeLoadingFallback()
  {
    return RESOURCE_TYPE::GetResourceTypeLoadingFallback();
  }
 
  template <typename RESOURCE_TYPE>
  static void SetResourceTypeMissingFallback(const plTypedResourceHandle<RESOURCE_TYPE>& hResource)
  {
    RESOURCE_TYPE::SetResourceTypeMissingFallback(hResource);
  }
 
  template <typename RESOURCE_TYPE>
  static inline const plTypedResourceHandle<RESOURCE_TYPE>& GetResourceTypeMissingFallback()
  {
    return RESOURCE_TYPE::GetResourceTypeMissingFallback();
  }
 
  using ResourceCleanupCB = plDelegate<void()>;
 
  static void AddResourceCleanupCallback(ResourceCleanupCB cb);
 
  static void ClearResourceCleanupCallback(ResourceCleanupCB cb);
 
  static void ExecuteAllResourceCleanupCallbacks();
 
 
public:
  template <typename RESOURCE_TYPE>
  static void SetResourceTypeDefaultPriority(plResourcePriority priority)
  {
    GetResourceTypePriorities()[plGetStaticRTTI<RESOURCE_TYPE>()] = priority;
  }
 
private:
  static plMap<const plRTTI*, plResourcePriority>& GetResourceTypePriorities();
 
 
private:
  friend class plResource;
  friend class plResourceManagerWorkerDataLoad;
  friend class plResourceManagerWorkerUpdateContent;
  friend class plResourceHandleReadContext;
 
  // Events
private:
  static void BroadcastResourceEvent(const plResourceEvent& e);
 
  // Miscellaneous
private:
  static plMutex s_ResourceMutex;
 
  // Startup / shutdown
private:
  PL_MAKE_SUBSYSTEM_STARTUP_FRIEND(Core, ResourceManager);
  static void OnEngineShutdown();
  static void OnCoreShutdown();
  static void OnCoreStartup();
  static void PluginEventHandler(const plPluginEvent& e);
 
  // Loading / reloading / creating resources
private:
  struct LoadedResources
  {
    plHashTable<plTempHashedString, plResource*> m_Resources;
  };
 
  struct LoadingInfo
  {
    float m_fPriority = 0;
    plResource* m_pResource = nullptr;
 
    PL_ALWAYS_INLINE bool operator==(const LoadingInfo& rhs) const { return m_pResource == rhs.m_pResource; }
    PL_ALWAYS_INLINE bool operator<(const LoadingInfo& rhs) const { return m_fPriority < rhs.m_fPriority; }
  };
  static void EnsureResourceLoadingState(plResource* pResource, const plResourceState RequestedState);
  static void PreloadResource(plResource* pResource);
  static void InternalPreloadResource(plResource* pResource, bool bHighestPriority);
 
  template <typename ResourceType>
  static ResourceType* GetResource(plStringView sResourceID, bool bIsReloadable);
  static plResource* GetResource(const plRTTI* pRtti, plStringView sResourceID, bool bIsReloadable);
  static void RunWorkerTask(plResource* pResource);
  static void UpdateLoadingDeadlines();
  static void ReverseBubbleSortStep(plDeque<LoadingInfo>& data);
  static bool ReloadResource(plResource* pResource, bool bForce);
 
  static void SetupWorkerTasks();
  static plTime GetLastFrameUpdate();
  static plHashTable<const plRTTI*, LoadedResources>& GetLoadedResources();
  static plDynamicArray<plResource*>& GetLoadedResourceOfTypeTempContainer();
 
  PL_ALWAYS_INLINE static bool IsQueuedForLoading(plResource* pResource) { return pResource->m_Flags.IsSet(plResourceFlags::IsQueuedForLoading); }
  [[nodiscard]] static plResult RemoveFromLoadingQueue(plResource* pResource);
  static void AddToLoadingQueue(plResource* pResource, bool bHighPriority);
 
  struct ResourceTypeInfo
  {
    bool m_bIncrementalUnload = true;
    bool m_bAllowNestedAcquireCached = false;
 
    plHybridArray<const plRTTI*, 8> m_NestedTypes;
  };
 
  static ResourceTypeInfo& GetResourceTypeInfo(const plRTTI* pRtti);
 
  // Type loaders
private:
  static plResourceTypeLoader* GetResourceTypeLoader(const plRTTI* pRTTI);
 
  static plMap<const plRTTI*, plResourceTypeLoader*>& GetResourceTypeLoaders();
 
  // Override / derived resources
private:
  struct DerivedTypeInfo
  {
    const plRTTI* m_pDerivedType = nullptr;
    plDelegate<bool(const plStringBuilder&)> m_Decider;
  };
 
  static const plRTTI* FindResourceTypeOverride(const plRTTI* pRtti, plStringView sResourceID);
};
 
#include <Core/ResourceManager/Implementation/ResourceLock.h>
#include <Core/ResourceManager/Implementation/ResourceManager_inl.h>