qssgrenderpass.cpp

++ // Copyright (C) 2022 The Qt Company Ltd.

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

++ // Qt-Security score:significant reason:default

++

++

++ #include "qssgrenderpass_p.h"

++ #include "qssgrhiquadrenderer_p.h"

++ #include "qssglayerrenderdata_p.h"

++ #include "qssgrendercontextcore.h"

++ #include "qssgdebugdrawsystem_p.h"

++ #include "extensionapi/qssgrenderextensions.h"

++ #include "qssgrenderhelpers_p.h"

++ #include "qssgrendercommands_p.h"

++ #include "graphobjects/qssgrenderskymaterial_p.h"

++

++ #include "../utils/qssgassert_p.h"

++

++ #include <QtQuick/private/qsgrenderer_p.h>

++ #include <qtquick3d_tracepoints_p.h>

++

++ QT_BEGIN_NAMESPACE

++

++ static const char defaultFragOutputs[][12] = {

++     "fragOutput",

++     "fragOutput1",

++     "fragOutput2",

++     "fragOutput3",

++ };

++

++ static QByteArrayView getDefaultOutputName(size_t index)

++ {

++     QSSG_ASSERT(std::size(defaultFragOutputs) > index, return defaultFragOutputs[0]);

++     return defaultFragOutputs[index];

++ }

++

++ static inline QMatrix4x4 correctMVPForScissor(QRectF viewportRect, QRect scissorRect, bool isYUp) {

++     const auto &scissorCenter = scissorRect.center();

++     const auto &viewCenter = viewportRect.center();

++     const float scaleX = viewportRect.width() / float(scissorRect.width());

++     const float scaleY = viewportRect.height() / float(scissorRect.height());

++     const float dx = 2 * (viewCenter.x() - scissorCenter.x()) / scissorRect.width();

++     const float dyRect = isYUp ? (scissorCenter.y() - viewCenter.y())

++                                 : (viewCenter.y() - scissorCenter.y());

++     const float dy = 2 * dyRect / scissorRect.height();

++

++     return QMatrix4x4(scaleX, 0.0f, 0.0f, dx,

++                       0.0f, scaleY, 0.0f, dy,

++                       0.0f, 0.0f, 1.0f, 0.0f,

++                       0.0f, 0.0f, 0.0f, 1.0f);

++ }

++

++ QSSGRenderPass::~QSSGRenderPass()

++ {

++

++ }

++

++

++ // MOTION VECTOR PASS

++

++ void MotionVectorMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     Q_UNUSED(renderer)

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     camera = data.renderedCameras[0];

++     QMatrix4x4 viewProjection(Qt::Uninitialized);

++     QMatrix4x4 cameraGlobalTransform(Qt::Uninitialized);

++     cameraGlobalTransform = data.getGlobalTransform(*camera);

++     data.renderedCameras[0]->calculateViewProjectionMatrix(cameraGlobalTransform, viewProjection);

++

++     const auto &layerPrepResult = data.layerPrepResult;

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++

++     const auto &renderedOpaques = data.getSortedOpaqueRenderableObjects(*camera);

++     const auto &renderedTransparent = data.getSortedTransparentRenderableObjects(*camera);

++

++     rhiMotionVectorTexture = data.getRenderResult(QSSGRenderResult::Key::MotionVectorTexture);

++     bool textureReady = rhiMotionVectorTexture &&

++             rhiPrepareMotionVectorTexture(rhiCtx.get(), layerPrepResult.textureDimensions(), rhiMotionVectorTexture);

++

++     if (!textureReady) {

++         rhiMotionVectorTexture = nullptr;

++         enabled = false;

++         return;

++     }

++

++     motionVectorMapManager = data.requestMotionVectorMapManager();

++     ps = data.getPipelineState();

++     ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled,

++                   QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled };

++     ps.samples = 1;

++     ps.viewCount = data.layer.viewCount;

++

++     for (int i = 0; i < MaxBuckets; ++i)

++         motionVectorPassObjects[i].clear();

++     enabled = false;

++

++     for (const auto &handles : { &renderedOpaques, &renderedTransparent }) {

++         for (const auto &handle : *handles) {

++             if (handle.obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||

++                 handle.obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {

++                 QSSGSubsetRenderable *renderable(static_cast<QSSGSubsetRenderable *>(handle.obj));

++                 if (handle.obj->renderableFlags.isMotionVectorParticipant()) {

++                     if (renderable->modelContext.model.instancing() && renderable->modelContext.model.instanceCount() == 0)

++                         continue;

++                     bool skin = renderable->modelContext.model.usesBoneTexture();

++                     bool instance = renderable->modelContext.model.instanceCount() > 0;

++                     bool morph = renderable->modelContext.model.morphTargets.size() > 0;

++                     int bucketIndex = (int(skin) << 2) | (int(instance) << 1) | int(morph);

++                     motionVectorPassObjects[bucketIndex].push_back(handle);

++

++                     QSSGRhiGraphicsPipelineState tempPs = ps;

++

++                     rhiPrepareMotionVectorRenderable(rhiCtx.get(),

++                                                      this,

++                                                      data,

++                                                      viewProjection,

++                                                      *handle.obj,

++                                                      rhiMotionVectorTexture->rpDesc,

++                                                      &tempPs,

++                                                      *motionVectorMapManager);

++                     enabled = true;

++                 }

++             }

++         }

++     }

++ }

++

++ void MotionVectorMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++     if (enabled) {

++         const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++         QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++         QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D motion vector map"));

++         Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D motion vector map"));

++

++         if (Q_LIKELY(rhiMotionVectorTexture && rhiMotionVectorTexture->isValid())) {

++             cb->beginPass(rhiMotionVectorTexture->rt, QColor(0, 0, 0, 0), { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());

++             QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rhiMotionVectorTexture->rt));

++             Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++             rhiRenderMotionVector(rhiCtx.get(),

++                                   ps,

++                                   motionVectorPassObjects,

++                                   MaxBuckets);

++

++             cb->endPass();

++             QSSGRHICTX_STAT(rhiCtx, endRenderPass());

++             Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("motion_vector_map"));

++         }

++         cb->debugMarkEnd();

++     }

++ }

++

++ void MotionVectorMapPass::resetForFrame()

++ {

++     QSSG_CHECK(motionVectorMapManager);

++     motionVectorMapManager->endFrame();

++     camera = nullptr;

++     ps = {};

++     rhiMotionVectorTexture = nullptr;

++     for (int i = 0; i < MaxBuckets; ++i)

++         motionVectorPassObjects[i].clear();

++ }

++

++ // SHADOW PASS

++

++ void ShadowMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     Q_UNUSED(renderer)

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     camera = data.renderedCameras[0];

++

++     QSSG_ASSERT(shadowPassObjects.isEmpty(), shadowPassObjects.clear());

++

++     data.getShadowCastingObjects(*camera, shadowPassObjects, castingObjectsBox, receivingObjectsBox);

++

++     globalLights = data.globalLights;

++     enabled = !shadowPassObjects.isEmpty() || !globalLights.isEmpty();

++

++     if (enabled) {

++         shadowMapManager = data.requestShadowMapManager();

++

++         ps = data.getPipelineState();

++         ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled };

++         // Try reducing self-shadowing and artifacts.

++         ps.depthBias = 2;

++         ps.slopeScaledDepthBias = 1.5f;

++

++         if (!debugCamera) {

++             debugCamera = std::make_unique<QSSGRenderCamera>(QSSGRenderGraphObject::Type::OrthographicCamera);

++         }

++     }

++ }

++

++ void ShadowMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: Sorted opaque and transparent + depth, global lights (scoped lights not supported) and camera.

++

++     // DEPENDECY: None

++

++     // OUTPUT: Texture (Shadowmap Texture Atlas)

++

++     // CONDITION: Lights (shadowPassObjects)

++

++     if (enabled) {

++         const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++         QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++         QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D shadow map"));

++         Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D shadow map"));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++         QSSG_CHECK(shadowMapManager);

++         rhiRenderShadowMap(rhiCtx.get(),

++                            this,

++                            ps,

++                            *shadowMapManager,

++                            *camera,

++                            debugCamera.get(),

++                            globalLights, // scoped lights are not relevant here

++                            shadowPassObjects,

++                            renderer,

++                            castingObjectsBox,

++                            receivingObjectsBox);

++

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("shadow_map"));

++     }

++ }

++

++ void ShadowMapPass::resetForFrame()

++ {

++     enabled = false;

++     camera = nullptr;

++     castingObjectsBox = {};

++     receivingObjectsBox = {};

++     ps = {};

++     shadowPassObjects.clear();

++     globalLights.clear();

++ }

++

++ // REFLECTIONMAP PASS

++

++ ReflectionMapPass::ReflectionMapPass()

++ {

++     // Read the environment variable to check if the old behavior of including the screen texture objects

++     // in the reflection pass should be kept for compatibility reasons.

++     // Besides being expensive, we shouldn't be using the main screen texture in the probes at all.

++     m_includeSTO = qEnvironmentVariableIntValue("QT_QUICK3D_REFLECTION_PASS_INCLUDE_SCREEN_TEXTURE_OBJECTS") != 0;

++ }

++

++ void ReflectionMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     Q_UNUSED(renderer);

++     Q_UNUSED(data);

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     ps = data.getPipelineState();

++     ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled,

++                   QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled,

++                   QSSGRhiGraphicsPipelineState::Flag::BlendEnabled };

++

++     QSSG_ASSERT(data.reflectionProbesView.size() != 0, return);

++

++     reflectionProbes = { data.reflectionProbesView.begin(), data.reflectionProbesView.end() };

++     reflectionMapManager = data.requestReflectionMapManager();

++

++     const auto &sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++     const auto &sortedTransparentObjects = data.getSortedTransparentRenderableObjects(*camera);

++     QSSGRenderableObjectList emptyList{};

++     const auto &sortedScreenTextureObjects = m_includeSTO ? data.getSortedScreenTextureRenderableObjects(*camera) : emptyList;

++

++     QSSG_ASSERT(reflectionPassObjects.isEmpty(), reflectionPassObjects.clear());

++

++     // NOTE: We should consider keeping track of the reflection casting objects to avoid

++     // filtering this list on each prep.

++     for (const auto &handles : { &sortedOpaqueObjects, &sortedTransparentObjects, &sortedScreenTextureObjects }) {

++         for (const auto &handle : *handles) {

++             if (handle.obj->renderableFlags.testFlag(QSSGRenderableObjectFlag::CastsReflections))

++                 reflectionPassObjects.push_back(handle);

++         }

++     }

++ }

++

++ void ReflectionMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: Reflection probes, sorted opaque and transparent

++

++     // DEPENDECY: None

++

++     // OUTPUT: Cube maps (1 per probe)

++

++     // NOTE: Full pass with a sky box pass

++

++     // CONDITION: Probes and sorted opaque and transparent

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     const auto *layerData = QSSGLayerRenderData::getCurrent(renderer);

++     QSSG_ASSERT(layerData, return);

++

++     QSSG_CHECK(reflectionMapManager);

++     if (!reflectionPassObjects.isEmpty() || (reflectionProbes.size() != 0)) {

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D reflection map"));

++         Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D reflection map"));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         rhiRenderReflectionMap(*renderer.contextInterface(), this, *layerData, &ps, *reflectionMapManager, reflectionProbes, reflectionPassObjects, renderer);

++

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("reflection_map"));

++     }

++ }

++

++ void ReflectionMapPass::resetForFrame()

++ {

++     ps = {};

++     reflectionProbes.clear();

++     reflectionPassObjects.clear();

++ }

++

++ // SKY MATERIAL PASS

++

++ void SkyMaterialPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     Q_UNUSED(renderer);

++     Q_UNUSED(data);

++ }

++

++ void SkyMaterialPass::renderPass(QSSGRenderer &renderer)

++ {

++     auto layerData = QSSGLayerRenderData::getCurrent(renderer);

++     QSSG_ASSERT(layerData, return);

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D Sky Material"));

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D Sky Material"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++     layerData->resolveLayerIblTexture(this);

++

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("sky_material"));

++ }

++

++ void SkyMaterialPass::resetForFrame() { }

++

++ // ZPrePass

++ void ZPrePassPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: Item2Ds + depth write + depth prepass

++

++     // DEPENDECY: none

++

++     // OUTPUT: Depth buffer attchment for current target

++

++     // NOTE: Could we make the depth pass more complete and just do a blit here?

++     //

++     // 1. If we have a depth map, just do a blit and then update with the rest

++     // 2. If we don't have a depth map (and/or SSAO) consider using a lower lod level.

++

++     // CONDITION: Input + globally enabled or ?

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     ps = data.getPipelineState();

++

++     renderedDepthWriteObjects = data.getSortedRenderedDepthWriteObjects(*camera);

++     renderedOpaqueDepthPrepassObjects = data.getSortedrenderedOpaqueDepthPrepassObjects(*camera);

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare Z prepass"));

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D prepare Z prepass"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     active = rhiPrepareDepthPass(rhiCtx.get(), this, ps, rhiCtx->mainRenderPassDescriptor(), data,

++                                          renderedDepthWriteObjects, renderedOpaqueDepthPrepassObjects,

++                                          rhiCtx->mainPassSampleCount(), data.layer.viewCount);

++     data.setZPrePassPrepResult(active);

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("prepare_z_prepass"));

++ }

++

++ void ZPrePassPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++

++     bool needsSetViewport = true;

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     if (active) {

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render Z prepass"));

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D render Z prepass"));

++         rhiRenderDepthPass(rhiCtx.get(), ps, renderedDepthWriteObjects, renderedOpaqueDepthPrepassObjects, &needsSetViewport);

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("render_z_prepass"));

++     }

++ }

++

++ void ZPrePassPass::resetForFrame()

++ {

++     renderedDepthWriteObjects.clear();

++     renderedOpaqueDepthPrepassObjects.clear();

++     ps = {};

++     active = false;

++ }

++

