display.cpp

Go to the documentation of this file.

/**
 * \file display.cpp
 * \brief Implements the Qt3D window for displaying spherical moving bodies.
 * \author Laurent, Jules
 * \author Le Bars, Yoann
 *
 * 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 "display.hpp"
 
#include <QApplication>
#include <QColor>
#include <QTimer>
#include <QVector3D>
#include <Qt3DCore/QEntity>
#include <Qt3DCore/QTransform>
#include <Qt3DExtras/QConeMesh>
#include <Qt3DExtras/QCylinderMesh>
#include <Qt3DExtras/QDiffuseSpecularMaterial>
#include <Qt3DExtras/QSphereMesh>
#include <Qt3DExtras/Qt3DWindow>  // NOLINT
#include <chrono>
#include <random>
 
#include "app_profiler.hpp"
#include "pcg_random.hpp"
#include "space.hpp"
 
Window::Display::~Display() {
    // Ensure the thread is properly shut down before Qt destroys it.
    // The thread was created with 'this' as parent, so Qt will destroy it
    // automatically when Display is destroyed. However, we must ensure it's
    // stopped first to avoid issues.
    if (physicsThread_ && physicsThread_->isRunning()) {
        physicsThread_->quit();
        physicsThread_->wait();  // Wait for the thread to finish.
    }
 
    // No explicit deletion needed:
    // - physicsThread_ is destroyed by Qt (parent = this)
    // - physicsWorker_ is destroyed by Qt (parent = thread after moveToThread)
    // - QPointer automatically becomes nullptr when the object is destroyed
}
 
std::pair<Qt3DCore::QEntity*, Qt3DCore::QTransform*>
Window::Display::createArrowEntity(Qt3DCore::QEntity* parent,
                                   const QColor& colour, float radius,
                                   float length) {
    auto* arrowEntity = new Qt3DCore::QEntity(parent);
    auto* arrowTransform = new Qt3DCore::QTransform(arrowEntity);
 
    // --- Material ---
    auto* material = new Qt3DExtras::QDiffuseSpecularMaterial(arrowEntity);
    material->setAmbient(colour);
 
    // --- Shaft (Cylinder) ---
    auto* shaftEntity = new Qt3DCore::QEntity(arrowEntity);
    auto* shaftMesh = new Qt3DExtras::QCylinderMesh();
    shaftMesh->setRadius(radius);
    shaftMesh->setLength(length);
    auto* shaftTransform = new Qt3DCore::QTransform();
    // The cylinder is oriented along the Y-axis by default. We rotate it to
    // align with Z.
    shaftTransform->setRotationX(90);
    shaftEntity->addComponent(shaftMesh);
    shaftEntity->addComponent(shaftTransform);
    shaftEntity->addComponent(material);
 
    // --- Head (Cone) ---
    auto* headEntity = new Qt3DCore::QEntity(arrowEntity);
    auto* headMesh = new Qt3DExtras::QConeMesh();
    headMesh->setTopRadius(0);
    headMesh->setBottomRadius(radius * 2.5f);
    headMesh->setLength(radius * 5.0f);
    auto* headTransform = new Qt3DCore::QTransform();
    headTransform->setTranslation(QVector3D(0, 0, length));
    headTransform->setRotationX(90);
    headEntity->addComponent(headMesh);
    headEntity->addComponent(headTransform);
    headEntity->addComponent(material);
 
    // The arrow entity itself will be scaled and rotated to match the vector.
    arrowEntity->addComponent(arrowTransform);
    arrowEntity->setEnabled(false);  // Initially hidden
 
    return {arrowEntity, arrowTransform};
}
 
/**
 * \brief Create and set up the spherical bodies in the scene.
 */
