tst_qquick3dmaterials.cpp

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

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

#include <QTest>

#include <QSignalSpy>

#include <QtCore/qmath.h>

#include <QtQuick3D/private/qquick3dscenemanager_p.h>

#include <QtQuick3D/private/qquick3ddefaultmaterial_p.h>

#include <QtQuick3D/private/qquick3dcustommaterial_p.h>

#include <QtQuick3D/private/qquick3dprincipledmaterial_p.h>

#include <QtQuick3D/private/qquick3dspecularglossymaterial_p.h>

#include <QtQuick3D/private/qquick3dviewport_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrendercustommaterial_p.h>

#include <QtQuick3DRuntimeRender/private/qssgrenderimage_p.h>

#include <QtQuick3DUtils/private/qssgutils_p.h>

class tst_QQuick3DMaterials : public QObject

    Q_OBJECT

    // Work-around to get access to updateSpatialNode

    class Material : public QQuick3DDefaultMaterial

    public:

        using QQuick3DMaterial::updateSpatialNode;

};

    class CustomMaterial : public QQuick3DCustomMaterial

    public:

        using QQuick3DCustomMaterial::updateSpatialNode;

};

    class PrincipledMaterial : public QQuick3DPrincipledMaterial

    public:

        using QQuick3DPrincipledMaterial::updateSpatialNode;

};

    class SpecularGlossyMaterial : public QQuick3DSpecularGlossyMaterial

    public:

        using QQuick3DSpecularGlossyMaterial::updateSpatialNode;

};

    class Texture : public QQuick3DTexture

    public:

        using QQuick3DTexture::updateSpatialNode;

};

private slots:

    void testDefaultProperties();

    void testDefaultTextures();

    void testDefaultEnums();

    void testPrincipledProperties();

    void testPrincipledTextures();

    void testPrincipledEnums();

    void testSpecularGlossyProperties();

    void testSpecularGlossyTextures();

    void testSpecularGlossyEnums();

    void testCustomMaterials();

};

void tst_QQuick3DMaterials::testDefaultProperties()

    Material material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    const float opacity = 0.4f;

    material.setOpacity(opacity);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(material.opacity(), node->opacity);

    const float specularAmount = 10.0f;

    material.setSpecularAmount(specularAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(material.specularAmount(), node->specularAmount);

    const float emissiveFactor = 0.5f;

    material.setEmissiveFactor(QVector3D(emissiveFactor, emissiveFactor, emissiveFactor));

    material.setLighting(QQuick3DDefaultMaterial::FragmentLighting);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    auto expectedEmissiceColor = material.emissiveFactor();

    QCOMPARE(expectedEmissiceColor, node->emissiveColor);

    const float bumpAmount = 0.3f;

    material.setBumpAmount(bumpAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(material.bumpAmount(), node->bumpAmount);

    material.setVertexColorsEnabled(true);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(material.vertexColorsEnabled(), node->vertexColorsEnabled);

    material.setVertexColorsEnabled(false);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(material.vertexColorsEnabled(), node->vertexColorsEnabled);

    QColor color1("#12345678");

    QVector4D color1Vec4 = QSSGUtils::color::sRGBToLinear(color1);

    material.setDiffuseColor(color1);

    material.setEmissiveFactor(color1Vec4.toVector3D());

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(color1Vec4, node->color);

    // Note: emissiveColor doesn't contain alpha

    QCOMPARE(QVector3D(color1Vec4), node->emissiveColor);

void tst_QQuick3DMaterials::testDefaultTextures()

    Material material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    Texture texture1;

    texture1.setSource(QUrl(":/Built_with_Qt.png"));

    Texture texture2;

    texture2.setSource(QUrl(":/Built_with_Qt_2.png"));

    QQuick3DSceneManager sceneManager;

    sceneManager.updateDirtyResource(&texture1);

    sceneManager.updateDirtyResource(&texture2);

    // Diffusemaps

    material.setDiffuseMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QVERIFY(texture1.getRenderImage());

    QCOMPARE(texture1.getRenderImage(), node->colorMap);

    // Specularmaps

    QVERIFY(!node->specularMap);

    QVERIFY(!node->specularReflection);

    QVERIFY(!material.specularMap());

    QVERIFY(!material.specularReflectionMap());

    material.setSpecularMap(&texture2);

    material.setSpecularReflectionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.specularMap());

    QCOMPARE(material.specularMap()->getRenderImage(), node->specularMap);

    QVERIFY(material.specularReflectionMap());

    QCOMPARE(material.specularReflectionMap()->getRenderImage(), node->specularReflection);

    // Bumpmap

    QVERIFY(!node->bumpMap);

    QVERIFY(!material.bumpMap());

    material.setBumpMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.bumpMap());

    QCOMPARE(material.bumpMap()->getRenderImage(), node->bumpMap);

    // Opacitymap

    QVERIFY(!node->opacityMap);

    QVERIFY(!material.opacityMap());

    material.setOpacityMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.opacityMap());

    QCOMPARE(material.opacityMap()->getRenderImage(), node->opacityMap);

    QCOMPARE(material.opacityMap()->getRenderImage(), material.bumpMap()->getRenderImage());