++ // SSAO PASS

++ void SSAOMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     // Assumption for now is that all passes are keept alive and only reset once a frame is done.

++     // I.e., holding data like this should be safe (If that's no longer the case we need to do ref counting

++     // for shared data).

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++

++     rhiAoTexture = data.getRenderResult(QSSGRenderResult::Key::AoTexture);

++     rhiDepthTexture = data.getRenderResult(QSSGRenderResult::Key::DepthTexture);

++     QSSG_ASSERT_X(!data.renderedCameras.isEmpty(), "Preparing AO pass failed, missing camera", return);

++     camera = data.renderedCameras[0];

++     QSSG_ASSERT_X((rhiDepthTexture && rhiDepthTexture->isValid()), "Preparing AO pass failed, missing equired texture(s)", return);

++

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++     ssaoShaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiSsaoShader(data.layer.viewCount);

++     aoSettings = { data.layer.aoStrength, data.layer.aoDistance, data.layer.aoSoftness, data.layer.aoBias, data.layer.aoSamplerate, data.layer.aoDither };

++

++     ps = data.getPipelineState();

++     const auto &layerPrepResult = data.layerPrepResult;

++     const bool ready = rhiAoTexture && rhiPrepareAoTexture(rhiCtx.get(), layerPrepResult.textureDimensions(), rhiAoTexture, data.layer.viewCount);

++

++     if (Q_UNLIKELY(!ready))

++         rhiAoTexture = nullptr;

++ }

++

++ void SSAOMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: Camera + depth map

++

++     // DEPENDECY: Depth map (zprepass)

++

++     // OUTPUT: AO Texture

++

++     // NOTE:

++

++     // CONDITION: SSAO enabled

++     QSSG_ASSERT(camera && rhiDepthTexture && rhiDepthTexture->isValid(), return);

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D SSAO map"));

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D SSAO map"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++     if (Q_LIKELY(rhiAoTexture && rhiAoTexture->isValid())) {

++         rhiRenderAoTexture(rhiCtx.get(),

++                            this,

++                            renderer,

++                            *ssaoShaderPipeline,

++                            ps,

++                            aoSettings,

++                            *rhiAoTexture,

++                            *rhiDepthTexture,

++                            *camera);

++     }

++

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("ssao_map"));

++ }

++

++ void SSAOMapPass::resetForFrame()

++ {

++     rhiDepthTexture = nullptr;

++     rhiAoTexture = nullptr;

++     camera = nullptr;

++     ps = {};

++     aoSettings = {};

++ }

++

++ // DEPTH TEXTURE PASS

++ void DepthMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     const auto &layerPrepResult = data.layerPrepResult;

++     bool ready = false;

++     ps = data.getPipelineState();

++

++     if (m_multisampling) {

++         ps.samples = rhiCtx->mainPassSampleCount();

++         rhiDepthTexture = data.getRenderResult(QSSGRenderResult::Key::DepthTextureMS);

++     } else {

++         ps.samples = 1;

++         rhiDepthTexture = data.getRenderResult(QSSGRenderResult::Key::DepthTexture);

++     }

++

++     if (Q_LIKELY(rhiDepthTexture && rhiPrepareDepthTexture(rhiCtx.get(), layerPrepResult.textureDimensions(), rhiDepthTexture, data.layer.viewCount, ps.samples))) {

++         sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++         sortedTransparentObjects = data.getSortedTransparentRenderableObjects(*camera);

++         // the depth texture is always non-MSAA, but is a 2D array with multiview

++         ready = rhiPrepareDepthPass(rhiCtx.get(), this, ps, rhiDepthTexture->rpDesc, data,

++                                     sortedOpaqueObjects, sortedTransparentObjects,

++                                     ps.samples, data.layer.viewCount);

++     }

++

++     if (Q_UNLIKELY(!ready))

++         rhiDepthTexture = nullptr;

++ }

++

++ void DepthMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: sorted objects (opaque + transparent) (maybe...)

++

++     // DEPENDECY: If this is only used for the AO case, that dictates if this should be done or not.

++

++     // OUTPUT: Texture

++

++     // NOTE: Why are we prepping opaque + transparent object if we're not using them? And why are we staying compatible with 5.15?

++     //       Only used for AO? Merge into the AO pass?

++

++     // NOTES:

++     //

++     // 1: If requested, use this and blit it in the z-pre pass.

++     // 2. Why are we handling the transparent objects in the render prep (only)?

++

++     // CONDITION:

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D depth texture"));

++

++     if (Q_LIKELY(rhiDepthTexture && rhiDepthTexture->isValid())) {

++         bool needsSetViewport = true;

++         cb->beginPass(rhiDepthTexture->rt, Qt::transparent, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());

++         QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rhiDepthTexture->rt));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         // NB! We do not pass sortedTransparentObjects in the 4th

++         // argument to stay compatible with the 5.15 code base,

++         // which also does not include semi-transparent objects in

++         // the depth texture. In addition, capturing after the

++         // opaque pass, not including transparent objects, is part

++         // of the contract for screen reading custom materials,

++         // both for depth and color.

++         rhiRenderDepthPass(rhiCtx.get(), ps, sortedOpaqueObjects, {}, &needsSetViewport);

++         cb->endPass();

++         QSSGRHICTX_STAT(rhiCtx, endRenderPass());

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("depth_texture"));

++     }

++

++     cb->debugMarkEnd();

++ }

++

++ void DepthMapPass::resetForFrame()

++ {

++     rhiDepthTexture = nullptr;

++     sortedOpaqueObjects.clear();

++     sortedTransparentObjects.clear();

++     ps = {};

++ }

++

++ // NORMAL TEXTURE PASS

++

++ void NormalPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QRhi *rhi = rhiCtx->rhi();

++     QSSG_ASSERT(rhi->isRecordingFrame(), return);

++     const auto &layerPrepResult = data.layerPrepResult;

++

++     // the normal texture is not multiview-dependent and it is always a 2D texture

++     // (so not an array with multiview either)

++

++     // the normal texture is always non-MSAA

++

++     ps = data.getPipelineState();

++     ps.samples = 1;

++     ps.viewCount = 1;

++

++     sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++

++     // transparent objects are not included in the normal texture pass

++

++     QSSGShaderFeatures shaderFeatures = data.getShaderFeatures();

++     shaderFeatures.set(QSSGShaderFeatures::Feature::NormalPass, true);

++

++     normalTexture = data.getRenderResult(QSSGRenderResult::Key::NormalTexture);

++

++     const QSize size = layerPrepResult.textureDimensions();

++     bool needsBuild = false;

++

++     if (!normalTexture->texture) {

++         QRhiTexture::Format format = QRhiTexture::RGBA16F;

++         if (!rhi->isTextureFormatSupported(format)) {

++             qWarning("No float formats, not great");

++             format = QRhiTexture::RGBA8;

++         }

++         normalTexture->texture = rhiCtx->rhi()->newTexture(format, size, 1, QRhiTexture::RenderTarget);

++         needsBuild = true;

++         normalTexture->texture->setName(QByteArrayLiteral("Normal texture"));

++     } else if (normalTexture->texture->pixelSize() != size) {

++         normalTexture->texture->setPixelSize(size);

++         needsBuild = true;

++     }

++

++     if (!normalTexture->depthStencil) {

++         normalTexture->depthStencil = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, size);

++         needsBuild = true;

++     } else if (normalTexture->depthStencil->pixelSize() != size) {

++         normalTexture->depthStencil->setPixelSize(size);

++         needsBuild = true;

++     }

++

++     if (needsBuild) {

++         if (!normalTexture->texture->create()) {

++             qWarning("Failed to build normal texture (size %dx%d, format %d)",

++                      size.width(), size.height(), int(normalTexture->texture->format()));

++             normalTexture->reset();

++             return;

++         }

++

++         if (!normalTexture->depthStencil->create()) {

++             qWarning("Failed to build depth-stencil buffer for normal texture (size %dx%d)",

++                      size.width(), size.height());

++             normalTexture->reset();

++             return;

++         }

++

++         normalTexture->resetRenderTarget();

++

++         QRhiTextureRenderTargetDescription rtDesc;

++         QRhiColorAttachment colorAttachment(normalTexture->texture);

++         rtDesc.setColorAttachments({ colorAttachment });

++         rtDesc.setDepthStencilBuffer(normalTexture->depthStencil);

++

++         normalTexture->rt = rhi->newTextureRenderTarget(rtDesc);

++         normalTexture->rt->setName(QByteArrayLiteral("Normal texture RT"));

++         normalTexture->rpDesc = normalTexture->rt->newCompatibleRenderPassDescriptor();

++         normalTexture->rt->setRenderPassDescriptor(normalTexture->rpDesc);

++         if (!normalTexture->rt->create()) {

++             qWarning("Failed to build render target for normal texture");

++             normalTexture->reset();

++             return;

++         }

++     }

++

++     rhiPrepareNormalPass(rhiCtx.get(), this, ps, normalTexture->rpDesc, data, sortedOpaqueObjects);

++ }

++

++ void NormalPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D normal texture"));

++

++     if (Q_LIKELY(normalTexture && normalTexture->isValid())) {

++          bool needsSetViewport = true;

++          cb->beginPass(normalTexture->rt, Qt::transparent, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());

++          QSSGRHICTX_STAT(rhiCtx, beginRenderPass(normalTexture->rt));

++          Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++         rhiRenderNormalPass(rhiCtx.get(), ps, sortedOpaqueObjects, &needsSetViewport);

++

++         cb->endPass();

++         QSSGRHICTX_STAT(rhiCtx, endRenderPass());

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("normal_texture"));

++     }

++

++     cb->debugMarkEnd();

++ }

++

++ void NormalPass::resetForFrame()

++ {

++     normalTexture = nullptr;

++     depthBuffer = nullptr;

++     sortedOpaqueObjects.clear();

++     ps = {};

++ }

++

++ // SCREEN TEXTURE PASS

++

++ void ScreenMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     rhiScreenTexture = data.getRenderResult(QSSGRenderResult::Key::ScreenTexture);

++     auto &layer = data.layer;

++     const auto &layerPrepResult = data.layerPrepResult;

++     wantsMips = layerPrepResult.getFlags().requiresMipmapsForScreenTexture();

++     sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++     ps = data.getPipelineState();

++     ps.samples = 1; // screen texture is always non-MSAA

++     ps.viewCount = data.layer.viewCount; // but is a 2D texture array when multiview

++     if (ps.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled))

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, true);

++

++     if (layer.background == QSSGRenderLayer::Background::Color)

++         clearColor = QColor::fromRgbF(layer.clearColor.x(), layer.clearColor.y(), layer.clearColor.z());

++

++     if (rhiCtx->rhi()->isFeatureSupported(QRhi::TexelFetch)) {

++         if (layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap && layer.skyBoxCubeMap) {

++             if (!skyboxCubeMapPass)

++                 skyboxCubeMapPass = SkyboxCubeMapPass();

++

++             skyboxCubeMapPass->skipTonemapping = true;

++             skyboxCubeMapPass->renderPrep(renderer, data);

++

++             // The pass expects to output to the main render target, but we have

++             // our own texture here, possibly with a differing sample count, so

++             // override the relevant settings once renderPrep() is done.

++             skyboxCubeMapPass->ps.samples = ps.samples;

++

++             skyboxPass = std::nullopt;

++         } else if ((layer.background == QSSGRenderLayer::Background::SkyBox && layer.lightProbe)

++                    || (layer.background == QSSGRenderLayer::Background::SkyMaterial && layer.skyMaterial)) {

++             if (!skyboxPass)

++                 skyboxPass = SkyboxPass();

++

++             skyboxPass->skipTonemapping = true;

++             skyboxPass->renderPrep(renderer, data);

++

++             skyboxPass->ps.samples = ps.samples;

++

++             skyboxCubeMapPass = std::nullopt;

++         }

++     }

++

++     bool ready = false;

++     if (Q_LIKELY(rhiScreenTexture && rhiPrepareScreenTexture(rhiCtx.get(), layerPrepResult.textureDimensions(), wantsMips, rhiScreenTexture, layer.viewCount))) {

++         ready = true;

++         if (skyboxCubeMapPass)

++             skyboxCubeMapPass->rpDesc = rhiScreenTexture->rpDesc;

++         if (skyboxPass)

++             skyboxPass->rpDesc = rhiScreenTexture->rpDesc;

++         // NB: not compatible with disabling LayerEnableDepthTest

++         // because there are effectively no "opaque" objects then.

++         // Disable Tonemapping for all materials in the screen pass texture

++         shaderFeatures = data.getShaderFeatures();

++         shaderFeatures.disableTonemapping();

++         const auto &sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++         for (const auto &handle : sortedOpaqueObjects) {

++             // Reflection cube maps are not available at this point, make sure they are turned off.

++             bool recRef = handle.obj->renderableFlags.receivesReflections();

++             handle.obj->renderableFlags.setReceivesReflections(false);

++             rhiPrepareRenderableForScreenMapPass(rhiCtx.get(), this, data, *handle.obj, rhiScreenTexture->rpDesc, &ps, shaderFeatures, 1, data.layer.viewCount);

++             handle.obj->renderableFlags.setReceivesReflections(recRef);

++         }

++     }

++

++     if (Q_UNLIKELY(!ready))

++         rhiScreenTexture = nullptr;

++ }

++

++ void ScreenMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     // INPUT: Sorted opaque objects + depth objects

++

++     // DEPENDECY: Depth pass (if enabled)

++

++     // OUTPUT: Texture (screen texture).

++

++     // NOTE: Used for refrection and effects (?)

++

++     // CONDITION:

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D screen texture"));

++

++     if (Q_LIKELY(rhiScreenTexture && rhiScreenTexture->isValid())) {

++         cb->beginPass(rhiScreenTexture->rt, clearColor, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());

++         QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rhiScreenTexture->rt));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++

++         bool needsSetViewport = true;

++         for (const auto &handle : std::as_const(sortedOpaqueObjects))

