AssetSystem.h

#pragma once
 
#include "Systems/ComponentSystem.h"
 
#include "Components/Core/AssetComponent.h"
 
#include "Resources/Asset.h"
#include "Scene/GetBounds.h"
 
#include "Context.h"
 
#include "DynamicComponentSystem.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
 
namespace Cogs::Core
{
  class AssetBounds final : public IGetBounds {
  public:
    explicit AssetBounds(AssetSystem* assetSystem) : assetSystem(assetSystem) {}
 
    void getBounds(Context* context, Cogs::Geometry::BoundingBox& bounds) override;
    bool getBounds(Context* context, const ComponentModel::Entity* entity, Cogs::Geometry::BoundingBox& bounds, bool ignoreVisibility) const override;
 
  private:
    AssetSystem* assetSystem = nullptr;
  };
 
  class AssetData
  {
  public:
    AssetData() = default;
    AssetData(const AssetData & other) = delete;
 
    bool hasChanged(const AssetHandle & asset) const
    {
      return this->asset != asset || (asset && !isGeneration(static_cast<uint8_t>(asset->getGeneration())));
    }
 
    void setAsset(AssetHandle asset)
    {
      this->asset = asset;
      setGeneration(asset ? static_cast<uint8_t>(asset->getGeneration()) : 0);
    }
 
    void setGeneration(uint8_t generation) { this->generation = generation; }
    bool isGeneration(uint8_t generation) const { return this->generation == generation; }
 
    AssetHandle asset;
    std::shared_ptr<struct AssetInstanceData> instanceData;
 
  private:
    uint8_t generation = 0;
  };
 
  struct AssetModelRequest
  {
      StringView path;
      struct AssetInstanceData* assetInstance = nullptr;
 
      uint32_t priority = 0;          
      uint32_t modelFileIndex = 0;
 
      ModelHandle model;
 
      bool canceled = false;
  };
 
  class COGSCORE_DLL_API AssetSystem : public ComponentSystemWithDataPools<AssetComponent, AssetData>
  {
    using base = Cogs::Core::ComponentSystemWithDataPools<AssetComponent, AssetData>;
  public:
    AssetSystem(Memory::Allocator * allocator, SizeType capacity);
    ~AssetSystem() override;
 
    void initialize(Context * context) override;
    void update(Context * context) override;
    void postUpdate(Context * context) override;
 
    ComponentHandle createComponent() override;
    void destroyComponent(ComponentHandle component) override;
 
    const struct AssetInstanceStats * getStats(AssetComponent * assetComponent) const;
    const Geometry::BoundingBox * getLocalBounds(AssetComponent * assetComponent) const;
    Geometry::BoundingBox getWorldBounds(AssetComponent* assetComponent, bool ignoreVisibility) const;
    std::span<const AssetModelRequest* const> getPendingRequests() const;
    std::span<const AssetModelRequest* const> getInFlightRequests() const;
 
  private:
    std::unique_ptr<AssetBounds> bounds;
    std::unique_ptr<struct AssetSystemData> systemData;
  };
}