TextureCache.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <filesystem>
#include <optional>
#include <string>
 
#include "Core/Levels/TileType.h"
#include "HMI/Graphics/AnimationCatalog.h"
#include "HMI/Graphics/AssetContract.h"
#include "HMI/Graphics/AssetPaths.h"
#include "HMI/Graphics/CacheRegistry.h"
#include "HMI/Graphics/RhiContext.h"
#include "HMI/Graphics/TextureLoader.h"
#include "HMI/Graphics/TileSilhouette.h"

 
namespace hmi {

class TextureCache {
public:
    TextureCache(const RhiContext& context, AssetPaths paths);
 
    TextureCache(const TextureCache&) = delete;
    TextureCache& operator=(const TextureCache&) = delete;

    [[nodiscard]] const LoadedTexture* get(const std::string& fileName, AssetFamily family);

    [[nodiscard]] const LoadedTexture* getMasked(const std::string& fileName, AssetFamily family,
                                                 core::TileType type);

    [[nodiscard]] const AnimationDescription* getAnimation(const std::string& fileName,
                                                           int textureWidth, int textureHeight);

    [[nodiscard]] const LoadedTexture* getFromPath(const std::filesystem::path& path);

    void invalidate(const std::string& fileName);

    void invalidateAll();

    [[nodiscard]] std::size_t entryCount() const noexcept {
        return _entries.size();
    }

    [[nodiscard]] const LoadedTexture* missingTexture();

    [[nodiscard]] const AssetPaths& assetPaths() const noexcept {
        return _paths;
    }
 
private:
    [[nodiscard]] std::optional<LoadedTexture> load(
        const std::string& fileName, AssetFamily family,
        std::optional<core::TileType> maskType = std::nullopt) const;

    [[nodiscard]] const LoadedTexture* getUnderKey(const std::string& cacheKey,
                                                   const std::string& fileName, AssetFamily family,
                                                   std::optional<core::TileType> maskType);

    [[nodiscard]] std::optional<AnimationDescription> loadAnimation(const std::string& fileName,
                                                                    int textureWidth,
                                                                    int textureHeight) const;
 
    const RhiContext& _context;  // possédé par le viewport
    AssetPaths _paths;
    CacheRegistry<LoadedTexture> _entries;
    CacheRegistry<AnimationDescription> _animationEntries;
    std::optional<LoadedTexture> _missingTexture;
};

[[nodiscard]] const LoadedTexture* resolveOrPlaceholder(TextureCache& cache,
                                                        const std::string& fileName,
                                                        AssetFamily family);
 
}  // namespace hmi