++             rhiRenderRenderable(rhiCtx.get(), ps, *handle.obj, &needsSetViewport);

++

++         if (skyboxCubeMapPass)

++             skyboxCubeMapPass->renderPass(renderer);

++         else if (skyboxPass)

++             skyboxPass->renderPass(renderer);

++

++         QRhiResourceUpdateBatch *rub = nullptr;

++         if (wantsMips) {

++             rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++             rub->generateMips(rhiScreenTexture->texture);

++         }

++         cb->endPass(rub);

++         QSSGRHICTX_STAT(rhiCtx, endRenderPass());

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("screen_texture"));

++     }

++

++     cb->debugMarkEnd();

++ }

++

++ void ScreenMapPass::resetForFrame()

++ {

++     rhiScreenTexture = nullptr;

++     if (skyboxPass)

++         skyboxPass->resetForFrame();

++     if (skyboxCubeMapPass)

++         skyboxCubeMapPass->resetForFrame();

++     ps = {};

++     wantsMips = false;

++     clearColor = Qt::transparent;

++     shaderFeatures = {};

++     sortedOpaqueObjects.clear();

++ }

++

++ void ScreenReflectionPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     rhiScreenTexture = data.getRenderResult(QSSGRenderResult::Key::ScreenTexture);

++     QSSG_ASSERT_X(rhiScreenTexture && rhiScreenTexture->isValid(), "Invalid screen texture!", return);

++

++     const auto &layer = data.layer;

++     const auto shaderFeatures = data.getShaderFeatures();

++     const bool layerEnableDepthTest = layer.layerFlags.testFlag(QSSGRenderLayer::LayerFlag::EnableDepthTest);

++

++     QRhiRenderPassDescriptor *mainRpDesc = rhiCtx->mainRenderPassDescriptor();

++     const int samples = rhiCtx->mainPassSampleCount();

++     const int viewCount = data.layer.viewCount;

++

++     // NOTE: We're piggybacking on the screen map pass for now, but we could do better.

++     ps = data.getPipelineState();

++     const bool depthTestEnabled = (data.screenMapPass.ps.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled));

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, depthTestEnabled);

++     const bool depthWriteEnabled = (data.screenMapPass.ps.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled));

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, depthWriteEnabled);

++     sortedScreenTextureObjects = data.getSortedScreenTextureRenderableObjects(*camera);

++     for (const auto &handle : std::as_const(sortedScreenTextureObjects)) {

++         QSSGRenderableObject *theObject = handle.obj;

++         const auto depthWriteMode = theObject->depthWriteMode;

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, theObject->renderableFlags.hasTransparency());

++         const bool curDepthWriteEnabled = !(depthWriteMode == QSSGDepthDrawMode::Never || depthWriteMode == QSSGDepthDrawMode::OpaquePrePass

++                                      || data.isZPrePassActive() || !layerEnableDepthTest);

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, curDepthWriteEnabled);

++         RenderHelpers::rhiPrepareRenderable(rhiCtx.get(), this, data, *theObject, mainRpDesc, &ps, shaderFeatures, samples, viewCount);

++     }

++ }

++

++ void ScreenReflectionPass::renderPass(QSSGRenderer &renderer)

++ {

++     if (QSSG_GUARD(rhiScreenTexture && rhiScreenTexture->isValid())) {

++         const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++         QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++         QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++         // 3. Screen texture depended objects

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D render screen texture dependent"));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         Q_TRACE(QSSG_renderPass_entry, QStringLiteral("Quick3D render screen texture dependent"));

++         bool needsSetViewport = true;

++         for (const auto &handle : std::as_const(sortedScreenTextureObjects)) {

++             QSSGRenderableObject *theObject = handle.obj;

++             RenderHelpers::rhiRenderRenderable(rhiCtx.get(), ps, *theObject, &needsSetViewport);

++         }

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("screen_texture_dependent"));

++         Q_TRACE(QSSG_renderPass_exit);

++     }

++ }

++

++ void ScreenReflectionPass::resetForFrame()

++ {

++     sortedScreenTextureObjects.clear();

++     rhiScreenTexture = nullptr;

++     ps = {};

++ }

++

++ void OpaquePass::prep(const QSSGRenderContextInterface &ctx,

++                       QSSGLayerRenderData &data,

++                       QSSGPassKey passKey,

++                       QSSGRhiGraphicsPipelineState &ps,

++                       QSSGShaderFeatures shaderFeatures,

++                       QRhiRenderPassDescriptor *rpDesc,

++                       const QSSGRenderableObjectList &sortedOpaqueObjects)

++ {

++     const auto &rhiCtx = ctx.rhiContext();

++     QSSG_ASSERT(rpDesc && rhiCtx->rhi()->isRecordingFrame(), return);

++

++     const auto &layer = data.layer;

++     const bool layerEnableDepthTest = layer.layerFlags.testFlag(QSSGRenderLayer::LayerFlag::EnableDepthTest);

++

++     for (const auto &handle : std::as_const(sortedOpaqueObjects)) {

++         QSSGRenderableObject *theObject = handle.obj;

++         const auto depthWriteMode = theObject->depthWriteMode;

++         const bool curDepthWriteEnabled = !(depthWriteMode == QSSGDepthDrawMode::Never ||

++                                             depthWriteMode == QSSGDepthDrawMode::OpaquePrePass ||

++                                             data.isZPrePassActive() || !layerEnableDepthTest);

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, curDepthWriteEnabled);

++         RenderHelpers::rhiPrepareRenderable(rhiCtx.get(), passKey, data, *theObject, rpDesc, &ps, shaderFeatures, ps.samples, ps.viewCount);

++     }

++ }

++

++ void OpaquePass::render(const QSSGRenderContextInterface &ctx,

++                         const QSSGRhiGraphicsPipelineState &ps,

++                         const QSSGRenderableObjectList &sortedOpaqueObjects)

++ {

++     const auto &rhiCtx = ctx.rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     bool needsSetViewport = true;

++     for (const auto &handle : std::as_const(sortedOpaqueObjects)) {

++         QSSGRenderableObject *theObject = handle.obj;

++         RenderHelpers::rhiRenderRenderable(rhiCtx.get(), ps, *theObject, &needsSetViewport);

++     }

++ }

++

++ void OpaquePass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(!data.renderedCameras.isEmpty() && data.renderedCameraData.has_value() , return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++     ps.depthFunc = QRhiGraphicsPipeline::LessOrEqual;

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, false);

++

++     // opaque objects (or, this list is empty when LayerEnableDepthTest is disabled)

++     sortedOpaqueObjects = data.getSortedOpaqueRenderableObjects(*camera);

++     shaderFeatures = data.getShaderFeatures();

++

++     QRhiRenderPassDescriptor *mainRpDesc = rhiCtx->mainRenderPassDescriptor();

++     prep(*ctx, data, this, ps, shaderFeatures, mainRpDesc, sortedOpaqueObjects);

++ }

++

++ void OpaquePass::renderPass(QSSGRenderer &renderer)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D render opaque"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE(QSSG_renderPass_entry, QStringLiteral("Quick3D render opaque"));

++     render(*ctx, ps, sortedOpaqueObjects);

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("opaque_pass"));

++     Q_TRACE(QSSG_renderPass_exit);

++ }

++

++ void OpaquePass::resetForFrame()

++ {

++     sortedOpaqueObjects.clear();

++     ps = {};

++     shaderFeatures = {};

++ }

++

++ void TransparentPass::prep(const QSSGRenderContextInterface &ctx,

++                            QSSGLayerRenderData &data,

++                            QSSGPassKey passKey,

++                            QSSGRhiGraphicsPipelineState &ps,

++                            QSSGShaderFeatures shaderFeatures,

++                            QRhiRenderPassDescriptor *rpDesc,

++                            const QSSGRenderableObjectList &sortedTransparentObjects,

++                            bool oit)

++ {

++     const auto &rhiCtx = ctx.rhiContext();

++     QSSG_ASSERT(rpDesc && rhiCtx->rhi()->isRecordingFrame(), return);

++

++     const bool zPrePassActive = data.isZPrePassActive();

++     for (const auto &handle : std::as_const(sortedTransparentObjects)) {

++         QSSGRenderableObject *theObject = handle.obj;

++         const auto depthWriteMode = theObject->depthWriteMode;

++         const bool curDepthWriteEnabled = (depthWriteMode == QSSGDepthDrawMode::Always && !zPrePassActive);

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, curDepthWriteEnabled);

++         if (!(theObject->renderableFlags.isCompletelyTransparent())) {

++             RenderHelpers::rhiPrepareRenderable(rhiCtx.get(), passKey, data, *theObject, rpDesc, &ps, shaderFeatures,

++                                                 ps.samples, ps.viewCount, nullptr, nullptr, QSSGRenderTextureCubeFaceNone, nullptr, oit);

++         }

++     }

++ }

++

++ void TransparentPass::render(const QSSGRenderContextInterface &ctx,

++                              const QSSGRhiGraphicsPipelineState &ps,

++                              const QSSGRenderableObjectList &sortedTransparentObjects)

++ {

++     const auto &rhiCtx = ctx.rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     // If scissorRect is set, Item2Ds will be drawn by a workaround of modifying

++     // viewport, not using actual 3D scissor test.

++     // It means non-opaque objects may be affected by this viewport setting.

++     bool needsSetViewport = true;

++     for (const auto &handle : std::as_const(sortedTransparentObjects)) {

++         QSSGRenderableObject *theObject = handle.obj;

++         if (!theObject->renderableFlags.isCompletelyTransparent())

++             RenderHelpers::rhiRenderRenderable(rhiCtx.get(), ps, *theObject, &needsSetViewport);

++     }

++ }

++

++ void TransparentPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty() && data.renderedCameraData.has_value() , return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     QRhiRenderPassDescriptor *mainRpDesc = rhiCtx->mainRenderPassDescriptor();

++

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++

++     // transparent objects (or, without LayerEnableDepthTest, all objects)

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, false);

++

++     shaderFeatures = data.getShaderFeatures();

++     sortedTransparentObjects = data.getSortedTransparentRenderableObjects(*camera);

++

++     prep(*ctx, data, this, ps, shaderFeatures, mainRpDesc, sortedTransparentObjects);

++ }

++

++ void TransparentPass::renderPass(QSSGRenderer &renderer)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D render alpha"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE(QSSG_renderPass_entry, QStringLiteral("Quick3D render alpha"));

++     render(*ctx, ps, sortedTransparentObjects);

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("transparent_pass"));

++     Q_TRACE(QSSG_renderPass_exit);

++ }

++

++ void TransparentPass::resetForFrame()

++ {

++     sortedTransparentObjects.clear();

++     ps = {};

++     shaderFeatures = {};

++ }

++

++ static void skyMaterialTonemapFeatures(QSSGRenderLayer::TonemapMode mode, QSSGShaderFeatures &features, quint32 &key)

++ {

++     switch (mode) {

++     case QSSGRenderLayer::TonemapMode::Linear:

++         features.set(QSSGShaderFeatures::Feature::LinearTonemapping, true);

++         key = 1;

++         break;

++     case QSSGRenderLayer::TonemapMode::Aces:

++         features.set(QSSGShaderFeatures::Feature::AcesTonemapping, true);

++         key = 2;

++         break;

++     case QSSGRenderLayer::TonemapMode::HejlDawson:

++         features.set(QSSGShaderFeatures::Feature::HejlDawsonTonemapping, true);

++         key = 3;

++         break;

++     case QSSGRenderLayer::TonemapMode::Filmic:

++         features.set(QSSGShaderFeatures::Feature::FilmicTonemapping, true);

++         key = 4;

++         break;

++     case QSSGRenderLayer::TonemapMode::None:

++     case QSSGRenderLayer::TonemapMode::Custom:

++         key = 0; // passthrough (Custom tonemapping in the sky is not yet supported)

++         break;

++     }

++ }

++

++ void SkyboxPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     if (!skipPrep) {

++         const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++         QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++         QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++         QSSG_ASSERT(data.renderedCameras.count() == data.layer.viewCount, return);

++         layer = &data.layer;

++         QSSG_ASSERT(layer, return);

++

++         rpDesc = rhiCtx->mainRenderPassDescriptor();

++         ps = data.getPipelineState();

++         ps.samples = rhiCtx->mainPassSampleCount();

++         ps.viewCount = data.layer.viewCount;

++         ps.polygonMode = QRhiGraphicsPipeline::Fill;

++

++         // When there are effects, then it is up to the last pass of the

++         // last effect to perform tonemapping, neither the skybox nor the

++         // main render pass should alter the colors then.

++         skipTonemapping = layer->firstEffect != nullptr;

++

++         RenderHelpers::rhiPrepareSkyBox(*renderer.contextInterface(), this, *layer, data.renderedCameras, renderer);

++         skipPrep = true;

++     }

++ }

++

++ void SkyboxPass::renderPass(QSSGRenderer &renderer)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(layer, return);

++

++     QRhiShaderResourceBindings *srb = layer->skyBoxSrb;

++     if (!srb)

++         return;

++

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render skybox"));

++

++     // Note: We get the shader here, as the screen map pass might modify the state of

++     // the tonemap mode.

++

++     QSSGRenderLayer::TonemapMode tonemapMode = skipTonemapping && (layer->tonemapMode != QSSGRenderLayer::TonemapMode::Custom) ?  QSSGRenderLayer::TonemapMode::None : layer->tonemapMode;

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++     auto shaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiSkyBoxShader(tonemapMode, layer->skyBoxIsRgbe8, layer->viewCount);

++     QSSG_CHECK(shaderPipeline);

++     QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, shaderPipeline.get());

++     renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rpDesc, { QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::RenderBehind });

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("skybox_map"));

++ }

++

++ void SkyboxPass::resetForFrame()

++ {

++     ps = {};

++     layer = nullptr;

++     skipPrep = false;

++ }

++

++ // SKY MATERIAL BACKGROUND PASS (screen-space)

