display.hpp

Go to the documentation of this file.

#ifndef DISPLAY_HPP
#define DISPLAY_HPP
 
/**
 * \file display.hpp
 * \brief Displaying spherical moving bodies.
 * \author Laurent, Jules
 * \author Le Bars, Yoann
 * \ingroup UIRendering
 *
 * This file is part of the pure C++ benchmark.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program. If not, see <https://www.gnu.org/licenses/>.
 */
 
#include <QPointer>
#include <QThread>
#include <QTimer>
#include <QVector3D>
#include <Qt3DExtras/QForwardRenderer>
#include <Qt3DExtras/QOrbitCameraController>
#include <Qt3DExtras/Qt3DWindow>
#include <Qt3DRender/QCamera>
#include <cstddef>
#include <tuple>
#include <vector>
 
#include "config.hpp"
#include "constants.hpp"
#include "pcg_random.hpp"
#include "physics_worker.hpp"
 
namespace Window {
    /**
     * \brief Manages the Qt3D window, scene setup, and the main simulation
     *        loop.
     *
     * This class orchestrates the 3D rendering and the physics worker thread.
     * \ingroup UIRendering
     */
    class Display : public Qt3DExtras::Qt3DWindow {
        Q_OBJECT
 
       public:
        /**
         * \brief A tuple to hold the Qt-specific components for a single
         * rendered body.
         */
        using BodyInformations = std::tuple<  // NOLINT
            QPointer<Qt3DCore::QEntity>, QPointer<Qt3DCore::QTransform>,
            QPointer<Qt3DCore::QEntity>, QPointer<Qt3DCore::QTransform>,
            QPointer<Qt3DCore::QEntity>, QPointer<Qt3DCore::QTransform>>;
        /**
         * \brief Initialise the 3D window and set up the scene.
         *
         * \param config The simulation configuration object.
         */
        explicit Display(const Configuration::SimulationConfig& config)
            : iterationCount_(0),
              maxIterations_(config.n_iter),
              cleanupCalled_(false) {
            showTorqueArrow_ = config.show_torque_arrow;
            showAlphaArrow_ = config.show_alpha_arrow;
            defaultFrameGraph()->setClearColor(QColor(0, 0, 0));
 
            // --- Camera Setup ---
            camera()->lens()->setPerspectiveProjection(45., 16. / 9., 0.1,
                                                       100000.);
            camera()->setPosition(QVector3D(0, 0, 820));
            camera()->setViewCenter(QVector3D(0, 0, 0));
            rootEntity_ = std::make_unique<Qt3DCore::QEntity>();
 
            // --- Physics Worker and Thread Setup ---
            physicsThread_ = new QThread(this);
            physicsWorker_ = new Model::PhysicsWorker(config);
            physicsWorker_->moveToThread(physicsThread_);
 
            // Connect signals from the worker to slots in this (GUI) thread.
            connect(physicsThread_, &QThread::started, physicsWorker_,
                    &Model::PhysicsWorker::startSimulation);
            connect(physicsWorker_, &Model::PhysicsWorker::updatedBodyData,
                    this, &Display::updateFrame, Qt::QueuedConnection);
            connect(physicsWorker_, &Model::PhysicsWorker::simulationFinished,
                    this, &Display::simulationFinished);  // NOLINT
 
            // --- Simulation Timer Setup ---
            // Create a reusable timer that will drive the simulation loop.
            // This is more efficient than using QTimer::singleShot() for each
            // frame.
            simulationTimer_ = new QTimer(this);
            connect(simulationTimer_, &QTimer::timeout, physicsWorker_,
                    &Model::PhysicsWorker::performSingleStep);
            // Stop the timer when the simulation finishes
            connect(physicsWorker_, &Model::PhysicsWorker::simulationFinished,
                    simulationTimer_, &QTimer::stop, Qt::QueuedConnection);
 
            // --- Scene Creation ---
            createScene(config.seed);
 
            // --- Camera Controller Setup ---
            camController_ =
                new Qt3DExtras::QOrbitCameraController(rootEntity_.get());
            camController_->setLinearSpeed(50);
            camController_->setLookSpeed(180);
            camController_->setCamera(camera());
 
            // Set the root entity for the scene.
            setRootEntity(rootEntity_.get());
        }
 
