ResourceBase.h

#pragma once
 
#include "IResourceManager.h"
#include "Utilities/Strings.h"
 
#include "Foundation/Platform/Atomic.h"
 
namespace Cogs::Core
{
  struct RenderResource;
 
  enum class ActivationResult : uint16_t
  {
    Success = 0x0001,
    Failure = 0x0002,
    Postponed = 0x0004,
    Delayed = 0x0008,
  };
 
  enum class ResourceFlags : uint32_t
  {
    None = 0,
    Initialized = 1 << 0,
    Queued = 1 << 1,
    Loading = 1 << 2,
    Loaded = 1 << 3,
    Changed = 1 << 4,
    Active = 1 << 5,
    Resident = 1 << 6,
    Static = 1 << 7,
    Orphaned = 1 << 8,
    Deleted = 1 << 9,
    Locked = 1 << 10,
    Dependency = 1 << 11,
    Watched = 1 << 12,
    Error = 1 << 13,
    FailedLoad = 1 << 14,
    FailedActivation = 1 << 15,
    Proxy = 1 << 16,
    KeepStorage = 1 << 17,
  };
 
  ENABLE_ENUM_FLAGS(ResourceFlags);
 
  enum class ResourceTypes : uint32_t
  {
    Unknown = 0,
    Asset,
    Model,
    Texture,
    Effect,
    Material,
    MaterialInstance,
    Mesh,
    Buffer,
    Font,
    Gui
  };
 
  enum class ResourceError : uint32_t
  {
    None = 0,
  };
 
  struct COGSCORE_DLL_API ResourceInfo
  {
    StringRef name = NoString;
 
    StringRef source = NoString;
 
    ResourceId id = NoResourceId;
 
    ResourceTypes type = ResourceTypes::Unknown;
 
    ResourceError error = ResourceError::None;
  };
 
  struct COGSCORE_DLL_API ResourceBase
  {
    const static uint32_t NoAttachment = 0xFFFFFFFF;
 
    ResourceBase() = default;
 
    ResourceBase(const ResourceBase & other) = delete;
 
    ResourceBase & operator=(const ResourceBase & other) = delete;
 
    ResourceBase(ResourceBase && other);
 
    ResourceBase & operator=(ResourceBase && other);
 
    ~ResourceBase()
    {
      // To ensure we will not leak rendering resources, make sure any attachments are removed.
      assert(!attachment && "Attachment still present when destructing resource.");
    }
 
    void setInitialized() { setFlag(ResourceFlags::Initialized); }
 
    void setChanged()
    {
      if (hasChanged()) return;
 
      setInitialized();
      incrementGeneration();
 
      flags |= static_cast<uint32_t>(ResourceFlags::Changed);
 
      if (owner) {
        owner->resourceChanged(this);
      }
    }
 
    bool hasChanged() const { return (flags & static_cast<uint32_t>(ResourceFlags::Changed)) != 0; }
 
    void setLoading() { setFlag(ResourceFlags::Loading); }
    void setLoaded() { setFlag(ResourceFlags::Loaded); }
    void setFailedLoad() { setFlag(ResourceFlags::FailedLoad); }
    void setActive() { setFlag(ResourceFlags::Active); }
    void setResident() { setFlag(ResourceFlags::Active | ResourceFlags::Resident); }
    void setProxy() { setFlag(ResourceFlags::Proxy); }
    void setKeepStorage() { setFlag(ResourceFlags::KeepStorage); }
 
    [[nodiscard]] bool isInitialized() const { return isSet(ResourceFlags::Initialized); }
    [[nodiscard]] bool isLoaded() const { return isSet(ResourceFlags::Loaded); }
    [[nodiscard]] bool isActive() const { return isSet(ResourceFlags::Active); }
    [[nodiscard]] bool isResident() const { return isSet(ResourceFlags::Resident); }
    [[nodiscard]] bool isDependency() const { return isSet(ResourceFlags::Dependency); }
    [[nodiscard]] bool isDeleted() const { return isSet(ResourceFlags::Deleted) && isSet(ResourceFlags::Orphaned); }
    [[nodiscard]] bool isOrphaned() const { return isSet(ResourceFlags::Orphaned); }
    [[nodiscard]] bool isProxy() const { return isSet(ResourceFlags::Proxy); }
 
    [[nodiscard]] bool hasFailedLoad() const { return isSet(ResourceFlags::FailedLoad); }
    [[nodiscard]] bool hasFailedActivation() const { return isSet(ResourceFlags::FailedActivation); }
 
    [[nodiscard]] bool keepStorage() const { return isSet(ResourceFlags::KeepStorage); }
 
    void setType(ResourceTypes type) { info->type = type; }
 
    [[nodiscard]] ResourceTypes getType() const { return info ? info->type : ResourceTypes::Unknown; }
 
    void setId(ResourceId resourceId)
    {
      assert(info);
      assert(info->id == NoResourceId || resourceId == info->id);
 
      info->id = resourceId;
    }
 
    ResourceId getId() const { return info ? info->id : NoResourceId; }
 
    void setFlag(ResourceFlags flags) { this->flags |= static_cast<uint32_t>(flags); }
    void setFlags(ResourceFlags flags) { this->flags |= static_cast<uint32_t>(flags); }
 
    void unsetFlag(ResourceFlags flag) { this->flags &= static_cast<uint32_t>(~flag); }
 
    bool isSet(ResourceFlags flag) const { return (this->flags & static_cast<uint32_t>(flag)) == static_cast<uint32_t>(flag); }
 
    ResourceFlags getFlags() const { return static_cast<ResourceFlags>(this->flags.load()); }
 
    void attachResource(RenderResource * attachment) { this->attachment = attachment; }
 
    bool hasAttachedResource() const { return this->attachment != nullptr; }
 
    RenderResource * getAttachedResource() const { return this->attachment; }
 
    void setOwner(IResourceManager * owner) { this->owner = owner; }
 
    IResourceManager * getOwner() const { return owner; }
 
    void setName(const StringView & name) { if (!info) return; info->name = Strings::add(name); }
 
    StringView getName() const { return info ? Strings::get(info->name) : StringView{}; }
 
    void setSource(const StringView & source) { if (!info) return; info->source = Strings::add(source); }
    StringView getSource() const { return info ? Strings::get(info->source) : StringView{}; }
 
    void increment()
    {
      if (++usage == 1 && isSet(ResourceFlags::Orphaned)) {
        unsetFlag(ResourceFlags::Orphaned);
      }
    }
 
    void decrement()
    {
      assert(usage.load() > 0 && "Reference count already at zero. Cannot decrement.");
 
      if (!--usage) {
        setFlag(ResourceFlags::Orphaned);
 
        if (owner) {
          owner->resourceDeleted(this);
        }
      }
    }
 
    uint32_t referenceCount() const { return usage.load(); }
 
    void incrementGeneration()
    {
      ++generation;
    }
 
    uint32_t getGeneration() const { return generation; }
 
    void setSlot(uint32_t slot) { this->slot = slot; }
 
    uint32_t getSlot() const { return slot; }
 
  private:
    void setInfo(ResourceInfo * info) { this->info = info; }
 
    Atomic<uint32_t> usage{ 0 };
 
    Atomic<uint32_t> flags = static_cast<uint32_t>(ResourceFlags::None);
 
    struct RenderResource * attachment = nullptr;
 
    ResourceInfo * info = nullptr;
 
    IResourceManager * owner = nullptr;
 
    uint32_t slot = 0xFFFFFFFF;
 
    uint32_t generation = 0;
 
    template<typename U>
    friend struct ResourcePool;
 
    friend class ResourceManagerBase;
  };
}