++

++ void SkyMaterialBackgroundPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     const auto &ctx = *renderer.contextInterface();

++     const auto &rhiCtx = ctx.rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSG_ASSERT(data.renderedCameras.count() == data.layer.viewCount, return);

++     layer = &data.layer;

++     QSSG_ASSERT(layer && layer->skyMaterial, return);

++

++     ready = false;

++

++     rpDesc = rhiCtx->mainRenderPassDescriptor();

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++     ps.polygonMode = QRhiGraphicsPipeline::Fill;

++     // When there are effects, the last effect pass performs tonemapping, so the sky must

++     // output linear here (TonemapMode::None below).

++     skipTonemapping = layer->firstEffect != nullptr;

++

++     QRhi *rhi = rhiCtx->rhi();

++     QSSGRenderSkyMaterial &skyMaterial = *layer->skyMaterial;

++     const int viewCount = data.layer.viewCount;

++

++     const QSSGRenderLayer::TonemapMode tonemapMode =

++             skipTonemapping && (layer->tonemapMode != QSSGRenderLayer::TonemapMode::Custom)

++             ? QSSGRenderLayer::TonemapMode::None

++             : layer->tonemapMode;

++     QSSGShaderFeatures tonemapFeatures;

++     quint32 tonemapKey = 0;

++     skyMaterialTonemapFeatures(tonemapMode, tonemapFeatures, tonemapKey);

++

++     pipeline = skyMaterial.ensureBackgroundPipeline(ctx, tonemapFeatures, tonemapKey, viewCount);

++     if (!pipeline) // shader/textures not ready yet — skip this frame (clear color shows)

++         return;

++

++     // Reconstruct the view direction inputs exactly like skybox.vert, per view:

++     //   eye = orientation * (cameraRotation * (inverseProjection * ndcPos))

++     // viewRotation folds orientation * cameraRotation into one translation-free matrix.

++     // orientation (the probe orientation) is shared across views.

++     const QMatrix3x3 o = layer->lightProbeSettings.probeOrientation;

++     const QMatrix4x4 orientation(o(0, 0), o(0, 1), o(0, 2), 0.0f,

++                                  o(1, 0), o(1, 1), o(1, 2), 0.0f,

++                                  o(2, 0), o(2, 1), o(2, 2), 0.0f,

++                                  0.0f,    0.0f,    0.0f,    1.0f);

++     QVarLengthArray<QMatrix4x4, 2> inverseProjections;

++     QVarLengthArray<QMatrix4x4, 2> viewRotations;

++     for (int v = 0; v < viewCount; ++v) {

++         const QSSGRenderCamera &camera = *data.renderedCameras[v];

++         inverseProjections.append(camera.projection.inverted());

++         QMatrix4x4 cameraRotation = data.getGlobalTransform(camera);

++         cameraRotation.setColumn(3, QVector4D(0.0f, 0.0f, 0.0f, 1.0f)); // drop translation

++         viewRotations.append(orientation * cameraRotation);

++     }

++     const float adjustY = rhi->isYUpInNDC() ? 1.0f : -1.0f;

++     const float exposure = layer->lightProbeSettings.probeExposure;

++

++     skyMaterial.updateBackgroundUniforms(ctx, this, inverseProjections, viewRotations, adjustY, exposure);

++

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++     backgroundSrb = rhiCtxD->srb(skyMaterial.backgroundBindings);

++

++     switch (skyMaterial.skyboxMode) {

++     case QSSGRenderSkyMaterial::SkyboxMode::ScreenSpaceHalf:

++         scaleDivisor = 2;

++         break;

++     case QSSGRenderSkyMaterial::SkyboxMode::ScreenSpaceQuarter:

++         scaleDivisor = 4;

++         break;

++     case QSSGRenderSkyMaterial::SkyboxMode::ScreenSpaceFull:

++     case QSSGRenderSkyMaterial::SkyboxMode::Cubemap:

++         scaleDivisor = 1;

++         break;

++     }

++

++     renderer.rhiQuadRenderer()->prepareQuad(rhiCtx.get(), nullptr);

++

++     // Reduced-scale: render the (tonemapped) sky into a smaller offscreen target now, in

++     // the prepare phase, so renderPass only has to upscale-blit it into the main pass.

++     if (scaleDivisor > 1) {

++         const std::array<float, 4> vp = ps.viewport.viewport();

++         const QSize fullSize(int(vp.at(2)), int(vp.at(3)));

++         const QSize targetSize = (fullSize / qreal(scaleDivisor)).expandedTo(QSize(1, 1));

++         const bool multiView = viewCount >= 2;

++         const int wantArraySize = multiView ? viewCount : 0;

++

++         offscreenTexture = data.getRenderResult(QSSGRenderResult::Key::SkyMaterialBackgroundTexture);

++         QSSGRhiRenderableTexture *tex = offscreenTexture;

++         if (!tex->texture || tex->texture->pixelSize() != targetSize || tex->texture->arraySize() != wantArraySize) {

++             tex->reset();

++             tex->texture = multiView ? rhi->newTextureArray(QRhiTexture::RGBA16F, viewCount, targetSize, 1, QRhiTexture::RenderTarget)

++                                      : rhi->newTexture(QRhiTexture::RGBA16F, targetSize, 1, QRhiTexture::RenderTarget);

++             if (!tex->texture->create()) {

++                 qWarning("Failed to build SkyMaterial screen-space background texture");

++                 tex->reset();

++                 offscreenTexture = nullptr;

++                 return;

++             }

++             QRhiColorAttachment att(tex->texture);

++             att.setMultiViewCount(viewCount);

++             QRhiTextureRenderTargetDescription desc;

++             desc.setColorAttachments({ att });

++             tex->rt = rhi->newTextureRenderTarget(desc);

++             tex->rt->setName(QByteArrayLiteral("SkyMaterial screen-space background"));

++             tex->rpDesc = tex->rt->newCompatibleRenderPassDescriptor();

++             tex->rt->setRenderPassDescriptor(tex->rpDesc);

++             if (!tex->rt->create()) {

++                 qWarning("Failed to build SkyMaterial screen-space background render target");

++                 tex->reset();

++                 offscreenTexture = nullptr;

++                 return;

++             }

++         }

++

++         QSSGRhiGraphicsPipelineState offscreenPs;

++         offscreenPs.viewport = QRhiViewport(0, 0, float(targetSize.width()), float(targetSize.height()));

++         offscreenPs.samples = 1;

++         offscreenPs.viewCount = viewCount;

++         offscreenPs.polygonMode = QRhiGraphicsPipeline::Fill;

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(offscreenPs, pipeline.get());

++         renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx.get(), &offscreenPs, backgroundSrb,

++                                                          offscreenTexture->rt, QSSGRhiQuadRenderer::RenderBehind);

++     }

++

++     ready = true;

++ }

++

++ void SkyMaterialBackgroundPass::renderPass(QSSGRenderer &renderer)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(layer, return);

++

++     if (!ready) // sky shader not ready this frame

++         return;

++

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render sky material background"));

++

++     if (scaleDivisor > 1) {

++         QSSG_ASSERT(offscreenTexture && offscreenTexture->isValid(), return);

++         const auto &shaderCache = renderer.contextInterface()->shaderCache();

++         auto upscaleShader = shaderCache->getBuiltInRhiShaders().getRhiSimpleQuadShader(layer->viewCount,

++                                                                                        QSSGRenderLayer::TonemapMode::None);

++         QSSG_CHECK(upscaleShader);

++

++         QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,

++                                                  QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });

++         QSSGRhiShaderResourceBindingList bindings;

++         bindings.addTexture(0, QRhiShaderResourceBinding::FragmentStage, offscreenTexture->texture, sampler);

++         QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++         QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);

++

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, upscaleShader.get());

++         renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rpDesc,

++                                                      { QSSGRhiQuadRenderer::UvCoords | QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::RenderBehind });

++     } else {

++         QSSG_ASSERT(pipeline && backgroundSrb, return);

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, pipeline.get());

++         renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, backgroundSrb, rpDesc,

++                                                      { QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::RenderBehind });

++     }

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("sky_material_background"));

++ }

++

++ void SkyMaterialBackgroundPass::resetForFrame()

++ {

++     ps = {};

++     layer = nullptr;

++     ready = false;

++     scaleDivisor = 1;

++     pipeline = nullptr;

++     backgroundSrb = nullptr;

++     offscreenTexture = nullptr;

++ }

++

++ void SkyboxCubeMapPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSG_ASSERT(data.renderedCameras.count() == data.layer.viewCount, return);

++     layer = &data.layer;

++     QSSG_ASSERT(layer, return);

++

++     rpDesc = rhiCtx->mainRenderPassDescriptor();

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++     ps.polygonMode = QRhiGraphicsPipeline::Fill;

++

++     QSSGRenderLayer::TonemapMode tonemapMode = skipTonemapping && (layer->tonemapMode != QSSGRenderLayer::TonemapMode::Custom) ?  QSSGRenderLayer::TonemapMode::None : layer->tonemapMode;

++

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++     skyBoxCubeShader = shaderCache->getBuiltInRhiShaders().getRhiSkyBoxCubeShader(tonemapMode, !data.layer.skyBoxIsSrgb, data.layer.viewCount);

++

++     RenderHelpers::rhiPrepareSkyBox(*renderer.contextInterface(), this, *layer, data.renderedCameras, renderer, uint(tonemapMode));

++ }

++

++ void SkyboxCubeMapPass::renderPass(QSSGRenderer &renderer)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(layer && skyBoxCubeShader, return);

++

++     QRhiShaderResourceBindings *srb = layer->skyBoxSrb;

++     QSSG_ASSERT(srb, return);

++

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render cubemap skybox"));

++

++     QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, skyBoxCubeShader.get());

++     renderer.rhiCubeRenderer()->recordRenderCube(rhiCtx.get(), &ps, srb, rpDesc, { QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::RenderBehind });

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("skybox_cube"));

++ }

++

++ void SkyboxCubeMapPass::resetForFrame()

++ {

++     ps = {};

++     layer = nullptr;

++ }

++

++ void Item2DPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     const auto &layer = data.layer;

++

++     const auto &item2Ds = data.getRenderableItem2Ds();

++     prepdItem2DRenderers.reserve(size_t(item2Ds.size()));

++     // NOTE: This marks the start of the 2D sub-scene rendering as it might result in

++     // a nested 3D scene to be rendered and if we don't save the state here, we can

++     // end up with a mismatched state in the QtQuick3D renderer.

++     // See the end of this function for the corresponding end call (endSubLayerRender()).

++     renderer.beginSubLayerRender(data);

++     for (const auto *item2D: std::as_const(item2Ds)) {

++         // Find data for item

++         auto item2DData = data.getItem2DRenderer(*item2D);

++         const auto &mvps = data.getItem2DMvps(*item2D);

++         QSGRenderer *renderer2d = item2DData;

++

++         QSSG_ASSERT(renderer2d, continue);

++

++         // NOTE: We shouldn't get into this state...

++         if (renderer2d && renderer2d->currentRhi() != rhiCtx->rhi()) {

++             static bool contextWarningShown = false;

++             if (!contextWarningShown) {

++                 qWarning () << "Scene with embedded 2D content can only be rendered in one window.";

++                 contextWarningShown = true;

++             }

++             continue;

++         }

++

++         // Set the projection matrix

++

++         auto layerPrepResult = data.layerPrepResult;

++

++         QRhiRenderTarget *renderTarget = rhiCtx->renderTarget();

++         auto *rpd = renderTarget->renderPassDescriptor();

++         renderer2d->setDevicePixelRatio(renderTarget->devicePixelRatio());

++         const QRect deviceRect(QPoint(0, 0), renderTarget->pixelSize());

++         const int viewCount = data.layer.viewCount;

++         if (layer.scissorRect.isValid()) {

++             QRect effScissor = layer.scissorRect & layerPrepResult.getViewport().toRect();

++             QMatrix4x4 correctionMat = correctMVPForScissor(layerPrepResult.getViewport(),

++                                                             effScissor,

++                                                             rhiCtx->rhi()->isYUpInNDC());

++             for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex) {

++                 const QMatrix4x4 projectionMatrix = correctionMat * mvps[viewIndex];

++                 renderer2d->setProjectionMatrix(projectionMatrix, viewIndex);

++             }

++             renderer2d->setViewportRect(effScissor);

++         } else {

++             for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex)

++                 renderer2d->setProjectionMatrix(mvps[viewIndex], viewIndex);

++             renderer2d->setViewportRect(RenderHelpers::correctViewportCoordinates(layerPrepResult.getViewport(), deviceRect));

++         }

++         renderer2d->setDeviceRect(deviceRect);

++         QSGRenderTarget sgRt(renderTarget, rpd, rhiCtx->commandBuffer());

++         sgRt.multiViewCount = data.layer.viewCount;

++         renderer2d->setRenderTarget(sgRt);

++         renderer2d->prepareSceneInline();

++         prepdItem2DRenderers.push_back(renderer2d);

++     }

++     renderer.endSubLayerRender(data);

++ }

++

++ void Item2DPass::renderPass(QSSGRenderer &renderer)

++ {

++     QSSG_ASSERT(prepdItem2DRenderers.size() > 0, return);

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D render 2D sub-scene"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render 2D sub-scene"));

++     QSSGLayerRenderData *data = QSSGLayerRenderData::getCurrent(renderer);

++     renderer.beginSubLayerRender(*data);

++     for (QSGRenderer *renderer2d : std::as_const(prepdItem2DRenderers))

++         renderer2d->renderSceneInline();

++     renderer.endSubLayerRender(*data);

++     cb->debugMarkEnd();

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("2D_sub_scene"));

++ }

++

++ void Item2DPass::resetForFrame()

++ {

++     prepdItem2DRenderers.clear();

++ }

++

++ void InfiniteGridPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSG_ASSERT(data.renderedCameras.count() == data.layer.viewCount, return);

