qt/qtquick3d/tests/auto/quick3d_visual/userpasses/tst_userpasses.cpp

Revision control

++ // Copyright (C) 2026 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include <QTest>
++ #include <QSignalSpy>
++ #include <QDir>
++ #include <QFile>
++ #include <QRegularExpression>
++ #include <QtQml/QQmlComponent>
++ #include <QtQuick/QQuickView>
++ #include <QtQuick3D/private/qquick3dviewport_p.h>
++ #include <QtQuick3D/private/qquick3drenderpass_p.h>
++ #include <QtQuick3D/private/qquick3dobject_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssgrenderuserpass_p.h>
++ #include <QtQuick3DRuntimeRender/private/qssguserrenderpassmanager_p.h>
++ #include "../shared/util.h"
++
++ class tst_UserPasses : public QQuick3DDataTest
++ {
++ Q_OBJECT
++
++ private slots:
++ void initTestCase() override;
++ void testBasicRenderPass();
++ void testMultipleRenderPasses();
++ void testMultipleRenderTargets();
++ void testDisableInternalPasses();
++ void testRenderPassTextures();
++ void testRenderPassTextures_data();
++ void testSubRenderPass();
++ void testContentLayers();
++ void testRenderablesFilter();
++ void testRenderablesFilter_data();
++ void testPipelineStateOverride();
++ void testPipelineStateOverride_data();
++ void subPassOverrideMaterial();
++ void multipleSubPasses();
++ void subPassNestingDepth();
++ void userPassManagerScheduling();
++ void subPassRoleTransition();
++ void subPassRefCounting();
++ void subPassCommandDestroyed();
++ void referencedPassDestroyed();
++ void unreferencedPassReturnsToTopLevel();
++ void nestedPassOrdering();
++ void nodeParentedPassIsTopLevel();
++ void reparentUpdatesDepth();
++ void multiConsumerProducerDepth();
++ void slotLimitDoesNotCrash();
++ void depthLimitDoesNotCrash();
++ void testAddDefine();
++ void testAugmentShaderTextureBinding();
++ void testAugmentShaderArrayTextureBinding();
++ void testSkyboxPass();
++ void testItem2DPass();
++ void testDepthTestDisabled();
++ void testBlendEnabled();
++ void testPreserveColorContents();
++ void testViewportOverride();
++ void testScreenTexture();
++ void testCullModeOverrideSubpass_data();
++ void testCullModeOverrideSubpass();
++ void testBlendOverrideOriginalMaterial();
++ void noColorAttachmentDoesNotCrash();
++ void testAugmentShaderWithCustomMaterial();
++
++ private:
++ // Helper function to check if an image contains a specific color (with lighting effects)
++ bool imageContainsColor(const QImage &image, const QColor &color, int tolerance = 30);
++ // Helper to check if image contains a dominant color (e.g. mostly red, mostly green)
++ bool imageContainsDominantColor(const QImage &image, const QColor &color, int minValue = 100);
++ // Helper to check if image is not all black (something rendered)
++ bool imageHasNonBlackPixels(const QImage &image);
++ };
++
++ void tst_UserPasses::initTestCase()
++ {
++ QQuick3DDataTest::initTestCase();
++ if (!initialized())
++ QSKIP("Could not initialize visual test");
++ }
++
++ bool tst_UserPasses::imageContainsColor(const QImage &image, const QColor &color, int tolerance)
++ {
++ for (int y = 0; y < image.height(); ++y) {
++ for (int x = 0; x < image.width(); ++x) {
++ QColor pixel = image.pixelColor(x, y);
++ int rDiff = qAbs(pixel.red() - color.red());
++ int gDiff = qAbs(pixel.green() - color.green());
++ int bDiff = qAbs(pixel.blue() - color.blue());
++
++ if (rDiff <= tolerance && gDiff <= tolerance && bDiff <= tolerance) {
++ return true;
++ }
++ }
++ }
++ return false;
++ }
++
++ bool tst_UserPasses::imageContainsDominantColor(const QImage &image, const QColor &color, int minValue)
++ {
++ // Check which component is dominant in the expected color
++ int r = color.red();
++ int g = color.green();
++ int b = color.blue();
++
++ for (int y = 0; y < image.height(); ++y) {
++ for (int x = 0; x < image.width(); ++x) {
++ QColor pixel = image.pixelColor(x, y);
++
++ // For gray (all channels equal or similar)
++ if (qAbs(r - g) < 20 && qAbs(g - b) < 20 && qAbs(r - b) < 20) {
++ int pixelAvg = (pixel.red() + pixel.green() + pixel.blue()) / 3;
++ int colorAvg = (r + g + b) / 3;
++ if (qAbs(pixelAvg - colorAvg) < 50) {
++ return true;
++ }
++ }
++ // For red: R should be high and dominant
++ else if (r > g && r > b && r > 128) {
++ if (pixel.red() >= minValue && pixel.red() > pixel.green() && pixel.red() > pixel.blue()) {
++ return true;
++ }
++ }
++ // For green: G should be high and dominant
++ else if (g > r && g > b && g > 128) {
++ if (pixel.green() >= minValue && pixel.green() > pixel.red() && pixel.green() > pixel.blue()) {
++ return true;
++ }
++ }
++ // For blue: B should be high and dominant
++ else if (b > r && b > g && b > 128) {
++ if (pixel.blue() >= minValue && pixel.blue() > pixel.red() && pixel.blue() > pixel.green()) {
++ return true;
++ }
++ }
++ // For dark blue (blue dominant but all low values)
++ else if (b > r && b > g && b < 200) {
++ if (pixel.blue() > pixel.red() && pixel.blue() > pixel.green() && pixel.blue() >= 50) {
++ return true;
++ }
++ }
++ // For cyan (G and B high, R low)
++ else if (r < 128 && g > 128 && b > 128) {
++ if (pixel.red() < 128 && pixel.green() >= minValue && pixel.blue() >= minValue) {
++ return true;
++ }
++ }
++ // For yellow (R and G high, B low)
++ else if (r > 128 && g > 128 && b < 128) {
++ if (pixel.red() >= minValue && pixel.green() >= minValue && pixel.blue() < 128) {
++ return true;
++ }
++ }
++ // For purple/magenta (R and B high, G low)
++ else if (r > 64 && g < 128 && b > 64) {
++ if (pixel.red() >= 50 && pixel.green() < 128 && pixel.blue() >= 50) {
++ return true;
++ }
++ }
++ // For orange (R high, G medium, B low)
++ else if (r > 128 && g > 64 && b < 128) {
++ if (pixel.red() >= minValue && pixel.green() >= 50 && pixel.blue() < 128) {
++ return true;
++ }
++ }
++ }
++ }
++ return false;
++ }
++
++ bool tst_UserPasses::imageHasNonBlackPixels(const QImage &image)
++ {
++ for (int y = 0; y < image.height(); ++y) {
++ for (int x = 0; x < image.width(); ++x) {
++ QColor pixel = image.pixelColor(x, y);
++ if (pixel.red() > 10 || pixel.green() > 10 || pixel.blue() > 10) {
++ return true;
++ }
++ }
++ }
++ return false;
++ }
++
++ void tst_UserPasses::testBasicRenderPass()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("basicrenderpass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Get the viewport
++ QQuick3DViewport *viewport = view->rootObject()->findChild<QQuick3DViewport *>();
++ QVERIFY(viewport);
++
++ // Verify render pass is created
++ QQuick3DRenderPass *renderPass = view->rootObject()->findChild<QQuick3DRenderPass *>();
++ QVERIFY(renderPass);
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++ // Size may be scaled for high DPI displays
++ QVERIFY(result.width() >= 400);
++ QVERIFY(result.height() >= 400);
++
++ // The test validates the user pass is being used by checking the clear color
++ // RenderPass.clearColor = "blue", environment.clearColor = "black"
++ // If the user pass is working, background should be blue, not black
++ QVERIFY2(imageContainsDominantColor(result, Qt::blue), "Background should be blue (from pass clearColor)");
++
++ // The red cube should also be visible
++ QVERIFY2(imageContainsDominantColor(result, Qt::red), "Red cube should be visible");
++
++ // Validate that no green is visible (proves the imageConainsDominantColor check is valid)
++ QVERIFY2(!imageContainsDominantColor(result, Qt::green), "No Green should be visible");
++ }
++
++ void tst_UserPasses::testMultipleRenderPasses()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("multiplepasses.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Verify multiple render passes are created
++ QList<QQuick3DRenderPass *> renderPasses = view->rootObject()->findChildren<QQuick3DRenderPass *>();
++ QVERIFY(renderPasses.size() > 1);
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // This test validates pass chaining:
++ // - pass1 renders red cube on yellow background to texture
++ // - pass2 uses pass1's texture on a sphere, with cyan background
++ // - We should see cyan background (from pass2) proving pass2 is active
++ // - We should see red/yellow (from pass1 texture on sphere) proving passes chain
++ QVERIFY2(imageContainsDominantColor(result, Qt::cyan), "Background should be cyan (from pass2)");
++ QVERIFY2(imageContainsDominantColor(result, Qt::red), "Red from pass1 should be visible on sphere");
++ QVERIFY2(imageContainsDominantColor(result, Qt::yellow), "Yellow from pass1 should be visible on sphere");
++ // Validate that no green is visible (proves the imageConainsDominantColor check is valid)
++ QVERIFY2(!imageContainsDominantColor(result, Qt::green), "No Green should be visible");
++ }
++
++ void tst_UserPasses::testMultipleRenderTargets()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("gbufferpass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Verify render pass with multiple attachments
++ QQuick3DRenderPass *renderPass = view->rootObject()->findChild<QQuick3DRenderPass *>("mrtPass");
++ QVERIFY(renderPass);
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // This test validates Multiple Render Targets (MRT) work:
++ // - ONE render pass with 3 color attachments (GBUFFER0, GBUFFER1, GBUFFER2)
++ // - CustomMaterial fragment shader writes:
++ // - RED to GBUFFER0 (attachment 0)
++ // - YELLOW to GBUFFER1 (attachment 1)
++ // - BLUE to GBUFFER2 (attachment 2)
++ // - We display attachment 1 (GBUFFER1)
++ // - Should see yellow, proving MRT works (if MRT failed, we'd see red or black)
++ QVERIFY2(imageContainsDominantColor(result, Qt::yellow), "Should see yellow (from GBUFFER1), proving MRT works");
++ QVERIFY2(!imageContainsDominantColor(result, Qt::red), "Should NOT see red (GBUFFER0 not displayed)");
++ QVERIFY2(!imageContainsDominantColor(result, Qt::blue), "Should NOT see blue (GBUFFER2 not displayed)");
++ }
++
++ void tst_UserPasses::testDisableInternalPasses()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("disableinternalpasses.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Get the viewport
++ QQuick3DViewport *viewport = view->rootObject()->findChild<QQuick3DViewport *>();
++ QVERIFY(viewport);
++
++ // Verify DisableInternalPasses is set
++ QVERIFY(viewport->renderOverrides() & QQuick3DViewport::RenderOverride::DisableInternalPasses);
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // This test validates DisableInternalPasses works:
++ // - environment.clearColor = "red"
++ // - RenderPass.clearColor = "green"
++ // - With DisableInternalPasses, we should see green, not red
++ QVERIFY2(imageContainsDominantColor(result, Qt::green), "Background should be green (from pass), proving DisableInternalPasses works");
++ QVERIFY2(!imageContainsDominantColor(result, Qt::red), "Should NOT see red (from environment)");
++ }
++
++ void tst_UserPasses::testRenderPassTextures_data()
++ {
++ QTest::addColumn<QString>("formatName");
++ QTest::addColumn<bool>("isSingleChannel");
++ QTest::addColumn<int>("expectedColor"); // QColor as int for easy comparison
++
++ // Test all color texture formats
++ QTest::newRow("RGBA8") << "RGBA8" << false << static_cast<int>(Qt::yellow);
++ QTest::newRow("RGBA16F") << "RGBA16F" << false << static_cast<int>(Qt::yellow);
++ QTest::newRow("RGBA32F") << "RGBA32F" << false << static_cast<int>(Qt::yellow);
++ QTest::newRow("R8") << "R8" << true << static_cast<int>(Qt::white); // Single channel
++ QTest::newRow("R16") << "R16" << true << static_cast<int>(Qt::white); // Single channel
++ QTest::newRow("R16F") << "R16F" << true << static_cast<int>(Qt::white); // Single channel
++ QTest::newRow("R32F") << "R32F" << true << static_cast<int>(Qt::white); // Single channel
++ }
++
++ void tst_UserPasses::testRenderPassTextures()
++ {
++ QFETCH(QString, formatName);
++ QFETCH(bool, isSingleChannel);
++ QFETCH(int, expectedColor);
++
++ // For single-channel formats, use gray clear color (will show in red channel)
++ // For multi-channel formats, use distinctive color
++ QString clearColorValue = isSingleChannel ? "gray" : "darkBlue";
++ QString sphereColor = isSingleChannel ? "white" : "yellow";
++
++ // Create a temporary QML file with the specific format
++ QString qmlContent = QString(R"(
++ import QtQuick
++ import QtQuick3D
++ import QtQuick3D.Helpers
++
++ Item {
++ width: 400
++ height: 400
++
++ View3D {
++ id: view3D
++ anchors.fill: parent
++ renderOverrides: View3D.DisableInternalPasses
++
++ environment: SceneEnvironment {
++ backgroundMode: SceneEnvironment.Color
++ clearColor: "black"
++ }
++
++ PerspectiveCamera {
++ position: Qt.vector3d(0, 0, 300)
++ }
++
++ DirectionalLight {}
++
++ RenderPassTexture {
++ id: colorTexture
++ format: RenderPassTexture.%1
++ }
++
++ RenderPassTexture {
++ id: depthTexture
++ format: RenderPassTexture.Depth24Stencil8
++ }
++
++ RenderPass {
++ id: texturePass
++ materialMode: RenderPass.OriginalMaterial
++ clearColor: "%2"
++
++ commands: [
++ ColorAttachment { target: colorTexture },
++ DepthTextureAttachment { target: depthTexture }
++ ]
++ }
++
++ SimpleQuadRenderer {
++ texture: Texture {
++ textureProvider: RenderOutputProvider {
++ textureSource: RenderOutputProvider.UserPassTexture
++ renderPass: texturePass
++ attachmentSelector: RenderOutputProvider.Attachment0
++ }
++ }
++ }
++
++ Model {
++ source: "#Sphere"
++ materials: PrincipledMaterial {
++ baseColor: "%3"
++ lighting: PrincipledMaterial.NoLighting
++ }
++ }
++ }
++ }
++ )")
++ .arg(formatName, clearColorValue, sphereColor);
++
++ // Write temporary QML file
++ QString tempPath = QDir::temp().filePath(QString("test_%1.qml").arg(formatName));
++ QFile tempFile(tempPath);
++ QVERIFY(tempFile.open(QIODevice::WriteOnly | QIODevice::Text));
++ tempFile.write(qmlContent.toUtf8());
++ tempFile.close();
++
++ // Load and test
++ QScopedPointer<QQuickView> view(new QQuickView);
++ view->setSource(QUrl::fromLocalFile(tempPath));
++ view->setResizeMode(QQuickView::SizeRootObjectToView);
++ view->resize(400, 400);
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // Validate format-specific rendering
++ if (!isSingleChannel) {
++ // Multi-channel formats should show the distinctive clear color
++ QColor darkBlue(0, 0, 139);
++ QVERIFY2(imageContainsDominantColor(result, darkBlue),
++ qPrintable(QString("Background should be dark blue for format %1").arg(formatName)));
++ }
++
++ // For single-channel formats, just verify something rendered (not all black)
++ // These formats can only store red channel data, so color validation is limited
++ if (isSingleChannel) {
++ QVERIFY2(imageHasNonBlackPixels(result),
++ qPrintable(QString("Image should render for single-channel format %1").arg(formatName)));
++ } else {
++ QColor expected = QColor(static_cast<Qt::GlobalColor>(expectedColor));
++ QVERIFY2(imageContainsDominantColor(result, expected),
++ qPrintable(QString("Expected color should be visible for format %1").arg(formatName)));
++ }
++
++ // Cleanup
++ tempFile.remove();
++ }
++
++ void tst_UserPasses::testSubRenderPass()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subrenderpass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Verify nested render passes
++ QList<QQuick3DRenderPass *> renderPasses = view->rootObject()->findChildren<QQuick3DRenderPass *>();
++ QVERIFY(renderPasses.size() >= 2);
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // This test validates SubRenderPass works:
++ // - Parent pass has magenta clear color and filters to Layer0 (nothing)
++ // - Child SubRenderPass filters to Layer1 and renders the cyan cone
++ // - If SubRenderPass wasn't executing, we'd only see magenta background
++ // - Seeing the cyan cone proves SubRenderPass executed
++ QColor magenta(255, 0, 255);
++ QVERIFY2(imageContainsDominantColor(result, magenta), "Background should be magenta (from parent pass)");
++ QVERIFY2(imageContainsDominantColor(result, Qt::cyan), "Cyan cone should be visible (proves SubRenderPass executed)");
++ }
++
++ void tst_UserPasses::testContentLayers()
++ {
++ QScopedPointer<QQuickView> view(createView(QLatin1String("contentlayers.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // This test validates ContentLayer filtering works:
++ // - Pass filters to Layer0 | Layer1 only
++ // - Gray background (from pass) proves pass is active
++ // - Layer0 (red cube) and Layer1 (green sphere) should be visible
++ // - Layer2 (blue cone) should NOT be visible (filtered out)
++ QVERIFY2(imageContainsDominantColor(result, Qt::gray), "Background should be gray (from pass)");
++ QVERIFY2(imageContainsDominantColor(result, Qt::red), "Red cube (Layer0) should be visible");
++ QVERIFY2(imageContainsDominantColor(result, Qt::green), "Green sphere (Layer1) should be visible");
++ QVERIFY2(!imageContainsDominantColor(result, Qt::blue), "Blue cone (Layer2) should NOT be visible (filtered)");
++ }
++
++ void tst_UserPasses::testRenderablesFilter_data()
++ {
++ QTest::addColumn<QString>("filterMode");
++ QTest::addColumn<bool>("expectRed"); // Opaque red cube
++ QTest::addColumn<bool>("expectGreen"); // Transparent green sphere
++
++ // Test all filter modes
++ QTest::newRow("Opaque") << "RenderablesFilter.Opaque" << true << false;
++ QTest::newRow("Transparent") << "RenderablesFilter.Transparent" << false << true;
++ QTest::newRow("Opaque | Transparent") << "RenderablesFilter.Opaque | RenderablesFilter.Transparent" << true << true;
++ QTest::newRow("None") << "RenderablesFilter.None" << false << false; // No renderables
++ }
++
++ void tst_UserPasses::testRenderablesFilter()
++ {
++ QFETCH(QString, filterMode);
++ QFETCH(bool, expectRed);
++ QFETCH(bool, expectGreen);
++
++ // Create a temporary QML file with the specific filter mode
++ QString qmlContent = QString(R"(
++ import QtQuick
++ import QtQuick3D
++ import QtQuick3D.Helpers
++
++ Item {
++ width: 400
++ height: 400
++
++ View3D {
++ id: view3D
++ anchors.fill: parent
++ renderOverrides: View3D.DisableInternalPasses
++
++ environment: SceneEnvironment {
++ backgroundMode: SceneEnvironment.Color
++ clearColor: "yellow"
++ }
++
++ PerspectiveCamera {
++ position: Qt.vector3d(0, 0, 300)
++ }
++
++ DirectionalLight {}
++
++ RenderPassTexture {
++ id: outputTexture
++ format: RenderPassTexture.RGBA8
++ }
++
++ RenderPass {
++ id: filterPass
++ materialMode: RenderPass.OriginalMaterial
++ clearColor: "blue"
++
++ commands: [
++ ColorAttachment { target: outputTexture },
++ DepthStencilAttachment {},
++ RenderablesFilter {
++ renderableTypes: %1
++ }
++ ]
++ }
++
++ SimpleQuadRenderer {
++ texture: Texture {
++ textureProvider: RenderOutputProvider {
++ textureSource: RenderOutputProvider.UserPassTexture
++ renderPass: filterPass
++ attachmentSelector: RenderOutputProvider.Attachment0
++ }
++ }
++ }
++
++ // Opaque red cube
++ Model {
++ source: "#Cube"
++ materials: PrincipledMaterial {
++ baseColor: "red"
++ alphaMode: PrincipledMaterial.Opaque
++ lighting: PrincipledMaterial.NoLighting
++ }
++ }
++
++ // Transparent green sphere
++ Model {
++ source: "#Sphere"
++ position: Qt.vector3d(150, 0, 0)
++ materials: PrincipledMaterial {
++ baseColor: Qt.rgba(0, 1, 0, 0.5)
++ alphaMode: PrincipledMaterial.Blend
++ lighting: PrincipledMaterial.NoLighting
++ }
++ }
++ }
++ }
++ )")
++ .arg(filterMode);
++
++ // Write temporary QML file
++ QString tempPath = QDir::temp().filePath(QString("test_filter_%1.qml").arg(filterMode.replace(" ", "_").replace("|", "or")));
++ QFile tempFile(tempPath);
++ QVERIFY(tempFile.open(QIODevice::WriteOnly | QIODevice::Text));
++ tempFile.write(qmlContent.toUtf8());
++ tempFile.close();
++
++ // Load and test
++ QScopedPointer<QQuickView> view(new QQuickView);
++ view->setSource(QUrl::fromLocalFile(tempPath));
++ view->setResizeMode(QQuickView::SizeRootObjectToView);
++ view->resize(400, 400);
++ QVERIFY(view);
++ view->show();
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Capture the rendered image
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // Blue background should always be visible (proves pass is active)
++ QVERIFY2(imageContainsDominantColor(result, Qt::blue),
++ qPrintable(QString("Background should be blue for filter mode: %1").arg(filterMode)));
++
++ // Validate presence/absence of red cube (opaque)
++ if (expectRed) {
++ QVERIFY2(imageContainsDominantColor(result, Qt::red),
++ qPrintable(QString("Red cube (opaque) should be visible for filter mode: %1").arg(filterMode)));
++ } else {
++ QVERIFY2(!imageContainsDominantColor(result, Qt::red),
++ qPrintable(QString("Red cube (opaque) should NOT be visible for filter mode: %1").arg(filterMode)));
++ }
++
++ // Validate presence/absence of green sphere (transparent)
++ if (expectGreen) {
++ QVERIFY2(imageContainsDominantColor(result, Qt::green),
++ qPrintable(QString("Green sphere (transparent) should be visible for filter mode: %1").arg(filterMode)));
++ } else {
++ QVERIFY2(!imageContainsDominantColor(result, Qt::green),
++ qPrintable(QString("Green sphere (transparent) should NOT be visible for filter mode: %1").arg(filterMode)));
++ }
++
++ // Cleanup
++ tempFile.remove();
++ }
++
++ void tst_UserPasses::testPipelineStateOverride_data()
++ {
++ QTest::addColumn<QString>("qmlFile");
++ QTest::addColumn<QColor>("expectedColor");
++ QTest::addColumn<QString>("description");
++
++ QTest::newRow("Wireframe") << "pipelinestateoverride_wireframe.qml" << QColor("white")
++ << "White edges should be visible in wireframe mode (polygonMode = Line)";
++
++ QTest::newRow("CullFront") << "pipelinestateoverride_cullfront.qml" << QColor("white")
++ << "Back faces should be visible with cullMode = Front";
++
++ QTest::newRow("Scissor") << "pipelinestateoverride_scissor.qml" << QColor("cyan")
++ << "Cyan cube should be clipped to bottom-left region with scissor";
++ }
++
++ void tst_UserPasses::testPipelineStateOverride()
++ {
++ QFETCH(QString, qmlFile);
++ QFETCH(QColor, expectedColor);
++ QFETCH(QString, description);
++
++ QQuickView view;
++ view.setSource(testFileUrl(qmlFile));
++ view.setResizeMode(QQuickView::SizeRootObjectToView);
++ view.show();
++
++ QVERIFY(QTest::qWaitForWindowExposed(&view));
++
++ QImage result = grab(&view);
++ QVERIFY(result.width() >= 400);
++ QVERIFY(result.height() >= 400);
++
++ // Validate the specific pipeline state override effect
++ // Skip generic color check for tests with specific validation
++ if (!qmlFile.contains("cullfront") && !qmlFile.contains("scissor")) {
++ QVERIFY2(imageContainsDominantColor(result, expectedColor), qPrintable(description));
++ }
++
++ // Additional validation based on test type
++ if (qmlFile.contains("wireframe")) {
++ // Wireframe test: verify mostly black (not filled)
++ int blackPixels = 0;
++ int whitePixels = 0;
++ for (int y = 0; y < result.height(); ++y) {
++ for (int x = 0; x < result.width(); ++x) {
++ QColor pixel = result.pixelColor(x, y);
++ if (pixel.red() < 30 && pixel.green() < 30 && pixel.blue() < 30) {
++ blackPixels++;
++ } else if (pixel.red() > 200 || pixel.green() > 200 || pixel.blue() > 200) {
++ whitePixels++;
++ }
++ }
++ }
++ // Wireframe should be mostly black (not filled)
++ QVERIFY2(blackPixels > whitePixels * 5, "Wireframe mode should show mostly black background (not filled faces)");
++ } else if (qmlFile.contains("cullfront")) {
++ // CullFront test: front faces are culled, so the center of the cube (where the
++ // camera looks straight through the culled front face to the dark back face) must
++ // be near-black, while some back/edge faces visible at glancing angles are non-black.
++ const QColor center = result.pixelColor(result.width() / 2, result.height() / 2);
++ const int centerBrightness = (center.red() + center.green() + center.blue()) / 3;
++ QVERIFY2(centerBrightness < 30, "Front face should be culled: center must be dark");
++ int nonBlackPixels = 0;
++ for (int y = 0; y < result.height(); ++y) {
++ for (int x = 0; x < result.width(); ++x) {
++ QColor pixel = result.pixelColor(x, y);
++ int brightness = (pixel.red() + pixel.green() + pixel.blue()) / 3;
++ if (brightness > 20)
++ nonBlackPixels++;
++ }
++ }
++ QVERIFY2(nonBlackPixels > 100, "Some back/edge faces should be visible");
++ } else if (qmlFile.contains("scissor")) {
++ // Scissor test: verify cyan is clipped to bottom-left region
++ // Scissor rect is Qt.rect(100, 100, 200, 200) which appears in bottom-left
++ int cyanPixels = 0;
++ int cyanInBottomLeft = 0; // Cyan in bottom-left region
++ int blackInTopRight = 0; // Black in top-right region (should be clipped)
++
++ for (int y = 0; y < result.height(); ++y) {
++ for (int x = 0; x < result.width(); ++x) {
++ QColor pixel = result.pixelColor(x, y);
++ bool isCyan = (pixel.green() > 100 && pixel.blue() > 100 && pixel.red() < 100);
++ bool isBlack = (pixel.red() < 30 && pixel.green() < 30 && pixel.blue() < 30);
++
++ if (isCyan) {
++ cyanPixels++;
++ // Check if cyan appears in bottom-left region (where scissor rect is)
++ if (x >= 50 && x < 350 && y >= result.height() - 350 && y < result.height() - 50) {
++ cyanInBottomLeft++;
++ }
++ }
++
++ // Check top-right region should be black (clipped)
++ if (x >= result.width() - 100 && y < 100) {
++ if (isBlack) {
++ blackInTopRight++;
++ }
++ }
++ }
++ }
++
++ // Should have cyan visible (scissor allows rendering)
++ QVERIFY2(cyanPixels > 100, "Should have some cyan visible within scissor rectangle");
++
++ // Cyan should be concentrated in bottom-left region (where scissor rect is)
++ QVERIFY2(cyanInBottomLeft > 50, "Cyan should appear in bottom-left region within scissor rectangle");
++
++ // Top-right should be mostly black (clipped by scissor)
++ QVERIFY2(blackInTopRight > 500, "Top-right region should be black (clipped by scissor)");
++ }
++ }
++
++ // NoLighting DefaultMaterial colors are stored as linear in the RGBA16F render
++ // target and displayed after sRGB encoding. Pure primaries (0 or 1 in linear)
++ // encode identically in sRGB, but rounding and the display pipeline can shift
++ // channel values by up to ~50 out of 255. Use a generous fuzz that still
++ // clearly distinguishes red from blue or green from black.
++ static const int FUZZ = 50;
++
++ void tst_UserPasses::subPassOverrideMaterial()
++ {
++ // A sphere with a blue PrincipledMaterial is rendered through a SubRenderPass
++ // whose renderPass uses OverrideMaterial with a red NoLighting DefaultMaterial.
++ // The center pixel must be red, not blue, proving that the override material's
++ // uniform buffer properties (colour) were applied rather than the original material's.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_overridematerial.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage result = grab(view.data());
++ if (result.isNull())
++ return;
++
++ // Center of the sphere should be red (override), not blue (original material).
++ QVERIFY(comparePixelNormPos(result, 0.5, 0.5, Qt::red, FUZZ));
++ }
++
++ void tst_UserPasses::multipleSubPasses()
++ {
++ // Two SubRenderPasses in one main pass, each targeting a different layer with
++ // a different override material:
++ // SubPass 1: red override, Layer0 -> cube at left (x = -150)
++ // SubPass 2: blue override, Layer1 -> sphere at right (x = +150)
++ // If both sub-passes correctly acquire unique userPassData slots the left
++ // region will be red and the right region blue. If they share a slot the
++ // second pass overwrites the first and both sides show the same colour.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("multiple_subpasses.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage result = grab(view.data());
++ if (result.isNull())
++ return;
++
++ // Left quarter (cube on Layer0) should be red.
++ QVERIFY(comparePixelNormPos(result, 0.25, 0.5, Qt::red, FUZZ));
++ // Right quarter (sphere on Layer1) should be blue.
++ QVERIFY(comparePixelNormPos(result, 0.75, 0.5, Qt::blue, FUZZ));
++ }
++
++ void tst_UserPasses::subPassNestingDepth()
++ {
++ // Regression test for QTBUG-148554. A pass referenced as a SubRenderPass
++ // (Role::SubPass) must carry no ordering state: its nesting depth stays 0
++ // even though it is declared as a QML child of the top-level pass. If a
++ // sub-pass carried a non-zero depth and ever entered the scheduled list
++ // (e.g. its output consumed via a provider) it would sort ahead of genuine
++ // top-level passes.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_nesting_depth.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Force a full synchronize + render so the classification runs.
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ auto *mainPass = view->rootObject()->findChild<QQuick3DRenderPass *>("mainPass");
++ auto *subPass = view->rootObject()->findChild<QQuick3DRenderPass *>("subPass");
++ QVERIFY(mainPass);
++ QVERIFY(subPass);
++
++ auto *mainNode = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(mainPass)->spatialNode);
++ auto *subNode = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(subPass)->spatialNode);
++ QVERIFY(mainNode);
++ QVERIFY(subNode);
++
++ // Roles are assigned during sync: the main pass is top-level and the
++ // referenced pass is tagged as a sub-pass.
++ QCOMPARE(mainNode->role, QSSGRenderUserPass::Role::TopLevel);
++ QCOMPARE(subNode->role, QSSGRenderUserPass::Role::SubPass);
++
++ // The invariants under test: a sub-pass carries no ordering state, and the
++ // top-level pass parented to the View3D sits at depth 0.
++ QCOMPARE(subNode->m_nestingDepth, 0u);
++ QCOMPARE(mainNode->m_nestingDepth, 0u);
++ }
++
++ void tst_UserPasses::userPassManagerScheduling()
++ {
++ // Unit test of the manager's scheduling contract, which the scene sync and
++ // the RenderOutputProvider path both depend on.
++ auto manager = QSSGUserRenderPassManager::create();
++
++ QSSGRenderUserPass topA;
++ QSSGRenderUserPass topB;
++ QSSGRenderUserPass topC;
++ QSSGRenderUserPass sub;
++ topA.role = QSSGRenderUserPass::Role::TopLevel;
++ topB.role = QSSGRenderUserPass::Role::TopLevel;
++ topC.role = QSSGRenderUserPass::Role::TopLevel;
++ sub.role = QSSGRenderUserPass::Role::SubPass;
++
++ // Sync establishes the top-level set wholesale.
++ manager->setScheduledPasses({ &topA, &topB });
++ QCOMPARE(manager->scheduledUserPasses().size(), 2);
++
++ // Provider path: confirming an already-scheduled pass is a no-op.
++ manager->scheduleUserPass(&topA);
++ QCOMPARE(manager->scheduledUserPasses().size(), 2);
++
++ // A top-level pass not yet scheduled is added (first-frame fallback).
++ manager->scheduleUserPass(&topC);
++ QCOMPARE(manager->scheduledUserPasses().size(), 3);
++
++ // A sub-pass is rejected, even via the provider path (QTBUG-148554).
++ manager->scheduleUserPass(&sub);
++ QCOMPARE(manager->scheduledUserPasses().size(), 3);
++ QVERIFY(!manager->scheduledUserPasses().contains(&sub));
++
++ // Ordering: deeper nesting first, then lower declaration order.
++ topA.m_nestingDepth = 1; topA.m_declarationOrder = 0;
++ topB.m_nestingDepth = 3; topB.m_declarationOrder = 1;
++ topC.m_nestingDepth = 1; topC.m_declarationOrder = 2;
++ manager->setScheduledPasses({ &topA, &topB, &topC });
++ manager->updateUserPassOrder(true);
++ const auto &ordered = manager->scheduledUserPasses();
++ QCOMPARE(ordered.size(), 3);
++ QCOMPARE(ordered.at(0), &topB); // deepest nesting
++ QCOMPARE(ordered.at(1), &topA); // equal depth, lower declaration order first
++ QCOMPARE(ordered.at(2), &topC);
++ }
++
++ void tst_UserPasses::nestedPassOrdering()
++ {
++ // A producer declared as a QML child of its consumer gets nesting depth 1
++ // and renders first, into its own render target.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("nested_pass_ordering.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ auto *consumer = view->rootObject()->findChild<QQuick3DRenderPass *>("consumerPass");
++ auto *producer = view->rootObject()->findChild<QQuick3DRenderPass *>("producerPass");
++ QVERIFY(consumer);
++ QVERIFY(producer);
++
++ auto *consumerNode = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(consumer)->spatialNode);
++ auto *producerNode = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(producer)->spatialNode);
++ QVERIFY(consumerNode);
++ QVERIFY(producerNode);
++
++ QCOMPARE(consumerNode->role, QSSGRenderUserPass::Role::TopLevel);
++ QCOMPARE(producerNode->role, QSSGRenderUserPass::Role::TopLevel);
++ QCOMPARE(consumerNode->m_nestingDepth, 0u);
++ QCOMPARE(producerNode->m_nestingDepth, 1u);
++
++ // The sphere drawn by the consumer is textured with the producer's output
++ // (red cube on yellow), so both colors must reach the screen.
++ QVERIFY(imageContainsDominantColor(result, Qt::red));
++ QVERIFY(imageContainsDominantColor(result, Qt::yellow));
++ }
++
++ void tst_UserPasses::nodeParentedPassIsTopLevel()
++ {
++ // A pass declared under a Node is an active top-level pass. The Node is
++ // transparent for ordering: only RenderPass ancestors count towards the
++ // nesting depth, so the pass sits at depth 0.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("node_parented_pass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ auto *grouped = view->rootObject()->findChild<QQuick3DRenderPass *>("groupedPass");
++ QVERIFY(grouped);
++ auto *groupedNode = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(grouped)->spatialNode);
++ QVERIFY(groupedNode);
++
++ QCOMPARE(groupedNode->role, QSSGRenderUserPass::Role::TopLevel);
++ QCOMPARE(groupedNode->m_nestingDepth, 0u);
++
++ // The scene renders normally alongside the grouped pass.
++ QVERIFY(imageContainsDominantColor(result, Qt::red));
++ }
++
++ void tst_UserPasses::reparentUpdatesDepth()
++ {
++ // Reparenting a pass at runtime re-derives its validity and depth.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("reparent_depth.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *viewport = view->rootObject()->findChild<QQuick3DViewport *>("view");
++ auto *passA = view->rootObject()->findChild<QQuick3DRenderPass *>("passA");
++ auto *passB = view->rootObject()->findChild<QQuick3DRenderPass *>("passB");
++ auto *nodeParent = view->rootObject()->findChild<QQuick3DObject *>("nodeParent");
++ QVERIFY(viewport);
++ QVERIFY(passA);
++ QVERIFY(passB);
++ QVERIFY(nodeParent);
++
++ const auto nodeOf = [](QQuick3DRenderPass *pass) {
++ return static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ };
++
++ // Initially both passes are children of the viewport: depth 0.
++ QVERIFY(!grab(view.data()).isNull());
++ QVERIFY(nodeOf(passA));
++ QCOMPARE(nodeOf(passA)->m_nestingDepth, 0u);
++
++ // Under another pass: depth 1.
++ passA->setParentItem(passB);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(nodeOf(passA)->m_nestingDepth, 1u);
++
++ // Under a Node: the Node is transparent for ordering, so depth 0 again.
++ passA->setParentItem(nodeParent);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(nodeOf(passA)->m_nestingDepth, 0u);
++
++ // Back under the viewport's scene root: still depth 0.
++ passA->setParentItem(viewport->scene());
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(nodeOf(passA)->m_nestingDepth, 0u);
++ }
++
++ void tst_UserPasses::multiConsumerProducerDepth()
++ {
++ // A producer nested in consumerA (depth 1) renders before all depth-0
++ // passes, so consumerB also sees its output without a second edge.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("multi_consumer.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ auto *consumerA = view->rootObject()->findChild<QQuick3DRenderPass *>("consumerA");
++ auto *consumerB = view->rootObject()->findChild<QQuick3DRenderPass *>("consumerB");
++ auto *producer = view->rootObject()->findChild<QQuick3DRenderPass *>("producerPass");
++ QVERIFY(consumerA);
++ QVERIFY(consumerB);
++ QVERIFY(producer);
++
++ const auto nodeOf = [](QQuick3DRenderPass *pass) {
++ return static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ };
++ QVERIFY(nodeOf(consumerA));
++ QVERIFY(nodeOf(consumerB));
++ QVERIFY(nodeOf(producer));
++
++ QCOMPARE(nodeOf(producer)->m_nestingDepth, 1u);
++ QCOMPARE(nodeOf(consumerA)->m_nestingDepth, 0u);
++ QCOMPARE(nodeOf(consumerB)->m_nestingDepth, 0u);
++
++ // consumerB's sphere is textured with the producer's output (red cube on
++ // yellow), even though the producer is nested inside consumerA.
++ QVERIFY(imageContainsDominantColor(result, Qt::red));
++ QVERIFY(imageContainsDominantColor(result, Qt::yellow));
++ }
++
++ void tst_UserPasses::subPassRoleTransition()
++ {
++ // The classification is only re-derived when the flag on the scene manager is
++ // set (pass add/remove or command-list rebuild). Flipping which leaf pass the
++ // container references at runtime must re-derive the roles accordingly.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_role_transition.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *leafA = view->rootObject()->findChild<QQuick3DRenderPass *>("leafA");
++ auto *leafB = view->rootObject()->findChild<QQuick3DRenderPass *>("leafB");
++ QVERIFY(leafA);
++ QVERIFY(leafB);
++
++ const auto roleOf = [](QQuick3DRenderPass *pass) {
++ auto *node = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ return node ? node->role : QSSGRenderUserPass::Role::TopLevel;
++ };
++
++ // Initially the container references leafB as its sub-pass.
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(leafB), QSSGRenderUserPass::Role::SubPass);
++ QCOMPARE(roleOf(leafA), QSSGRenderUserPass::Role::TopLevel);
++
++ // Flip the reference: leafA becomes the sub-pass, leafB returns to top-level.
++ view->rootObject()->setProperty("useLeafAAsSubPass", true);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(leafA), QSSGRenderUserPass::Role::SubPass);
++ QCOMPARE(roleOf(leafB), QSSGRenderUserPass::Role::TopLevel);
++
++ // And back again.
++ view->rootObject()->setProperty("useLeafAAsSubPass", false);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(leafB), QSSGRenderUserPass::Role::SubPass);
++ QCOMPARE(roleOf(leafA), QSSGRenderUserPass::Role::TopLevel);
++ }
++
++ void tst_UserPasses::subPassRefCounting()
++ {
++ // Two containers reference the SAME leaf pass. The classification counts
++ // references, so the leaf stays a sub-pass until the LAST reference is
++ // dropped.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_refcount.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *sharedLeaf = view->rootObject()->findChild<QQuick3DRenderPass *>("sharedLeaf");
++ QVERIFY(sharedLeaf);
++
++ const auto roleOf = [](QQuick3DRenderPass *pass) {
++ auto *node = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ return node ? node->role : QSSGRenderUserPass::Role::TopLevel;
++ };
++
++ // Both references active.
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(sharedLeaf), QSSGRenderUserPass::Role::SubPass);
++
++ // Dropping one of two references keeps the leaf a sub-pass.
++ view->rootObject()->setProperty("refA", false);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(sharedLeaf), QSSGRenderUserPass::Role::SubPass);
++
++ // Dropping the last reference makes it top-level again.
++ view->rootObject()->setProperty("refB", false);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(sharedLeaf), QSSGRenderUserPass::Role::TopLevel);
++
++ // And re-referencing flips it back.
++ view->rootObject()->setProperty("refA", true);
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(sharedLeaf), QSSGRenderUserPass::Role::SubPass);
++ }
++
++ void tst_UserPasses::subPassCommandDestroyed()
++ {
++ // Destroying the referencing SubRenderPass command (with its container
++ // pass) releases the reference: the leaf returns to top-level.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_dynamic_ref.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *viewport = view->rootObject()->findChild<QQuick3DViewport *>("view");
++ auto *staticLeaf = view->rootObject()->findChild<QQuick3DRenderPass *>("staticLeaf");
++ QVERIFY(viewport);
++ QVERIFY(staticLeaf);
++
++ const auto roleOf = [](QQuick3DRenderPass *pass) {
++ auto *node = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ return node ? node->role : QSSGRenderUserPass::Role::TopLevel;
++ };
++
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(staticLeaf), QSSGRenderUserPass::Role::TopLevel);
++
++ // Create a container pass at runtime that references the static leaf.
++ QQmlComponent component(view->engine());
++ component.setData(QByteArrayLiteral(
++ "import QtQuick3D\n"
++ "RenderPass {\n"
++ " commands: [ SubRenderPass { objectName: \"dynSubCmd\" } ]\n"
++ "}\n"),
++ QUrl(QStringLiteral("dyncontainer.qml")));
++ QVERIFY2(component.isReady(), qPrintable(component.errorString()));
++ auto *dynContainer = qobject_cast<QQuick3DRenderPass *>(component.create());
++ QVERIFY(dynContainer);
++ dynContainer->setParentItem(viewport->scene());
++ auto *dynSubCmd = dynContainer->findChild<QObject *>("dynSubCmd");
++ QVERIFY(dynSubCmd);
++ QVERIFY(dynSubCmd->setProperty("renderPass", QVariant::fromValue(staticLeaf)));
++
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(staticLeaf), QSSGRenderUserPass::Role::SubPass);
++
++ // Destroying the container destroys the command, releasing the reference.
++ delete dynContainer;
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(staticLeaf), QSSGRenderUserPass::Role::TopLevel);
++ }
++
++ void tst_UserPasses::referencedPassDestroyed()
++ {
++ // Destroying the referenced pass while the SubRenderPass command is alive
++ // must not crash: the watcher resets the command's renderPass and the
++ // dying pass is never dereferenced.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_dynamic_ref.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *viewport = view->rootObject()->findChild<QQuick3DViewport *>("view");
++ auto *staticContainer = view->rootObject()->findChild<QQuick3DRenderPass *>("staticContainer");
++ auto *staticSubCmd = view->rootObject()->findChild<QObject *>("staticSubCmd");
++ QVERIFY(viewport);
++ QVERIFY(staticContainer);
++ QVERIFY(staticSubCmd);
++
++ const auto roleOf = [](QQuick3DRenderPass *pass) {
++ auto *node = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ return node ? node->role : QSSGRenderUserPass::Role::TopLevel;
++ };
++
++ // Create a leaf pass at runtime and reference it from the static command.
++ QQmlComponent component(view->engine());
++ component.setData(QByteArrayLiteral(
++ "import QtQuick3D\n"
++ "RenderPass {\n"
++ " commands: [ RenderablesFilter { renderableTypes: RenderablesFilter.None } ]\n"
++ "}\n"),
++ QUrl(QStringLiteral("dynleaf.qml")));
++ QVERIFY2(component.isReady(), qPrintable(component.errorString()));
++ auto *dynLeaf = qobject_cast<QQuick3DRenderPass *>(component.create());
++ QVERIFY(dynLeaf);
++ dynLeaf->setParentItem(viewport->scene());
++ QVERIFY(staticSubCmd->setProperty("renderPass", QVariant::fromValue(dynLeaf)));
++
++ QVERIFY(!grab(view.data()).isNull());
++ QCOMPARE(roleOf(dynLeaf), QSSGRenderUserPass::Role::SubPass);
++
++ // Destroy the referenced pass; the watcher clears the command's property.
++ delete dynLeaf;
++ QCOMPARE(staticSubCmd->property("renderPass").value<QQuick3DRenderPass *>(), nullptr);
++
++ // The scene keeps rendering and the container is unaffected.
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++ QCOMPARE(roleOf(staticContainer), QSSGRenderUserPass::Role::TopLevel);
++ QVERIFY(imageContainsDominantColor(result, Qt::red));
++ }
++
++ void tst_UserPasses::unreferencedPassReturnsToTopLevel()
++ {
++ // A pass that is no longer referenced by any SubRenderPass command must
++ // return to being a top-level pass, and actually render as one again:
++ // the provider-driven quad shows the leaf's own output, which only exists
++ // when the leaf renders standalone.
++ //
++ // While referenced, the provider requests the leaf every frame and the
++ // manager rejects it with a once-per-pass warning; the first frames render
++ // during window exposure, so the expectation is armed up front.
++ QTest::ignoreMessage(QtWarningMsg,
++ QRegularExpression(QStringLiteral("Ignoring request to schedule sub-pass")));
++ QScopedPointer<QQuickView> view(createView(QLatin1String("subpass_unreference.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ auto *leafPass = view->rootObject()->findChild<QQuick3DRenderPass *>("leafPass");
++ QVERIFY(leafPass);
++
++ const auto roleOf = [](QQuick3DRenderPass *pass) {
++ auto *node = static_cast<QSSGRenderUserPass *>(QQuick3DObjectPrivate::get(pass)->spatialNode);
++ return node ? node->role : QSSGRenderUserPass::Role::TopLevel;
++ };
++
++ // Referenced: the leaf is a sub-pass and the quad has nothing to show.
++ const QImage subPassResult = grab(view.data());
++ QVERIFY(!subPassResult.isNull());
++ QCOMPARE(roleOf(leafPass), QSSGRenderUserPass::Role::SubPass);
++ QVERIFY(!imageContainsDominantColor(subPassResult, Qt::green));
++
++ // Unreferenced: the leaf returns to top-level and renders the green cube
++ // into its own attachment, which the provider now exposes.
++ view->rootObject()->setProperty("useAsSubPass", false);
++ QVERIFY(!grab(view.data()).isNull()); // settle: role flip + first standalone render
++ const QImage topLevelResult = grab(view.data());
++ QVERIFY(!topLevelResult.isNull());
++ QCOMPARE(roleOf(leafPass), QSSGRenderUserPass::Role::TopLevel);
++ QVERIFY(imageContainsDominantColor(topLevelResult, Qt::green));
++ }
++
++ void tst_UserPasses::slotLimitDoesNotCrash()
++ {
++ // 17 SubRenderPasses in a single main pass exceeds the effective per-frame
++ // pass limit. The UserRenderPass implementation tracks visited passes in a
++ // set shared across sibling sub-passes; once that set reaches
++ // MAX_SUBPASS_DEPTH (16) the renderer emits a depth-limit warning and skips
++ // the excess passes gracefully. Verify no crash occurs.
++ QQuick3DTestMessageHandler msgHandler;
++
++ QScopedPointer<QQuickView> view(createView(QLatin1String("slot_limit.qml"), QSize(100, 100)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++ grab(view.data()); // ensure at least one frame is rendered
++
++ // The visited-pass set fills up before the explicit slot-limit counter is
++ // exhausted, so the depth-limit warning is what gets emitted.
++ QVERIFY2(msgHandler.messageString().contains(QLatin1String("Maximum SubRenderPass nesting depth")),
++ qPrintable(msgHandler.messageString()));
++ }
++
++ void tst_UserPasses::depthLimitDoesNotCrash()
++ {
++ // 17 levels of nested SubRenderPasses exceeds MAX_SUBPASS_DEPTH = 16.
++ // The renderer should emit a qWarning for the excess level and skip it
++ // gracefully without crashing.
++ QQuick3DTestMessageHandler msgHandler;
++
++ QScopedPointer<QQuickView> view(createView(QLatin1String("depth_limit.qml"), QSize(100, 100)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++ grab(view.data()); // ensure at least one frame is rendered
++
++ // Verify the expected warning was emitted.
++ QVERIFY2(msgHandler.messageString().contains(QLatin1String("Maximum SubRenderPass nesting depth")),
++ qPrintable(msgHandler.messageString()));
++ }
++
++ void tst_UserPasses::testAddDefine()
++ {
++ // An AugmentMaterial pass injects #define MY_DEFINE 1 via AddDefine.
++ // The augment shader outputs green when MY_DEFINE is defined and red
++ // when it is absent. The test grabs a frame, verifies green pixels on
++ // the sphere, then removes the define by clearing its name and grabs
++ // again, verifying that the output changed to red.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("adddefine.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Static check: MY_DEFINE is active → sphere should be green
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ const bool hasGreen1 = imageContainsDominantColor(result1, Qt::green);
++ QVERIFY2(hasGreen1, "With AddDefine active, sphere should appear green");
++
++ // Dynamic check: clear the define name → shader should see no MY_DEFINE → red
++ QObject *addDefine = view->rootObject()->findChild<QObject *>(QLatin1String("testDefine"));
++ QVERIFY2(addDefine, "testDefine object must be found for dynamic check");
++ addDefine->setProperty("name", QByteArray(""));
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const bool hasRed2 = imageContainsDominantColor(result2, Qt::red);
++ QVERIFY2(hasRed2, "After clearing AddDefine name, sphere should appear red");
++ }
++
++ void tst_UserPasses::testAugmentShaderTextureBinding()
++ {
++ // The pass declares a sampler for every texture property, but only binds
++ // the ones that resolve to a GPU texture; the rest have to be filled with
++ // the engine's dummy texture so the shader resource bindings stay
++ // complete. The augment shader checks that the bound sampler still reads
++ // its own texture and the unbound one reads the dummy, so filling a
++ // sampler that was already bound -- or leaving one unfilled -- shows up as
++ // red rather than as a subtly wrong image.
++ //
++ // The unbound cube map covers the same ground for a samplerCube, and in
++ // particular that the dummy has content on every face, not just on the
++ // first one.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("augment_texture_binding.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // The bound texture is backed by a sourceItem, which needs a frame to be
++ // rendered into before it can be sampled, so check the second frame.
++ QImage warmup = grab(view.data());
++ QVERIFY(!warmup.isNull());
++
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ QVERIFY2(imageContainsDominantColor(result, Qt::green),
++ "The bound texture property should still be sampled from its own texture, "
++ "and the unbound 2D and cube ones from the dummy");
++ }
++
++ void tst_UserPasses::testAugmentShaderArrayTextureBinding()
++ {
++ // Same idea for an array sampler. A sampler2DArray that nothing binds has
++ // to be filled with a dummy that is itself a texture array -- a plain 2D
++ // dummy would be a view type mismatch against what the shader declares,
++ // which is undefined rather than diagnosed on most backends. The material
++ // shader samples two layers of it and expects the dummy's opaque black.
++ //
++ // A sampler hint is only honoured for CustomMaterial properties, hence the
++ // custom material here, and the augment shader only forwards the verdict
++ // the material arrived at.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("augment_array_texture_binding.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage warmup = grab(view.data());
++ QVERIFY(!warmup.isNull());
++
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ QVERIFY2(imageContainsDominantColor(result, Qt::green),
++ "The unbound array sampler should read the dummy texture array");
++ }
++
++ void tst_UserPasses::testSkyboxPass()
++ {
++ // A SubRenderPass with passMode: RenderPass.SkyboxPass renders the
++ // ProceduralSkyTextureData environment into the custom render target.
++ // If SkyboxPass works, the output should contain non-black sky colours.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("skyboxpass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // The sky texture is a gradient with distinct colours; any non-black
++ // pixel proves that the SkyboxPass rendered something.
++ const bool hasSkyColors = imageHasNonBlackPixels(result);
++ QVERIFY2(hasSkyColors, "SkyboxPass should render sky texture: output should not be all-black");
++ }
++
++ void tst_UserPasses::testItem2DPass()
++ {
++ // A Qt Quick 2D Item (red Rectangle) embedded in a 3D Node is rendered
++ // by a SubRenderPass with passMode: RenderPass.Item2DPass.
++ // If Item2DPass works, red pixels should appear in the output.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("item2dpass.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ const bool hasRed1 = imageContainsDominantColor(result1, Qt::red);
++ QVERIFY2(hasRed1, "Item2DPass should render the embedded red Rectangle");
++
++ // Dynamic check: change the Rectangle colour to blue
++ // root.item2DColor is a QML property that drives the Rectangle colour
++ view->rootObject()->setProperty("item2DColor", QColor(Qt::blue));
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const bool hasBlue2 = imageContainsDominantColor(result2, Qt::blue);
++ QVERIFY2(hasBlue2, "After changing item colour to blue, Item2DPass output should be blue");
++ QVERIFY2(!imageContainsDominantColor(result2, Qt::red), "After colour change, red should no longer be dominant");
++ }
++
++ void tst_UserPasses::testDepthTestDisabled()
++ {
++ // Two overlapping spheres: blue (z=100, closer to camera) and red (z=-100, farther).
++ // Opaque objects are sorted front-to-back, so blue draws first, red draws second.
++ // With PipelineStateOverride { depthTestEnabled: false }, the GPU depth test is
++ // disabled. The second-drawn object (red) is not depth-rejected and overwrites blue
++ // at the overlap → center pixel should be red.
++ // Dynamic check: re-enable depth test → closer sphere (blue) wins → center = blue.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("depthtestdisabled.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ // Static check: depth test disabled → red sphere (drawn second) should be visible
++ const bool hasRed1 = imageContainsDominantColor(result1, Qt::red);
++ QVERIFY2(hasRed1, "With depthTestEnabled:false, farther red sphere (drawn second) should be visible");
++
++ // Dynamic check: re-enable depth test → blue (closer) wins
++ QObject *pso = view->rootObject()->findChild<QObject *>(QLatin1String("pso"));
++ if (!pso) {
++ qWarning("testDepthTestDisabled: pso object not found, skipping dynamic check");
++ return;
++ }
++ pso->setProperty("depthTestEnabled", true);
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const bool hasBlue2 = imageContainsDominantColor(result2, Qt::blue);
++ QVERIFY2(hasBlue2, "After re-enabling depthTest, closer blue sphere should be visible");
++ }
++
++ void tst_UserPasses::testBlendEnabled()
++ {
++ // AugmentMaterial pass with clear colour blue. The augment shader outputs
++ // white at 50% alpha (vec4(1,1,1,0.5)). With blendEnabled: true and SrcAlpha
++ // blend mode, the result blends against the blue background producing a mix
++ // (light blue / cyan). With blendEnabled: false, the output is white (no blend).
++ QScopedPointer<QQuickView> view(createView(QLatin1String("blendenabled.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ // Static check: with blend active, center pixel should have a noticeable blue
++ // component (blending of white + blue) and NOT be pure white.
++ const QRgb centerPixel1 = result1.pixel(200, 200);
++ const int r1 = qRed(centerPixel1);
++ const int b1 = qBlue(centerPixel1);
++ // For alpha=0.5 blend: result = 0.5*white + 0.5*blue. The blue channel should
++ // clearly exceed the red channel. A 20-point gap is sufficient to account for
++ // color-space handling in the compositing pipeline.
++ const bool blendActive1 = (b1 > r1 + 20) && (b1 > 100);
++ QVERIFY2(blendActive1, "With blendEnabled:true, sphere should blend white + blue → blue channel dominant");
++
++ // Dynamic check: disable blend → sphere should become white (pure white)
++ QObject *pso = view->rootObject()->findChild<QObject *>(QLatin1String("pso"));
++ if (!pso) {
++ qWarning("testBlendEnabled: pso object not found, skipping dynamic check");
++ return;
++ }
++ pso->setProperty("blendEnabled", false);
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const QRgb centerPixel2 = result2.pixel(200, 200);
++ const int r2 = qRed(centerPixel2);
++ const int g2 = qGreen(centerPixel2);
++ const int b2 = qBlue(centerPixel2);
++ // Without blend: white sphere → all channels near 255
++ const bool isWhite2 = (r2 > 200 && g2 > 200 && b2 > 200);
++ QVERIFY2(isWhite2, "After disabling blend, white sphere should render as opaque white");
++ }
++
++ void tst_UserPasses::testPreserveColorContents()
++ {
++ // Two passes share one colour attachment (sharedTex).
++ // Pass 1 clears sharedTex to red with no geometry.
++ // Pass 2 has renderTargetFlags: PreserveColorContents (no clear) and renders a blue sphere.
++ // Expected: background area = red (pass 1 contents preserved), sphere area = blue.
++ // Dynamic: clear renderTargetFlags → pass 2 clears buffer → background becomes black.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("preservecolor.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ // Static checks:
++ // Corner pixel (background, no sphere) should be red (pass 1 contents preserved).
++ const QRgb cornerPixel1 = result1.pixel(10, 10);
++ const bool cornerIsRed1 = qRed(cornerPixel1) > 200 && qGreen(cornerPixel1) < 50 && qBlue(cornerPixel1) < 50;
++ QVERIFY2(cornerIsRed1, "Background corner should be red (pass 1 clear preserved by PreserveColorContents)");
++
++ // Center pixel (sphere area) should be blue.
++ const bool hasBlue1 = imageContainsDominantColor(result1, Qt::blue);
++ QVERIFY2(hasBlue1, "Sphere area should be blue (pass 2 rendered on top of preserved red)");
++
++ // Dynamic check: clear renderTargetFlags → pass 2 clears to black → background = black
++ QObject *pass2 = view->rootObject()->findChild<QObject *>(QLatin1String("pass2"));
++ if (!pass2) {
++ qWarning("testPreserveColorContents: pass2 object not found, skipping dynamic check");
++ return;
++ }
++ // Reset renderTargetFlags to None (0)
++ pass2->setProperty("renderTargetFlags", 0);
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const QRgb cornerPixel2 = result2.pixel(10, 10);
++ const bool cornerIsBlack2 = qRed(cornerPixel2) < 20 && qGreen(cornerPixel2) < 20 && qBlue(cornerPixel2) < 20;
++ QVERIFY2(cornerIsBlack2, "After removing PreserveColorContents, background should be black (pass 2 clears)");
++ }
++
++ void tst_UserPasses::testViewportOverride()
++ {
++ // A large yellow sphere fills the entire view under normal rendering.
++ // PipelineStateOverride.viewport is set at runtime (from C++ to be DPR-aware)
++ // to the RIGHT half of the device-pixel render target. The viewport uses
++ // device-pixel coordinates with OpenGL convention (y=0 at bottom).
++ // Static check: left half of the grabbed image = black, right half = yellow.
++ // Dynamic check: switch viewport to left half → sides flip.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("viewportoverride.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QObject *pso = view->rootObject()->findChild<QObject *>(QLatin1String("pso"));
++ QVERIFY2(pso, "pso PipelineStateOverride object must be found");
++
++ // Compute the device-pixel render-target dimensions (viewport uses device pixels,
++ // OpenGL y convention: y=0 at bottom).
++ const qreal dpr = view->devicePixelRatio();
++ const int dw = qRound(view->width() * dpr);
++ const int dh = qRound(view->height() * dpr);
++
++ // Set viewport to the RIGHT half: x = [dw/2, dw), full height in OpenGL y
++ pso->setProperty("viewport", QRectF(dw / 2.0, 0, dw / 2.0, dh));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ // Count yellow and black pixels in each horizontal half of the grabbed image.
++ // The grabbed image is at device-pixel resolution.
++ int yellowLeft1 = 0, yellowRight1 = 0;
++ const int imgMidX = result1.width() / 2;
++ for (int y = 0; y < result1.height(); ++y) {
++ for (int x = 0; x < result1.width(); ++x) {
++ const QRgb px = result1.pixel(x, y);
++ const bool isYellow = qRed(px) > 150 && qGreen(px) > 150 && qBlue(px) < 50;
++ if (x < imgMidX) {
++ if (isYellow)
++ ++yellowLeft1;
++ } else {
++ if (isYellow)
++ ++yellowRight1;
++ }
++ }
++ }
++
++ // Left half should be entirely black (outside the right-half viewport) - this is the key restriction check
++ QVERIFY2(yellowLeft1 == 0, "Left half should contain no yellow pixels (outside viewport)");
++
++ // Right half should contain yellow (sphere rendered in the right half viewport)
++ QVERIFY2(yellowRight1 > 1000, "Right half should contain yellow pixels (sphere in viewport)");
++
++ // Dynamic check: switch viewport to left half
++ pso->setProperty("viewport", QRectF(0, 0, dw / 2.0, dh));
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ int yellowLeft2 = 0, yellowRight2 = 0;
++ for (int y = 0; y < result2.height(); ++y) {
++ for (int x = 0; x < result2.width(); ++x) {
++ const QRgb px = result2.pixel(x, y);
++ const bool isYellow = qRed(px) > 150 && qGreen(px) > 150 && qBlue(px) < 50;
++ if (x < imgMidX) {
++ if (isYellow)
++ ++yellowLeft2;
++ } else {
++ if (isYellow)
++ ++yellowRight2;
++ }
++ }
++ }
++
++ // Left half should have yellow after switching viewport to left
++ // Note: sphere fills entire view because viewport restriction is not working, so this passes trivially
++ QVERIFY2(yellowLeft2 > 1000, "After switching to left-half viewport, left half should have yellow");
++
++ // Right half should have no yellow after switching viewport to left - this is the key restriction check
++ QVERIFY2(yellowRight2 == 0, "After switching to left-half viewport, right half should have no yellow");
++ }
++
++ void tst_UserPasses::testScreenTexture()
++ {
++ // A red sphere is rendered by the standard internal pipeline.
++ // A SimpleQuadRenderer reads RenderOutputProvider.ScreenTexture and displays
++ // the rendered scene texture covering the full view.
++ // Static check: output has red pixels (ScreenTexture captured the rendered scene).
++ // Dynamic check: change sphere colour to blue → ScreenTexture updates.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("screentexture.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QImage result1 = grab(view.data());
++ QVERIFY(!result1.isNull());
++
++ // Static check: red sphere should be visible via ScreenTexture
++ const bool hasRed1 = imageContainsDominantColor(result1, Qt::red);
++ QVERIFY2(hasRed1, "ScreenTexture should show the rendered scene (red sphere)");
++
++ // Dynamic check: change sphere colour to blue → ScreenTexture should update
++ view->rootObject()->setProperty("sphereColor", QColor(Qt::blue));
++
++ QImage result2 = grab(view.data());
++ QVERIFY(!result2.isNull());
++
++ const bool hasBlue2 = imageContainsDominantColor(result2, Qt::blue);
++ QVERIFY2(hasBlue2, "After changing sphere to blue, ScreenTexture should show blue");
++ }
++
++ void tst_UserPasses::testCullModeOverrideSubpass_data()
++ {
++ QTest::addColumn<QString>("qmlFile");
++ QTest::addColumn<QColor>("visibleColor");
++
++ QTest::newRow("OriginalMaterial") << "cull_override_subpass_original.qml" << QColor("white");
++ QTest::newRow("OverrideMaterial") << "cull_override_subpass_override.qml" << QColor("red");
++ QTest::newRow("AugmentMaterial") << "cull_override_subpass_augment.qml" << QColor("white");
++ }
++
++ void tst_UserPasses::testCullModeOverrideSubpass()
++ {
++ // Verify that PipelineStateOverride { cullMode } in a SubRenderPass is respected and
++ // not overwritten by the material's cull mode setting.
++ // Phase 1 (useFrontCulling=false): Back culling -> rectangle visible -> center matches visibleColor.
++ // Phase 2 (useFrontCulling=true): Front culling override -> rectangle culled -> center = black.
++ QFETCH(QString, qmlFile);
++ QFETCH(QColor, visibleColor);
++
++ QScopedPointer<QQuickView> view(createView(qmlFile, QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage img1 = grab(view.data());
++ QVERIFY(!img1.isNull());
++ const QRgb p1 = img1.pixel(img1.width() / 2, img1.height() / 2);
++ QVERIFY2(qAbs(qRed(p1) - visibleColor.red()) < FUZZ && qAbs(qGreen(p1) - visibleColor.green()) < FUZZ
++ && qAbs(qBlue(p1) - visibleColor.blue()) < FUZZ,
++ "Phase 1: rectangle should be visible with Back culling");
++
++ view->rootObject()->setProperty("useFrontCulling", true);
++
++ const QImage img2 = grab(view.data());
++ QVERIFY(!img2.isNull());
++ const QRgb p2 = img2.pixel(img2.width() / 2, img2.height() / 2);
++ QVERIFY2(qRed(p2) < 30 && qGreen(p2) < 30 && qBlue(p2) < 30,
++ "Phase 2: rectangle should be culled with Front culling override (center must be black)");
++ }
++
++ void tst_UserPasses::testBlendOverrideOriginalMaterial()
++ {
++ // Verify that PipelineStateOverride blend settings in a SubRenderPass with
++ // OriginalMaterial are preserved and not overwritten by the material's blend state.
++ // Phase 1 (useStandardBlend=true): SrcAlpha/OneMinusSrcAlpha -> purplish center (R and B both significant).
++ // Phase 2 (useStandardBlend=false): One/Zero -> pure red center (R high, B near zero).
++ QScopedPointer<QQuickView> view(createView(QLatin1String("blend_override.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ const QImage img1 = grab(view.data());
++ QVERIFY(!img1.isNull());
++ const QRgb p1 = img1.pixel(img1.width() / 2, img1.height() / 2);
++ QVERIFY2(qRed(p1) > 80, "Phase 1: red sphere should contribute");
++ QVERIFY2(qBlue(p1) > 80, "Phase 1: blue background should bleed through (blend is working)");
++ QVERIFY2(qBlue(p1) < 230, "Phase 1: not pure blue — sphere must be present");
++
++ view->rootObject()->setProperty("useStandardBlend", false);
++
++ const QImage img2 = grab(view.data());
++ QVERIFY(!img2.isNull());
++ const QRgb p2 = img2.pixel(img2.width() / 2, img2.height() / 2);
++ QVERIFY2(qRed(p2) > 200, "Phase 2: strong red from sphere with One/Zero blend");
++ QVERIFY2(qBlue(p2) < 30, "Phase 2: no blue bleed — One/Zero override must have worked");
++
++ QVERIFY2(qBlue(p1) - qBlue(p2) > 60, "Phases must produce measurably different blue channel values");
++ }
++
++ void tst_UserPasses::noColorAttachmentDoesNotCrash()
++ {
++ // A pass without ColorAttachment commands gets one implicit default color
++ // attachment. Before the fix, building the pass's render target indexed
++ // the empty command list (assert in debug, out-of-bounds read in release),
++ // and the compatibility check on the next frame both forced a rebuild and
++ // did the same.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("no_color_attachment.qml"), QSize(200, 200)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ // Two grabs: the first exercises the render target build, the second the
++ // compatibility check against the implicitly created attachment.
++ QVERIFY(!grab(view.data()).isNull());
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ // The pass renders the red cube into the implicit default attachment,
++ // which the provider exposes for display.
++ QVERIFY(imageContainsDominantColor(result, Qt::red));
++ }
++
++ void tst_UserPasses::testAugmentShaderWithCustomMaterial()
++ {
++ // A custom material folds the augmentation into its shader path key, and
++ // that key is emitted as the "//Shader name -" comment of the generated
++ // shader. Appending the augmentation verbatim spilled everything after its
++ // first line out of the comment, so the shader did not compile at all and
++ // nothing was drawn. The augment shader here paints green over the
++ // material's red.
++ QScopedPointer<QQuickView> view(createView(QLatin1String("augment_custom_material.qml"), QSize(400, 400)));
++ QVERIFY(view);
++ QVERIFY(QTest::qWaitForWindowExposed(view.data()));
++
++ QVERIFY(!grab(view.data()).isNull());
++ const QImage result = grab(view.data());
++ QVERIFY(!result.isNull());
++
++ QVERIFY2(imageContainsDominantColor(result, Qt::green),
++ "The augment shader should have overridden the custom material's own output");
++ }
++
++ QTEST_MAIN(tst_UserPasses)
++ #include "tst_userpasses.moc"