physics_worker.hpp

Go to the documentation of this file.

#ifndef PHYSICS_WORKER_HPP
#define PHYSICS_WORKER_HPP
 
/**
 * \file physics_worker.hpp
 * \brief Worker object to run the physics simulation in a separate thread.
 * \author Le Bars, Yoann
 *
 * This file is part of the pure C++ benchmark.
 */
 
#include <QObject>
#include <QVector>
#include <tuple>
 
#include "body.hpp"
#include "config.hpp"
 
Q_DECLARE_METATYPE(Model::Vector3dVec);
Q_DECLARE_METATYPE(Model::QuaterniondVec);
 
namespace Model {
    // Forward-declare Space to avoid including the full header.
    class Space;
 
    /**
     * \brief Runs the physics simulation in a separate thread to keep the UI
     *        responsive.
     *
     * This worker object owns the `Space` instance and communicates with the
     * main (GUI) thread via signals and slots.
     * \ingroup PhysicsCore
     */
    class PhysicsWorker : public QObject {
        Q_OBJECT
 
       public:
        /**
         * \brief Constructs the physics worker.
         *
         * \param config The simulation configuration.
         * \param in_parent The parent QObject, if any.
         */
        explicit PhysicsWorker(const Configuration::SimulationConfig& config,
                               QObject* in_parent = nullptr);
 
        /// \brief Destructor.
        ~PhysicsWorker() override;
 
        /**
         * \brief Triggers cleanup tasks before the worker is destroyed.
         *
         * This is primarily used to instruct the `Space` object to print its
         * final profiling report.
         */
        void cleanup();
 
        /**
         * \brief Provides read-only access to the initial list of body
         * proxies.
         * \return A vector of const proxies to the initially created bodies.
         */
        [[nodiscard]] std::vector<ConstBodyProxy> getInitialBodies() const;
 
       signals:
        /**
         * \brief Emitted after each simulation step with the updated state of
         * all bodies.
         * \param positions A vector of all body positions.
         * \param quaternions A vector of all body orientations.
         * \param torques A vector of all body torques.
         * \param alphas A vector of all body angular accelerations.
         * \param iteration The current simulation iteration number.
         */
        void updatedBodyData(const Vector3dVec& positions,
                             const QuaterniondVec& quaternions,
                             const Vector3dVec& torques,  // NOLINT
                             const Vector3dVec& alphas,   // NOLINT
                             std::size_t iteration);
 
        /// \brief Emitted when the simulation has completed all iterations.
        void simulationFinished();
 
       public slots:
        /**
         * \brief Starts the simulation loop.
         *
         * This slot is connected to the QThread's `started` signal.
         */
        void startSimulation();
        /**
         * \brief Performs a single step of the physics simulation and emits the
         * results.
         */
        void performSingleStep();
        
        /**
         * \brief Stops the simulation loop.
         * This should be called before cleanup to prevent new steps from being scheduled.
         */
        void stopSimulation();
 
       private:
        /// \brief The simulation space containing all bodies and physics logic.
        std::unique_ptr<Space> space_;
        /// \brief The current simulation iteration count.
        std::size_t iterationCount_;
        /// \brief The maximum number of iterations to run.
        std::size_t maxIterations_;
        /// \brief A flag to control the execution of the simulation loop.
        bool isRunning_;
    };
}  // namespace Model
 
#endif  // PHYSICS_WORKER_HPP