++     layer = &data.layer;

++     QSSG_ASSERT(layer, return);

++

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++     gridShader = shaderCache->getBuiltInRhiShaders().getRhiGridShader(data.layer.viewCount);

++

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++     ps.polygonMode = QRhiGraphicsPipeline::Fill;

++

++     RenderHelpers::rhiPrepareGrid(rhiCtx.get(), this, *layer, data.renderedCameras, renderer);

++ }

++

++ void InfiniteGridPass::renderPass(QSSGRenderer &renderer)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(gridShader && rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     cb->debugMarkBegin(QByteArrayLiteral("Quick3D render grid"));

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++     Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick3D render grid"));

++     QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, gridShader.get());

++     QRhiShaderResourceBindings *srb = layer->gridSrb;

++     QRhiRenderPassDescriptor *rpDesc = rhiCtx->mainRenderPassDescriptor();

++     renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rpDesc, { QSSGRhiQuadRenderer::DepthTest });

++     Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("render_grid"));

++ }

++

++ void InfiniteGridPass::resetForFrame()

++ {

++     ps = {};

++     layer = nullptr;

++ }

++

++ void DebugDrawPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     QSSG_ASSERT(data.renderedCameras.count() == data.layer.viewCount, return);

++

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++     debugObjectShader = shaderCache->getBuiltInRhiShaders().getRhiDebugObjectShader(data.layer.viewCount);

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = data.layer.viewCount;

++

++     // debug objects

++     const auto &debugDraw = renderer.contextInterface()->debugDrawSystem();

++     if (debugDraw && debugDraw->hasContent()) {

++         QRhi *rhi = rhiCtx->rhi();

++         QRhiResourceUpdateBatch *rub = rhi->nextResourceUpdateBatch();

++         debugDraw->prepareGeometry(rhiCtx.get(), rub);

++         QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ this, nullptr, nullptr, nullptr, 0 });

++         if (!dcd.ubuf) {

++             dcd.ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, 64 * data.renderedCameras.count());

++             dcd.ubuf->create();

++         }

++         char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();

++         QMatrix4x4 viewProjection(Qt::Uninitialized);

++         QMatrix4x4 cameraGlobalTransform(Qt::Uninitialized);

++         for (qsizetype viewIdx = 0; viewIdx < data.renderedCameras.count(); ++viewIdx) {

++             cameraGlobalTransform = data.getGlobalTransform(*data.renderedCameras[viewIdx]);

++             data.renderedCameras[viewIdx]->calculateViewProjectionMatrix(cameraGlobalTransform, viewProjection);

++             viewProjection = rhi->clipSpaceCorrMatrix() * viewProjection;

++             memcpy(ubufData, viewProjection.constData() + viewIdx * 64, 64);

++         }

++         dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();

++

++         QSSGRhiShaderResourceBindingList bindings;

++         bindings.addUniformBuffer(0, QRhiShaderResourceBinding::VertexStage, dcd.ubuf);

++         dcd.srb = rhiCtxD->srb(bindings);

++

++         rhiCtx->commandBuffer()->resourceUpdate(rub);

++     }

++ }

++

++ void DebugDrawPass::renderPass(QSSGRenderer &renderer)

++ {

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(debugObjectShader && rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++

++     const auto &debugDraw = renderer.contextInterface()->debugDrawSystem();

++     if (debugDraw && debugDraw->hasContent()) {

++         cb->debugMarkBegin(QByteArrayLiteral("Quick 3D debug objects"));

++         Q_TRACE_SCOPE(QSSG_renderPass, QStringLiteral("Quick 3D debug objects"));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, debugObjectShader.get());

++         QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ this, nullptr, nullptr, nullptr, 0 });

++         QRhiShaderResourceBindings *srb = dcd.srb;

++         QRhiRenderPassDescriptor *rpDesc = rhiCtx->mainRenderPassDescriptor();

++         debugDraw->recordRenderDebugObjects(rhiCtx.get(), &ps, srb, rpDesc);

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("debug_objects"));

++     }

++ }

++

++ void DebugDrawPass::resetForFrame()

++ {

++     ps = {};

++ }

++

++ void UserExtensionPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     Q_UNUSED(renderer);

++     auto &frameData = data.getFrameData();

++     for (const auto &p : std::as_const(extensions)) {

++         p->prepareRender(frameData);

++         if (p->mode() == QSSGRenderExtension::RenderMode::Standalone)

++             p->render(frameData);

++     }

++ }

++

++ void UserExtensionPass::renderPass(QSSGRenderer &renderer)

++ {

++     auto *data = QSSGLayerRenderData::getCurrent(renderer);

++     QSSG_ASSERT(data, return);

++     auto &frameData = data->getFrameData();

++     for (const auto &p : std::as_const(extensions)) {

++         if (p->mode() == QSSGRenderExtension::RenderMode::Main)

++             p->render(frameData);

++     }

++ }

++

++ void UserExtensionPass::resetForFrame()

++ {

++     for (const auto &p : std::as_const(extensions))

++         p->resetForFrame();

++

++     // TODO: We should track if we need to update this list.

++     extensions.clear();

++ }

++

++ static quint32 nextMultipleOf(quint32 value, quint32 multiple)

++ {

++     return multiple * ((value / multiple) + 1);

++ }

++

++ static quint32 ensureFreeNodes(quint32 value, quint32 multiple)

++ {

++     quint32 multipleOf = nextMultipleOf(value, multiple);

++     if (multipleOf - value < multiple)

++         multipleOf += multiple;

++     return multipleOf;

++ }

++

++ bool OITRenderPass::linkedListRequiresResize(QSize dim)

++ {

++     quint32 reported = reportedNodeCount;

++     quint32 current = currentNodeCount;

++     quint32 fullCount = dim.width() * dim.height();

++

++     // resize if reported is greater than current or if there are less than 50% of screen size nodes free

++     if (reported > current)

++         return true;

++     quint32 freeCount = current - reported;

++     if (freeCount < fullCount / 2)

++         return true;

++     // resize if we have more than 100% screen size free nodes

++     if (freeCount > fullCount)

++         return true;

++     return false;

++ }

++

++ void OITRenderPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++     auto *rhi = rhiCtx->rhi();

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty() && data.renderedCameraData.has_value() , return);

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = rhiCtx->mainPassViewCount();

++

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++     ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, false);

++

++     shaderFeatures = data.getShaderFeatures();

++     sortedTransparentObjects = data.getSortedTransparentRenderableObjects(*camera);

++

++     if (method == QSSGRenderLayer::OITMethod::WeightedBlended) {

++         ps.colorAttachmentCount = 2;

++

++         rhiAccumTexture = data.getRenderResult(QSSGRenderResult::Key::AccumTexture);

++         rhiRevealageTexture = data.getRenderResult(QSSGRenderResult::Key::RevealageTexture);

++         if (ps.samples > 1)

++             rhiDepthTexture = data.getRenderResult(QSSGRenderResult::Key::DepthTextureMS);

++         else

++             rhiDepthTexture = data.getRenderResult(QSSGRenderResult::Key::DepthTexture);

++         if (!rhiDepthTexture->isValid())

++             return;

++         auto &oitrt = data.getOitRenderContext();

++         if (!oitrt.oitRenderTarget || oitrt.oitRenderTarget->pixelSize() != data.layerPrepResult.textureDimensions()

++             || rhiDepthTexture->texture != oitrt.oitRenderTarget->description().depthTexture()

++             || ps.samples != oitrt.oitRenderTarget->sampleCount()) {

++             if (oitrt.oitRenderTarget) {

++                 delete oitrt.oitRenderTarget;

++                 delete oitrt.renderPassDescriptor;

++                 delete rhiAccumTexture->texture;

++                 delete rhiRevealageTexture->texture;

++                 oitrt.oitRenderTarget = nullptr;

++                 oitrt.renderPassDescriptor = nullptr;

++                 rhiAccumTexture->texture = nullptr;

++                 rhiRevealageTexture->texture = nullptr;

++             }

++             const QRhiTexture::Flags textureFlags = QRhiTexture::RenderTarget;

++             if (ps.viewCount >= 2) {

++                 rhiAccumTexture->texture = rhi->newTextureArray(QRhiTexture::RGBA16F, ps.viewCount, data.layerPrepResult.textureDimensions(), ps.samples, textureFlags);

++                 rhiRevealageTexture->texture = rhi->newTextureArray(QRhiTexture::R16F, ps.viewCount, data.layerPrepResult.textureDimensions(), ps.samples, textureFlags);

++             } else {

++                 rhiAccumTexture->texture = rhi->newTexture(QRhiTexture::RGBA16F, data.layerPrepResult.textureDimensions(), ps.samples, textureFlags);

++                 rhiRevealageTexture->texture = rhi->newTexture(QRhiTexture::R16F, data.layerPrepResult.textureDimensions(), ps.samples, textureFlags);

++             }

++             rhiAccumTexture->texture->create();

++             rhiRevealageTexture->texture->create();

++

++             QRhiTextureRenderTargetDescription desc;

++             desc.setColorAttachments({{rhiAccumTexture->texture}, {rhiRevealageTexture->texture}});

++             desc.setDepthTexture(rhiDepthTexture->texture);

++

++             if (oitrt.oitRenderTarget == nullptr) {

++                 oitrt.oitRenderTarget = rhi->newTextureRenderTarget(desc, QRhiTextureRenderTarget::PreserveDepthStencilContents);

++                 oitrt.renderPassDescriptor = oitrt.oitRenderTarget->newCompatibleRenderPassDescriptor();

++                 oitrt.oitRenderTarget->setRenderPassDescriptor(oitrt.renderPassDescriptor);

++                 oitrt.oitRenderTarget->create();

++

++                 renderTarget = oitrt.oitRenderTarget;

++             }

++         }

++         QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++         const auto &shaderCache = renderer.contextInterface()->shaderCache();

++         clearPipeline = shaderCache->getBuiltInRhiShaders().getRhiClearMRTShader();

++

++         QSSGRhiShaderResourceBindingList bindings;

++         QVector4D clearData[2];

++         clearData[0] = QVector4D(0.0, 0.0, 0.0, 0.0);

++         clearData[1] = QVector4D(1.0, 1.0, 1.0, 1.0);

++

++         QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ this, clearPipeline.get(), nullptr, nullptr, 0 }));

++         QRhiBuffer *&ubuf = dcd.ubuf;

++         const int ubufSize = sizeof(clearData);

++         if (!ubuf) {

++             ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);

++             ubuf->create();

++         }

++

++         QRhiResourceUpdateBatch *rub = rhi->nextResourceUpdateBatch();

++         rub->updateDynamicBuffer(ubuf, 0, ubufSize, &clearData);

++         renderer.rhiQuadRenderer()->prepareQuad(rhiCtx.get(), rub);

++

++         bindings.addUniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, ubuf);

++

++         clearSrb = rhiCtxD->srb(bindings);

++

++         ps.targetBlend[0].srcAlpha = QRhiGraphicsPipeline::One;

++         ps.targetBlend[0].srcColor = QRhiGraphicsPipeline::One;

++         ps.targetBlend[0].dstAlpha = QRhiGraphicsPipeline::One;

++         ps.targetBlend[0].dstColor = QRhiGraphicsPipeline::One;

++         ps.targetBlend[1].srcAlpha = QRhiGraphicsPipeline::Zero;

++         ps.targetBlend[1].srcColor = QRhiGraphicsPipeline::Zero;

++         ps.targetBlend[1].dstAlpha = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++         ps.targetBlend[1].dstColor = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++

++         TransparentPass::prep(*ctx, data, this, ps, shaderFeatures, oitrt.renderPassDescriptor, sortedTransparentObjects, true);

++     } else if (method == QSSGRenderLayer::OITMethod::LinkedList) {

++         oitRenderContext = &data.getOitRenderContext();

++         if (oitRenderContext->rub) {

++             rhiCtx->commandBuffer()->resourceUpdate(oitRenderContext->rub);

++             oitRenderContext->rub = nullptr;

++         }

++

++         // same as transparent pass

++         // transparent objects (or, without LayerEnableDepthTest, all objects)

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, false);

++         ps.targetBlend[0].srcAlpha = QRhiGraphicsPipeline::One;

++         ps.targetBlend[0].srcColor = QRhiGraphicsPipeline::SrcAlpha;

++         ps.targetBlend[0].dstAlpha = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++         ps.targetBlend[0].dstColor = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++

++         shaderFeatures = data.getShaderFeatures();

++         sortedTransparentObjects = data.getSortedTransparentRenderableObjects(*camera);

++

++ #ifdef QSSG_OIT_USE_BUFFERS

++         auto &oitCtx = data.getOitRenderContext();

++         rhiABuffer = oitCtx.aBuffer;

++         rhiAuxBuffer = oitCtx.auxBuffer;

++         rhiCounterBuffer = oitCtx.counterBuffer;

++ #else

++         rhiABufferImage = data.getRenderResult(QSSGRenderResult::Key::ABufferImage);

++         rhiAuxiliaryImage = data.getRenderResult(QSSGRenderResult::Key::AuxiliaryImage);

++         rhiCounterImage = data.getRenderResult(QSSGRenderResult::Key::CounterImage);

++ #endif

++         QSize dim = data.layerPrepResult.textureDimensions();

++         dim.setWidth(dim.width() * ps.samples);

++         dim.setHeight(dim.height() * ps.viewCount);

++ #ifdef QSSG_OIT_USE_BUFFERS

++         if (!rhiAuxBuffer || rhiAuxBuffer->size() != (dim.width() * dim.height() * 4u) || currentNodeCount == 0 || linkedListRequiresResize(dim))

++ #else

++         if (!rhiAuxiliaryImage->texture || rhiAuxiliaryImage->texture->pixelSize() != dim || currentNodeCount == 0 || linkedListRequiresResize(dim))

++ #endif