void Window::Display::createSpheres(Rng::Pcg32& gen) {
    // Hue in [0, 1) for vibrant, distinct colours (HSV, aligned with Python).
    std::uniform_real_distribution<> hueDis(0.0, 1.0);
 
    bodies_.resize(physicsWorker_->getInitialBodies().size());
 
    for (std::size_t i = 0; i < bodies_.size(); ++i) {
        // Create an entity for each body. It is parented to the root entity,
        // so its lifetime is managed by the root.
        auto* entity = new Qt3DCore::QEntity(rootEntity_.get());
 
        // Mesh (the shape). Parented to the entity.
        auto* mesh = new Qt3DExtras::QSphereMesh(entity);  // NOLINT
        mesh->setRadius(physicsWorker_->getInitialBodies()[i].r());
 
        // Transform (position, rotation, scale). Parented to the entity.
        auto* transform = new Qt3DCore::QTransform(entity);  // NOLINT
 
        // Create a unique material for each sphere (HSV: saturation 0.9, value
        // 0.95).
        const QColor randomColour = QColor::fromHsvF(hueDis(gen), 0.9, 0.95);
        auto* colouredMaterial =  // NOLINT
            new Qt3DExtras::QDiffuseSpecularMaterial(entity);
 
        // Attach components to the entity *before* configuring them. This
        // ensures Qt's backend fully owns the components before their
        // properties are modified, which can prevent race conditions with the
        // render thread.
        entity->addComponent(mesh);
        entity->addComponent(transform);
        entity->addComponent(colouredMaterial);
 
        // Now that the component is part of the scene graph, configure it.
        colouredMaterial->setDiffuse(randomColour);
        colouredMaterial->setShininess(200);
        colouredMaterial->setAmbient(randomColour.darker(110));
        // Save every new sphere to a body list with its parameters.
 
        // Create visualisers for torque and angular acceleration
        auto [torqueArrowEntity, torqueArrowTransform] =
            createArrowEntity(entity, QColor("magenta"), 0.5f, 10.0f);
        auto [alphaArrowEntity, alphaArrowTransform] =
            createArrowEntity(entity, QColor("cyan"), 0.5f, 10.0f);
 
        bodies_[i] = std::make_tuple(
            QPointer<Qt3DCore::QEntity>(entity), QPointer(transform),
            QPointer<Qt3DCore::QEntity>(torqueArrowEntity),
            QPointer<Qt3DCore::QTransform>(torqueArrowTransform),
            QPointer<Qt3DCore::QEntity>(alphaArrowEntity),
            QPointer<Qt3DCore::QTransform>(alphaArrowTransform));
    }
}
 
/**
 * \brief Set up the scene.
 */
void Window::Display::createScene(unsigned int seed) {
    // Use std::random_device to get a non-deterministic seed if none is
    // provided.
    Rng::Pcg32 gen(seed == 0 ? std::random_device{}() : seed);
    createSpheres(gen);
}
 
/**
 * \brief Starts the physics simulation by starting the worker thread.
 */
void Window::Display::runSimulation() {
    // Start the physics thread. The thread's `started` signal will trigger the
    // first simulation step. The simulation timer will then take over to drive
    // subsequent steps.
    physicsThread_->start();
    // Start the timer with 0ms interval (triggers as soon as possible)
    // This timer will automatically call performSingleStep() repeatedly
    simulationTimer_->start(0);
}
 
/**
 * \brief Performs cleanup actions, such as printing profiling reports.
 */
void Window::Display::cleanup() {
    using CleanupClock = std::chrono::high_resolution_clock;
    auto phaseStart = CleanupClock::now();
 
    // Prevent cleanup from being called multiple times
    if (cleanupCalled_) {
        return;
    }
    cleanupCalled_ = true;
 
    // CRITICAL: Stop the simulation timer FIRST to prevent new steps from being
    // scheduled
    if (simulationTimer_) {
        simulationTimer_->stop();
    }
 
    // CRITICAL: Disconnect all signals FIRST to prevent updateFrame from being
    // called This must be done before stopping the simulation to avoid race
    // conditions We check the return value of disconnect() to handle cases
    // where signals are already disconnected (more robust, similar to Python's
    // try/except pattern)
    if (physicsWorker_) {
        // Disconnect updatedBodyData signal (ignore if already disconnected)
        disconnect(physicsWorker_, &Model::PhysicsWorker::updatedBodyData, this,
                   &Display::updateFrame);
        // Disconnect simulationFinished signal (ignore if already disconnected)
        disconnect(physicsWorker_, &Model::PhysicsWorker::simulationFinished,
                   this, &Display::simulationFinished);
        // Disconnect simulationFinished from timer (if connected)
        if (simulationTimer_) {
            disconnect(physicsWorker_,
                       &Model::PhysicsWorker::simulationFinished,
                       simulationTimer_, &QTimer::stop);
        }
        // Stop the simulation loop to prevent new steps from being scheduled
        physicsWorker_->stopSimulation();
    }
 
    // Disconnect thread started signal (if connected)
    if (physicsThread_) {
        disconnect(physicsThread_, &QThread::started, physicsWorker_,
                   &Model::PhysicsWorker::startSimulation);
    }
 
    // Disconnect timer timeout signal (if connected)
    if (simulationTimer_) {
        disconnect(simulationTimer_, &QTimer::timeout, physicsWorker_,
                   &Model::PhysicsWorker::performSingleStep);
    }
    AppUtils::AppProfiler::addCleanupDisplayPrep(
        std::chrono::duration<double>(CleanupClock::now() - phaseStart)
            .count());
 
    // Process any pending events to ensure all queued signals are handled
    phaseStart = CleanupClock::now();
    QApplication::processEvents(QEventLoop::ExcludeUserInputEvents);
    AppUtils::AppProfiler::addCleanupDisplayProcessEvents(
        std::chrono::duration<double>(CleanupClock::now() - phaseStart)
            .count());
 
    // Stop the physics thread before cleanup
    // This ensures the thread is stopped before the worker is cleaned up
    phaseStart = CleanupClock::now();
    if (physicsThread_ && physicsThread_->isRunning()) {
        physicsThread_->quit();
        physicsThread_->wait(
            5000);  // Wait up to 5 seconds for thread to finish
    }
    AppUtils::AppProfiler::addCleanupDisplayThreadStop(
        std::chrono::duration<double>(CleanupClock::now() - phaseStart)
            .count());
 
    // Now cleanup the worker (prints profiling report)
    phaseStart = CleanupClock::now();
    if (physicsWorker_) {
        physicsWorker_->cleanup();
    }
    AppUtils::AppProfiler::addCleanupDisplayWorkerCleanup(
        std::chrono::duration<double>(CleanupClock::now() - phaseStart)
            .count());
}
 