        /// \brief Destructor to ensure worker thread is cleaned up.
        ~Display() override;
 
        /// \brief Performs cleanup actions, such as printing profiling reports.
        void cleanup();
 
        /// \brief Starts the physics simulation by starting the worker thread.
        void runSimulation();
 
       signals:
        /**
         * \brief Emitted when the simulation has run for n_iter iterations.
         */
        void simulationFinished();
 
       private slots:
        /**
         * \brief Slot to receive updated data from the physics worker and
         * update the scene.
         */
        void updateFrame(const Model::Vector3dVec& positions,
                         const Model::QuaterniondVec& quaternions,
                         const Model::Vector3dVec& torques,  // NOLINT
                         const Model::Vector3dVec& alphas,   // NOLINT
                         std::size_t iteration);             // NOLINT
 
       private:
        /// \brief The current iteration count.
        std::size_t iterationCount_;
 
        /// \brief Maximum number of iterations.
        std::size_t maxIterations_;
 
        /// \brief Flag to display torque vectors in the UI.
        bool showTorqueArrow_;
 
        /// \brief Flag to display angular acceleration vectors in the UI.
        bool showAlphaArrow_;
 
        /// \brief The root entity for the 3D scene.
        std::unique_ptr<Qt3DCore::QEntity> rootEntity_;
 
        /// \brief Mouse camera controller.
        QPointer<Qt3DExtras::QOrbitCameraController> camController_;
 
        /**
         * \brief List of spheres representing bodies. This list differs from
         * the actual physical bodies in the simulation.
         */
        std::vector<BodyInformations> bodies_;
 
        /// \brief The worker object running the simulation.
        /// Uses QPointer for safety: it becomes nullptr if the object is
        /// destroyed.
        QPointer<Model::PhysicsWorker> physicsWorker_;
 
        /// \brief The thread where the physics worker runs.
        /// Created with 'this' as parent, so Qt manages its lifetime.
        QThread* physicsThread_;
 
        /// \brief Timer to drive the simulation loop.
        /// Reused timer that triggers physics steps automatically.
        QTimer* simulationTimer_;
 
        /// \brief Flag to track if cleanup has already been called.
        /// This prevents cleanup from being called multiple times.
        bool cleanupCalled_;
 
        /**
         * \brief Create and set up the spherical bodies in the scene.
         *
         * \param gen A seeded random number generator for reproducible body
         *            colours.
         */
        void createSpheres(Rng::Pcg32& gen);
 
        /**
         * \brief Set up the scene.
         *
         * \param seed The seed for the random number generator.
         */
        void createScene(unsigned int seed);
 
        /**
         * \brief Creates a 3D arrow entity for vector visualization.
         * \param parent The parent entity.
         * \param colour The colour of the arrow.
         * \param radius The radius of the arrow's shaft.
         * \param length The initial length of the arrow.
         * \return A tuple containing the arrow's root entity and its
         * transform component.
         */
        std::pair<Qt3DCore::QEntity*, Qt3DCore::QTransform*> createArrowEntity(
            Qt3DCore::QEntity* parent, const QColor& colour, float radius,
            float length);
 
        /**
         * \brief Updates the transform of an arrow entity to represent a 3D
         * vector.
         * \param arrowTransform The transform component of the arrow to update.
         * \param vector The 3D vector to visualise.
         * \param scaleFactor A multiplier for the arrow's length.
         */
        void updateVectorArrow(Qt3DCore::QTransform* arrowTransform,
                               const Model::Vector3d& vector,
                               double scaleFactor) const;
    };
}
 
#endif  // DISPLAY_HPP