GameViewport.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Valentin Eloy
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
#include <QRhiWidget>
#include <QString>
#include <chrono>
#include <filesystem>
#include <memory>
#include <optional>
#include <utility>
#include <vector>
 
#include "Core/Levels/GridPosition.h"
#include "Core/Levels/LevelDraft.h"
#include "Core/Levels/TileType.h"
#include "Core/Math/Rect.h"
#include "Core/Time/FixedTimestep.h"
#include "HMI/Editor/EditContextTarget.h"
#include "HMI/Editor/EditorTool.h"
#include "HMI/Game/DiagnosticsHud.h"
#include "HMI/Game/GameSession.h"
#include "HMI/Graphics/Camera2D.h"
#include "HMI/Graphics/LayerVisibility.h"
#include "HMI/Graphics/PlaneVisibility.h"
#include "HMI/Graphics/RenderMode.h"
#include "HMI/Graphics/SceneResources.h"
#include "HMI/Graphics/SkinCatalog.h"
#include "HMI/Input/EditorKeyBindings.h"
#include "HMI/Input/GameKeyBindings.h"
#include "HMI/Input/GamepadBindings.h"
#include "HMI/Input/GamepadPoller.h"
#include "HMI/Input/InputState.h"

 
namespace hmi {
class SpriteBatch;
class TextureAtlas;
class TextureCache;
class DraftRenderer;
class Localization;
class BitmapFont;
class AudioEngine;
}  // namespace hmi
 
namespace hmi {

class GameViewport : public QRhiWidget, public EditContextTarget {
    Q_OBJECT
 
public:
    explicit GameViewport(QWidget* parent = nullptr);
    ~GameViewport() override;
 
    GameViewport(const GameViewport&) = delete;
    GameViewport& operator=(const GameViewport&) = delete;

    void setActiveTile(core::TileType type) noexcept {
        _activeTile = type;
    }

    void setActiveTextureAsset(std::optional<std::string> asset) noexcept {
        _activeTextureAsset = std::move(asset);
    }

    void setTool(hmi::EditorTool tool);

    void setLocalization(const Localization* loc) noexcept {
        _loc = loc;
    }

    void setAudioEngine(AudioEngine* engine) noexcept {
        _audioEngine = engine;
    }

    [[nodiscard]] hmi::GameKeyBindings& gameBindings() noexcept {
        return _gameBindings;
    }

    [[nodiscard]] hmi::GamepadBindings& gamepadBindings() noexcept {
        return _gamepadBindings;
    }

    [[nodiscard]] hmi::EditorKeyBindings& editorBindings() noexcept {
        return _editorBindings;
    }

    void save();

    void openLevel(const std::filesystem::path& path);

    [[nodiscard]] bool isDirty() const noexcept {
        return _dirty;
    }

    bool renameOpenLevel(const std::string& newName);

    void startPlaytest();

    void undo() override;
    void redo() override;
    [[nodiscard]] bool canUndo() const override {
        return _draft.canUndo();
    }

    [[nodiscard]] bool canRedo() const override {
        return _draft.canRedo();
    }

    void copy() override {
        copySelection();
    }

    void paste() override {
        pasteClipboard();
    }

    [[nodiscard]] bool canCopy() const override {
        return _selection.has_value();
    }

    [[nodiscard]] bool canPaste() const override {
        return !_clipboard.empty();
    }

    void toggleGrid() noexcept;
    void resetCamera() noexcept;
    void toggleRenderMode();

    void toggleDiagnosticsOverlay() noexcept;


    [[nodiscard]] bool diagnosticsOverlayEnabled() const noexcept {
        return _diagnosticsEnabled;
    }

    void setDiagnosticsOverlayEnabled(bool enabled) noexcept;

    void startGame(std::filesystem::path map);

    void pauseSimulation() noexcept;
    void resumeSimulation();
    [[nodiscard]] bool simulationPaused() const noexcept {
        return _paused;
    }

    void quitGame() noexcept;

