Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquick3dcubemaptexture_p.h"
#include "qquick3dscenerenderer_p.h"
#include "qquick3dsceneenvironment_p.h"
#include "qquick3dobject_p.h"
#include "qquick3dnode_p.h"
#include "qquick3dscenemanager_p.h"
#include "qquick3dtexture_p.h"
#include "qquick3dcamera_p.h"
#include "qquick3dpickresult_p.h"
#include "qquick3dmodel_p.h"
#include "qquick3drenderstats_p.h"
#include "qquick3ddebugsettings_p.h"
#include "qquick3dskymaterial_p.h"
#include "extensions/qquick3drenderextensions.h"
#include <QtQuick3DUtils/private/qquick3dprofiler_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrendererutil_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderer_p.h>
#include <QtQuick/private/qquickwindow_p.h>
#include <QtQuick/private/qsgdefaultrendercontext_p.h>
#include <QtQuick/private/qsgtexture_p.h>
#include <QtQuick/private/qsgplaintexture_p.h>
#include <QtQuick/private/qsgrendernode_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrendereffect_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrhieffectsystem_p.h>
#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrhiquadrenderer_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrhicontext_p.h>
#include <QtQuick3DRuntimeRender/private/qssgcputonemapper_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderroot_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderskymaterial_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderuserpass_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrendercommands_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
#include <QtQuick3DUtils/private/qssgassert_p.h>
#include <qtquick3d_tracepoints_p.h>
#include <QtCore/QObject>
#include <QtCore/qqueue.h>
QT_BEGIN_NAMESPACE
Q_TRACE_PREFIX(qtquick3d,
"QT_BEGIN_NAMESPACE" \
"class QQuick3DViewport;" \
"QT_END_NAMESPACE"
)
Q_TRACE_POINT(qtquick3d, QSSG_prepareFrame_entry, int width, int height);
Q_TRACE_POINT(qtquick3d, QSSG_prepareFrame_exit);
Q_TRACE_POINT(qtquick3d, QSSG_renderFrame_entry, int width, int height);
Q_TRACE_POINT(qtquick3d, QSSG_renderFrame_exit);
Q_TRACE_POINT(qtquick3d, QSSG_synchronize_entry, QQuick3DViewport *view3D, const QSize &size, float dpr);
Q_TRACE_POINT(qtquick3d, QSSG_synchronize_exit);
Q_TRACE_POINT(qtquick3d, QSSG_renderPass_entry, const QString &renderPass);
Q_TRACE_POINT(qtquick3d, QSSG_renderPass_exit);
static bool dumpRenderTimes()
{
static bool val = (qEnvironmentVariableIntValue("QT_QUICK3D_DUMP_RENDERTIMES") > 0);
return val;
}
#if QT_CONFIG(qml_debug)
static inline quint64 statDrawCallCount(const QSSGRhiContextStats &stats)
{
quint64 count = 0;
const QSSGRhiContextStats::PerLayerInfo &info(stats.perLayerInfo[stats.layerKey]);
for (const auto &pass : info.renderPasses)
count += QSSGRhiContextStats::totalDrawCallCountForPass(pass);
count += QSSGRhiContextStats::totalDrawCallCountForPass(info.externalRenderPass);
return count;
}
#define STAT_PAYLOAD(stats) \
(statDrawCallCount(stats) | (quint64(stats.perLayerInfo[stats.layerKey].renderPasses.size()) << 32))
#endif
template <typename In, typename Out>
static void bfs(In *inExtension, QList<Out *> &outList)
{
QSSG_ASSERT(inExtension, return);
QQueue<In *> queue { { inExtension } };
while (queue.size() > 0) {
if (auto cur = queue.dequeue()) {
if (auto *ext = static_cast<Out *>(QQuick3DObjectPrivate::get(cur)->spatialNode))
outList.push_back(ext);
for (auto &chld : cur->childItems())
queue.enqueue(qobject_cast<In *>(chld));
}
}
}
SGFramebufferObjectNode::SGFramebufferObjectNode()
: window(nullptr)
, renderer(nullptr)
, renderPending(true)
, invalidatePending(false)
, devicePixelRatio(1)
{
qsgnode_set_description(this, QStringLiteral("fbonode"));
setFlag(QSGNode::UsePreprocess, true);
}
SGFramebufferObjectNode::~SGFramebufferObjectNode()
{
delete renderer;
delete texture();
}
void SGFramebufferObjectNode::scheduleRender()
{
renderPending = true;
markDirty(DirtyMaterial);
}
QSGTexture *SGFramebufferObjectNode::texture() const
{
return QSGSimpleTextureNode::texture();
}
void SGFramebufferObjectNode::preprocess()
{
render();
}
// QQuickWindow::update() behaves differently depending on whether it's called from the GUI thread
// or the render thread.
// TODO: move this to QQuickWindow::fullUpdate(), if we can't change update()
static void requestFullUpdate(QQuickWindow *window)
{
if (QThread::currentThread() == QCoreApplication::instance()->thread())
window->update();
else
QCoreApplication::postEvent(window, new QEvent(QEvent::Type(QQuickWindowPrivate::FullUpdateRequest)));
}
void SGFramebufferObjectNode::render()
{
if (renderPending) {
if (renderer->renderStats())
renderer->renderStats()->startRender();
renderPending = false;
if (renderer->m_sgContext->rhiContext()->isValid()) {
QRhiTexture *rhiTexture = renderer->renderToRhiTexture(window);
bool needsNewWrapper = false;
if (!texture() || (texture()->textureSize() != renderer->surfaceSize()
|| texture()->rhiTexture() != rhiTexture))
{
needsNewWrapper = true;
}
if (needsNewWrapper) {
delete texture();
QSGPlainTexture *t = new QSGPlainTexture;
t->setOwnsTexture(false);
t->setHasAlphaChannel(true);
t->setTexture(rhiTexture);
t->setTextureSize(renderer->surfaceSize());
setTexture(t);
}
}
markDirty(QSGNode::DirtyMaterial);
emit textureChanged();
if (renderer->renderStats())
renderer->renderStats()->endRender(dumpRenderTimes());
if (renderer->m_requestedFramesCount > 0) {
scheduleRender();
requestFullUpdate(window);
renderer->m_requestedFramesCount--;
}
}
}
void SGFramebufferObjectNode::handleScreenChange()
{
if (!qFuzzyCompare(window->effectiveDevicePixelRatio(), devicePixelRatio)) {
renderer->invalidateFramebufferObject();
quickFbo->update();
}
}
QQuick3DSceneRenderer::QQuick3DSceneRenderer(const std::shared_ptr<QSSGRenderContextInterface> &rci)
: m_sgContext(rci)
{
}
QQuick3DSceneRenderer::~QQuick3DSceneRenderer()
{
const auto &rhiCtx = m_sgContext->rhiContext();
auto *rhi = rhiCtx->rhi();
rhi->finish(); // finish active readbacks
QSSGRhiContextStats::get(*rhiCtx).cleanupLayerInfo(m_layer);
m_sgContext->bufferManager()->releaseResourcesForLayer(m_layer);
if (m_layer) {
// The uniform buffer for the tonemapping/blit quad is keyed on the layer.
if (rhiCtx->isValid())
QSSGRhiContextPrivate::get(rhiCtx.get())->cleanupDrawCallDataForCid(m_layer);
// The scene root is created by the scene manager and released by the normal cleanup of
// scene nodes. Since we delete the layer at a later point, detach the scene root from the
// layer now. QSSGRenderNode::removeChild() ignores a node that is no longer a child of
// the layer, so this is safe even if the scene manager has already cleaned up (and
// unlinked) the scene root.
if (m_sceneRootNode)
removeNodeFromLayer(m_sceneRootNode);
m_sceneRootNode = nullptr;
// There might be nodes queued for cleanup that still reference the layer,
// so we schedule the layer for cleanup so that it is deleted after the nodes
// have been cleaned up.
if (winAttacment)
winAttacment->queueForCleanup(m_layer);
else
delete m_layer;
m_layer = nullptr;
}
delete m_texture;
releaseAaDependentRhiResources();
delete m_effectSystem;
}
void QQuick3DSceneRenderer::releaseAaDependentRhiResources()
{
const auto &rhiCtx = m_sgContext->rhiContext();
if (!rhiCtx->isValid())
return;
delete m_textureRenderTarget;
m_textureRenderTarget = nullptr;
delete m_textureRenderPassDescriptor;
m_textureRenderPassDescriptor = nullptr;
delete m_depthStencilBuffer;
m_depthStencilBuffer = nullptr;
delete m_multiViewDepthStencilBuffer;
m_multiViewDepthStencilBuffer = nullptr;
delete m_msaaRenderBufferLegacy;
m_msaaRenderBufferLegacy = nullptr;
delete m_msaaRenderTexture;
m_msaaRenderTexture = nullptr;
delete m_msaaMultiViewRenderBuffer;
m_msaaMultiViewRenderBuffer = nullptr;
delete m_ssaaTexture;
m_ssaaTexture = nullptr;
delete m_ssaaTextureToTextureRenderTarget;
m_ssaaTextureToTextureRenderTarget = nullptr;
delete m_ssaaTextureToTextureRenderPassDescriptor;
m_ssaaTextureToTextureRenderPassDescriptor = nullptr;
delete m_temporalAATexture;
m_temporalAATexture = nullptr;
delete m_temporalAARenderTarget;
m_temporalAARenderTarget = nullptr;
delete m_temporalAARenderPassDescriptor;
m_temporalAARenderPassDescriptor = nullptr;
delete m_prevTempAATexture;
m_prevTempAATexture = nullptr;
}
// Blend factors are in the form of (frame blend factor, accumulator blend factor)
static const QVector2D s_ProgressiveAABlendFactors[QSSGLayerRenderData::MAX_AA_LEVELS] = {
QVector2D(0.500000f, 0.500000f), // 1x
QVector2D(0.333333f, 0.666667f), // 2x
QVector2D(0.250000f, 0.750000f), // 3x
QVector2D(0.200000f, 0.800000f), // 4x
QVector2D(0.166667f, 0.833333f), // 5x
QVector2D(0.142857f, 0.857143f), // 6x
QVector2D(0.125000f, 0.875000f), // 7x
QVector2D(0.111111f, 0.888889f), // 8x
};
static const QVector2D s_TemporalAABlendFactors = { 0.5f, 0.5f };
QRhiTexture *QQuick3DSceneRenderer::renderToRhiTexture(QQuickWindow *qw)
{
if (!m_layer)
return nullptr;
QRhiTexture *currentTexture = m_texture; // the result so far
if (qw) {
if (m_renderStats)
m_renderStats->startRenderPrepare();
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DPrepareFrame);
QSSGRhiContext *rhiCtx = m_sgContext->rhiContext().get();
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
rhiCtxD->setMainRenderPassDescriptor(m_textureRenderPassDescriptor);
rhiCtxD->setRenderTarget(m_textureRenderTarget);
QRhiCommandBuffer *cb = nullptr;
QRhiSwapChain *swapchain = qw->swapChain();
if (swapchain) {
cb = swapchain->currentFrameCommandBuffer();
rhiCtxD->setCommandBuffer(cb);
} else {
QSGRendererInterface *rif = qw->rendererInterface();
cb = static_cast<QRhiCommandBuffer *>(
rif->getResource(qw, QSGRendererInterface::RhiRedirectCommandBuffer));
if (cb)
rhiCtxD->setCommandBuffer(cb);
else {
qWarning("Neither swapchain nor redirected command buffer are available.");
return currentTexture;
}
}
// Graphics pipeline objects depend on the MSAA sample count, so the
// renderer needs to know the value.
rhiCtxD->setMainPassSampleCount(m_msaaRenderBufferLegacy ? m_msaaRenderBufferLegacy->sampleCount() :
(m_msaaRenderTexture ? m_msaaRenderTexture->sampleCount() :
(m_msaaMultiViewRenderBuffer ? m_msaaMultiViewRenderBuffer->sampleCount() : 1)));
// mainPassViewCount is left unchanged
int ssaaAdjustedWidth = m_surfaceSize.width();
int ssaaAdjustedHeight = m_surfaceSize.height();
if (m_layer->antialiasingMode == QSSGRenderLayer::AAMode::SSAA) {
ssaaAdjustedWidth *= m_layer->ssaaMultiplier;
ssaaAdjustedHeight *= m_layer->ssaaMultiplier;
}
Q_TRACE(QSSG_prepareFrame_entry, ssaaAdjustedWidth, ssaaAdjustedHeight);
float dpr = m_sgContext->renderer()->dpr();
const QRect vp = QRect(0, 0, ssaaAdjustedWidth, ssaaAdjustedHeight);
beginFrame();
rhiPrepare(vp, dpr);
if (m_renderStats)
m_renderStats->endRenderPrepare();
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DPrepareFrame, quint64(ssaaAdjustedWidth) | quint64(ssaaAdjustedHeight) << 32, profilingId);
Q_TRACE(QSSG_prepareFrame_exit);
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderFrame);
Q_TRACE(QSSG_renderFrame_entry, ssaaAdjustedWidth, ssaaAdjustedHeight);
if (m_renderStats)
m_renderStats->startRender();
QColor clearColor = Qt::transparent;
if (m_backgroundMode == QSSGRenderLayer::Background::Color
|| (m_backgroundMode == QSSGRenderLayer::Background::SkyBoxCubeMap && !m_layer->skyBoxCubeMap)
|| (m_backgroundMode == QSSGRenderLayer::Background::SkyBox && !m_layer->lightProbe)
|| (m_backgroundMode == QSSGRenderLayer::Background::SkyMaterial && !m_layer->skyMaterial)) {
// Same logic as with the main render pass and skybox: tonemap
// based on tonemapMode (unless it is None), unless there are effects.
clearColor = m_layer->firstEffect ? m_linearBackgroundColor : m_tonemappedBackgroundColor;
}
// This is called from the node's preprocess() meaning Qt Quick has not
// actually began recording a renderpass. Do our own.
cb->beginPass(m_textureRenderTarget, clearColor, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(m_textureRenderTarget));
rhiRender();
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, quint64(ssaaAdjustedWidth) | quint64(ssaaAdjustedHeight) << 32, QByteArrayLiteral("main"));
const bool temporalAA = m_layer->temporalAAIsActive;
const bool progressiveAA = m_layer->progressiveAAIsActive;
const bool superSamplingAA = m_layer->antialiasingMode == QSSGRenderLayer::AAMode::SSAA;
QRhi *rhi = rhiCtx->rhi();
currentTexture = superSamplingAA ? m_ssaaTexture : m_texture;
// Do effects before antialiasing
if (m_effectSystem && m_layer->firstEffect && !m_layer->renderedCameras.isEmpty()) {
const auto &renderer = m_sgContext->renderer();
QSSGLayerRenderData *theRenderData = renderer->getOrCreateLayerRenderData(*m_layer);
Q_ASSERT(theRenderData);
QRhiTexture *theDepthTexture = theRenderData->getRenderResult(QSSGRenderResult::Key::DepthTexture)->texture;
QRhiTexture *theNormalTexture = theRenderData->getRenderResult(QSSGRenderResult::Key::NormalTexture)->texture;
QRhiTexture *theMotionVectorTexture = theRenderData->getRenderResult(QSSGRenderResult::Key::MotionVectorTexture)->texture;
currentTexture = m_effectSystem->process(*m_layer,
currentTexture,
theDepthTexture,
theNormalTexture,
theMotionVectorTexture);
}
if ((progressiveAA || temporalAA) && m_prevTempAATexture) {
cb->debugMarkBegin(QByteArrayLiteral("Temporal AA"));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Temporal AA"));
QRhiTexture *blendResult;
uint *aaIndex = progressiveAA ? &m_layer->progAAPassIndex : &m_layer->tempAAPassIndex; // TODO: can we use only one index?
if (*aaIndex > 0) {
if ((temporalAA && m_layer->temporalAAMode != QSSGRenderLayer::TAAMode::MotionVector) ||
*aaIndex <
(temporalAA && m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::MotionVector ?
quint32(QSSGLayerRenderData::MAX_AA_LEVELS) :
quint32(m_layer->antialiasingQuality))) {
const auto &renderer = m_sgContext->renderer();
QRhiResourceUpdateBatch *rub = rhi->nextResourceUpdateBatch();
QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ m_layer, nullptr, nullptr, nullptr, 0 }));
QRhiBuffer *&ubuf = dcd.ubuf;
const int ubufSize = 4 * sizeof(float);
if (!ubuf) {
ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);
ubuf->create();
}
int idx = *aaIndex - 1;
const QSize textureSize = m_prevTempAATexture->pixelSize();
QVector4D bufferData;
if (progressiveAA)
bufferData = QVector4D(s_ProgressiveAABlendFactors[idx]);
else if (m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::Default)
bufferData = QVector4D(s_TemporalAABlendFactors);
else
bufferData = QVector4D(1.0f / qMax(textureSize.width(), 1), 1.0f / qMax(textureSize.height(), 1),
0.9f + (qMin(qMax(m_layer->temporalAAStrength, 0.3f), 1.0f) - 0.3f) / 0.7f * 0.09f, 0.0f); //map it to 0.9 to 0.99
rub->updateDynamicBuffer(ubuf, 0, 4 * sizeof(float), &bufferData);
QSSGRhiGraphicsPipelineState ps;
ps.viewport = QRhiViewport(0, 0, float(textureSize.width()), float(textureSize.height()));
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, ubuf);
bindings.addTexture(1, QRhiShaderResourceBinding::FragmentStage, currentTexture, sampler);
bindings.addTexture(2, QRhiShaderResourceBinding::FragmentStage, m_prevTempAATexture, sampler);
if (m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::MotionVector) {
QSSGLayerRenderData *theRenderData = renderer->getOrCreateLayerRenderData(*m_layer);
Q_ASSERT(theRenderData);
QRhiTexture *theDepthTexture = theRenderData->getRenderResult(QSSGRenderResult::Key::DepthTexture)->texture;
QRhiTexture *theMotionVectorTexture = theRenderData->getRenderResult(QSSGRenderResult::Key::MotionVectorTexture)->texture;
bindings.addTexture(3, QRhiShaderResourceBinding::FragmentStage, theDepthTexture, sampler);
bindings.addTexture(4, QRhiShaderResourceBinding::FragmentStage, theMotionVectorTexture, sampler);
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, m_sgContext->shaderCache()->getBuiltInRhiShaders().getRhiTemporalAAShader().get());
} else {
// The fragment shader relies on per-target compilation and
// QSHADER_ macros of qsb, hence no need to communicate a flip
// flag from here.
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, m_sgContext->shaderCache()->getBuiltInRhiShaders().getRhiProgressiveAAShader().get());
}
QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);
renderer->rhiQuadRenderer()->prepareQuad(rhiCtx, rub);
renderer->rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, m_temporalAARenderTarget, QSSGRhiQuadRenderer::UvCoords);
blendResult = m_temporalAATexture;
} else {
blendResult = m_prevTempAATexture;
}
} else {
// For the first frame: no blend, only copy
blendResult = currentTexture;
}
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
const bool isMotionVector = m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::MotionVector;
const quint32 aaLimit = (temporalAA && isMotionVector) ? quint32(QSSGLayerRenderData::MAX_AA_LEVELS) : quint32(m_layer->antialiasingQuality);
const bool aaActive = (temporalAA && !isMotionVector) || (*aaIndex < aaLimit);
const bool usePrevTexture = m_prevTempAATexture != nullptr;
if (aaActive && usePrevTexture) {
QRhiTexture *copySource = (blendResult && (progressiveAA || isMotionVector)) ? blendResult : currentTexture;
if (copySource) {
auto *rub = rhi->nextResourceUpdateBatch();
rub->copyTexture(m_prevTempAATexture, copySource);
cb->resourceUpdate(rub);
}
}
(*aaIndex)++;
cb->debugMarkEnd();
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("temporal_aa"));
currentTexture = blendResult;
}
if (m_layer->antialiasingMode == QSSGRenderLayer::AAMode::SSAA) {
// With supersampling antialiasing we at this point have the
// content rendered at a larger size into m_ssaaTexture. Now scale
// it down to the expected size into m_texture, using linear
// filtering. Unlike in the OpenGL world, there is no
// glBlitFramebuffer equivalent available, because APIs like D3D
// and Metal have no such operation (the generally supported
// texture copy operations are 1:1 copies, without support for
// scaling, which is what we would need here). So draw a quad.
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
const auto &renderer = m_sgContext->renderer();
cb->debugMarkBegin(QByteArrayLiteral("SSAA downsample"));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("SSAA downsample"));
renderer->rhiQuadRenderer()->prepareQuad(rhiCtx, nullptr);
// Instead of passing in a flip flag we choose to rely on qsb's
// per-target compilation mode in the fragment shader. (it does UV
// flipping based on QSHADER_ macros) This is just better for
// performance and the shaders are very simple so introducing a
// uniform block and branching dynamically would be an overkill.
const auto &shaderPipeline = m_sgContext->shaderCache()->getBuiltInRhiShaders().getRhiSupersampleResolveShader(m_layer->viewCount);
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
QSSGRhiShaderResourceBindingList bindings;
bindings.addTexture(0, QRhiShaderResourceBinding::FragmentStage, currentTexture, sampler);
QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);
QSSGRhiGraphicsPipelineState ps;
ps.viewport = QRhiViewport(0, 0, float(m_surfaceSize.width()), float(m_surfaceSize.height()));
ps.viewCount = m_layer->viewCount;
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, shaderPipeline.get());
renderer->rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, m_ssaaTextureToTextureRenderTarget, QSSGRhiQuadRenderer::UvCoords);
cb->debugMarkEnd();
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("ssaa_downsample"));
currentTexture = m_texture;
}
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DRenderFrame,
STAT_PAYLOAD(QSSGRhiContextStats::get(*rhiCtx)),
profilingId);
endFrame();
if (m_renderStats)
m_renderStats->endRender(dumpRenderTimes());
Q_TRACE(QSSG_renderFrame_exit);
}
if (m_layer && m_layer->skyMaterial && m_layer->skyMaterial->wantsMoreFrames)
++m_requestedFramesCount;
return currentTexture;
}
void QQuick3DSceneRenderer::beginFrame()
{
m_sgContext->renderer()->beginFrame(*m_layer);
}
void QQuick3DSceneRenderer::endFrame()
{
m_sgContext->renderer()->endFrame(*m_layer);
}
void QQuick3DSceneRenderer::rhiPrepare(const QRect &viewport, qreal displayPixelRatio)
{
if (!m_layer)
return;
const auto &renderer = m_sgContext->renderer();
renderer->setDpr(displayPixelRatio);
renderer->setViewport(viewport);
renderer->prepareLayerForRender(*m_layer);
// If sync was called the assumption is that the scene is dirty regardless of what
// the scene prep function says, we still should verify that we have a camera before
// we call render prep and render.
const bool renderReady = !m_layer->renderData->renderedCameras.isEmpty();
if (renderReady) {
renderer->rhiPrepare(*m_layer);
m_prepared = true;
}
}
void QQuick3DSceneRenderer::rhiRender()
{
if (m_prepared) {
// There is no clearFirst flag - the rendering here does not record a
// beginPass() so it never clears on its own.
m_sgContext->renderer()->rhiRender(*m_layer);
}
m_prepared = false;
}
#if QT_CONFIG(quick_shadereffect)
static QRhiTexture::Format toRhiTextureFormat(QQuickShaderEffectSource::Format format)
{
switch (format) {
case QQuickShaderEffectSource::RGBA8:
return QRhiTexture::RGBA8;
case QQuickShaderEffectSource::RGBA16F:
return QRhiTexture::RGBA16F;
case QQuickShaderEffectSource::RGBA32F:
return QRhiTexture::RGBA32F;
default:
return QRhiTexture::RGBA8;
}
}
#endif
static QVector3D tonemapRgb(const QVector3D &c, QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes tonemapMode)
{
switch (tonemapMode) {
case QQuick3DSceneEnvironment::TonemapModeLinear:
return QSSGTonemapper::tonemapLinearToSrgb(c);
case QQuick3DSceneEnvironment::TonemapModeHejlDawson:
return QSSGTonemapper::tonemapHejlDawson(c);
case QQuick3DSceneEnvironment::TonemapModeAces:
return QSSGTonemapper::tonemapAces(c);
case QQuick3DSceneEnvironment::TonemapModeFilmic:
return QSSGTonemapper::tonemapFilmic(c);
default:
break;
}
return c;
}
void QQuick3DSceneRenderer::synchronize(QQuick3DViewport *view3D, const QSize &size, float dpr)
{
Q_TRACE_SCOPE(QSSG_synchronize, view3D, size, dpr);
Q_ASSERT(view3D != nullptr); // This is not an option!
QSSGRhiContext *rhiCtx = m_sgContext->rhiContext().get();
Q_ASSERT(rhiCtx != nullptr);
// Generate layer node
if (!m_layer)
m_layer = new QSSGRenderLayer();
bool newRenderStats = false;
if (!m_renderStats) {
m_renderStats = view3D->renderStats();
newRenderStats = true;
}
if (m_renderStats)
m_renderStats->startSync();
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DSynchronizeFrame);
m_sgContext->renderer()->setDpr(dpr);
bool layerSizeIsDirty = m_surfaceSize != size;
m_surfaceSize = size;
QQuick3DSceneEnvironment *environment = view3D->environment();
if (environment->lightmapper()) {
QQuick3DLightmapper *lightmapper = environment->lightmapper();
lmOptions.opacityThreshold = lightmapper->opacityThreshold();
lmOptions.bias = lightmapper->bias();
lmOptions.useAdaptiveBias = lightmapper->isAdaptiveBiasEnabled();
lmOptions.indirectLightEnabled = lightmapper->isIndirectLightEnabled();
lmOptions.indirectLightSamples = lightmapper->samples();
lmOptions.indirectLightWorkgroupSize = lightmapper->indirectLightWorkgroupSize();
lmOptions.indirectLightBounces = lightmapper->bounces();
lmOptions.indirectLightFactor = lightmapper->indirectLightFactor();
lmOptions.sigma = lightmapper->denoiseSigma();
lmOptions.texelsPerUnit = lightmapper->texelsPerUnit();
} else {
lmOptions = {};
}
if (environment->m_dirtyFlags & QQuick3DSceneEnvironment::InternalDirtyFlag::LightmapperDirty) {
environment->m_dirtyFlags &= ~QQuick3DSceneEnvironment::InternalDirtyFlag::LightmapperDirty;
// Resolve lightmaps source url
const QQmlContext *context = qmlContext(view3D);
const QUrl originalSource = environment->lightmapper() ? environment->lightmapper()->source()
: QUrl::fromLocalFile(QStringLiteral("lightmaps.bin"));
const auto resolvedUrl = context ? context->resolvedUrl(originalSource) : originalSource;
const auto qmlSource = QQmlFile::urlToLocalFileOrQrc(resolvedUrl);
const QString lightmapSource = qmlSource.isEmpty() ? originalSource.path() : qmlSource;
lmOptions.source = lightmapSource;
m_layer->lightmapSource = lightmapSource;
// HACK: this is also set in the render layer but we need to set it here since
// it is needed below when calculating bounding boxes from the stored lightmap mesh
m_sgContext->bufferManager()->setLightmapSource(m_layer->lightmapSource);
if (QQuick3DSceneManager *sceneManager = QQuick3DObjectPrivate::get(view3D->scene())->sceneManager)
sceneManager->lightmapSourceTracker = { m_layer->lightmapSource, true };
}
// Synchronize scene managers under this window
QSet<QSSGRenderGraphObject *> resourceLoaders;
QQuick3DWindowAttachment::SyncResult requestSharedUpdate = QQuick3DWindowAttachment::SyncResultFlag::None;
if (auto window = view3D->window()) {
if (!winAttacment || winAttacment->window() != window)
winAttacment = QQuick3DSceneManager::getOrSetWindowAttachment(*window);
if (winAttacment && winAttacment->rci() != m_sgContext)
winAttacment->setRci(m_sgContext);
QSSGRenderRoot *rootNode = winAttacment->rootNode();
if (m_layer->rootNode != rootNode) {
Q_ASSERT(m_layer->rootNode == nullptr);
rootNode->addChild(*m_layer);
rootNode->setStartVersion(m_layer->h.version());
m_layer->ref(rootNode);
}
if (winAttacment)
requestSharedUpdate |= winAttacment->synchronize(resourceLoaders);
}
// Import scenes used in a multi-window application...
QQuick3DNode *importScene = view3D->importScene();
if (importScene) {
QQuick3DSceneManager *importSceneManager = QQuick3DObjectPrivate::get(importScene)->sceneManager;
// If the import scene is used with 3D views under a different window, then we'll
// need to trigger updates for those as well.
if (auto window = importSceneManager->window(); window && window != view3D->window()) {
if (auto winAttacment = importSceneManager->wattached) {
// Not the same window but backed by the same rhi?
auto rci = winAttacment->rci();
const bool inlineSync = (rci && rci->rhi() && (rci->rhi()->thread() == m_sgContext->rhi()->thread()));
if (inlineSync) {
// Given that we're on the same thread, we can do an immediate sync
// (rhi instances can differ, e.g., basic renderloop).
winAttacment->synchronize(resourceLoaders);
} else if (rci && !window->isExposed()) { // Forced sync of non-exposed windows
// Not exposed, so not rendering (playing with fire here)...
winAttacment->synchronize(resourceLoaders);
} else if (!rci || (requestSharedUpdate & QQuick3DWindowAttachment::SyncResultFlag::SharedResourcesDirty)) {
// If there's no RCI for the importscene we'll request an update, which should
// mean we only get here once. It also means the update to any secondary windows
// will be delayed. Note that calling this function on each sync would cause the
// different views to ping-pong for updated forever...
winAttacment->requestUpdate();
}
}
}
}
// Update the layer node properties
// Store the view count in the layer. If there are multiple, or nested views, sync is called multiple times and the view count
// can change (see: updateLayerNode()), so we need to store the value on the layer to make sure we don't end up with a mismatch
// between between the view count of the views rendering directly to the screen (XrView instance) and the view count of the offscreen
// rendered View3Ds.
// See also: preSynchronize(), queryMainRenderPassDescriptorAndCommandBuffer() and queryInlineRenderPassDescriptorAndCommandBuffer()
// (At this point the mainPassViewCount for this view should be set to the correct value)
m_layer->viewCount = rhiCtx->mainPassViewCount();
updateLayerNode(*m_layer, *view3D, resourceLoaders.values());
// If the viewport visibility has changed, we need to mark the layer as dirty to ensure it gets re-rendered.
// NOTE: This is needed when there are multiple viewports using a shared scene since the viewport that becomes
// visible might wake-up to a scene where all the data is up-to-date, but we still need to render the scene and
// not skip it, which would be the case if we see there's no dirty data and therefore skip rendering the frame.
if (view3D->m_visibilityChanged) {
view3D->m_visibilityChanged = false;
m_layer->markDirty(QSSGRenderLayer::DirtyFlag::VisibilityDirty);
}
// Request extra frames for antialiasing (ProgressiveAA/TemporalAA)
m_requestedFramesCount = 0;
if (m_layer->isProgressiveAAEnabled() || m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::MotionVector) {
// with progressive AA or temporal AA motion vector mode, we need a number of extra frames after the last dirty one
// if we always reset requestedFramesCount when dirty, we will get the extra frames eventually
// +1 since we need a normal frame to start with, and we're not copying that from the screen
// Temporal AA (MotionVector mode) requires ~44 frames to reach 99% convergence when
// blending with mix(current, previous, 0.9). This exponential accumulation ensures
// sub-pixel details are properly resolved through temporal super-sampling.
m_requestedFramesCount = (m_layer->temporalAAMode == QSSGRenderLayer::TAAMode::MotionVector ? 45 :
int(m_layer->antialiasingQuality) + 1);
} else if (m_layer->isTemporalAAEnabled()) {
// When temporalAA is on and antialiasing mode changes,
// layer needs to be re-rendered (at least) MAX_TEMPORAL_AA_LEVELS times
// depend on the temporalAA mode to generate temporal antialiasing.
// Also, we need to do an extra render when animation stops
m_requestedFramesCount = (m_aaIsDirty || m_temporalIsDirty) ? QSSGLayerRenderData::MAX_TEMPORAL_AA_LEVELS : 1;
}
// Now that we have the effect list used for rendering, finalize the shader
// code based on the layer (scene.env.) settings.
for (QSSGRenderEffect *effectNode = m_layer->firstEffect; effectNode; effectNode = effectNode->m_nextEffect)
effectNode->finalizeShaders(*m_layer, m_sgContext.get());
// Schedule the top-level user passes. A pass is a sub-pass iff another pass
// references it through a SubRenderPass command; a sub-pass is invoked by its
// parent and renders into the parent's target, so it is never scheduled. Its
// order is its command index, established by the parent. A top-level pass
// orders by its nesting depth, the number of RenderPass ancestors it has:
// deeper passes render first ("children before parents"), so a pass
// declared inside its consumer renders before it. Other ancestors do not
// count towards the depth, so a pass grouped under a Node orders as if it
// were declared at the level of that Node. The
// manager breaks ties between passes at equal depth by declaration order, so
// the render order is deterministic regardless of the order a
// RenderOutputProvider scheduled a pass.
//
// The role itself is not derived here: each pass mirrors it to its backend
// node in updateSpatialNode() from the reference count the SubRenderPass
// commands maintain, and the node updates have already been flushed above.
if (QQuick3DSceneManager *sm = QQuick3DObjectPrivate::get(view3D->scene())->sceneManager; sm) {
// The classification-dependent state only changes when a pass is added
// or removed, a command list is rebuilt, a pass is reparented, or a
// pass's role flips, so re-derive it only then.
if (sm->userRenderPassesDirty) {
// A sub-pass renders into its parent's render target, so any attachment
// commands it declares are ignored. Warn so the mistake is not silent;
// this block only runs when the classification changes.
for (QSSGRenderUserPass *userPass : std::as_const(sm->userRenderPasses)) {
if (userPass->role != QSSGRenderUserPass::Role::SubPass)
continue;
for (const QSSGCommand *cmd : std::as_const(userPass->commands)) {
if (cmd->m_type == CommandType::ColorAttachment
|| cmd->m_type == CommandType::DepthStencilAttachment
|| cmd->m_type == CommandType::DepthTextureAttachment) {
qWarning() << "RenderPass" << sm->lookUpNode(userPass)
<< "is used as a sub-pass; its" << cmd->typeAsString()
<< "command is ignored because a sub-pass renders into its parent's render target.";
}
}
}
// Nesting depth. Only top-level passes are considered: a sub-pass's
// placement never affects ordering, and a pass declared inline on a
// SubRenderPass command has no parent item. The depth is the number
// of RenderPass ancestors; other ancestors (a Node used for
// grouping, for example) are transparent and do not affect the
// order. RenderPass ancestors count regardless of their role, so
// the order is stable when a pass's role flips at runtime.
for (QSSGRenderUserPass *userPass : std::as_const(sm->userRenderPasses)) {
userPass->m_nestingDepth = 0;
if (userPass->role != QSSGRenderUserPass::Role::TopLevel)
continue;
const QQuick3DObject *fo = sm->lookUpNode(userPass);
if (!fo)
continue; // Property-referenced pass without a parent; depth 0.
quint32 depth = 0;
for (QQuick3DObject *p = fo->parentItem(); p; p = p->parentItem()) {
if (QSSGRenderGraphObjectUtils::isUserRenderPass(QQuick3DObjectPrivate::get(p)->type))
++depth;
}
userPass->m_nestingDepth = depth;
}
quint32 declarationOrder = 0;
for (QSSGRenderUserPass *userPass : std::as_const(sm->userRenderPasses)) {
if (userPass->role == QSSGRenderUserPass::Role::TopLevel)
userPass->m_declarationOrder = declarationOrder++;
}
sm->userRenderPassesDirty = false;
}
QSSGUserRenderPassManager::UserPassSet topLevelPasses;
topLevelPasses.reserve(sm->userRenderPasses.size());
for (QSSGRenderUserPass *userPass : std::as_const(sm->userRenderPasses)) {
userPass->finalizeShaders(*m_sgContext);
if (userPass->role == QSSGRenderUserPass::Role::TopLevel)
topLevelPasses.push_back(userPass);
}
// The layer render data (and thus the manager) may not exist yet on the
// first frame; the provider path schedules on demand until it does.
if (m_layer->renderData) {
if (const QSSGUserRenderPassManagerPtr &upm = m_layer->renderData->requestUserRenderPassManager())
upm->setScheduledPasses(topLevelPasses);
}
}
if (newRenderStats)
m_renderStats->setRhiContext(rhiCtx, m_layer);
static const auto getStageIndex = [](const QSSGRenderExtension &ext) -> size_t {
const QSSGRenderExtension::RenderMode mode = ext.mode();
const QSSGRenderExtension::RenderStage stage = ext.stage();
// If the mode is 'Standalone' then the stage is irrelevant and we put the
// extension in the 'TextureProvider' list.
if (mode == QSSGRenderExtension::RenderMode::Standalone)
return size_t(QSSGRenderLayer::RenderExtensionStage::TextureProviders);
switch (stage) {
case QSSGRenderExtension::RenderStage::PreColor:
return size_t(QSSGRenderLayer::RenderExtensionStage::Underlay);
case QSSGRenderExtension::RenderStage::PostColor:
return size_t(QSSGRenderLayer::RenderExtensionStage::Overlay);
}
Q_UNREACHABLE_RETURN(size_t(QSSGRenderLayer::RenderExtensionStage::Underlay));
};
// if the list is dirty we rebuild (assumption is that this won't happen frequently).
// NOTE: We do this is two steps as extensions can be added both via the extensionList
// or via auto-registration.
if (QQuick3DSceneManager *sm = QQuick3DObjectPrivate::get(view3D->scene())->sceneManager; sm) {
const bool rebuildExtensionLists = (requestSharedUpdate & QQuick3DWindowAttachment::SyncResultFlag::ExtensionsDiry)
|| view3D->extensionListDirty()
|| sm->autoRegisteredExtensionsDirty;
// Explicit extensions from the extension list
// NOTE: If either the explicit or auto-registered extensions are dirty we need to
// rebuild the list of active extensions.
if (rebuildExtensionLists) {
// Clear existing extensions
for (size_t i = 0; i != size_t(QSSGRenderLayer::RenderExtensionStage::Count); ++i)
m_layer->renderExtensions[i].clear();
// All items in the extension list are root items,
const auto &extensions = view3D->extensionList();
for (const auto &ext : extensions) {
const auto type = QQuick3DObjectPrivate::get(ext)->type;
if (QSSGRenderGraphObject::isExtension(type)) {
if (type == QSSGRenderGraphObject::Type::RenderExtension) {
if (auto *renderExt = qobject_cast<QQuick3DRenderExtension *>(ext)) {
if (QSSGRenderExtension *ssgExt = static_cast<QSSGRenderExtension *>(QQuick3DObjectPrivate::get(renderExt)->spatialNode)) {
const auto stage = getStageIndex(*ssgExt);
auto &list = m_layer->renderExtensions[size_t(stage)];
bfs(qobject_cast<QQuick3DRenderExtension *>(ext), list);
}
}
}
}
}
view3D->clearExtensionListDirty();
}
// Auto-registered extensions
if (sm->autoRegisteredExtensionsDirty) {
for (QSSGRenderExtension *ae : std::as_const(sm->autoRegisteredExtensions))
m_layer->renderExtensions[getStageIndex(*ae)].push_back(ae);
sm->autoRegisteredExtensionsDirty = false;
}
}
bool postProcessingNeeded = m_layer->firstEffect;
bool postProcessingWasActive = m_effectSystem;
QSSGRenderTextureFormat::Format effectOutputFormatOverride = QSSGRenderTextureFormat::Unknown;
if (postProcessingNeeded) {
QSSGRenderEffect *lastEffect = m_layer->firstEffect;
while (lastEffect->m_nextEffect)
lastEffect = lastEffect->m_nextEffect;
effectOutputFormatOverride = QSSGRhiEffectSystem::overriddenOutputFormat(lastEffect);
}
const auto layerTextureFormat = [effectOutputFormatOverride, view3D](QRhi *rhi, bool postProc) {
if (effectOutputFormatOverride != QSSGRenderTextureFormat::Unknown)
return QSSGBufferManager::toRhiFormat(effectOutputFormatOverride);
// Our standard choice for the postprocessing input/output textures'
// format is a floating point one. (unlike intermediate Buffers, which
// default to RGBA8 unless the format is explicitly specified)
// This is intentional since a float format allows passing in
// non-tonemapped content without colors being clamped when written out
// to the render target.
//
// When it comes to the output, this applies to that too due to
// QSSGRhiEffectSystem picking it up unless overridden (with a Buffer
// an empty 'name'). Here too a float format gives more flexibility:
// the effect may or may not do its own tonemapping and this approach
// is compatible with potential future on-screen HDR output support.
const QRhiTexture::Format preferredPostProcFormat = QRhiTexture::RGBA16F;
if (postProc && rhi->isTextureFormatSupported(preferredPostProcFormat))
return preferredPostProcFormat;
#if QT_CONFIG(quick_shadereffect)
const QRhiTexture::Format preferredView3DFormat = toRhiTextureFormat(view3D->renderFormat());
if (rhi->isTextureFormatSupported(preferredView3DFormat))
return preferredView3DFormat;
#endif
return QRhiTexture::RGBA8;
};
bool postProcessingStateDirty = postProcessingNeeded != postProcessingWasActive;
// Store from the layer properties the ones we need to handle ourselves (with the RHI code path)
m_backgroundMode = QSSGRenderLayer::Background(view3D->environment()->backgroundMode());
// This is stateful since we only want to recalculate the tonemapped color
// when the color changes, not in every frame.
QColor currentUserBackgroundColor = view3D->environment()->clearColor();
if (m_userBackgroundColor != currentUserBackgroundColor) {
m_userBackgroundColor = currentUserBackgroundColor;
m_linearBackgroundColor = QSSGUtils::color::sRGBToLinearColor(m_userBackgroundColor);
const QVector3D tc = tonemapRgb(QVector3D(m_linearBackgroundColor.redF(),
m_linearBackgroundColor.greenF(),
m_linearBackgroundColor.blueF()),
view3D->environment()->tonemapMode());
m_tonemappedBackgroundColor = QColor::fromRgbF(tc.x(), tc.y(), tc.z(), m_linearBackgroundColor.alphaF());
}
m_layer->scissorRect = QRect(view3D->environment()->scissorRect().topLeft() * dpr,
view3D->environment()->scissorRect().size() * dpr);
// Add the scene root node for the scene to the layer
// NOTE: The scene root is not the same as THE root node.
// The scene root is the root of the scene in a view (There can be multiple views.)
// THE root node, which there's only one of, is the root for all nodes in the window.
auto sceneRootNode = static_cast<QSSGRenderNode*>(QQuick3DObjectPrivate::get(view3D->scene())->spatialNode);
if (sceneRootNode != m_sceneRootNode) {
if (m_sceneRootNode)
removeNodeFromLayer(m_sceneRootNode);
if (sceneRootNode)
addNodeToLayer(sceneRootNode);
m_sceneRootNode = sceneRootNode;
}
// Add the referenced scene root node to the layer as well if available
QSSGRenderNode *importSceneRootNode = nullptr;
if (importScene)
importSceneRootNode = static_cast<QSSGRenderNode*>(QQuick3DObjectPrivate::get(importScene)->spatialNode);
if (importSceneRootNode != m_importSceneRootNode) {
if (m_importSceneRootNode)
m_layer->removeImportScene(*m_importSceneRootNode);
if (importSceneRootNode) {
// if importScene has the rendered viewport as ancestor, it probably means
// "importScene: MyScene { }" type of inclusion.
// In this case don't duplicate content by adding it again.
QObject *sceneParent = importScene->parent();
bool isEmbedded = false;
while (sceneParent) {
if (sceneParent == view3D) {
isEmbedded = true;
break;
}
sceneParent = sceneParent->parent();
}
if (!isEmbedded)
m_layer->setImportScene(*importSceneRootNode);
}
m_importSceneRootNode = importSceneRootNode;
}
// If the tree is dirty, reindex() rebuilds node indices and marks all
// child layers tree-dirty so they rebuild their node views during prep.
// The layer dirty flag is cleared in the layer prep function; the root
// dirty flag is cleared inside reindex() itself.
{
QSSGRenderRoot *rootNode = winAttacment->rootNode();
if (rootNode->isDirty(QSSGRenderRoot::DirtyFlag::TreeDirty)) {
rootNode->reindex();
}
}
maybeSetupLightmapBaking(view3D);
if (m_useFBO && rhiCtx->isValid()) {
QRhi *rhi = rhiCtx->rhi();
const QSize renderSize = m_layer->isSsaaEnabled() ? m_surfaceSize * m_layer->ssaaMultiplier : m_surfaceSize;
if (m_texture) {
// the size changed, or the AA settings changed, or toggled between some effects - no effect
if (layerSizeIsDirty || postProcessingStateDirty) {
m_texture->setPixelSize(m_surfaceSize);
m_texture->setFormat(layerTextureFormat(rhi, postProcessingNeeded));
m_texture->create();
// If AA settings changed, then we drop and recreate all
// resources, otherwise use a lighter path if just the size
// changed.
if (!m_aaIsDirty) {
// A special case: when toggling effects and AA is on,
// use the heavier AA path because the renderbuffer for
// MSAA and texture for SSAA may need a different
// format now since m_texture's format could have
// changed between RBGA8 and RGBA16F (due to layerTextureFormat()).
if (postProcessingStateDirty && (m_layer->antialiasingMode != QSSGRenderLayer::AAMode::NoAA || m_layer->isTemporalAAEnabled())) {
releaseAaDependentRhiResources();
} else {
if (m_ssaaTexture) {
m_ssaaTexture->setPixelSize(renderSize);
m_ssaaTexture->create();
}
if (m_depthStencilBuffer) {
m_depthStencilBuffer->setPixelSize(renderSize);
m_depthStencilBuffer->create();
}
if (m_multiViewDepthStencilBuffer) {
m_multiViewDepthStencilBuffer->setPixelSize(renderSize);
m_multiViewDepthStencilBuffer->create();
}
if (m_msaaRenderBufferLegacy) {
m_msaaRenderBufferLegacy->setPixelSize(renderSize);
m_msaaRenderBufferLegacy->create();
}
if (m_msaaRenderTexture) {
m_msaaRenderTexture->setPixelSize(renderSize);
m_msaaRenderTexture->create();
}
if (m_msaaMultiViewRenderBuffer) {
m_msaaMultiViewRenderBuffer->setPixelSize(renderSize);
m_msaaMultiViewRenderBuffer->create();
}
// Toggling effects on and off will change the format
// (assuming effects default to a floating point
// format) and that needs on a different renderpass on
// Vulkan. Hence renewing m_textureRenderPassDescriptor as well.
if (postProcessingStateDirty) {
delete m_textureRenderPassDescriptor;
m_textureRenderPassDescriptor = m_textureRenderTarget->newCompatibleRenderPassDescriptor();
m_textureRenderTarget->setRenderPassDescriptor(m_textureRenderPassDescriptor);
}
m_textureRenderTarget->create();
if (m_ssaaTextureToTextureRenderTarget)
m_ssaaTextureToTextureRenderTarget->create();
if (m_temporalAATexture) {
m_temporalAATexture->setPixelSize(renderSize);
m_temporalAATexture->create();
}
if (m_prevTempAATexture) {
m_prevTempAATexture->setPixelSize(renderSize);
m_prevTempAATexture->create();
}
if (m_temporalAARenderTarget)
m_temporalAARenderTarget->create();
}
}
} else if (m_aaIsDirty && rhi->backend() == QRhi::Metal) { // ### to avoid garbage upon enabling MSAA with macOS 10.14 (why is this needed?)
m_texture->create();
}
if (m_aaIsDirty)
releaseAaDependentRhiResources();
}
const QRhiTexture::Flags textureFlags = QRhiTexture::RenderTarget
| QRhiTexture::UsedAsTransferSource; // transfer source is for progressive/temporal AA
const QRhiTexture::Format textureFormat = layerTextureFormat(rhi, postProcessingNeeded);
if (!m_texture) {
if (m_layer->viewCount >= 2)
m_texture = rhi->newTextureArray(textureFormat, m_layer->viewCount, m_surfaceSize, 1, textureFlags);
else
m_texture = rhi->newTexture(textureFormat, m_surfaceSize, 1, textureFlags);
m_texture->create();
}
if (!m_ssaaTexture && m_layer->isSsaaEnabled()) {
if (m_layer->viewCount >= 2)
m_ssaaTexture = rhi->newTextureArray(textureFormat, m_layer->viewCount, renderSize, 1, textureFlags);
else
m_ssaaTexture = rhi->newTexture(textureFormat, renderSize, 1, textureFlags);
m_ssaaTexture->create();
}
if (m_timeBasedAA && !m_temporalAATexture) {
m_temporalAATexture = rhi->newTexture(textureFormat, renderSize, 1, textureFlags);
m_temporalAATexture->create();
m_prevTempAATexture = rhi->newTexture(textureFormat, renderSize, 1, textureFlags);
m_prevTempAATexture->create();
}
// we need to re-render time-based AA not only when AA state changes, but also when resized
if (m_aaIsDirty || layerSizeIsDirty)
m_layer->tempAAPassIndex = m_layer->progAAPassIndex = 0;
if (m_aaIsDirty) {
m_samples = 1;
if (m_layer->antialiasingMode == QSSGRenderLayer::AAMode::MSAA) {
if (rhi->isFeatureSupported(QRhi::MultisampleRenderBuffer)) {
m_samples = qMax(1, int(m_layer->antialiasingQuality));
// The Quick3D API exposes high level values such as
// Medium, High, VeryHigh instead of direct sample
// count values. Therefore, be nice and find a sample
// count that's actually supported in case the one
// associated by default is not.
const QVector<int> supported = rhi->supportedSampleCounts(); // assumed to be sorted
if (!supported.contains(m_samples)) {
if (!supported.isEmpty()) {
auto it = std::lower_bound(supported.cbegin(), supported.cend(), m_samples);
m_samples = it == supported.cend() ? supported.last() : *it;
} else {
m_samples = 1;
}
}
} else {
static bool warned = false;
if (!warned) {
warned = true;
qWarning("Multisample renderbuffers are not supported, disabling MSAA for Offscreen View3D");
}
}
}
}
if (m_layer->viewCount >= 2) {
if (!m_multiViewDepthStencilBuffer) {
const auto format = rhi->isTextureFormatSupported(QRhiTexture::D24S8) ? QRhiTexture::D24S8 : QRhiTexture::D32FS8;
m_multiViewDepthStencilBuffer = rhi->newTextureArray(format, m_layer->viewCount, renderSize,
m_samples, QRhiTexture::RenderTarget);
m_multiViewDepthStencilBuffer->create();
}
} else {
if (!m_depthStencilBuffer) {
m_depthStencilBuffer = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, renderSize, m_samples);
m_depthStencilBuffer->create();
}
}
if (!m_textureRenderTarget) {
QRhiTextureRenderTargetDescription rtDesc;
QRhiColorAttachment att;
if (m_samples > 1) {
if (m_layer->viewCount >= 2) {
m_msaaMultiViewRenderBuffer = rhi->newTextureArray(textureFormat, m_layer->viewCount, renderSize, m_samples, QRhiTexture::RenderTarget);
m_msaaMultiViewRenderBuffer->create();
att.setTexture(m_msaaMultiViewRenderBuffer);
} else {
if (!rhi->isFeatureSupported(QRhi::MultisampleTexture)) {
// pass in the texture's format (which may be a floating point one!) as the preferred format hint
m_msaaRenderBufferLegacy = rhi->newRenderBuffer(QRhiRenderBuffer::Color, renderSize, m_samples, {}, m_texture->format());
m_msaaRenderBufferLegacy->create();
att.setRenderBuffer(m_msaaRenderBufferLegacy);
} else {
// The texture-backed MSAA path has the benefit of being able to use
// GL_EXT_multisampled_render_to_texture on OpenGL ES when supported (Mali
// and Qualcomm GPUs typically), potentially giving significant performance
// gains. Whereas with 3D APIs other than OpenGL there is often no
// difference between QRhiRenderBuffer and QRhiTexture anyway.
m_msaaRenderTexture = rhi->newTexture(textureFormat, renderSize, m_samples, QRhiTexture::RenderTarget);
m_msaaRenderTexture->create();
att.setTexture(m_msaaRenderTexture);
}
}
att.setResolveTexture(m_texture);
} else {
if (m_layer->antialiasingMode == QSSGRenderLayer::AAMode::SSAA)
att.setTexture(m_ssaaTexture);
else
att.setTexture(m_texture);
}
att.setMultiViewCount(m_layer->viewCount);
rtDesc.setColorAttachments({ att });
if (m_depthStencilBuffer)
rtDesc.setDepthStencilBuffer(m_depthStencilBuffer);
if (m_multiViewDepthStencilBuffer)
rtDesc.setDepthTexture(m_multiViewDepthStencilBuffer);
m_textureRenderTarget = rhi->newTextureRenderTarget(rtDesc);
m_textureRenderTarget->setName(QByteArrayLiteral("View3D"));
m_textureRenderPassDescriptor = m_textureRenderTarget->newCompatibleRenderPassDescriptor();
m_textureRenderTarget->setRenderPassDescriptor(m_textureRenderPassDescriptor);
m_textureRenderTarget->create();
}
if (!m_ssaaTextureToTextureRenderTarget && m_layer->antialiasingMode == QSSGRenderLayer::AAMode::SSAA) {
QRhiColorAttachment att(m_texture);
att.setMultiViewCount(m_layer->viewCount);
m_ssaaTextureToTextureRenderTarget = rhi->newTextureRenderTarget(QRhiTextureRenderTargetDescription({ att }));
m_ssaaTextureToTextureRenderTarget->setName(QByteArrayLiteral("SSAA texture"));
m_ssaaTextureToTextureRenderPassDescriptor = m_ssaaTextureToTextureRenderTarget->newCompatibleRenderPassDescriptor();
m_ssaaTextureToTextureRenderTarget->setRenderPassDescriptor(m_ssaaTextureToTextureRenderPassDescriptor);
m_ssaaTextureToTextureRenderTarget->create();
}
if (m_layer->firstEffect) {
if (!m_effectSystem)
m_effectSystem = new QSSGRhiEffectSystem(m_sgContext);
m_effectSystem->setup(renderSize);
} else if (m_effectSystem) {
delete m_effectSystem;
m_effectSystem = nullptr;
}
if (m_timeBasedAA && !m_temporalAARenderTarget) {
m_temporalAARenderTarget = rhi->newTextureRenderTarget({ m_temporalAATexture });
m_temporalAARenderTarget->setName(QByteArrayLiteral("Temporal AA texture"));
m_temporalAARenderPassDescriptor = m_temporalAARenderTarget->newCompatibleRenderPassDescriptor();
m_temporalAARenderTarget->setRenderPassDescriptor(m_temporalAARenderPassDescriptor);
m_temporalAARenderTarget->create();
}
m_textureNeedsFlip = rhi->isYUpInFramebuffer();
m_aaIsDirty = false;
}
if (m_renderStats)
m_renderStats->endSync(dumpRenderTimes());
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DSynchronizeFrame, quint64(m_surfaceSize.width()) | quint64(m_surfaceSize.height()) << 32, profilingId);
}
void QQuick3DSceneRenderer::invalidateFramebufferObject()
{
if (fboNode)
fboNode->invalidatePending = true;
}
void QQuick3DSceneRenderer::releaseCachedResources()
{
if (m_layer && m_layer->renderData) {
if (const auto &mgr = m_layer->renderData->getShadowMapManager())
mgr->releaseCachedResources();
if (const auto &mgr = m_layer->renderData->getReflectionMapManager())
mgr->releaseCachedResources();
}
}
std::optional<QSSGRenderRay> QQuick3DSceneRenderer::getRayFromViewportPos(const QPointF &pos)
{
if (!m_layer || !m_layer->renderData)
return std::nullopt;
QMutexLocker locker(&m_layer->renderedCamerasMutex);
if (m_layer->renderedCameras.isEmpty())
return std::nullopt;
QMatrix4x4 globalTransform = m_layer->renderData->getGlobalTransform(*m_layer->renderedCameras[0]);
const QVector2D viewportSize(m_surfaceSize.width(), m_surfaceSize.height());
const QVector2D position(float(pos.x()), float(pos.y()));
const QRectF viewportRect(QPointF{}, QSizeF(m_surfaceSize));
// First invert the y so we are dealing with numbers in a normal coordinate space.
// Second, move into our layer's coordinate space
QVector2D correctCoords(position.x(), viewportSize.y() - position.y());
QVector2D theLocalMouse = QSSGUtils::rect::toRectRelative(viewportRect, correctCoords);
if ((theLocalMouse.x() < 0.0f || theLocalMouse.x() >= viewportSize.x() || theLocalMouse.y() < 0.0f
|| theLocalMouse.y() >= viewportSize.y()))
return std::nullopt;
return m_layer->renderedCameras[0]->unproject(globalTransform, theLocalMouse, viewportRect);
}
std::optional<QSSGRenderPickResult> QQuick3DSceneRenderer::syncPickClosestPoint(const QVector3D ¢er, float radiusSquared, QSSGRenderNode *node)
{
if (!m_layer)
return std::nullopt;
return QSSGRendererPrivate::syncPickClosestPoint(*m_sgContext,
*m_layer,
center, radiusSquared,
node);
}
QQuick3DSceneRenderer::PickResultList QQuick3DSceneRenderer::syncPick(const QSSGRenderRay &ray)
{
if (!m_layer)
return QQuick3DSceneRenderer::PickResultList();
return QSSGRendererPrivate::syncPick(*m_sgContext,
*m_layer,
ray);
}
QQuick3DSceneRenderer::PickResultList QQuick3DSceneRenderer::syncPickOne(const QSSGRenderRay &ray, QSSGRenderNode *node)
{
if (!m_layer)
return QQuick3DSceneRenderer::PickResultList();
return QSSGRendererPrivate::syncPick(*m_sgContext,
*m_layer,
ray,
node);
}
QQuick3DSceneRenderer::PickResultList QQuick3DSceneRenderer::syncPickSubset(const QSSGRenderRay &ray,
QVarLengthArray<QSSGRenderNode *> subset)
{
if (!m_layer)
return QQuick3DSceneRenderer::PickResultList();
return QSSGRendererPrivate::syncPickSubset(*m_layer,
*m_sgContext->bufferManager(),
ray,
subset);
}
QQuick3DSceneRenderer::PickResultList QQuick3DSceneRenderer::syncPickAll(const QSSGRenderRay &ray)
{
if (!m_layer)
return QQuick3DSceneRenderer::PickResultList();
return QSSGRendererPrivate::syncPickAll(*m_sgContext,
*m_layer,
ray);
}
QList<const QSSGRenderNode *> QQuick3DSceneRenderer::syncPickInFrustum(const QSSGFrustum &frustum)
{
if (!m_layer)
return {};
return QSSGRendererPrivate::syncPickInFrustum(*m_sgContext, *m_layer, frustum);
}
void QQuick3DSceneRenderer::setGlobalPickingEnabled(bool isEnabled)
{
QSSGRendererPrivate::setGlobalPickingEnabled(*m_sgContext->renderer(), isEnabled);
}
QQuick3DRenderStats *QQuick3DSceneRenderer::renderStats()
{
return m_renderStats;
}
void QQuick3DRenderLayerHelpers::updateLayerNodeHelper(const QQuick3DViewport &view3D,
const std::shared_ptr<QSSGRenderContextInterface>& rci,
QSSGRenderLayer &layerNode,
bool &aaIsDirty,
bool &temporalIsDirty)
{
QList<QSSGRenderGraphObject *> resourceLoaders; // empty list
QQuick3DSceneRenderer dummyRenderer(rci);
// Update the layer node properties
dummyRenderer.updateLayerNode(layerNode, view3D, resourceLoaders);
aaIsDirty = dummyRenderer.m_aaIsDirty;
temporalIsDirty = dummyRenderer.m_temporalIsDirty;
}
void QQuick3DSceneRenderer::updateLayerNode(QSSGRenderLayer &layerNode,
const QQuick3DViewport &view3D,
const QList<QSSGRenderGraphObject *> &resourceLoaders)
{
QQuick3DSceneEnvironment *environment = view3D.environment();
const auto &effects = environment->effectList();
QSSGRenderLayer::AAMode aaMode = QSSGRenderLayer::AAMode(environment->antialiasingMode());
if (aaMode != layerNode.antialiasingMode) {
layerNode.antialiasingMode = aaMode;
layerNode.progAAPassIndex = 0;
m_aaIsDirty = true;
}
QSSGRenderLayer::AAQuality aaQuality = QSSGRenderLayer::AAQuality(environment->antialiasingQuality());
if (aaQuality != layerNode.antialiasingQuality) {
layerNode.antialiasingQuality = aaQuality;
layerNode.ssaaMultiplier = QSSGRenderLayer::ssaaMultiplierForQuality(aaQuality);
m_aaIsDirty = true;
}
// NOTE: Temporal AA is disabled when MSAA is enabled.
const bool temporalAARequested = environment->temporalAAEnabled();
const bool wasTaaEnabled = layerNode.isTemporalAAEnabled();
layerNode.temporalAAMode = temporalAARequested ? QSSGRenderLayer::TAAMode(environment->m_temporalAAMode + 1) // map the environment mode to the layer mode
: QSSGRenderLayer::TAAMode::Off;
// If the state changed we need to reset the temporal AA pass index etc.
if (wasTaaEnabled != layerNode.isTemporalAAEnabled()) {
layerNode.tempAAPassIndex = 0;
m_aaIsDirty = true;
m_temporalIsDirty = true;
}
layerNode.temporalAAStrength = environment->temporalAAStrength();
layerNode.specularAAEnabled = environment->specularAAEnabled();
layerNode.background = QSSGRenderLayer::Background(environment->backgroundMode());
layerNode.clearColor = QVector3D(float(environment->clearColor().redF()),
float(environment->clearColor().greenF()),
float(environment->clearColor().blueF()));
layerNode.gridEnabled = environment->gridEnabled();
layerNode.gridScale = environment->gridScale();
layerNode.gridFlags = environment->gridFlags();
layerNode.aoStrength = environment->aoStrength();
layerNode.aoDistance = environment->aoDistance();
layerNode.aoSoftness = environment->aoSoftness();
layerNode.aoEnabled = environment->aoEnabled();
layerNode.aoBias = environment->aoBias();
layerNode.aoSamplerate = environment->aoSampleRate();
layerNode.aoDither = environment->aoDither();
// ### These images will not be registered anywhere
if (environment->lightProbe()) {
layerNode.lightProbe = environment->lightProbe()->getRenderImage();
// FIXME: Band-aid. Need a proper solution where textureData is setting the format of the render node.
if (auto texData = environment->lightProbe()->textureData();
texData && texData->format() == QQuick3DTextureData::Format::RGBE8) {
layerNode.lightProbe->m_format = QSSGRenderTextureFormat::Format::RGBE8;
}
} else
layerNode.lightProbe = nullptr;
if (view3D.environment()->skyBoxCubeMap())
layerNode.skyBoxCubeMap = view3D.environment()->skyBoxCubeMap()->getRenderImage();
else
layerNode.skyBoxCubeMap = nullptr;
layerNode.skyMaterial = nullptr;
if (auto skyMaterial = environment->skyMaterial())
layerNode.skyMaterial = static_cast<QSSGRenderSkyMaterial *>(QQuick3DObjectPrivate::get(skyMaterial)->spatialNode);
layerNode.lightProbeSettings.probeExposure = environment->probeExposure();
// Remap the probeHorizon to the expected Range
layerNode.lightProbeSettings.probeHorizon = qMin(environment->probeHorizon() - 1.0f, -0.001f);
layerNode.setProbeOrientation(environment->probeOrientation());
QQuick3DViewport::updateCameraForLayer(view3D, layerNode);
layerNode.layerFlags.setFlag(QSSGRenderLayer::LayerFlag::EnableDepthTest, environment->depthTestEnabled());
layerNode.layerFlags.setFlag(QSSGRenderLayer::LayerFlag::EnableDepthPrePass, environment->depthPrePassEnabled());
layerNode.tonemapMode = QQuick3DSceneRenderer::getTonemapMode(*environment);
layerNode.skyboxBlurAmount = environment->skyboxBlurAmount();
if (auto debugSettings = view3D.environment()->debugSettings()) {
layerNode.debugMode = QSSGRenderLayer::MaterialDebugMode(debugSettings->materialOverride());
layerNode.wireframeMode = debugSettings->wireframeEnabled();
layerNode.drawDirectionalLightShadowBoxes = debugSettings->drawDirectionalLightShadowBoxes();
layerNode.drawPointLightShadowBoxes = debugSettings->drawPointLightShadowBoxes();
layerNode.drawShadowCastingBounds = debugSettings->drawShadowCastingBounds();
layerNode.drawShadowReceivingBounds = debugSettings->drawShadowReceivingBounds();
layerNode.drawCascades = debugSettings->drawCascades();
layerNode.drawSceneCascadeIntersection = debugSettings->drawSceneCascadeIntersection();
layerNode.disableShadowCameraUpdate = debugSettings->disableShadowCameraUpdate();
layerNode.drawCulledObjects = debugSettings->drawCulledObjects();
} else {
layerNode.debugMode = QSSGRenderLayer::MaterialDebugMode::None;
layerNode.wireframeMode = false;
}
if (environment->fog() && environment->fog()->isEnabled()) {
layerNode.fog.enabled = true;
const QQuick3DFog *fog = environment->fog();
layerNode.fog.color = QSSGUtils::color::sRGBToLinear(fog->color()).toVector3D();
layerNode.fog.density = fog->density();
layerNode.fog.depthEnabled = fog->isDepthEnabled();
layerNode.fog.depthBegin = fog->depthNear();
layerNode.fog.depthEnd = fog->depthFar();
layerNode.fog.depthCurve = fog->depthCurve();
layerNode.fog.heightEnabled = fog->isHeightEnabled();
layerNode.fog.heightMin = fog->leastIntenseY();
layerNode.fog.heightMax = fog->mostIntenseY();
layerNode.fog.heightCurve = fog->heightCurve();
layerNode.fog.transmitEnabled = fog->isTransmitEnabled();
layerNode.fog.transmitCurve = fog->transmitCurve();
} else {
layerNode.fog.enabled = false;
}
const auto method = static_cast<QSSGRenderLayer::OITMethod>(environment->oitMethod());
layerNode.oitMethodDirty = method != layerNode.oitMethod;
layerNode.oitMethod = method;
// Effects need to be rendered in reverse order as described in the file.
// NOTE: We only build up the list here, don't do anything that depends
// on the collected layer state yet. See sync() for that.
layerNode.firstEffect = nullptr; // We reset the linked list
auto rit = effects.crbegin();
const auto rend = effects.crend();
for (; rit != rend; ++rit) {
QQuick3DObjectPrivate *p = QQuick3DObjectPrivate::get(*rit);
QSSGRenderEffect *effectNode = static_cast<QSSGRenderEffect *>(p->spatialNode);
if (effectNode) {
if (layerNode.hasEffect(effectNode)) {
qWarning() << "Duplicate effect found, skipping!";
} else {
effectNode->className = (*rit)->metaObject()->className(); //### persistent, but still icky to store a const char* returned from a function
layerNode.addEffect(*effectNode);
}
}
}
const bool hasEffects = (layerNode.firstEffect != nullptr);
const auto renderMode = view3D.renderMode();
const bool progressiveAA = layerNode.isProgressiveAAEnabled();
const bool temporalAA = layerNode.isTemporalAAEnabled();
const bool superSamplingAA = layerNode.isSsaaEnabled();
m_timeBasedAA = progressiveAA || temporalAA;
m_postProcessingStack = hasEffects || m_timeBasedAA || superSamplingAA;
m_useFBO = renderMode == QQuick3DViewport::RenderMode::Offscreen ||
((renderMode == QQuick3DViewport::RenderMode::Underlay || renderMode == QQuick3DViewport::RenderMode::Overlay)
&& m_postProcessingStack);
// Update the view count
// NOTE: If we're rendering to an FBO, the view count is more than 1, and the View3D is not an XR view instance,
// we need to force the view count to 1 (The only time this should be the case is when embedding View3D(s)
// in XR with multiview enabled).
// Also, note that embedding View3D(s) in XR with multiview enabled only works if those View3D(s) are
// being rendered through a FBO.
if (m_useFBO && (layerNode.viewCount > 1) && !view3D.isXrViewInstance())
layerNode.viewCount = 1;
// ResourceLoaders
layerNode.resourceLoaders.clear();
layerNode.resourceLoaders = resourceLoaders;
layerNode.renderOverrides = QSSGRenderLayer::RenderOverridesT(view3D.renderOverrides().toInt());
}
void QQuick3DSceneRenderer::removeNodeFromLayer(QSSGRenderNode *node)
{
if (!m_layer)
return;
m_layer->removeChild(*node);
}
void QQuick3DSceneRenderer::maybeSetupLightmapBaking(QQuick3DViewport *view3D)
{
if (m_layer->renderData && m_layer->renderData->lightmapBaker)
return;
// Check if we have interactive bake requested or if we are coming in here the second
// time from cmd line request (needs to wait a frame before starting to bake).
bool bakeRequested = false;
bool denoiseRequested = false;
bool fromCmd = false;
QQuick3DLightmapBaker *lightmapBaker = view3D->maybeLightmapBaker();
if (lightmapBaker && (lightmapBaker->m_bakingRequested || lightmapBaker->m_denoisingRequested)) {
bakeRequested = std::exchange(lightmapBaker->m_bakingRequested, false);
denoiseRequested = std::exchange(lightmapBaker->m_denoisingRequested, false);
} else {
bakeRequested = m_lightmapBakingFromCmdRequested;
denoiseRequested = m_lightmapDenoisingFromCmdRequested;
fromCmd = bakeRequested;
}
// Start the bake (we should have a valid layer render data at this point).
if (bakeRequested || denoiseRequested) {
QSSGLightmapBaker::Context ctx;
ctx.settings.bakeRequested = bakeRequested;
ctx.settings.denoiseRequested = denoiseRequested;
ctx.settings.quitWhenFinished = fromCmd;
// We want the frontend callback in the case that a QQuick3DLightmapBaker is present
if (lightmapBaker) {
QQuick3DLightmapBaker::Callback qq3dCallback = lightmapBaker->m_callback;
QQuick3DLightmapBaker::BakingControl *qq3dBakingControl = lightmapBaker->m_bakingControl;
QSSGLightmapper::Callback callback =
[qq3dCallback,
qq3dBakingControl](const QVariantMap &payload,
QSSGLightmapper::BakingControl *qssgBakingControl) {
qq3dCallback(payload, qq3dBakingControl);
if (qq3dBakingControl->isCancelled() && !qssgBakingControl->cancelled)
qssgBakingControl->cancelled = true;
};
ctx.callbacks.lightmapBakingOutput = callback;
}
// Both the QQuick3DLightmapBaker and cmd / env variant needs this
ctx.callbacks.triggerNewFrame = [view3D](bool releaseResources) {
if (releaseResources) {
QMetaObject::invokeMethod(view3D->window(),
&QQuickWindow::releaseResources,
Qt::QueuedConnection);
}
QMetaObject::invokeMethod(view3D, &QQuick3DViewport::update, Qt::QueuedConnection);
};
ctx.callbacks.setCurrentlyBaking = [this](bool value) {
m_sgContext->bufferManager()->setCurrentlyLightmapBaking(value);
};
ctx.env.rhiCtx = m_sgContext->rhiContext().get();
ctx.env.renderer = m_sgContext->renderer().get();
ctx.env.lmOptions = lmOptions;
m_layer->renderData->initializeLightmapBaking(ctx);
} else {
// Check cmd line and env flags for request
static bool flagsChecked = false;
if (flagsChecked)
return;
flagsChecked = true;
auto isLightmapFlagSet = [](const QString &flag, const char *envVar) {
return QCoreApplication::arguments().contains(flag)
|| qEnvironmentVariableIntValue(envVar);
};
m_lightmapBakingFromCmdRequested = isLightmapFlagSet(QStringLiteral("--bake-lightmaps"), "QT_QUICK3D_BAKE_LIGHTMAPS");
m_lightmapDenoisingFromCmdRequested = isLightmapFlagSet(QStringLiteral("--denoise-lightmaps"), "QT_QUICK3D_DENOISE_LIGHTMAPS");
if (m_lightmapBakingFromCmdRequested || m_lightmapDenoisingFromCmdRequested) {
// Delay one frame so the render data is initialized
QMetaObject::invokeMethod(view3D, &QQuick3DViewport::update, Qt::QueuedConnection);
}
}
}
void QQuick3DSceneRenderer::addNodeToLayer(QSSGRenderNode *node)
{
if (!m_layer)
return;
m_layer->addChild(*node);
}
QSGRenderNode::StateFlags QQuick3DSGRenderNode::changedStates() const
{
return BlendState | StencilState | DepthState | ScissorState | ColorState | CullState | ViewportState | RenderTargetState;
}
namespace {
inline QRect convertQtRectToGLViewport(const QRectF &rect, const QSize surfaceSize)
{
const int x = int(rect.x());
const int y = surfaceSize.height() - (int(rect.y()) + int(rect.height()));
const int width = int(rect.width());
const int height = int(rect.height());
return QRect(x, y, width, height);
}
inline void queryMainRenderPassDescriptorAndCommandBuffer(QQuickWindow *window, QSSGRhiContext *rhiCtx)
{
if (rhiCtx->isValid()) {
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
// Query from the rif because that is available in the sync
// phase (updatePaintNode) already. QSGDefaultRenderContext's
// copies of the rp and cb are not there until the render
// phase of the scenegraph.
int sampleCount = 1;
int viewCount = 1;
QRhiSwapChain *swapchain = window->swapChain();
if (swapchain) {
rhiCtxD->setMainRenderPassDescriptor(swapchain->renderPassDescriptor());
rhiCtxD->setCommandBuffer(swapchain->currentFrameCommandBuffer());
rhiCtxD->setRenderTarget(swapchain->currentFrameRenderTarget());
sampleCount = swapchain->sampleCount();
} else {
QSGRendererInterface *rif = window->rendererInterface();
// no swapchain when using a QQuickRenderControl (redirecting to a texture etc.)
QRhiCommandBuffer *cb = static_cast<QRhiCommandBuffer *>(
rif->getResource(window, QSGRendererInterface::RhiRedirectCommandBuffer));
QRhiTextureRenderTarget *rt = static_cast<QRhiTextureRenderTarget *>(
rif->getResource(window, QSGRendererInterface::RhiRedirectRenderTarget));
if (cb && rt) {
rhiCtxD->setMainRenderPassDescriptor(rt->renderPassDescriptor());
rhiCtxD->setCommandBuffer(cb);
rhiCtxD->setRenderTarget(rt);
const auto descr = rt->description();
const QRhiColorAttachment *color0 = descr.cbeginColorAttachments();
if (color0 && color0->texture()) {
sampleCount = color0->texture()->sampleCount();
if (rt->resourceType() == QRhiResource::TextureRenderTarget) {
const QRhiTextureRenderTargetDescription desc = static_cast<QRhiTextureRenderTarget *>(rt)->description();
for (auto it = desc.cbeginColorAttachments(), end = desc.cendColorAttachments(); it != end; ++it) {
if (it->multiViewCount() >= 2) {
viewCount = it->multiViewCount();
break;
}
}
}
}
} else {
qWarning("Neither swapchain nor redirected command buffer and render target are available.");
}
}
// MSAA is out of our control on this path: it is up to the
// QQuickWindow and the scenegraph to set up the swapchain based on the
// QSurfaceFormat's samples(). The only thing we need to do here is to
// pass the sample count to the renderer because it is needed when
// creating graphics pipelines.
rhiCtxD->setMainPassSampleCount(sampleCount);
// The "direct renderer", i.e. the Underlay and Overlay modes are the
// only ones that support multiview rendering. This becomes active when
// the QQuickWindow is redirected into a texture array, typically with
// an array size of 2 (2 views, for the left and right eye). Otherwise,
// when targeting a window or redirected to a 2D texture, this is not
// applicable and the view count is 1.
rhiCtxD->setMainPassViewCount(viewCount);
}
}
// The alternative to queryMainRenderPassDescriptorAndCommandBuffer()
// specifically for the Inline render mode when there is a QSGRenderNode.
inline void queryInlineRenderPassDescriptorAndCommandBuffer(QSGRenderNode *node, QSSGRhiContext *rhiCtx)
{
QSGRenderNodePrivate *d = QSGRenderNodePrivate::get(node);
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
rhiCtxD->setMainRenderPassDescriptor(d->m_rt.rpDesc);
rhiCtxD->setCommandBuffer(d->m_rt.cb);
rhiCtxD->setRenderTarget(d->m_rt.rt);
rhiCtxD->setMainPassSampleCount(d->m_rt.rt->sampleCount());
rhiCtxD->setMainPassViewCount(1);
}
} // namespace
QQuick3DSGRenderNode::~QQuick3DSGRenderNode()
{
delete renderer;
}
void QQuick3DSGRenderNode::prepare()
{
// this is outside the main renderpass
if (!renderer->m_sgContext->rhiContext()->isValid())
return;
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DPrepareFrame);
if (renderer->renderStats())
renderer->renderStats()->startRenderPrepare();
queryInlineRenderPassDescriptorAndCommandBuffer(this, renderer->m_sgContext->rhiContext().get());
qreal dpr = window->effectiveDevicePixelRatio();
const QSizeF itemSize = renderer->surfaceSize() / dpr;
QRectF viewport = matrix()->mapRect(QRectF(QPoint(0, 0), itemSize));
viewport = QRectF(viewport.topLeft() * dpr, viewport.size() * dpr);
const QRect vp = convertQtRectToGLViewport(viewport, window->size() * dpr);
Q_TRACE_SCOPE(QSSG_prepareFrame, vp.width(), vp.height());
renderer->beginFrame();
renderer->rhiPrepare(vp, dpr);
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DPrepareFrame, quint64(vp.width()) | quint64(vp.height()) << 32, renderer->profilingId);
if (renderer->renderStats())
renderer->renderStats()->endRenderPrepare();
}
void QQuick3DSGRenderNode::render(const QSGRenderNode::RenderState *state)
{
Q_UNUSED(state);
const auto &rhiContext = renderer->m_sgContext->rhiContext();
if (rhiContext->isValid()) {
if (renderer->renderStats())
renderer->renderStats()->startRender();
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderFrame);
Q_TRACE_SCOPE(QSSG_renderFrame, 0, 0);
queryInlineRenderPassDescriptorAndCommandBuffer(this, renderer->m_sgContext->rhiContext().get());
renderer->rhiRender();
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DRenderFrame,
STAT_PAYLOAD(QSSGRhiContextStats::get(*rhiContext)), renderer->profilingId);
renderer->endFrame();
if (renderer->renderStats())
renderer->renderStats()->endRender(dumpRenderTimes());
}
}
void QQuick3DSGRenderNode::releaseResources()
{
}
QSGRenderNode::RenderingFlags QQuick3DSGRenderNode::flags() const
{
// don't want begin/endExternal() to be called by Quick
return NoExternalRendering;
}
QQuick3DSGDirectRenderer::QQuick3DSGDirectRenderer(QQuick3DSceneRenderer *renderer, QQuickWindow *window, QQuick3DSGDirectRenderer::QQuick3DSGDirectRendererMode mode)
: m_renderer(renderer)
, m_window(window)
{
if (QSGRendererInterface::isApiRhiBased(window->rendererInterface()->graphicsApi())) {
connect(window, &QQuickWindow::beforeRendering, this, &QQuick3DSGDirectRenderer::prepare, Qt::DirectConnection);
if (mode == Underlay)
connect(window, &QQuickWindow::beforeRenderPassRecording, this, &QQuick3DSGDirectRenderer::render, Qt::DirectConnection);
else
connect(window, &QQuickWindow::afterRenderPassRecording, this, &QQuick3DSGDirectRenderer::render, Qt::DirectConnection);
}
}
QQuick3DSGDirectRenderer::~QQuick3DSGDirectRenderer()
{
delete m_renderer;
}
void QQuick3DSGDirectRenderer::setViewport(const QRectF &viewport)
{
m_viewport = viewport;
}
void QQuick3DSGDirectRenderer::setVisibility(bool visible)
{
if (m_isVisible == visible)
return;
m_isVisible = visible;
m_window->update();
}
void QQuick3DSGDirectRenderer::requestRender()
{
renderPending = true;
requestFullUpdate(m_window);
}
void QQuick3DSGDirectRenderer::preSynchronize()
{
// This is called from the QQuick3DViewport's updatePaintNode(), before
// QQuick3DSceneRenderer::synchronize(). It is essential to query things
// such as the view count already here, so that synchronize() can rely on
// mainPassViewCount() for instance. prepare() is too late as that is only
// called on beforeRendering (so after the scenegraph sync phase).
if (m_renderer->m_sgContext->rhiContext()->isValid())
queryMainRenderPassDescriptorAndCommandBuffer(m_window, m_renderer->m_sgContext->rhiContext().get());
}
void QQuick3DSGDirectRenderer::prepare()
{
if (!m_isVisible || !m_renderer)
return;
if (m_renderer->m_sgContext->rhiContext()->isValid()) {
// this is outside the main renderpass
if (m_renderer->m_postProcessingStack) {
if (renderPending) {
renderPending = false;
m_rhiTexture = m_renderer->renderToRhiTexture(m_window);
// Set up the main render target again, e.g. the postprocessing
// stack could have clobbered some settings such as the sample count.
queryMainRenderPassDescriptorAndCommandBuffer(m_window, m_renderer->m_sgContext->rhiContext().get());
const auto &quadRenderer = m_renderer->m_sgContext->renderer()->rhiQuadRenderer();
quadRenderer->prepareQuad(m_renderer->m_sgContext->rhiContext().get(), nullptr);
if (m_renderer->m_requestedFramesCount > 0) {
requestRender();
m_renderer->m_requestedFramesCount--;
}
}
}
else
{
QQuick3DRenderStats *renderStats = m_renderer->renderStats();
if (renderStats)
renderStats->startRenderPrepare();
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DPrepareFrame);
queryMainRenderPassDescriptorAndCommandBuffer(m_window, m_renderer->m_sgContext->rhiContext().get());
const QRect vp = convertQtRectToGLViewport(m_viewport, m_window->size() * m_window->effectiveDevicePixelRatio());
Q_TRACE_SCOPE(QSSG_prepareFrame, vp.width(), vp.height());
m_renderer->beginFrame();
m_renderer->rhiPrepare(vp, m_window->effectiveDevicePixelRatio());
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DPrepareFrame, quint64(vp.width()) | quint64(vp.height()) << 32, m_renderer->profilingId);
if (renderStats)
renderStats->endRenderPrepare();
}
}
}
void QQuick3DSGDirectRenderer::render()
{
if (!m_isVisible || !m_renderer)
return;
const auto &rhiContext = m_renderer->m_sgContext->rhiContext();
if (rhiContext->isValid()) {
// the command buffer is recording the main renderpass at this point
// No m_window->beginExternalCommands() must be done here. When the
// renderer is using the same
// QRhi/QRhiCommandBuffer/QRhiRenderPassDescriptor as the Qt Quick
// scenegraph, there is no difference from the RHI's perspective. There are
// no external (native) commands here.
// Requery the command buffer and co. since Offscreen mode View3Ds may
// have altered these on the context.
if (m_renderer->m_postProcessingStack) {
if (m_rhiTexture) {
queryMainRenderPassDescriptorAndCommandBuffer(m_window, rhiContext.get());
auto rhiCtx = m_renderer->m_sgContext->rhiContext().get();
const auto &renderer = m_renderer->m_sgContext->renderer();
QRhiCommandBuffer *cb = rhiContext->commandBuffer();
cb->debugMarkBegin(QByteArrayLiteral("Post-processing result to main rt"));
// Instead of passing in a flip flag we choose to rely on qsb's
// per-target compilation mode in the fragment shader. (it does UV
// flipping based on QSHADER_ macros) This is just better for
// performance and the shaders are very simple so introducing a
// uniform block and branching dynamically would be an overkill.
QRect vp = convertQtRectToGLViewport(m_viewport, m_window->size() * m_window->effectiveDevicePixelRatio());
const auto &shaderCache = m_renderer->m_sgContext->shaderCache();
const auto &shaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiSimpleQuadShader(m_renderer->m_layer->viewCount);
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge });
QSSGRhiShaderResourceBindingList bindings;
bindings.addTexture(0, QRhiShaderResourceBinding::FragmentStage, m_rhiTexture, sampler);
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiContext.get());
QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);
QSSGRhiGraphicsPipelineState ps;
ps.viewport = QRhiViewport(float(vp.x()), float(vp.y()), float(vp.width()), float(vp.height()));
ps.samples = rhiCtx->mainPassSampleCount();
ps.viewCount = m_renderer->m_layer->viewCount;
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, shaderPipeline.get());
renderer->rhiQuadRenderer()->recordRenderQuad(rhiCtx, &ps, srb, rhiCtx->mainRenderPassDescriptor(), QSSGRhiQuadRenderer::UvCoords | QSSGRhiQuadRenderer::PremulBlend);
cb->debugMarkEnd();
}
}
else
{
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderFrame);
Q_TRACE_SCOPE(QSSG_renderFrame, 0, 0);
if (m_renderer->renderStats())
m_renderer->renderStats()->startRender();
queryMainRenderPassDescriptorAndCommandBuffer(m_window, rhiContext.get());
m_renderer->rhiRender();
Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DRenderFrame,
STAT_PAYLOAD(QSSGRhiContextStats::get(*rhiContext)),
m_renderer->profilingId);
m_renderer->endFrame();
if (m_renderer->renderStats())
m_renderer->renderStats()->endRender(dumpRenderTimes());
}
}
}
QT_END_NAMESPACE