++         {

++             quint32 extraNodeCount = 0;

++ #ifdef QSSG_OIT_USE_BUFFERS

++             if (rhiAuxBuffer && rhiAuxBuffer->size() != (dim.width() * dim.height() * 4u)) {

++                 if (rhiAuxBuffer->size() < (dim.width() * dim.height() * 4u))

++                     extraNodeCount = ensureFreeNodes((dim.width() * dim.height() * 4u) - rhiAuxBuffer->size(), 32u * 1024u);

++                 rhiAuxBuffer->destroy();

++                 rhiAuxBuffer = nullptr;

++             }

++ #else

++             if (rhiABufferImage->texture) {

++                 const auto s = rhiAuxiliaryImage->texture->pixelSize();

++                 if (s.width() * s.height() < dim.width() * dim.height())

++                     extraNodeCount = ensureFreeNodes(dim.width() * dim.height() - s.width() * s.height(), 32u * 1024u);

++                 rhiABufferImage->texture->destroy();

++                 rhiAuxiliaryImage->texture->destroy();

++             }

++ #endif

++

++             if (reportedNodeCount) {

++                 // ensure there are at least 50% of the screen size nodes available

++                 currentNodeCount = ensureFreeNodes(reportedNodeCount + extraNodeCount, dim.width() * dim.height() / 2);

++             } else {

++                 quint32 size = RenderHelpers::rhiCalculateABufferSize(data.layerPrepResult.textureDimensions(), 4 * ps.samples * ps.viewCount);

++                 currentNodeCount = ensureFreeNodes(size * size, 32u * 1024u);

++             }

++             data.layer.oitNodeCount = currentNodeCount;

++

++ #ifdef QSSG_OIT_USE_BUFFERS

++             if (rhiABuffer && currentNodeCount * 16 != rhiABuffer->size()) {

++                 rhiABuffer->destroy();

++                 rhiABuffer = nullptr;

++             }

++             if (!rhiABuffer) {

++                 rhiABuffer = rhi->newBuffer(QRhiBuffer::Static, QRhiBuffer::StorageBuffer, currentNodeCount * 16);

++                 rhiABuffer->create();

++             }

++             if (!rhiAuxBuffer) {

++                 rhiAuxBuffer = rhi->newBuffer(QRhiBuffer::Static, QRhiBuffer::StorageBuffer, dim.width() * dim.height() * 4);

++                 rhiAuxBuffer->create();

++             }

++             if (!rhiCounterBuffer) {

++                 rhiCounterBuffer = rhi->newBuffer(QRhiBuffer::Static, QRhiBuffer::StorageBuffer, 4);

++                 rhiCounterBuffer->create();

++                 oitCtx.counterBuffer = rhiCounterBuffer;

++             }

++             oitCtx.aBuffer = rhiABuffer;

++             oitCtx.auxBuffer = rhiAuxBuffer;

++ #else

++             quint32 sizeWithLayers = RenderHelpers::rhiCalculateABufferSize(currentNodeCount);

++             const QRhiTexture::Flags textureFlags = QRhiTexture::UsedWithLoadStore;

++             rhiABufferImage->texture = rhi->newTexture(QRhiTexture::RGBA32UI, QSize(sizeWithLayers, sizeWithLayers), 1, textureFlags);

++             rhiABufferImage->texture->create();

++             rhiAuxiliaryImage->texture = rhi->newTexture(QRhiTexture::R32UI, dim, 1, textureFlags);

++             rhiAuxiliaryImage->texture->create();

++             if (!rhiCounterImage->texture) {

++                 rhiCounterImage->texture = rhi->newTexture(QRhiTexture::R32UI, QSize(1, 1), 1, textureFlags | QRhiTexture::UsedAsTransferSource);

++                 rhiCounterImage->texture->create();

++

++                 auto &oitrt = data.getOitRenderContext();

++                 readbackImage = rhi->newTexture(QRhiTexture::R32UI, QSize(1, 1), 1, QRhiTexture::UsedAsTransferSource);

++                 readbackImage->create();

++                 oitrt.copyTexture = readbackImage;

++             }

++ #endif

++         }

++         QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++

++         QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++         const auto &shaderCache = renderer.contextInterface()->shaderCache();

++ #ifdef QSSG_OIT_USE_BUFFERS

++         clearPipeline = shaderCache->getBuiltInRhiShaders().getRhiClearBufferShader();

++ #else

++         clearPipeline = shaderCache->getBuiltInRhiShaders().getRhiClearImageShader();

++ #endif

++         QSSGRhiShaderResourceBindingList bindings;

++         quint32 clearImageData[8] = {0};

++

++         QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ this, clearPipeline.get(), nullptr, nullptr, 0 }));

++         QRhiBuffer *&ubuf = dcd.ubuf;

++         const int ubufSize = sizeof(clearImageData);

++         if (!ubuf) {

++             ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);

++             ubuf->create();

++         }

++

++         clearImageData[4] = data.layerPrepResult.textureDimensions().width();

++         clearImageData[5] = data.layerPrepResult.textureDimensions().height();

++         clearImageData[6] = ps.samples;

++         clearImageData[7] = ps.viewCount;

++

++         rub->updateDynamicBuffer(ubuf, 0, ubufSize, clearImageData);

++         quint32 zero = 0;

++ #ifdef QSSG_OIT_USE_BUFFERS

++         rub->uploadStaticBuffer(rhiCounterBuffer, 0, 4, &zero);

++ #else

++         rub->uploadTexture(rhiCounterImage->texture, {{0, 0, {&zero, 4}}});

++ #endif

++

++         bindings.addUniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, ubuf);

++ #ifdef QSSG_OIT_USE_BUFFERS

++         bindings.addStorageBufferStore(1, QRhiShaderResourceBinding::FragmentStage, rhiAuxBuffer);

++ #else

++         bindings.addImageStore(1, QRhiShaderResourceBinding::FragmentStage, rhiAuxiliaryImage->texture, 0);

++ #endif

++

++         clearSrb = rhiCtxD->srb(bindings);

++

++         renderer.rhiQuadRenderer()->prepareQuad(rhiCtx.get(), rub);

++

++         TransparentPass::prep(*ctx, data, this, ps, shaderFeatures, rhiCtx->mainRenderPassDescriptor(), sortedTransparentObjects, true);

++     }

++ }

++

++ void OITRenderPass::renderPass(QSSGRenderer &renderer)

++ {

++     auto *ctx = renderer.contextInterface();

++     const auto &rhiCtx = ctx->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     if (method == QSSGRenderLayer::OITMethod::WeightedBlended) {

++         if (Q_LIKELY(renderTarget)) {

++             cb->beginPass(renderTarget, Qt::black, {});

++

++             QRhiShaderResourceBindings *srb = clearSrb;

++             QSSG_ASSERT(srb, return);

++             ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, false);

++             QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, clearPipeline.get());

++             renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, renderTarget->renderPassDescriptor(), {});

++             ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++

++             cb->debugMarkBegin(QByteArrayLiteral("Quick3D render order-independent alpha"));

++             Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++             Q_TRACE(QSSG_renderPass_entry, QStringLiteral("Quick3D render order-independent alpha"));

++             ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, true);

++             ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, false);

++             TransparentPass::render(*ctx, ps, sortedTransparentObjects);

++             cb->debugMarkEnd();

++             Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("transparent_order_independent_pass"));

++             Q_TRACE(QSSG_renderPass_exit);

++

++             cb->endPass();

++         }

++     } else if (method == QSSGRenderLayer::OITMethod::LinkedList) {

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D render alpha"));

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);

++         Q_TRACE(QSSG_renderPass_entry, QStringLiteral("Quick3D render alpha"));

++

++         QRhiShaderResourceBindings *srb = clearSrb;

++         QSSG_ASSERT(srb, return);

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, clearPipeline.get());

++         renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rhiCtx->mainRenderPassDescriptor(), {});

++

++         TransparentPass::render(*ctx, ps, sortedTransparentObjects);

++

++         if (!oitRenderContext->pendingResult) {

++             QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++             QRhiReadbackResult *result = nullptr;

++             if (oitRenderContext->completedResults.size()) {

++                 result = oitRenderContext->completedResults.takeLast();

++                 result->pixelSize = {};

++                 result->data = {};

++                 result->format = QRhiTexture::UnknownFormat;

++             }  else  {

++                 result = new QRhiReadbackResult();

++             }

++             auto *oitrt = oitRenderContext;

++             const auto completedFunc = [this, oitrt, result](){

++                 if (result) {

++                     const quint32 *d = reinterpret_cast<const quint32 *>(result->data.constData());

++                     quint32 nodeCount = *d;

++                     if (nodeCount)

++                         this->reportedNodeCount = ensureFreeNodes(nodeCount, 32u * 1024u);

++                     oitrt->completedResults.append(result);

++                     QSSG_ASSERT(oitrt->pendingResult == result, return;);

++                     oitrt->pendingResult = nullptr;

++                 }

++             };

++             result->completed = completedFunc;

++ #ifdef QSSG_OIT_USE_BUFFERS

++             rub->readBackBuffer(rhiCounterBuffer, 0, 4, result);

++ #else

++             rub->copyTexture(readbackImage, rhiCounterImage->texture);

++             QRhiReadbackDescription rbdesc;

++             rbdesc.setTexture(readbackImage);

++             rub->readBackTexture(rbdesc, result);

++ #endif

++             oitRenderContext->rub = rub;

++             oitRenderContext->pendingResult = result;

++         }

++         cb->debugMarkEnd();

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("transparent_order_independent_pass"));

++         Q_TRACE(QSSG_renderPass_exit);

++     }

++ }

++

++ QSSGRenderPass::Type OITRenderPass::passType() const

++ {

++     if (method == QSSGRenderLayer::OITMethod::WeightedBlended)

++         return Type::Standalone;

++     return Type::Main;

++ }

++

++

++ void OITRenderPass::resetForFrame()

++ {

++     sortedTransparentObjects.clear();

++     ps = {};

++     shaderFeatures = {};

++     rhiAccumTexture = nullptr;

++     rhiRevealageTexture = nullptr;

++     rhiDepthTexture = nullptr;

++     rhiCounterImage = nullptr;

++     oitRenderContext = nullptr;

++ }

++

++ void OITCompositePass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     using namespace RenderHelpers;

++

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     const auto &shaderCache = renderer.contextInterface()->shaderCache();

++

++     ps = data.getPipelineState();

++     ps.samples = rhiCtx->mainPassSampleCount();

++     ps.viewCount = rhiCtx->mainPassViewCount();

++

++     if (method == QSSGRenderLayer::OITMethod::WeightedBlended) {

++         rhiAccumTexture = data.getRenderResult(QSSGRenderResult::Key::AccumTexture);

++         rhiRevealageTexture = data.getRenderResult(QSSGRenderResult::Key::RevealageTexture);

++         compositeShaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiOitCompositeShader(method, ps.samples > 1 ? true : false);

++     } else if (method == QSSGRenderLayer::OITMethod::LinkedList) {

++ #ifdef QSSG_OIT_USE_BUFFERS

++         rhiABuffer = data.getOitRenderContext().aBuffer;

++         rhiAuxBuffer = data.getOitRenderContext().auxBuffer;

++         compositeShaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiOitCompositeShader(method, ps.samples > 1 ? true : false, true);

++ #else

++         rhiABufferImage = data.getRenderResult(QSSGRenderResult::Key::ABufferImage);

++         rhiAuxiliaryImage = data.getRenderResult(QSSGRenderResult::Key::AuxiliaryImage);

++         compositeShaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiOitCompositeShader(method, ps.samples > 1 ? true : false);

++ #endif

++

++         QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++         QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ this, nullptr, nullptr, nullptr, 0 }));

++         QRhiBuffer *&ubuf = dcd.ubuf;

++         const int ubufSize = 6 * sizeof(quint32);

++         if (!ubuf) {

++             ubuf = rhiCtx->rhi()->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);

++             ubuf->create();

++         }

++ #ifdef QSSG_OIT_USE_BUFFERS

++         const quint32 values[6] = { 0,

++                                     quint32(data.layer.oitNodeCount),

++                                     quint32(ps.samples),

++                                     0,

++                                     quint32(data.layerPrepResult.textureDimensions().width()),

++                                     quint32(data.layerPrepResult.textureDimensions().height())

++         };

++ #else

++         const quint32 sizeWithLayers = rhiABufferImage->texture->pixelSize().width();

++         const quint32 values[6] = { sizeWithLayers,

++                                     sizeWithLayers * sizeWithLayers,

++                                     quint32(ps.samples),

++                                     0,

++                                     quint32(data.layerPrepResult.textureDimensions().width()),

++                                     quint32(data.layerPrepResult.textureDimensions().height())

++                                     };

++ #endif

++         QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++         rub->updateDynamicBuffer(ubuf, 0, ubufSize, values);

++         renderer.rhiQuadRenderer()->prepareQuad(rhiCtx.get(), rub);

++     }

++ }

++

++ void OITCompositePass::renderPass(QSSGRenderer &renderer)

++ {

++     using namespace RenderHelpers;

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++

++     if (!rhiAccumTexture->texture || !rhiRevealageTexture->texture)

++         return;

++

++     if (method == QSSGRenderLayer::OITMethod::WeightedBlended) {

++         QSSGRhiShaderResourceBindingList bindings;

++

++         QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                  QRhiSampler::Nearest,

++                                                  QRhiSampler::None,

++                                                  QRhiSampler::ClampToEdge,

++                                                  QRhiSampler::ClampToEdge,

++                                                  QRhiSampler::ClampToEdge });

++         bindings.addTexture(1, QRhiShaderResourceBinding::FragmentStage, rhiAccumTexture->texture, sampler);

++         bindings.addTexture(2, QRhiShaderResourceBinding::FragmentStage, rhiRevealageTexture->texture, sampler);

++

++         compositeSrb = rhiCtxD->srb(bindings);

++

++         QRhiShaderResourceBindings *srb = compositeSrb;

++         QSSG_ASSERT(srb, return);

