physics_worker.cpp

Go to the documentation of this file.

/**
 * \file physics_worker.cpp
 * \brief Implementation of the worker object that runs the physics simulation
 *        in a separate thread.
 * \author Le Bars, Yoann
 *
 * This file is part of the pure C++ benchmark.
 */
 
#include "physics_worker.hpp"
 
#include <memory>
 
#include "space.hpp"
 
namespace Model {
 
    /**
     * \brief Constructs the physics worker.
     */
    PhysicsWorker::PhysicsWorker(const Configuration::SimulationConfig& config,
                                 QObject* in_parent)
        : QObject(in_parent),
          space_(std::make_unique<Space>(config)),
          iterationCount_(0),
          maxIterations_(config.n_iter),
          isRunning_(false) {
        // Register the custom vector types for use in signals and slots.
        qRegisterMetaType<Vector3dVec>("Model::Vector3dVec");
        qRegisterMetaType<QuaterniondVec>("Model::QuaterniondVec");
    }
 
    /**
     * \brief Destructor. The definition must be in the .cpp file where Space is
     * fully defined.
     */
    PhysicsWorker::~PhysicsWorker() = default;
 
    /**
     * \brief Instructs the `Space` object to print its final profiling
     * report.
     */
    void PhysicsWorker::cleanup() {
        if (space_) {
            space_->printProfilingReport();
        }
    }
 
    /**
     * \brief Provides read-only access to the initial list of body proxies.
     */
    std::vector<ConstBodyProxy> PhysicsWorker::getInitialBodies() const {
        std::vector<ConstBodyProxy> bodies;
        if (space_) {
            bodies.reserve(space_->n());
            for (std::size_t i = 0; i < space_->n(); ++i) {
                bodies.emplace_back(space_->body(i));
            }
        }
        return bodies;
    }
 
    /**
     * \brief Starts the simulation loop.
     */
    void PhysicsWorker::startSimulation() {
        isRunning_ = true;
        iterationCount_ = 0;
        performSingleStep();  // Start the first step.
    }
 
    /**
     * \brief Performs a single step of the physics simulation and emits the
     * results.
     */
    void PhysicsWorker::performSingleStep() {
        if (isRunning_ && iterationCount_ < maxIterations_) {
            space_->computeDynamics(iterationCount_);
 
            Vector3dVec positions;
            QuaterniondVec quaternions;
            Vector3dVec torques;
            Vector3dVec alphas;
            std::tie(positions, quaternions, torques, alphas) =
                space_->getDataForDisplay();
 
            emit updatedBodyData(positions, quaternions, torques,
                                 alphas,            // NOLINT
                                 iterationCount_);  // NOLINT
 
            iterationCount_++;
            if (iterationCount_ >= maxIterations_) {
                emit simulationFinished();
                isRunning_ = false;
            }
        }
    }
    
    void PhysicsWorker::stopSimulation() {
        isRunning_ = false;
    }
 
}  // namespace Model
 
/* The MOC compiler needs to see the implementation of the class that uses
   signals and slots. We include the generated moc file here.
   This explicit inclusion ensures that the Meta-Object Compiler’s output is
   compiled with the rest of the implementation, which is a robust pattern
   for handling Qt’s meta-object system. */
#include "moc_physics_worker.cpp"