TileAppearance.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
#include "Core/Ecs/Components/Sprite.h"
#include "HMI/Graphics/RenderLayer.h"
#include "HMI/Graphics/RenderMode.h"
#include "HMI/Graphics/SkinCatalog.h"
#include "HMI/Graphics/TileSilhouette.h"
#include "HMI/Graphics/TileSkinTag.h"

 
namespace hmi {

enum class AppearanceSource {
    Atlas,
    MissingTexture,
    Skin,
    Override,
};

struct TileAppearance {
    AppearanceSource source = AppearanceSource::Atlas;
    core::AtlasRegion region{};
    int skinIndex = -1;
};

struct SkinTexture {
    std::string asset;
    std::optional<core::TileType> maskType;
    TextureHandle texture = nullptr;
    int width = 0;
    int height = 0;
    std::optional<core::AtlasRegion> animatedFrame;
};

struct SceneTextures {
    TextureHandle atlas = nullptr;
    int atlasWidth = 0;
    int atlasHeight = 0;
    TextureHandle missing = nullptr;
    int missingWidth = 0;
    int missingHeight = 0;

    TextureHandle characterSheet = nullptr;
    int characterSheetWidth = 0;
    int characterSheetHeight = 0;

    std::vector<SkinTexture> skins;
    const SkinCatalog* skinCatalog = nullptr;
    std::string skinSet;

    std::vector<SkinTexture> objects;

    [[nodiscard]] int skinIndexOf(std::string_view asset, core::TileType type) const noexcept {
        const bool masked = hasSilhouette(type);
        for (std::size_t index = 0; index < skins.size(); ++index) {
            const SkinTexture& skin = skins[index];
            if (skin.asset != asset) {
                continue;
            }
            if (masked ? (skin.maskType == type) : !skin.maskType.has_value()) {
                return static_cast<int>(index);
            }
        }
        return -1;
    }

    [[nodiscard]] int objectIndexOf(std::string_view asset) const noexcept {
        for (std::size_t index = 0; index < objects.size(); ++index) {
            if (objects[index].asset == asset) {
                return static_cast<int>(index);
            }
        }
        return -1;
    }

    [[nodiscard]] TextureHandle textureFor(const TileAppearance& appearance) const noexcept {
        switch (appearance.source) {
            case AppearanceSource::Atlas:
                return atlas;
            case AppearanceSource::MissingTexture:
                return missing;
            case AppearanceSource::Skin:
                return skinAt(appearance.skinIndex) ? skinAt(appearance.skinIndex)->texture
                                                    : missing;
            case AppearanceSource::Override:
                return objectAt(appearance.skinIndex) ? objectAt(appearance.skinIndex)->texture
                                                      : missing;
        }
        return missing;
    }

    [[nodiscard]] int widthFor(const TileAppearance& appearance) const noexcept {
        switch (appearance.source) {
            case AppearanceSource::Atlas:
                return atlasWidth;
            case AppearanceSource::MissingTexture:
                return missingWidth;
            case AppearanceSource::Skin:
                return skinAt(appearance.skinIndex) ? skinAt(appearance.skinIndex)->width
                                                    : missingWidth;
            case AppearanceSource::Override:
                return objectAt(appearance.skinIndex) ? objectAt(appearance.skinIndex)->width
                                                      : missingWidth;
        }
        return missingWidth;
    }

    [[nodiscard]] int heightFor(const TileAppearance& appearance) const noexcept {
        switch (appearance.source) {
            case AppearanceSource::Atlas:
                return atlasHeight;
            case AppearanceSource::MissingTexture:
                return missingHeight;
            case AppearanceSource::Skin:
                return skinAt(appearance.skinIndex) ? skinAt(appearance.skinIndex)->height
                                                    : missingHeight;
            case AppearanceSource::Override:
                return objectAt(appearance.skinIndex) ? objectAt(appearance.skinIndex)->height
                                                      : missingHeight;
        }
        return missingHeight;
    }
 
private:
    // Acces borne au tableau de skins : un index invalide rend nullptr, ce qui fait retomber les
    // accesseurs ci-dessus sur le damier plutot que de lire hors des bornes.
    [[nodiscard]] const SkinTexture* skinAt(int index) const noexcept {
        if (index < 0 || static_cast<std::size_t>(index) >= skins.size()) {
            return nullptr;
        }
        return &skins[static_cast<std::size_t>(index)];
    }
 
    // Meme garde-fou que skinAt, pour le tableau d'objets (EX-EDIT-043, LOT-45).
    [[nodiscard]] const SkinTexture* objectAt(int index) const noexcept {
        if (index < 0 || static_cast<std::size_t>(index) >= objects.size()) {
            return nullptr;
        }
        return &objects[static_cast<std::size_t>(index)];
    }
};

[[nodiscard]] std::optional<TileAppearance> resolveTileAppearance(
    RenderMode mode, const core::AtlasRegion& physicalRegion, const TileSkinTag* tag,
    const SceneTextures& textures, bool skinVisible = true, bool overrideVisible = true) noexcept;

[[nodiscard]] bool animationExcludedForTile(SkinMode mode, core::TileType type) noexcept;
 
}  // namespace hmi