    void setVSync(bool enabled) noexcept;
    [[nodiscard]] bool vsyncEnabled() const noexcept {
        return _vsync;
    }

    void resizeLevel(int width, int height);

    [[nodiscard]] bool wouldResizeDrop(int width, int height) const;

    [[nodiscard]] int levelWidth() const;
    [[nodiscard]] int levelHeight() const;

    [[nodiscard]] const core::LevelDraft& draft() const noexcept {
        return _draft;
    }

    [[nodiscard]] std::optional<std::size_t> selectedPlaneIndex() const noexcept {
        return _selectedPlane;
    }

    [[nodiscard]] const PlaneVisibility& planeVisibility() const noexcept {
        return _planeVisibility;
    }

    [[nodiscard]] std::optional<core::GridPosition> hoveredCell() const noexcept {
        return _hoverCell;
    }

    [[nodiscard]] float zoom() const noexcept {
        return _camera.zoom();
    }

    [[nodiscard]] EditorTool activeTool() const noexcept {
        return _tool;
    }

    void setHighlightedLink(std::optional<std::pair<core::GridPosition, core::GridPosition>> link);

    void unlinkMechanism(core::GridPosition targetPosition);

    void removeTextureOverride(core::GridPosition position);

    void setHighlightedTextureOverride(std::optional<core::GridPosition> position);

    void setLevelBackground(std::optional<std::string> background);

    void setLevelSkinSet(std::optional<std::string> skinSet);

    void setLevelCameraFraming(core::CameraFramingConfig cameraFraming);

    void removeCameraZone(std::size_t index);

    [[nodiscard]] RenderMode renderMode() const noexcept {
        return _renderMode;
    }

    [[nodiscard]] const LayerVisibility& layerVisibility() const noexcept {
        return _layerVisibility;
    }

    void setLayerVisible(RenderLayer layer, bool visible) noexcept {
        _layerVisibility.setVisible(layer, visible);
    }

    void showAllLayers() noexcept {
        _layerVisibility.showAll();
    }

    [[nodiscard]] SkinCatalog& skinCatalog() noexcept {
        return _scene.skins();
    }

    void setSkinSet(const std::string& setName);

    void reloadAssets();

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

    void setRenderMode(RenderMode mode);

    void selectPlane(std::optional<std::size_t> index);
    void addPlane(core::Plane plane);
    void removePlane(std::size_t index);
    void movePlane(std::size_t index, bool forward);
    void setPlaneDepth(std::size_t index, core::PlaneDepth depth);
    void setPlaneDensity(std::size_t index, int pixelsPerUnit);
    void setPlaneParallax(std::size_t index, float parallaxX, float parallaxY);
    void setPlaneOpacity(std::size_t index, float opacity);
    void setLevelParallaxEnabled(bool enabled);
    void setPlaneVisible(std::size_t index, bool visible);
    void setPlaneIsolated(std::size_t index, bool isolate);
 
signals:
    void statusMessage(const QString& message);
    void exitToMenuRequested();
    void pauseRequested();
    void draftChanged();
    void renderModeChanged(RenderMode mode);
    void toolChanged(hmi::EditorTool tool);
    void planeSelectionChanged(std::optional<std::size_t> index);
    void hoveredCellChanged(std::optional<core::GridPosition> cell);
    void zoomChanged(float zoom);
    void resourcesReady();
 
protected:
    void initialize(QRhiCommandBuffer* commandBuffer) override;
    void render(QRhiCommandBuffer* commandBuffer) override;
    void releaseResources() override;
    bool event(QEvent* event) override;
    void keyPressEvent(QKeyEvent* event) override;
    void keyReleaseEvent(QKeyEvent* event) override;
    void mousePressEvent(QMouseEvent* event) override;
    void mouseReleaseEvent(QMouseEvent* event) override;
    void mouseMoveEvent(QMouseEvent* event) override;
    void wheelEvent(QWheelEvent* event) override;
 
private:
    void createResources();
    void tick(float elapsedSeconds);
    void renderFrame(QRhiCommandBuffer* commandBuffer, float deltaSeconds);
    void renderDiagnosticsOverlay(int viewportWidth, int viewportHeight);
    void stopPlaytest();  
    void loadGameMap();   
    void updateMousePosition(const QMouseEvent* event);

