Asset.h

Go to the documentation of this file.

#pragma once
#include "Engine/Logging/TracyMacros.hpp"
#include <optional>
#include <cstdint>
#include <entt/entt.hpp>
#include <unordered_map>
#include <Engine/Ecs/RegistryManager.h>

namespace Asset
{
    enum CpuLoadingState : uint8_t {
        UNLOADED = 0,
        REQUESTED_LOAD = 1,
        LOADING = 2,
        LOADED = 3
    };

    class AssetBase
    {
    public:
        explicit AssetBase(bool initializeDefaultEntity = false) :
            loadingState( initializeDefaultEntity ? LOADING : UNLOADED )
          , mainRegistry( Ecs::RegistryManager::get() )
          , data( initializeDefaultEntity ? mainRegistry.create() : entt::null )
        {
        };
        virtual ~AssetBase();

        [[nodiscard]] CpuLoadingState getLoadingState();

        void requestLoad();

        virtual void unload();

        entt::entity getEntity() const;
 
    protected:
        virtual void updateLoadingState()
        {
        }
        CpuLoadingState loadingState = UNLOADED;
 
        entt::registry& mainRegistry;
        entt::entity data;
    };
 
    inline AssetBase::~AssetBase()
    {
        AssetBase::unload();
    }
 
    inline CpuLoadingState AssetBase::getLoadingState()
    {
        updateLoadingState();
        return loadingState;
    }
 
    inline void AssetBase::requestLoad()
    {
        loadingState = REQUESTED_LOAD;
        data = mainRegistry.create();
    }
 
    inline void AssetBase::unload()
    {
        if (data != entt::null)
            mainRegistry.destroy(data);
        loadingState = (UNLOADED);
    }
 
    inline entt::entity AssetBase::getEntity() const
    {
        return data;
    }

    template <typename Key, typename AssetClass>
    class AssetManager {
    public:
        AssetManager() = default;
        virtual ~AssetManager() = default;

        template <typename... Args>
        void declare( Key path, Args &&... args );
        void add(Key path, AssetClass* asset);

        bool exists(Key path);

        bool isDeclared(Key path);

        CpuLoadingState getAssetLoadingState(const Key& path);
        std::optional<AssetClass*> getAsset(const Key& path);

        virtual void clear();

        template<typename Func>
        void forEachAsset(Func&& func) const {
            for (const auto& [key, asset] : assets) {
                if (asset != nullptr) {
                    func(key, asset);
                }
            }
        }
 
    private:
        std::unordered_map<Key, AssetClass*> assets;
    };
 
    template<typename Key, typename AssetClass>
    template<typename... Args>
    void AssetManager<Key, AssetClass>::declare(Key path, Args&&... args) {
        assets[path] = new AssetClass(std::forward<Args>(args)...);
    }
 
    template<typename Key, typename AssetClass>
    void AssetManager<Key, AssetClass>::add(Key path, AssetClass *asset) {
        TRACY_ZONE_SCOPED_NAMED( "Added Asset to Asset Manager" );
        assert(asset != nullptr); // use declare for that
        assets[path] = asset;
    }
 
    template<typename Key, typename AssetClass>
    bool AssetManager<Key, AssetClass>::exists(Key path) {
        return assets.contains(path) && assets[path] != nullptr;
    }
 
    template <typename Key, typename AssetClass>
    bool AssetManager<Key, AssetClass>::isDeclared( Key path )
    {
        return assets.contains(path);
    }
 
    template <typename Key, typename AssetClass>
    CpuLoadingState AssetManager<Key, AssetClass>::getAssetLoadingState(const Key& path) {
        if (!assets.contains(path)) return UNLOADED;
        if (assets.contains(path) && assets[path] == nullptr) return LOADING;
        return assets[path]->getLoadingState();
    }
 
    template<typename Key, typename AssetClass>
    std::optional<AssetClass *> AssetManager<Key, AssetClass>::getAsset(const Key& path) {
        TRACY_ZONE_SCOPED_NAMED("Retrieve Asset");
        if (!assets.contains(path)) return std::nullopt;
        return assets[path];
    }
 
    template <typename Key, typename AssetClass>
    void AssetManager<Key, AssetClass>::clear()
    {
        TRACY_ZONE_SCOPED_NAMED( "Unloading data" );
        for (auto& asset : assets)
        {
            TRACY_ZONE_SCOPED_NAMED("Deleting loaded data");
            delete asset.second;
            asset.second = nullptr;
        }
        assets.clear();
    }
}  // namespace Asset