void Window::Display::updateVectorArrow(Qt3DCore::QTransform* arrowTransform,
                                        const Model::Vector3d& vector,
                                        double scaleFactor) const {
    if (!arrowTransform) {
        return;
    }
 
    const double magnitudeSq = vector.squaredNorm();
    if (magnitudeSq < Model::EPSILON * Model::EPSILON) {
        static_cast<Qt3DCore::QEntity*>(arrowTransform->parent())
            ->setEnabled(false);
        return;
    }
 
    static_cast<Qt3DCore::QEntity*>(arrowTransform->parent())->setEnabled(true);
 
    // The arrow is created along the Z-axis. We need to find the rotation
    // that aligns the Z-axis with our target vector.
    const QVector3D zAxis(0.0f, 0.0f, 1.0f);
    const QVector3D targetVector(static_cast<float>(vector.x()),
                                 static_cast<float>(vector.y()),
                                 static_cast<float>(vector.z()));
 
    const QQuaternion rotation =
        QQuaternion::rotationTo(zAxis, targetVector.normalized());
 
    arrowTransform->setRotation(rotation);
    arrowTransform->setScale3D(QVector3D(
        1.0f, 1.0f, static_cast<float>(std::sqrt(magnitudeSq) * scaleFactor)));
}
 
void Window::Display::updateFrame(const Model::Vector3dVec& positions,
                                  const Model::QuaterniondVec& quaternions,
                                  const Model::Vector3dVec& torques,
                                  const Model::Vector3dVec& alphas,  // NOLINT
                                  std::size_t iteration) {
    AppUtils::AppProfiler::startFrameRender();
    /* Update each body's transform based on the new state. */
    for (std::size_t i = 0; i < bodies_.size(); ++i) {
        auto& transform = std::get<1>(bodies_[i]);
        if (transform) {
            transform->setTranslation({static_cast<float>(positions[i].x()),
                                       static_cast<float>(positions[i].y()),
                                       static_cast<float>(positions[i].z())});
            transform->setRotation({static_cast<float>(quaternions[i].w()),
                                    static_cast<float>(quaternions[i].x()),
                                    static_cast<float>(quaternions[i].y()),
                                    static_cast<float>(quaternions[i].z())});
        }
 
        if (showTorqueArrow_) {
            updateVectorArrow(std::get<3>(bodies_[i]), torques[i],
                              Model::TORQUE_ARROW_SCALE);
        } else {
            std::get<2>(bodies_[i])->setEnabled(false);
        }
 
        if (showAlphaArrow_) {
            updateVectorArrow(std::get<5>(bodies_[i]), alphas[i],
                              Model::ALPHA_ARROW_SCALE);
        } else {
            std::get<4>(bodies_[i])->setEnabled(false);
        }
    }
 
    iterationCount_ = iteration + 1;
    // The simulation timer automatically drives the next physics step.
    // No need to schedule manually - the timer will trigger performSingleStep()
    // as soon as the event loop is free (0ms interval).
    AppUtils::AppProfiler::stopFrameRender();
}
 
// Include the MOC-generated file for this class.
// This ensures the compiler sees the definitions for signals and slots.
#include "moc_display.cpp"