    void updateEditCamera();
    [[nodiscard]] core::Vector2 screenPosition(const QMouseEvent* event) const;
    [[nodiscard]] float minManualZoom() const;
    [[nodiscard]] float maxManualZoom() const;
    [[nodiscard]] std::optional<core::GridPosition> cellAt(const QMouseEvent* event);
    [[nodiscard]] core::GridPosition clampedCell(const QMouseEvent* event);
    void paintAt(const QMouseEvent* event);
    void applyRectangle(core::GridPosition a, core::GridPosition b);
    void addCameraZoneFromDrag(core::GridPosition a, core::GridPosition b);
    void copySelection();
    void pasteClipboard();
    [[nodiscard]] std::optional<std::pair<core::GridPosition, core::GridPosition>> highlight()
        const;
    void handleLinkClick(const QMouseEvent* event);
    void handleTextureAssignClick(const QMouseEvent* event, bool rightClick);
    [[nodiscard]] core::Vector2 worldPositionAt(const QMouseEvent* event);
    [[nodiscard]] bool linkExists(core::GridPosition switchPosition,
                                  core::GridPosition targetPosition) const;
    void markDraftMutated();
 
    [[nodiscard]] int pixelWidth() const;
    [[nodiscard]] int pixelHeight() const;

    [[nodiscard]] QString statusText(const char* key) const;
 
    using Clock = std::chrono::steady_clock;

    hmi::SceneResources _scene;
    std::unique_ptr<hmi::DraftRenderer> _draftRenderer;
    std::string _skinSet;
    hmi::GameKeyBindings _gameBindings;
    hmi::GamepadBindings _gamepadBindings;
    hmi::EditorKeyBindings _editorBindings;  
    hmi::InputState _input;
    hmi::GamepadPoller _gamepad;
    core::FixedTimestep _timestep;
    Clock::time_point _previousFrame;
    bool _loopStarted = false;

    bool _diagnosticsEnabled = false;
    hmi::FrameRateAverage _frameRateAverage;
    int _lastSimulationSteps = 0;
    hmi::ComposedScene _diagnosticsScene;
 
    core::LevelDraft _draft;  
    hmi::Camera2D _camera;    
    bool _manualCamera = false;
    float _manualZoom = 1.0f;       
    core::Vector2 _manualCenter{};  
    bool _rightDragging = false;    
    bool _cameraPanned = false;
    core::Vector2 _rightDragLastScreen{};  
    core::TileType _activeTile = core::TileType::Solid;  
    std::optional<std::string> _activeTextureAsset;
    std::optional<std::size_t> _selectedPlane;
    hmi::PlaneVisibility _planeVisibility;
    hmi::EditorTool _tool = hmi::EditorTool::Paint;  
    bool _painting = false;             
    bool _dragging = false;             
    core::GridPosition _dragStart{};    
    core::GridPosition _dragCurrent{};  
    std::optional<core::GridPosition> _hoverCell;
    float _lastEmittedZoom =
        0.0f;  
    const Localization* _loc = nullptr;  
    AudioEngine* _audioEngine = nullptr;
 
    std::optional<std::pair<core::GridPosition, core::GridPosition>> _selection;
    std::optional<core::GridPosition> _pendingLink;
    std::optional<std::pair<core::GridPosition, core::GridPosition>> _selectedLink;
    std::optional<core::GridPosition> _highlightedOverride;
    std::vector<std::vector<core::TileType>> _clipboard;
    bool _dirty = false;    
    bool _showGrid = true;  
    RenderMode _renderMode = DEFAULT_RENDER_MODE;
    LayerVisibility _layerVisibility;
    bool _vsync = true;      
    bool _gameMode = false;  
    bool _paused = false;
    std::filesystem::path _gameMap;  

    std::optional<hmi::GameSession> _session;
};
 
}  // namespace hmi