SpriteRenderer.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 <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <DirectXMath.h>
 
#include "Core/Ecs/Components/Animation.h"
#include "Core/Levels/Level.h"
#include "Core/Levels/Plane.h"
#include "HMI/Graphics/BackgroundRenderer.h"
#include "HMI/Graphics/ComposedScene.h"
#include "HMI/Graphics/PlaneVisuals.h"
#include "HMI/Graphics/SkinCatalog.h"
#include "HMI/Graphics/SpriteBatch.h"

 
namespace core {
class World;
}  // namespace core
 
namespace hmi {
 
class Camera2D;
class TextureAtlas;
class TextureCache;

void submitComposedScene(SpriteBatch& batch, const DirectX::XMFLOAT4X4& projection,
                         const ComposedScene& scene);

inline const std::string SKINS_SUBDIRECTORY = "Skins/";

void advanceTileAnimations(const SkinCatalog* skins, const std::string& skinSet,
                           TextureCache& cache, float deltaSeconds,
                           std::unordered_map<std::string, core::Animation>& tileAnimations,
                           std::set<std::string>& warnedExclusions);

inline const std::string BACKGROUNDS_SUBDIRECTORY = "Backgrounds/";

inline const std::string OBJECTS_SUBDIRECTORY = "Objects/";

[[nodiscard]] SceneTextures sceneTextures(
    const TextureAtlas& atlas, TextureCache& cache, const SkinCatalog* skins = nullptr,
    const std::string& skinSet = {},
    const std::vector<core::TileTextureOverride>& textureOverrides = {},
    const std::unordered_map<std::string, core::Animation>& tileAnimations = {});

[[nodiscard]] BackgroundTexture resolveBackgroundTexture(
    const std::optional<std::string>& background, TextureCache& cache);

class SpriteRenderer {
public:
    SpriteRenderer(SpriteBatch& batch, const TextureAtlas& atlas, TextureCache& cache);

    void render(core::World& world, const Camera2D& camera, RenderMode mode,
                float interpolationAlpha, const std::optional<std::string>& background = {},
                int levelWidth = 0, int levelHeight = 0,
                const std::vector<core::TileTextureOverride>& textureOverrides = {},
                const std::unordered_map<std::string, core::Animation>& tileAnimations = {},
                const std::vector<core::Plane>& planes = {}, bool planeParallax = false,
                const core::TileMap* doorCollision = nullptr);

    void setPlanesDirectory(std::filesystem::path directory) {
        _planesDirectory = std::move(directory);
    }

    [[nodiscard]] const ComposedScene& lastScene() const noexcept {
        return _scene;
    }

    void setSkins(const SkinCatalog* skins, std::string skinSet = {}) {
        _skins = skins;
        _skinSet = std::move(skinSet);
    }
 
private:
    void logStatisticsIfChanged();

    std::filesystem::path _planesDirectory;
    SpriteBatch* _batch;                  // non possédé
    const TextureAtlas* _atlas;           // non possédé
    TextureCache* _cache;                 // non possédé
    const SkinCatalog* _skins = nullptr;  // non possédé
    std::string _skinSet;
    ComposedScene _scene;
    SceneStatistics _loggedStatistics;
};
 
}  // namespace hmi