++

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D revealage"));

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, compositeShaderPipeline.get());

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++         renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rhiCtx->mainRenderPassDescriptor(),

++                                                      { QSSGRhiQuadRenderer::UvCoords | QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::PremulBlend});

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("revealage"));

++         cb->debugMarkEnd();

++     } else if (method == QSSGRenderLayer::OITMethod::LinkedList) {

++         QSSGRhiShaderResourceBindingList bindings;

++

++         QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx.get());

++         QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ this, nullptr, nullptr, nullptr, 0 }));

++         QRhiBuffer *&ubuf = dcd.ubuf;

++

++         bindings.addUniformBuffer(0, QRhiShaderResourceBinding::FragmentStage, ubuf);

++ #ifdef QSSG_OIT_USE_BUFFERS

++         bindings.addStorageBufferLoad(1, QRhiShaderResourceBinding::FragmentStage, rhiABuffer);

++         bindings.addStorageBufferLoad(2, QRhiShaderResourceBinding::FragmentStage, rhiAuxBuffer);

++ #else

++         bindings.addImageLoad(1, QRhiShaderResourceBinding::FragmentStage, rhiABufferImage->texture, 0);

++         bindings.addImageLoad(2, QRhiShaderResourceBinding::FragmentStage, rhiAuxiliaryImage->texture, 0);

++ #endif

++

++         compositeSrb = rhiCtxD->srb(bindings);

++

++         QRhiShaderResourceBindings *srb = compositeSrb;

++         QSSG_ASSERT(srb, return);

++

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D oit-composite"));

++         QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, compositeShaderPipeline.get());

++         ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, true);

++         renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx.get(), &ps, srb, rhiCtx->mainRenderPassDescriptor(),

++                                                      { QSSGRhiQuadRenderer::UvCoords | QSSGRhiQuadRenderer::DepthTest | QSSGRhiQuadRenderer::PremulBlend});

++         Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("oit-composite"));

++     }

++ }

++

++ void OITCompositePass::resetForFrame()

++ {

++     ps = {};

++     shaderFeatures = {};

++     rhiAccumTexture = nullptr;

++     rhiRevealageTexture = nullptr;

++ }

++

++ Q_STATIC_LOGGING_CATEGORY(lcUserRenderPass, "qt.quick3d.rhi.userrenderpass")

++

++ void UserRenderPass::renderPrep(QSSGRenderer &renderer, QSSGLayerRenderData &data)

++ {

++     QSSG_ASSERT(!data.renderedCameras.isEmpty(), return);

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++

++     for (auto *passNode : std::as_const(userPasses)) {

++         QSSG_ASSERT(passNode != nullptr, continue);

++         prepareTopLevelPass(renderer, data, passNode);

++     }

++ }

++

++ void UserRenderPass::renderPass(QSSGRenderer &renderer)

++ {

++

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++     QSSG_ASSERT(rhiCtx->rhi()->isRecordingFrame(), return);

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++

++     for (UserPassData &passData : userPassData) {

++

++         const auto &ps = passData.ps;

++         const auto &renderables = passData.renderables;

++         const auto &clearColor = passData.clearColor;

++         const auto &depthStencilClearValue = passData.depthStencilClearValue;

++         const auto &renderableTexture = passData.renderableTexture;

++

++         cb->debugMarkBegin(QByteArrayLiteral("Quick3D UserRenderPass"));

++

++         if (Q_LIKELY(renderableTexture && renderableTexture->isValid())) {

++             cb->beginPass(renderableTexture->getRenderTarget().get(), clearColor, depthStencilClearValue, nullptr, rhiCtx->commonPassFlags());

++             if (passData.skyboxCubeMapPass) {

++                 passData.skyboxCubeMapPass->renderPass(renderer);

++             } else if (passData.skyboxPass) {

++                 passData.skyboxPass->renderPass(renderer);

++             } else if (passData.item2DPass) {

++                 passData.item2DPass->renderPass(renderer);

++             } else {

++                 // Regular User Passes

++                 bool needsSetViewport = true;

++                 if (passData.index >= 0) {

++                     for (const auto &handle : std::as_const(renderables))

++                         RenderHelpers::rhiRenderRenderable(rhiCtx.get(), ps, *handle.obj, &needsSetViewport, QSSGRenderTextureCubeFaceNone, qsizetype(passData.index));

++                 }

++             }

++             QRhiResourceUpdateBatch *rub = nullptr;

++

++             // Sub Passes

++             for (auto &subPassData : passData.subPassData) {

++                 const auto &subPs = subPassData.ps;

++                 const auto &subRenderables = subPassData.renderables;

++

++                 if (subPassData.skyboxCubeMapPass) {

++                     subPassData.skyboxCubeMapPass->renderPass(renderer);

++                 } else if (subPassData.skyboxPass) {

++                     subPassData.skyboxPass->renderPass(renderer);

++                 } else if (subPassData.item2DPass) {

++                     subPassData.item2DPass->renderPass(renderer);

++                 } else {

++                     bool needsSetViewport = true;

++                     if (subPassData.index >= 0) {

++                         for (const auto &handle : std::as_const(subRenderables))

++                             RenderHelpers::rhiRenderRenderable(rhiCtx.get(), subPs, *handle.obj, &needsSetViewport, QSSGRenderTextureCubeFaceNone, qsizetype(subPassData.index));

++                     }

++                 }

++             }

++

++             cb->endPass(rub);

++         }

++

++         cb->debugMarkEnd();

++     }

++ }

++

++ void UserRenderPass::resetForFrame()

++ {

++     qCDebug(lcUserRenderPass) << "resetForFrame in UserRenderPass";

++     userPasses.clear();

++

++     userPassData.clear();

++ }

++

++ void UserRenderPass::preparePassImpl(QSSGRenderer &renderer,

++                                      QSSGLayerRenderData &data,

++                                      QSSGRenderUserPass *passNode,

++                                      std::vector<UserPassData> &outData,

++                                      QSSGRhiRenderableTextureV2Ptr renderableTexture)

++ {

++     // NOTE: Only top-level passes should create their own renderable texture by passing in a null renderable texture.

++     // Ideally we this should be more explict...

++     const bool isTopLevelPass = (renderableTexture == nullptr);

++

++     QSSGRenderCamera *camera = data.renderedCameras[0];

++     const auto &rhiCtx = renderer.contextInterface()->rhiContext();

++

++     const QSize targetSize = data.layerPrepResult.textureDimensions();

++

++     static const auto needsRebuild = [](QRhiTexture *texture, const QSize &size, QRhiTexture::Format format) {

++         return !texture || texture->pixelSize() != size || texture->format() != format;

++     };

++

++     qCDebug(lcUserRenderPass, "renderPrep in UserRenderPass");

++

++     const QSSGResourceId currentPassId = QSSGRenderGraphObjectUtils::getResourceId(*passNode);

++     if (visitedPasses.find(currentPassId) != visitedPasses.end()) {

++         qWarning("UserRenderPass: Circular dependency detected in SubRenderPass chain. Ignoring pass.");

++         return;

++     }

++

++     // Check max depth

++     if (visitedPasses.size() >= MAX_SUBPASS_DEPTH) {

++         qWarning("UserRenderPass: Maximum SubRenderPass nesting depth (%zu) exceeded. Ignoring pass.", MAX_SUBPASS_DEPTH);

++         return;

++     }

++

++     visitedPasses.insert(currentPassId);

++

++     UserPassData currentPassData;

++     currentPassData.clearColor = passNode->clearColor;

++     currentPassData.depthStencilClearValue = passNode->depthStencilClearValue;

++     if (isTopLevelPass)

++         renderableTexture = currentPassData.renderableTexture = data.requestUserRenderPassManager()->getOrCreateRenderableTexture(*passNode);

++     else

++         currentPassData.renderableTexture = renderableTexture;

++

++     QSSGRenderableObjectList &renderables = currentPassData.renderables;

++     QSSGRhiGraphicsPipelineState &ps = currentPassData.ps;

++     const auto &renderTarget = currentPassData.renderableTexture;

++

++     // Initial pipeline state from layer data

++     ps = data.getPipelineState();

++

++     bool renderablesFiltered = false;

++

++     bool needsDepthStencilRenderBuffer = false;

++     QSSGAllocateTexturePtr depthTextureAllocCommand;

++

++     QVarLengthArray<QSSGColorAttachment *, 16> colorAttachments;

++     QVarLengthArray<QSSGResourceId, 4> subPassIds;

++

++     // Process commands in passNode

++     for (const QSSGCommand *theCommand : std::as_const(passNode->commands)) {

++         QSSG_ASSERT(theCommand != nullptr, continue);

++

++         qCDebug(lcUserRenderPass) << "Exec. command:    >" << theCommand->typeAsString() << "--" << theCommand->debugString();

++

++         switch (theCommand->m_type) {

++         case CommandType::ColorAttachment:

++         {

++             const QSSGColorAttachment *colorAttachCmd = static_cast<const QSSGColorAttachment *>(theCommand);

++             colorAttachments.push_back(const_cast<QSSGColorAttachment *>(colorAttachCmd));

++         }

++         break;

++         case CommandType::DepthTextureAttachment:

++         {

++             QSSG_ASSERT(depthTextureAllocCommand == nullptr, break);

++             const QSSGDepthTextureAttachment *depthAttachCmd = static_cast<const QSSGDepthTextureAttachment *>(theCommand);

++             needsDepthStencilRenderBuffer = false;

++             depthTextureAllocCommand = depthAttachCmd->m_textureCmd;

++         }

++         break;

++         case CommandType::AddShaderDefine:

++         {

++             const auto *defineCmd = static_cast<const QSSGAddShaderDefine *>(theCommand);

++             const auto &defineName = defineCmd->m_name;

++             if (defineName.size() > 0) {

++                 QByteArray value = QByteArray::number(defineCmd->m_value);

++                 currentPassData.shaderDefines.push_back({ defineName, value });

++             }

++         }

++         break;

++         case CommandType::RenderablesFilter:

++         {

++             auto filterCommand = static_cast<const QSSGRenderablesFilterCommand *>(theCommand);

++

++             // Use the filter to select which renderables to include

++             // renderableTypes can be: None (0x0), Opaque (0x1), Transparent (0x2), or both

++             enum RenderableType : quint8 {

++                 None = 0x0,

++                 Opaque = 0x1,

++                 Transparent = 0x2,

++             };

++

++             if (filterCommand->renderableTypes & RenderableType::Opaque) // Opaque

++                 renderables = data.getSortedOpaqueRenderableObjects(*camera, 0, filterCommand->layerMask);

++             if (filterCommand->renderableTypes & RenderableType::Transparent) // Transparent

++                 renderables += data.getSortedTransparentRenderableObjects(*camera, 0, filterCommand->layerMask);

++

++             // NOTE: If renderableTypes is None (0x0), no renderables are added

++             // NOTE: If no filter is run, all opaque objects are rendered.

++             renderablesFiltered = true;

++         }

++         break;

++

++         case CommandType::PipelineStateOverride:

++         {

++             auto pipelineCommand = static_cast<const QSSGPipelineStateOverrideCommand *>(theCommand);

++             if (pipelineCommand->m_depthTestEnabled)

++                 ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, *pipelineCommand->m_depthTestEnabled);

++             if (pipelineCommand->m_depthWriteEnabled)

++                 ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, *pipelineCommand->m_depthWriteEnabled);

++             if (pipelineCommand->m_blendEnabled)

++                 ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, *pipelineCommand->m_blendEnabled);

++             if (pipelineCommand->m_usesStencilReference)

++                 ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::UsesStencilRef, *pipelineCommand->m_usesStencilReference);

++             if (pipelineCommand->m_usesScissor)

++                 ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::UsesScissor, *pipelineCommand->m_usesScissor);

++             if (pipelineCommand->m_depthFunction)

++                 ps.depthFunc = *pipelineCommand->m_depthFunction;

++             if (pipelineCommand->m_cullMode) {

++                 ps.cullMode = *pipelineCommand->m_cullMode;

++                 ps.userSetCullMode = true;

++             }

++             if (pipelineCommand->m_polygonMode)

++                 ps.polygonMode = *pipelineCommand->m_polygonMode;

++             if (pipelineCommand->m_stencilOpFrontState)

++                 ps.stencilOpFrontState = *pipelineCommand->m_stencilOpFrontState;

++             if (pipelineCommand->m_stencilWriteMask)

++                 ps.stencilWriteMask = *pipelineCommand->m_stencilWriteMask;

++             if (pipelineCommand->m_stencilReference)

++                 ps.stencilRef = *pipelineCommand->m_stencilReference;

++             if (pipelineCommand->m_viewport)

++                 ps.viewport = *pipelineCommand->m_viewport;

++             if (pipelineCommand->m_scissor)

++                 ps.scissor = *pipelineCommand->m_scissor;

++             if (pipelineCommand->m_targetBlend0)

++                 ps.targetBlend[0] = *pipelineCommand->m_targetBlend0;

++             if (pipelineCommand->m_targetBlend1)

++                 ps.targetBlend[1] = *pipelineCommand->m_targetBlend1;

++             if (pipelineCommand->m_targetBlend2)

++                 ps.targetBlend[2] = *pipelineCommand->m_targetBlend2;

++             if (pipelineCommand->m_targetBlend3)

++                 ps.targetBlend[3] = *pipelineCommand->m_targetBlend3;

++             if (pipelineCommand->m_targetBlend4)

++                 ps.targetBlend[4] = *pipelineCommand->m_targetBlend4;

++             if (pipelineCommand->m_targetBlend5)

++                 ps.targetBlend[5] = *pipelineCommand->m_targetBlend5;

++             if (pipelineCommand->m_targetBlend6)

++                 ps.targetBlend[6] = *pipelineCommand->m_targetBlend6;

++             if (pipelineCommand->m_targetBlend7)

++                 ps.targetBlend[7] = *pipelineCommand->m_targetBlend7;

++             break;

++         }

++         case CommandType::DepthStencilAttachment:

