qssglightmapbaker.cpp

Enable keyboard shortcuts

// Copyright (C) 2025 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

// Qt-Security score:significant reason:default

#include "qssglightmapbaker_p.h"

#ifdef QT_QUICK3D_HAS_LIGHTMAPPER

#include <QGuiApplication>

#include <QString>

#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

#include <QThreadPool>

#include "qssgrendercontextcore.h"

#if QT_CONFIG(opengl)

#include <QOffscreenSurface>

#endif // QT_CONFIG(opengl)

QT_BEGIN_NAMESPACE

struct QSSGLightmapBakerPrivate

    QSSGLightmapBaker::Context ctx;

    std::unique_ptr<QSSGLightmapper> lightmapper = nullptr;

    QSSGLightmapBaker::Status currentStatus = QSSGLightmapBaker::Status::Preparing;

    // Use a local threadpool to be able to set highest thread priority on the bake thread

    QThreadPool localThreadPool;

    QOffscreenSurface *fallbackSurface = nullptr;

    bool waitingForInvoke = false;

};

QSSGLightmapBaker::QSSGLightmapBaker(const QSSGLightmapBaker::Context &ctx)

    : d(new QSSGLightmapBakerPrivate)

    d->ctx = ctx;

    d->currentStatus = QSSGLightmapBaker::Status::Preparing;

    d->localThreadPool.setMaxThreadCount(1);

QSSGLightmapBaker::~QSSGLightmapBaker()

    delete d;

QSSGLightmapBaker::Status QSSGLightmapBaker::process()

    if (d->waitingForInvoke)

        return d->currentStatus;

    auto &env = d->ctx.env;

    auto &settings = d->ctx.settings;

    auto &callbacks = d->ctx.callbacks;

    if (d->currentStatus == Status::Preparing) {

        // We need to prepare for lightmap baking by doing another frame so that

        // we can reload all meshes to use the original one and NOT the baked one.

        // When disableLightmaps is set on the layer, the mesh loader will always load the

        // original mesh and not the lightmap mesh.

        callbacks.setCurrentlyBaking(true);

        callbacks.triggerNewFrame(true);

#if QT_CONFIG(opengl)

        d->waitingForInvoke = true;

        QMetaObject::invokeMethod(qApp, [this]() {

            d->fallbackSurface = QRhiGles2InitParams::newFallbackSurface();

            d->currentStatus = Status::Running;

            d->waitingForInvoke = false;

},

        Qt::QueuedConnection);

#else

        d->currentStatus = Status::Running;

#endif

    } else if (d->currentStatus == Status::Running) {

        d->lightmapper = std::make_unique<QSSGLightmapper>();

        d->lightmapper->setRhiBackend(env.rhiCtx->rhi()->backend());

        d->lightmapper->setOptions(env.lmOptions);

        d->lightmapper->setOutputCallback(callbacks.lightmapBakingOutput);

        d->lightmapper->setDenoiseOnly(settings.denoiseRequested);

        // bakedLightingModels contains all models with

        // usedInBakedLighting: true. These, together with lights that

        // have a bakeMode set to either Indirect or All, form the

        // lightmapped scene. A lightmap is stored persistently only

        // for models that have their lightmapKey set.

        const auto &bakedLightingModels = callbacks.modelsToBake();

        for (int i = 0, ie = bakedLightingModels.size(); i != ie; ++i)

            d->lightmapper->add(bakedLightingModels[i]);

        if (!d->lightmapper->setupLights(*env.renderer)) {

            d->currentStatus = Status::Finished;

            callbacks.setCurrentlyBaking(false);

            callbacks.triggerNewFrame(true);

            if (settings.quitWhenFinished) {

                qDebug("Lightmap baking/denoising done, exiting application");

                QMetaObject::invokeMethod(qApp, "quit");

            return Status::Finished;

        QRhiCommandBuffer *cb = env.rhiCtx->commandBuffer();

        cb->debugMarkBegin("Quick3D lightmap baking/denoising");

        d->currentStatus = Status::Baking;

        const auto bakeTask = [this, callbacks, settings] {

#if QT_CONFIG(thread)

            QThread::currentThread()->setPriority(QThread::HighestPriority);

#endif // QT_CONFIG(thread)

            d->lightmapper->run(d->fallbackSurface);

            callbacks.setCurrentlyBaking(false);

            callbacks.triggerNewFrame(true);

#if QT_CONFIG(opengl)

            d->waitingForInvoke = true;

            QMetaObject::invokeMethod(qApp, [this]() {

                delete d->fallbackSurface;

                d->fallbackSurface = nullptr;

                d->currentStatus = Status::Finished;

                d->waitingForInvoke = false;

            }, Qt::QueuedConnection);

#else

            d->currentStatus = Status::Finished;

#endif

            if (settings.quitWhenFinished) {

                qDebug("Lightmap baking/denoising done, exiting application");

                QMetaObject::invokeMethod(qApp, "quit");

};

#if QT_CONFIG(thread)

        d->localThreadPool.start(bakeTask);

#else

        bakeTask();

#endif // QT_CONFIG(thread)

        // Wait until lightmapper is finished initializing

        d->lightmapper->waitForInit();

        cb->debugMarkEnd();

    return d->currentStatus;

QT_END_NAMESPACE

#else // QT_QUICK3D_HAS_LIGHTMAPPER

QT_BEGIN_NAMESPACE

QSSGLightmapBaker::QSSGLightmapBaker(const QSSGLightmapBaker::Context &ctx)

    qWarning("QSSGLightmapBaker: This build has no lightmap baking support.");

#if defined(qApp)

    if (ctx.settings.quitWhenFinished)

        QMetaObject::invokeMethod(qApp, "quit");

#else

    Q_UNUSED(ctx);

#endif

QSSGLightmapBaker::~QSSGLightmapBaker() = default;

QSSGLightmapBaker::Status QSSGLightmapBaker::process()

    return QSSGLightmapBaker::Status::Finished;

QT_END_NAMESPACE

#endif // QT_QUICK3D_HAS_LIGHTMAPPER