void tst_QQuick3DMaterials::testDefaultEnums()

    Material material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    QVERIFY(node);

    // These test rely on the different enums having the same values

    auto lightModes = { QQuick3DDefaultMaterial::Lighting::NoLighting,

                        QQuick3DDefaultMaterial::Lighting::FragmentLighting };

    for (const auto lightMode : lightModes)

        material.setLighting(lightMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.lighting()), int(node->lighting));

    auto blendModes = { QQuick3DDefaultMaterial::BlendMode::SourceOver,

                        QQuick3DDefaultMaterial::BlendMode::Screen,

                        QQuick3DDefaultMaterial::BlendMode::Multiply };

    for (const auto blendMode : blendModes)

        material.setBlendMode(blendMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.blendMode()), int(node->blendMode));

    auto specularModes = { QQuick3DDefaultMaterial::SpecularModel::Default,

                           QQuick3DDefaultMaterial::SpecularModel::KGGX};

    for (const auto specularMode : specularModes)

        material.setSpecularModel(specularMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.specularModel()), int(node->specularModel));

    auto depthDrawModes = {

        QQuick3DMaterial::DepthDrawMode::OpaqueOnlyDepthDraw,

        QQuick3DMaterial::DepthDrawMode::AlwaysDepthDraw,

        QQuick3DMaterial::DepthDrawMode::NeverDepthDraw,

        QQuick3DMaterial::DepthDrawMode::OpaquePrePassDepthDraw

};

    for (const auto depthDrawMode : depthDrawModes) {

        material.setDepthDrawMode(depthDrawMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.depthDrawMode()), int(node->depthDrawMode));