++             //auto depthStencilCommand = static_cast<const QSSGDepthStencilAttachment *>(theCommand);

++             QSSG_ASSERT(depthTextureAllocCommand == nullptr, break);

++             needsDepthStencilRenderBuffer = true;

++             break;

++         case CommandType::SubRenderPass:

++         {

++             auto subPassCommand = static_cast<const QSSGSubRenderPass *>(theCommand);

++             if (subPassCommand && subPassCommand->m_userPassId != QSSGResourceId::Invalid)

++                 subPassIds.append(subPassCommand->m_userPassId);

++             break;

++         }

++         default:

++             qWarning() << "Effect command" << theCommand->typeAsString() << "not implemented";

++             break;

++         }

++     }

++

++     if (colorAttachments.size() > 4) {

++         colorAttachments.resize(4);

++         qWarning() << "UserRenderPass supports up to 4 color attachments only.";

++     }

++

++     // m_passNode contains state for this UserRenderPass

++

++     if (isTopLevelPass) {

++         // 1) Setup the render target

++         bool needsBuild = !renderTarget->isValid();

++

++         const qsizetype oldAttachmentCount = renderTarget->colorAttachmentCount();

++         // A pass without ColorAttachment commands gets one implicit default

++         // attachment, so compare against the effective count.

++         const qsizetype wantedAttachmentCount = qMax<qsizetype>(colorAttachments.size(), 1);

++         // If the number of attachments has changed, we need to rebuild.

++         if (oldAttachmentCount != wantedAttachmentCount)

++             needsBuild = true;

++

++         // Even if the render target is valid we need to check if the textures are still compatible.

++         if (!needsBuild) {

++             // Render target flags (e.g. PreserveColorContents) change the Metal load/store actions

++             // baked into the QRhiRenderPassDescriptor, so a flag change requires a full rebuild.

++             if (renderTarget->getRenderTarget() && renderTarget->getRenderTarget()->flags() != passNode->renderTargetFlags)

++                 needsBuild = true;

++         }

++

++         if (!needsBuild) {

++             // Color attachments (oldAttachmentCount == wantedAttachmentCount here;

++             // an attachment without a command is the implicit default).

++             for (int i = 0; i != oldAttachmentCount; ++i) {

++                 QRhiTexture::Format expectedFormat = QRhiTexture::RGBA8;

++                 if (i < colorAttachments.size()) {

++                     const auto &colorAttachment = colorAttachments.at(i);

++                     QSSG_ASSERT(colorAttachment != nullptr, continue);

++                     expectedFormat = QSSGBufferManager::toRhiFormat(colorAttachment->format());

++                 }

++                 const auto &texture = renderTarget->getColorTexture(i);

++                 needsBuild = needsBuild || needsRebuild(&(*texture->texture()), targetSize, expectedFormat);

++             }

++

++             // depthStencilBuffer

++             if (needsDepthStencilRenderBuffer != (renderTarget->getDepthStencil() != nullptr))

++                 needsBuild = true;

++

++             // depthTexture

++             if (depthTextureAllocCommand) {

++                 const auto format = QSSGBufferManager::toRhiFormat(depthTextureAllocCommand->format());

++                 const auto &depthTextureWrapper = renderTarget->getDepthTexture();

++                 needsBuild = depthTextureWrapper == nullptr;

++                 needsBuild = needsBuild || needsRebuild(&(*depthTextureWrapper->texture()), targetSize, format);

++             } else {

++                 if (renderTarget->getDepthTexture() != nullptr)

++                     needsBuild = true;

++             }

++

++             // Flags are baked into the render pass descriptor.

++             if (!needsBuild) {

++                 const auto &rt = renderTarget->getRenderTarget();

++                 if (rt && rt->flags() != passNode->renderTargetFlags)

++                     needsBuild = true;

++             }

++         }

++

++         if (needsBuild) {

++             renderTarget->reset();

++

++             QRhiTextureRenderTargetDescription rtDesc;

++

++             // If no attachments are specified, create one (the implicit default).

++             const qsizetype colorAttachmentCount = wantedAttachmentCount;

++

++             bool createSucceeded = true;

++             bool colorAllocatorsNeedsUpdate = false;

++

++             {

++                 // Used to set the color attachments in rtDesc below (don't let the raw ptrs leave this scope).

++                 QVarLengthArray<QRhiTexture *, 4> textures;

++                 for (qsizetype i = 0; i < colorAttachmentCount && createSucceeded ; ++i) {

++                     if (i >= colorAttachments.size()) {

++                         // No ColorAttachment command; create the implicit default attachment.

++                         auto *tex = rhiCtx->rhi()->newTexture(QRhiTexture::RGBA8, targetSize, ps.samples, QRhiTexture::RenderTarget);

++                         tex->setName(QByteArrayLiteral("Default color attachment"));

++                         createSucceeded = createSucceeded && tex->create();

++                         textures.push_back(tex);

++                         continue;

++                     }

++                     const auto &colorAttCmd = colorAttachments.at(i);

++                     const auto &name = colorAttCmd->m_name;

++                     const auto format = QSSGBufferManager::toRhiFormat(colorAttCmd->format());

++                     const auto &allocateTexCmd = colorAttCmd->m_textureCmd;

++                     if (allocateTexCmd->texture() && !needsRebuild(&(*allocateTexCmd->texture()->texture()), targetSize, format)) {

++                         // NOTE: The QRhiTexture is tracked by the QSSGUserRenderPassManager, even if we create a new

++                         //       shared pointer wrapper here, it will ask the manager before destroying it.

++                         textures.push_back(allocateTexCmd->texture()->texture().get());

++                     } else {

++                         auto *tex = rhiCtx->rhi()->newTexture(format, targetSize, ps.samples, QRhiTexture::RenderTarget);

++                         tex->setName(name);

++                         createSucceeded = createSucceeded && tex->create();

++                         textures.push_back(tex);

++                         // We created a new texture, so we need to update the allocator.

++                         // NOTE: Since the render target type will take ownership of the texture, we need to

++                         //       request the textures once the render target description is set!

++                         colorAllocatorsNeedsUpdate = true;

++                     }

++                 }

++

++                 rtDesc.setColorAttachments(textures.cbegin(), textures.cend());

++             }

++

++             if (needsDepthStencilRenderBuffer) {

++                 auto renderBuffer = rhiCtx->rhi()->newRenderBuffer(QRhiRenderBuffer::DepthStencil, targetSize, ps.samples);

++                 if (renderBuffer->create())

++                     rtDesc.setDepthStencilBuffer(renderBuffer);

++             } else if (depthTextureAllocCommand) {

++                 const auto format = QSSGBufferManager::toRhiFormat(depthTextureAllocCommand->format());

++                 if (depthTextureAllocCommand->texture() && !needsRebuild(&(*depthTextureAllocCommand->texture()->texture()), targetSize, format)) {

++                     rtDesc.setDepthTexture(depthTextureAllocCommand->texture()->texture().get());

++                 } else {

++                     // Create new depth texture

++                     QRhiTexture *depthTex = rhiCtx->rhi()->newTexture(format, targetSize, ps.samples, QRhiTexture::RenderTarget);

++                     if (depthTex->create())

++                         rtDesc.setDepthTexture(depthTex);

++                 }

++             }

++

++             if (createSucceeded) {

++                 // Set description takes ownership of rtDesc and the textures inside it (Color + Depth).

++                 renderTarget->setDescription(rhiCtx->rhi(), std::move(rtDesc), passNode->renderTargetFlags);

++

++                 // Now we can update the allocators for the color attachments that were created here.

++                 // The implicit default attachment has no command, so only command-backed

++                 // attachments are updated.

++                 if (colorAllocatorsNeedsUpdate) {

++                     for (qsizetype i = 0; i < colorAttachments.size(); ++i) {

++                         const auto &colorAttCmd = colorAttachments.at(i);

++                         const auto &allocateTexCmd = colorAttCmd->m_textureCmd;

++                         allocateTexCmd->setTexture(renderTarget->getColorTexture(i));

++                     }

++                 }

++

++                 if (depthTextureAllocCommand)

++                     depthTextureAllocCommand->setTexture(renderTarget->getDepthTexture());

++

++             } else {

++                 renderTarget->resetRenderTarget();

++                 qWarning() << "Failed to create textures for UserRenderPass";

++             }

++         }

++

++     }

++

++     Q_ASSERT(renderTarget->isValid());

++

++     ps.colorAttachmentCount = int(renderTarget->colorAttachmentCount());

++

++     // Subpasses

++     for (const auto &subPassId : std::as_const(subPassIds)) {

++         QSSGRenderUserPass *userPassNode = QSSGRenderGraphObjectUtils::getResource<QSSGRenderUserPass>(subPassId);

++         QSSG_ASSERT(userPassNode && userPassNode->type == QSSGRenderGraphObject::Type::RenderPass, continue);

++         prepareSubPass(renderer, data, userPassNode, currentPassData.subPassData, currentPassData.renderableTexture);

++     }

++

++     if (passNode->passMode == QSSGRenderUserPass::PassModes::UserPass) {

++         // If no filter is specified, render all opaque objects

++         if (!renderablesFiltered && renderables.isEmpty())

++             renderables = data.getSortedOpaqueRenderableObjects(*camera);

++

++         if (passNode->materialMode == QSSGRenderUserPass::MaterialModes::AugmentMaterial) {

++

++             QSSGUserShaderAugmentation shaderAugmentation = passNode->shaderAugmentation;

++

++             QSSG_ASSERT(shaderAugmentation.outputs.size() == 0, shaderAugmentation.outputs.clear());

++             shaderAugmentation.defines = std::move(currentPassData.shaderDefines);

++

++             for (int i = 0, end = colorAttachments.size(); i < end; ++i) {

++                 const auto &colorAttCmd = colorAttachments.at(i);

++                 const auto &name = colorAttCmd->m_name;

++                 if (name.size() > 0)

++                     shaderAugmentation.outputs.push_back(name);

++                 else

++                     shaderAugmentation.outputs.push_back(getDefaultOutputName(size_t(i)));

++             }

++

++             QSSGShaderFeatures shaderFeatures = data.getShaderFeatures();

++             shaderFeatures.disableTonemapping();

++

++             currentPassData.index = RenderHelpers::rhiPrepareAugmentedUserPass(&(*rhiCtx), this, ps, renderTarget->getRenderPassDescriptor().get(), shaderAugmentation, data, renderables, shaderFeatures);

++         } else if (passNode->materialMode == QSSGRenderUserPass::MaterialModes::OverrideMaterial) {

++             // Every renderable will use the override material

++             QSSGShaderFeatures shaderFeatures = data.getShaderFeatures();

++             shaderFeatures.disableTonemapping();

++

++             currentPassData.index = RenderHelpers::rhiPrepareOverrideMaterialUserPass(&(*rhiCtx), this, ps, renderTarget->getRenderPassDescriptor().get(), passNode->overrideMaterial, data, renderables, shaderFeatures);

++

++         } else {

++             // Use original material of the renderables

++             QSSGShaderFeatures shaderFeatures = data.getShaderFeatures();

++             shaderFeatures.disableTonemapping();

++             currentPassData.index = RenderHelpers::rhiPrepareOriginalMaterialUserPass(&(*rhiCtx), this, ps, renderTarget->getRenderPassDescriptor().get(), data, renderables, shaderFeatures);

++         }

++         outData.push_back(currentPassData);

++     } else {

++         // Wrapped Built-in Passes

++         if (passNode->passMode == QSSGRenderUserPass::PassModes::SkyboxPass) {

++             if (rhiCtx->rhi()->isFeatureSupported(QRhi::TexelFetch)) {

++                 if (data.layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap && data.layer.skyBoxCubeMap) {

++                     if (!currentPassData.skyboxCubeMapPass)

++                         currentPassData.skyboxCubeMapPass = SkyboxCubeMapPass();

++

++                     currentPassData.skyboxCubeMapPass->skipTonemapping = true;

++                     currentPassData.skyboxCubeMapPass->renderPrep(renderer, data);

++                     currentPassData.skyboxCubeMapPass->ps.samples = ps.samples;

++                     currentPassData.skyboxCubeMapPass->rpDesc = renderTarget->getRenderPassDescriptor().get();

++

++                     currentPassData.skyboxPass = std::nullopt;

++                 } else if ((data.layer.background == QSSGRenderLayer::Background::SkyBox && data.layer.lightProbe)

++                            || (data.layer.background == QSSGRenderLayer::Background::SkyMaterial && data.layer.skyMaterial)) {

++                     if (!currentPassData.skyboxPass)

++                         currentPassData.skyboxPass = SkyboxPass();

++

++                     currentPassData.skyboxPass->skipTonemapping = true;

++                     currentPassData.skyboxPass->renderPrep(renderer, data);

++                     currentPassData.skyboxPass->ps.samples = ps.samples;

++                     currentPassData.skyboxPass->rpDesc = renderTarget->getRenderPassDescriptor().get();

++

++                     currentPassData.skyboxCubeMapPass = std::nullopt;

++                 }

++                 outData.push_back(currentPassData);

++             }

++         } else if (passNode->passMode == QSSGRenderUserPass::PassModes::Item2DPass) {

++             if (!currentPassData.item2DPass)

++                 currentPassData.item2DPass = Item2DPass();

++             const bool hasItem2Ds = (data.item2DsView.size() > 0);

++             if (hasItem2Ds) {

++                 //backup render target

++                 QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(renderer.contextInterface()->rhiContext().get());

++                 QRhiRenderTarget *prevRenderTarget = rhiCtx->renderTarget();

++                 rhiCtxD->setRenderTarget(renderTarget->getRenderTarget().get());

++                 currentPassData.item2DPass->renderPrep(renderer, data);

++                 //restore render target

++                 rhiCtxD->setRenderTarget(prevRenderTarget);

++                 outData.push_back(currentPassData);

++             }

++         }

++     }

++ }

++

++ QT_END_NAMESPACE

Revision control