ComposedScene.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "Core/Math/Rect.h"
#include "HMI/Graphics/LayerVisibility.h"
#include "HMI/Graphics/Quad.h"
#include "HMI/Graphics/RenderLayer.h"
#include "HMI/Graphics/RenderMode.h"
#include "HMI/Graphics/TileAppearance.h"

 
namespace core {
class World;
}
 
namespace hmi {

enum class QuadKind {
    Sprite,
    Line,
};

struct ComposedQuad {
    RenderLayer layer = DEFAULT_RENDER_LAYER;
    TextureHandle texture = nullptr;
    int textureRank = 0;
    std::int32_t sortOrder = 0;
    QuadKind kind = QuadKind::Sprite;
    SpriteQuad sprite{};
    LineQuad line{};
};

inline constexpr float DEPTH_SUBDIVISIONS_PER_UNIT = 16.0f;

[[nodiscard]] std::int32_t depthSortOrder(float footWorldY) noexcept;

struct SceneStatistics {
    int considered = 0;
    int culled = 0;
    int submitted = 0;
    int batches = 0;
    std::size_t textureBytes = 0;
};

class ComposedScene {
public:
    static constexpr float CULLING_MARGIN_UNITS = 1.0f;

    void clear() noexcept;

    void setVisibleBounds(const core::Rect& worldBounds) noexcept;

    void clearVisibleBounds() noexcept;

    [[nodiscard]] bool isCullingEnabled() const noexcept {
        return _visibleBounds.has_value();
    }

    [[nodiscard]] core::Rect cullingBounds() const noexcept;

    bool addSprite(RenderLayer layer, TextureHandle texture, std::int32_t sortOrder,
                   const SpriteQuad& quad);

    bool addLine(RenderLayer layer, TextureHandle texture, std::int32_t sortOrder,
                 const LineQuad& quad);

    void addTextureBytes(std::size_t bytes) noexcept;

    void sort();

    [[nodiscard]] const std::vector<ComposedQuad>& quads() const noexcept {
        return _quads;
    }

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

    [[nodiscard]] int batchCount() const noexcept;

    [[nodiscard]] SceneStatistics statistics() const noexcept;
 
private:
    [[nodiscard]] int textureRank(TextureHandle texture);
    [[nodiscard]] bool isVisible(const core::Rect& bounds) const;
 
    std::vector<ComposedQuad> _quads;
    std::vector<TextureHandle> _textureOrder;
    std::optional<core::Rect> _visibleBounds;
    int _considered = 0;
    int _culled = 0;
    std::size_t _textureBytes = 0;
};

[[nodiscard]] std::string formatSceneStatistics(const SceneStatistics& statistics);

[[nodiscard]] core::Rect spriteQuadBounds(const SpriteQuad& quad) noexcept;

[[nodiscard]] core::Rect lineQuadBounds(const LineQuad& quad) noexcept;

void composeWorldSprites(ComposedScene& scene, core::World& world, RenderMode mode,
                         const SceneTextures& textures, float interpolationAlpha,
                         const LayerVisibility& visibility = LayerVisibility{});
 
}  // namespace hmi