void tst_QQuick3DMaterials::testPrincipledProperties()

    PrincipledMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    const float metalness = 0.1f;

    material.setMetalness(metalness);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(metalness, material.metalness());

    QCOMPARE(metalness, node->metalnessAmount);

    // Note: metalness needs to be disabled for specularAmount and specularTint

    // to affect backend.

    material.setMetalness(0.0f);

    const float specularAmount = 0.2f;

    material.setSpecularAmount(specularAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(specularAmount, material.specularAmount());

    QCOMPARE(specularAmount, node->specularAmount);

    const float specularTint = 0.3f;

    material.setSpecularTint(specularTint);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(specularTint, material.specularTint());

    // Note: Backend uses vector3D for specularTint

    QCOMPARE(specularTint, node->specularTint.y());

    const float roughness = 0.4f;

    material.setRoughness(roughness);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(roughness, material.roughness());

    QCOMPARE(roughness, node->specularRoughness);

    const float opacity = 0.7f;

    material.setOpacity(opacity);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(opacity, material.opacity());

    QCOMPARE(opacity, node->opacity);

    const float normalStrength = 0.8f;

    material.setNormalStrength(normalStrength);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(normalStrength, material.normalStrength());

    QCOMPARE(normalStrength, node->bumpAmount);

    const float occlusionAmount = 0.9f;

    material.setOcclusionAmount(occlusionAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(occlusionAmount, material.occlusionAmount());

    QCOMPARE(occlusionAmount, node->occlusionAmount);

    const float alphaCutoff = 0.1f;

    material.setAlphaCutoff(alphaCutoff);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(alphaCutoff, material.alphaCutoff());

    QCOMPARE(alphaCutoff, node->alphaCutoff);

    QColor color1("#12345678");

    QVector4D color1Vec4 = QSSGUtils::color::sRGBToLinear(color1);

    QColor color2("#cccccccc");

    QVector3D color2Vec3 = QSSGUtils::color::sRGBToLinear(color2).toVector3D();

    material.setBaseColor(color1);

    material.setEmissiveFactor(color2Vec3);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(color1Vec4, node->color);

    // Note: emissiveColor doesn't contain alpha

    QCOMPARE(color2Vec3, node->emissiveColor);

    const float heightAmount = 0.2f;

    material.setHeightAmount(heightAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(heightAmount, material.heightAmount());

    QCOMPARE(heightAmount, node->heightAmount);

    const int minHeightMapSamples = 11;

    material.setMinHeightMapSamples(minHeightMapSamples);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(minHeightMapSamples, material.minHeightMapSamples());

    QCOMPARE(minHeightMapSamples, node->minHeightSamples);

    const int maxHeightMapSamples = 33;

    material.setMaxHeightMapSamples(maxHeightMapSamples);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(maxHeightMapSamples, material.maxHeightMapSamples());

    QCOMPARE(maxHeightMapSamples, node->maxHeightSamples);

    QVERIFY(!node->isClearcoatEnabled());

    float clearcoatAmount = 0.3f;

    material.setClearcoatAmount(clearcoatAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(clearcoatAmount, material.clearcoatAmount());

    QCOMPARE(clearcoatAmount, node->clearcoatAmount);

    QVERIFY(node->isClearcoatEnabled());

    clearcoatAmount = 0.0f;

    material.setClearcoatAmount(clearcoatAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isClearcoatEnabled());

    const float clearcoatRoughnessAmount = 0.4f;

    material.setClearcoatRoughnessAmount(clearcoatRoughnessAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(clearcoatRoughnessAmount, material.clearcoatRoughnessAmount());

    QCOMPARE(clearcoatRoughnessAmount, node->clearcoatRoughnessAmount);

    // Sheen is disabled while the color is black, since the color acts as

    // a multiplier for the sheen color map

    QVERIFY(!node->isSheenEnabled());

    material.setSheenColor(QColor(Qt::white));

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(QColor(Qt::white), material.sheenColor());

    QVERIFY(node->isSheenEnabled());

    material.setSheenColor(QColor(Qt::black));

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isSheenEnabled());

    const float sheenRoughness = 0.6f;

    material.setSheenRoughness(sheenRoughness);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(sheenRoughness, material.sheenRoughness());

    QCOMPARE(sheenRoughness, node->sheenRoughness);

    // Out of range values clamp, and a value that clamps to what the property

    // already holds is not a change, so it must not emit

    material.setSheenRoughness(2.0f);

    QCOMPARE(material.sheenRoughness(), 1.0f);

    QSignalSpy sheenRoughnessSpy(&material, &QQuick3DPrincipledMaterial::sheenRoughnessChanged);

    material.setSheenRoughness(3.0f);

    QCOMPARE(material.sheenRoughness(), 1.0f);

    QCOMPARE(sheenRoughnessSpy.size(), 0);

    material.setSheenRoughness(sheenRoughness);

    QVERIFY(!node->isAnisotropyEnabled());

    float anisotropyStrength = 0.7f;

    material.setAnisotropyStrength(anisotropyStrength);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(anisotropyStrength, material.anisotropyStrength());

    QCOMPARE(anisotropyStrength, node->anisotropyStrength);

    QVERIFY(node->isAnisotropyEnabled());

    anisotropyStrength = 0.0f;

    material.setAnisotropyStrength(anisotropyStrength);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isAnisotropyEnabled());

    // The property is in degrees to match the rest of the Qt Quick 3D API,

    // while the render graph works in radians

    const float anisotropyRotation = 90.0f;

    material.setAnisotropyRotation(anisotropyRotation);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(anisotropyRotation, material.anisotropyRotation());

    QCOMPARE(qDegreesToRadians(anisotropyRotation), node->anisotropyRotation);

    QVERIFY(!node->isIridescenceEnabled());

    float iridescenceFactor = 0.8f;

    material.setIridescenceFactor(iridescenceFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(iridescenceFactor, material.iridescenceFactor());

    QCOMPARE(iridescenceFactor, node->iridescenceFactor);

    QVERIFY(node->isIridescenceEnabled());

    iridescenceFactor = 0.0f;

    material.setIridescenceFactor(iridescenceFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isIridescenceEnabled());

    // The film has its own index of refraction, separate from the material's

    QCOMPARE(1.3f, material.iridescenceIndexOfRefraction());

    const float iridescenceIor = 1.8f;

    material.setIridescenceIndexOfRefraction(iridescenceIor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(iridescenceIor, material.iridescenceIndexOfRefraction());

    QCOMPARE(iridescenceIor, node->iridescenceIndexOfRefraction);

    // Thickness is in nanometers, and defaults to the range the extension uses

    QCOMPARE(100.0f, material.iridescenceThicknessMinimum());

    QCOMPARE(400.0f, material.iridescenceThicknessMaximum());

    const float thicknessMinimum = 250.0f;

    const float thicknessMaximum = 900.0f;

    material.setIridescenceThicknessMinimum(thicknessMinimum);

    material.setIridescenceThicknessMaximum(thicknessMaximum);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(thicknessMinimum, node->iridescenceThicknessMinimum);

    QCOMPARE(thicknessMaximum, node->iridescenceThicknessMaximum);

    QVERIFY(material.metalness() == 0.0f);

    QVERIFY(node->metalnessAmount == 0.0f);

    // Dispersion only means something when there is transmission to refract,

    // so the predicate has to account for both

    QVERIFY(!node->isDispersionEnabled());

    const float dispersion = 0.4f;

    material.setDispersion(dispersion);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(dispersion, material.dispersion());

    QCOMPARE(dispersion, node->dispersion);

    QVERIFY(!node->isDispersionEnabled()); // no transmission yet

    QVERIFY(!node->isTransmissionEnabled());

    const float transmissionFactor = 0.5f;

    material.setTransmissionFactor(transmissionFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(transmissionFactor, material.transmissionFactor());

    QCOMPARE(transmissionFactor, node->transmissionFactor);

    QVERIFY(node->isTransmissionEnabled());

    QVERIFY(node->isDispersionEnabled()); // now both are set

    material.setTransmissionFactor(0.0f);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isTransmissionEnabled());

    const float thicknessFactor = 0.6f;

    material.setThicknessFactor(thicknessFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(thicknessFactor, material.thicknessFactor());

    QCOMPARE(thicknessFactor, node->thicknessFactor);

    const float attenuationDistance = 0.7f;

    material.setAttenuationDistance(attenuationDistance);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(attenuationDistance, material.attenuationDistance());

    QCOMPARE(attenuationDistance, node->attenuationDistance);

    const QColor attenuationColor = QColor(Qt::green);

    const QVector3D attenuationColorVector = QSSGUtils::color::sRGBToLinear(attenuationColor).toVector3D();

    material.setAttenuationColor(attenuationColor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(attenuationColor, material.attenuationColor());

    QCOMPARE(attenuationColorVector, node->attenuationColor);

    const float ior = 1.45f;

    material.setIndexOfRefraction(ior);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(ior, material.indexOfRefraction());

    QCOMPARE(ior, node->ior);

void tst_QQuick3DMaterials::testPrincipledTextures()

    PrincipledMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    Texture texture1;

    texture1.setSource(QUrl(":/Built_with_Qt.png"));

    Texture texture2;

    texture2.setSource(QUrl(":/Built_with_Qt_2.png"));

    QQuick3DSceneManager sceneManager;

    sceneManager.updateDirtyResource(&texture1);

    sceneManager.updateDirtyResource(&texture2);

    // BasecolorMap

    QVERIFY(!material.baseColorMap());

    material.setBaseColorMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QVERIFY(material.baseColorMap());

    QVERIFY(texture1.getRenderImage());

    QCOMPARE(texture1.getRenderImage(), node->colorMap);

    // MetalnessMap

    material.setMetalnessMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QVERIFY(texture2.getRenderImage());

    QCOMPARE(texture2.getRenderImage(), node->metalnessMap);

    // SpecularMap

    // Note: metalness needs to be disabled for setSpecularMap to affect backend.

    material.setMetalness(0.0f);

    QVERIFY(!material.specularMap());

    material.setSpecularMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.specularMap());

    QCOMPARE(texture1.getRenderImage(), node->specularMap);

    // RoughnessMap

    QVERIFY(!material.roughnessMap());

    material.setRoughnessMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.roughnessMap());

    QCOMPARE(texture2.getRenderImage(), node->roughnessMap);

    // EmissiveMap

    QVERIFY(!material.emissiveMap());

    material.setEmissiveMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.emissiveMap());

    QCOMPARE(texture2.getRenderImage(), node->emissiveMap);

    // OpacityMap

    QVERIFY(!material.opacityMap());

    material.setOpacityMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.opacityMap());

    QCOMPARE(texture2.getRenderImage(), node->opacityMap);

    // NormalMap

    QVERIFY(!material.normalMap());

    material.setNormalMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.normalMap());

    QCOMPARE(texture2.getRenderImage(), node->normalMap);

    // SpecularReflectionMap

    QVERIFY(!material.specularReflectionMap());

    material.setSpecularReflectionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.specularReflectionMap());

    QCOMPARE(texture1.getRenderImage(), node->specularReflection);

    // OcclusionMap

    QVERIFY(!material.occlusionMap());

    material.setOcclusionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.occlusionMap());

    QCOMPARE(texture1.getRenderImage(), node->occlusionMap);

    // HeightMap

    QVERIFY(!material.heightMap());

    material.setHeightMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.heightMap());

    QCOMPARE(texture1.getRenderImage(), node->heightMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping1 = QQuick3DMaterial::A;

    material.setHeightChannel(channelMapping1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping1, material.heightChannel());

    QCOMPARE(qToUnderlying(channelMapping1),      // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->heightChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatMap

    QVERIFY(!material.clearcoatMap());

    material.setClearcoatMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatMap());

    QCOMPARE(texture1.getRenderImage(), node->clearcoatMap);

    QVERIFY(material.clearcoatChannel() == QQuick3DMaterial::R);

    const QQuick3DMaterial::TextureChannelMapping channelMapping = QQuick3DMaterial::B;

    material.setClearcoatChannel(channelMapping);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping, material.clearcoatChannel());

    QCOMPARE(qToUnderlying(channelMapping),          // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->clearcoatChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatRoughnessMap

    QVERIFY(!material.clearcoatRoughnessMap());

    material.setClearcoatRoughnessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatRoughnessMap());

    QCOMPARE(texture1.getRenderImage(), node->clearcoatRoughnessMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping2 = QQuick3DMaterial::A;

    material.setClearcoatRoughnessChannel(channelMapping2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping2, material.clearcoatRoughnessChannel());

    QCOMPARE(qToUnderlying(channelMapping2),                  // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->clearcoatRoughnessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // SheenColorMap (RGB, so no channel selection)

    QVERIFY(!material.sheenColorMap());

    material.setSheenColorMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.sheenColorMap());

    QCOMPARE(texture1.getRenderImage(), node->sheenColorMap);

    // SheenRoughnessMap; the glTF extension packs sheen roughness into the

    // alpha channel, so that is our default too

    QVERIFY(!material.sheenRoughnessMap());

    QVERIFY(material.sheenRoughnessChannel() == QQuick3DMaterial::A);

    material.setSheenRoughnessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.sheenRoughnessMap());

    QCOMPARE(texture1.getRenderImage(), node->sheenRoughnessMap);

    const QQuick3DMaterial::TextureChannelMapping sheenChannel = QQuick3DMaterial::G;

    material.setSheenRoughnessChannel(sheenChannel);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(sheenChannel, material.sheenRoughnessChannel());

    QCOMPARE(qToUnderlying(sheenChannel), // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->sheenRoughnessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // AnisotropyMap has a fixed RG=direction, B=strength layout, so unlike the

    // other maps it has no channel property

    QVERIFY(!material.anisotropyMap());

    material.setAnisotropyMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.anisotropyMap());

    QCOMPARE(texture1.getRenderImage(), node->anisotropyMap);

    // IridescenceMap

    QVERIFY(!material.iridescenceMap());

    QVERIFY(material.iridescenceChannel() == QQuick3DMaterial::R);

    material.setIridescenceMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.iridescenceMap());

    QCOMPARE(texture1.getRenderImage(), node->iridescenceMap);

    const QQuick3DMaterial::TextureChannelMapping iridescenceChannel = QQuick3DMaterial::B;

    material.setIridescenceChannel(iridescenceChannel);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(iridescenceChannel, material.iridescenceChannel());

    QCOMPARE(qToUnderlying(iridescenceChannel), // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->iridescenceChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // IridescenceThicknessMap; the glTF extension packs thickness into green

    QVERIFY(!material.iridescenceThicknessMap());

    QVERIFY(material.iridescenceThicknessChannel() == QQuick3DMaterial::G);

    material.setIridescenceThicknessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.iridescenceThicknessMap());

    QCOMPARE(texture1.getRenderImage(), node->iridescenceThicknessMap);

    const QQuick3DMaterial::TextureChannelMapping thicknessChannel = QQuick3DMaterial::A;

    material.setIridescenceThicknessChannel(thicknessChannel);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(thicknessChannel, material.iridescenceThicknessChannel());

    QCOMPARE(qToUnderlying(thicknessChannel), // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->iridescenceThicknessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatNormalMap

    QVERIFY(!material.clearcoatNormalMap());

    material.setClearcoatNormalMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatNormalMap());

    QCOMPARE(texture2.getRenderImage(), node->clearcoatNormalMap);

    // TransmissionMap

    QVERIFY(!material.transmissionMap());

    material.setTransmissionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.transmissionMap());

    QCOMPARE(texture1.getRenderImage(), node->transmissionMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping3 = QQuick3DMaterial::B;

    material.setTransmissionChannel(channelMapping3);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping3, material.transmissionChannel());

    QCOMPARE(qToUnderlying(channelMapping3),            // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->transmissionChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // Thickness Map

    QVERIFY(!material.thicknessMap());

    material.setThicknessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.thicknessMap());

    QCOMPARE(texture1.getRenderImage(), node->thicknessMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping4 = QQuick3DMaterial::A;

    material.setThicknessChannel(channelMapping4);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping4, material.thicknessChannel());

    QCOMPARE(qToUnderlying(channelMapping4),         // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->thicknessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

void tst_QQuick3DMaterials::testPrincipledEnums()

    PrincipledMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    QVERIFY(node);

    // These test rely on the different enums having the same values

    auto lightModes = { QQuick3DPrincipledMaterial::Lighting::NoLighting,

                        QQuick3DPrincipledMaterial::Lighting::FragmentLighting };

    for (const auto lightMode : lightModes) {

        material.setLighting(lightMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.lighting()), int(node->lighting));

    auto blendModes = { QQuick3DPrincipledMaterial::BlendMode::SourceOver,

                        QQuick3DPrincipledMaterial::BlendMode::Screen,

                        QQuick3DPrincipledMaterial::BlendMode::Multiply };

    for (const auto blendMode : blendModes) {

        material.setBlendMode(blendMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.blendMode()), int(node->blendMode));

    auto alphaModes = { QQuick3DPrincipledMaterial::AlphaMode::Default,

                        QQuick3DPrincipledMaterial::AlphaMode::Mask,

                        QQuick3DPrincipledMaterial::AlphaMode::Blend };

    for (const auto alphaMode : alphaModes) {

        material.setAlphaMode(alphaMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.alphaMode()), int(node->alphaMode));

    auto depthDrawModes = {

        QQuick3DMaterial::DepthDrawMode::OpaqueOnlyDepthDraw,

        QQuick3DMaterial::DepthDrawMode::AlwaysDepthDraw,

        QQuick3DMaterial::DepthDrawMode::NeverDepthDraw,

        QQuick3DMaterial::DepthDrawMode::OpaquePrePassDepthDraw

};

    for (const auto depthDrawMode : depthDrawModes) {

        material.setDepthDrawMode(depthDrawMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.depthDrawMode()), int(node->depthDrawMode));

void tst_QQuick3DMaterials::testSpecularGlossyProperties()

    SpecularGlossyMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    const QColor specularColor = QColor::fromRgbF(0.3f, 0.3f, 0.3f, 1.0f);

    const QVector3D specular = QSSGUtils::color::sRGBToLinear(specularColor).toVector3D();

    material.setSpecularColor(specularColor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(specularColor, material.specularColor());

    QCOMPARE(specular.y(), node->specularTint.y()); // yes, stored in specularTint

    const float glossiness = 0.4f;

    material.setGlossiness(glossiness);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(glossiness, material.glossiness());

    QCOMPARE(glossiness, node->specularRoughness); // yes that is correct

    const float opacity = 0.7f;

    material.setOpacity(opacity);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(opacity, material.opacity());

    QCOMPARE(opacity, node->opacity);

    const float normalStrength = 0.8f;

    material.setNormalStrength(normalStrength);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(normalStrength, material.normalStrength());

    QCOMPARE(normalStrength, node->bumpAmount);

    const float occlusionAmount = 0.9f;

    material.setOcclusionAmount(occlusionAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(occlusionAmount, material.occlusionAmount());

    QCOMPARE(occlusionAmount, node->occlusionAmount);

    const float alphaCutoff = 0.1f;

    material.setAlphaCutoff(alphaCutoff);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(alphaCutoff, material.alphaCutoff());

    QCOMPARE(alphaCutoff, node->alphaCutoff);

    QColor color1("#12345678");

    QVector4D color1Vec4 = QSSGUtils::color::sRGBToLinear(color1);

    QColor color2("#cccccccc");

    QVector3D color2Vec3 = QSSGUtils::color::sRGBToLinear(color2).toVector3D();

    material.setAlbedoColor(color1);

    material.setEmissiveFactor(color2Vec3);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QCOMPARE(color1Vec4, node->color);

    // Note: emissiveColor doesn't contain alpha

    QCOMPARE(color2Vec3, node->emissiveColor);

    const float heightAmount = 0.2f;

    material.setHeightAmount(heightAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(heightAmount, material.heightAmount());

    QCOMPARE(heightAmount, node->heightAmount);

    const int minHeightMapSamples = 11;

    material.setMinHeightMapSamples(minHeightMapSamples);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(minHeightMapSamples, material.minHeightMapSamples());

    QCOMPARE(minHeightMapSamples, node->minHeightSamples);

    const int maxHeightMapSamples = 33;

    material.setMaxHeightMapSamples(maxHeightMapSamples);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(maxHeightMapSamples, material.maxHeightMapSamples());

    QCOMPARE(maxHeightMapSamples, node->maxHeightSamples);

    QVERIFY(!node->isClearcoatEnabled());

    float clearcoatAmount = 0.3f;

    material.setClearcoatAmount(clearcoatAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(clearcoatAmount, material.clearcoatAmount());

    QCOMPARE(clearcoatAmount, node->clearcoatAmount);

    QVERIFY(node->isClearcoatEnabled());

    clearcoatAmount = 0.0f;

    material.setClearcoatAmount(clearcoatAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isClearcoatEnabled());

    const float clearcoatRoughnessAmount = 0.4f;

    material.setClearcoatRoughnessAmount(clearcoatRoughnessAmount);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(clearcoatRoughnessAmount, material.clearcoatRoughnessAmount());

    QCOMPARE(clearcoatRoughnessAmount, node->clearcoatRoughnessAmount);

    QVERIFY(!node->isTransmissionEnabled());

    const float transmissionFactor = 0.5f;

    material.setTransmissionFactor(transmissionFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(transmissionFactor, material.transmissionFactor());

    QCOMPARE(transmissionFactor, node->transmissionFactor);

    QVERIFY(node->isTransmissionEnabled());

    material.setTransmissionFactor(0.0f);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(!node->isTransmissionEnabled());

    const float thicknessFactor = 0.6f;

    material.setThicknessFactor(thicknessFactor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(thicknessFactor, material.thicknessFactor());

    QCOMPARE(thicknessFactor, node->thicknessFactor);

    const float attenuationDistance = 0.7f;

    material.setAttenuationDistance(attenuationDistance);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(attenuationDistance, material.attenuationDistance());

    QCOMPARE(attenuationDistance, node->attenuationDistance);

    const QColor attenuationColor = QColor(Qt::green);

    const QVector3D attenuationColorVector = QSSGUtils::color::sRGBToLinear(attenuationColor).toVector3D();

    material.setAttenuationColor(attenuationColor);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(attenuationColor, material.attenuationColor());

    QCOMPARE(attenuationColorVector, node->attenuationColor);

void tst_QQuick3DMaterials::testSpecularGlossyTextures()

    SpecularGlossyMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    const auto originalNode = node; // for comparisons later...

    QVERIFY(node);

    Texture texture1;

    texture1.setSource(QUrl(":/Built_with_Qt.png"));

    Texture texture2;

    texture2.setSource(QUrl(":/Built_with_Qt_2.png"));

    QQuick3DSceneManager sceneManager;

    sceneManager.updateDirtyResource(&texture1);

    sceneManager.updateDirtyResource(&texture2);

    // Albedo

    QVERIFY(!material.albedoMap());

    material.setAlbedoMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QVERIFY(material.albedoMap());

    QVERIFY(texture1.getRenderImage());

    QCOMPARE(texture1.getRenderImage(), node->colorMap);

    // SpecularMap

    material.setSpecularMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(originalNode, node);

    QVERIFY(texture2.getRenderImage());

    QCOMPARE(texture2.getRenderImage(), node->specularMap);

    // GlossinessMap

    QVERIFY(!material.glossinessMap());

    material.setGlossinessMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.glossinessMap());

    QCOMPARE(texture2.getRenderImage(), node->roughnessMap); // stored as roughness in backend

    // EmissiveMap

    QVERIFY(!material.emissiveMap());

    material.setEmissiveMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.emissiveMap());

    QCOMPARE(texture2.getRenderImage(), node->emissiveMap);

    // OpacityMap

    QVERIFY(!material.opacityMap());

    material.setOpacityMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.opacityMap());

    QCOMPARE(texture2.getRenderImage(), node->opacityMap);

    // NormalMap

    QVERIFY(!material.normalMap());

    material.setNormalMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.normalMap());

    QCOMPARE(texture2.getRenderImage(), node->normalMap);

    // OcclusionMap

    QVERIFY(!material.occlusionMap());

    material.setOcclusionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.occlusionMap());

    QCOMPARE(texture1.getRenderImage(), node->occlusionMap);

    // HeightMap

    QVERIFY(!material.heightMap());

    material.setHeightMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.heightMap());

    QCOMPARE(texture1.getRenderImage(), node->heightMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping1 = QQuick3DMaterial::A;

    material.setHeightChannel(channelMapping1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping1, material.heightChannel());

    QCOMPARE(qToUnderlying(channelMapping1),      // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->heightChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatMap

    QVERIFY(!material.clearcoatMap());

    material.setClearcoatMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatMap());

    QCOMPARE(texture1.getRenderImage(), node->clearcoatMap);

    QVERIFY(material.clearcoatChannel() == QQuick3DMaterial::R);

    const QQuick3DMaterial::TextureChannelMapping channelMapping = QQuick3DMaterial::B;

    material.setClearcoatChannel(channelMapping);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping, material.clearcoatChannel());

    QCOMPARE(qToUnderlying(channelMapping),          // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->clearcoatChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatRoughnessMap

    QVERIFY(!material.clearcoatRoughnessMap());

    material.setClearcoatRoughnessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatRoughnessMap());

    QCOMPARE(texture1.getRenderImage(), node->clearcoatRoughnessMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping2 = QQuick3DMaterial::A;

    material.setClearcoatRoughnessChannel(channelMapping2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping2, material.clearcoatRoughnessChannel());

    QCOMPARE(qToUnderlying(channelMapping2),                  // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->clearcoatRoughnessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // ClearcoatNormalMap

    QVERIFY(!material.clearcoatNormalMap());

    material.setClearcoatNormalMap(&texture2);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.clearcoatNormalMap());

    QCOMPARE(texture2.getRenderImage(), node->clearcoatNormalMap);

    // TransmissionMap

    QVERIFY(!material.transmissionMap());

    material.setTransmissionMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.transmissionMap());

    QCOMPARE(texture1.getRenderImage(), node->transmissionMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping3 = QQuick3DMaterial::B;

    material.setTransmissionChannel(channelMapping3);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping3, material.transmissionChannel());

    QCOMPARE(qToUnderlying(channelMapping3),            // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->transmissionChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

    // Thickness Map

    QVERIFY(!material.thicknessMap());

    material.setThicknessMap(&texture1);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QVERIFY(material.thicknessMap());

    QCOMPARE(texture1.getRenderImage(), node->thicknessMap);

    const QQuick3DMaterial::TextureChannelMapping channelMapping4 = QQuick3DMaterial::A;

    material.setThicknessChannel(channelMapping4);

    node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

    QCOMPARE(channelMapping4, material.thicknessChannel());

    QCOMPARE(qToUnderlying(channelMapping4),         // QQuick3DMaterial::TextureChannelMapping

             qToUnderlying(node->thicknessChannel)); // QSSGRenderDefaultMaterial::TextureChannelMapping

void tst_QQuick3DMaterials::testSpecularGlossyEnums()

    SpecularGlossyMaterial material;

    auto node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

    QVERIFY(node);

    // These test rely on the different enums having the same values

    auto lightModes = { QQuick3DSpecularGlossyMaterial::Lighting::NoLighting,

                        QQuick3DSpecularGlossyMaterial::Lighting::FragmentLighting };

    for (const auto lightMode : lightModes) {

        material.setLighting(lightMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.lighting()), int(node->lighting));

    auto blendModes = { QQuick3DSpecularGlossyMaterial::BlendMode::SourceOver,

                        QQuick3DSpecularGlossyMaterial::BlendMode::Screen,

                        QQuick3DSpecularGlossyMaterial::BlendMode::Multiply };

    for (const auto blendMode : blendModes) {

        material.setBlendMode(blendMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.blendMode()), int(node->blendMode));

    auto alphaModes = { QQuick3DSpecularGlossyMaterial::AlphaMode::Default,

                        QQuick3DSpecularGlossyMaterial::AlphaMode::Mask,

                        QQuick3DSpecularGlossyMaterial::AlphaMode::Blend };

    for (const auto alphaMode : alphaModes) {

        material.setAlphaMode(alphaMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(node));

        QCOMPARE(int(material.alphaMode()), int(node->alphaMode));

    auto depthDrawModes = {

        QQuick3DMaterial::DepthDrawMode::OpaqueOnlyDepthDraw,

        QQuick3DMaterial::DepthDrawMode::AlwaysDepthDraw,

        QQuick3DMaterial::DepthDrawMode::NeverDepthDraw,

        QQuick3DMaterial::DepthDrawMode::OpaquePrePassDepthDraw

};

    for (const auto depthDrawMode : depthDrawModes) {

        material.setDepthDrawMode(depthDrawMode);

        node = static_cast<QSSGRenderDefaultMaterial *>(material.updateSpatialNode(nullptr));

        QCOMPARE(int(material.depthDrawMode()), int(node->depthDrawMode));

void tst_QQuick3DMaterials::testCustomMaterials()

    QSKIP("Test can not work as implemented without crashing");

    CustomMaterial material;

    QQuick3DViewport *view3D = new QQuick3DViewport;

    material.setParent(view3D);

    auto node = static_cast<QSSGRenderCustomMaterial *>(material.updateSpatialNode(nullptr));

    QVERIFY(node);

    QQuick3DShaderUtilsTextureInput mTexture;

    QQuick3DTexture qTexture;

    QSignalSpy spy(&mTexture, SIGNAL(textureChanged()));

    mTexture.setTexture(&qTexture);

    QCOMPARE(spy.size(), 1);

    QVERIFY(&qTexture == mTexture.texture());

    QQuick3DShaderUtilsBuffer mBuffer;

    auto format = QQuick3DShaderUtilsBuffer::TextureFormat::RGBA8;

    mBuffer.setFormat(format);

    auto filterOp = QQuick3DShaderUtilsBuffer::TextureFilterOperation::Nearest;

    mBuffer.setTextureFilterOperation(filterOp);

    QCOMPARE(format, mBuffer.format());

    QCOMPARE(filterOp, mBuffer.textureFilterOperation());

    // TODO: Extend custom material testing with proper shaders

    view3D->deleteLater();

QTEST_APPLESS_MAIN(tst_QQuick3DMaterials)

#include "tst_qquick3dmaterials.moc"

Revision control

Copy as Markdown