qquick3dspecularglossymaterial.cpp

Go to the documentation of this file.

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dspecularglossymaterial_p.h"
#include "qquick3dobject_p.h"
 
#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
#include <QtQuick3D/private/qquick3dviewport_p.h>
 
QT_BEGIN_NAMESPACE
 
inline static float ensureNormalized(float val) { return qBound(0.0f, val, 1.0f); }
 
QQuick3DSpecularGlossyMaterial::QQuick3DSpecularGlossyMaterial(QQuick3DObject *parent)
    : QQuick3DMaterial(*(new QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::SpecularGlossyMaterial)), parent)
{}
 
QQuick3DSpecularGlossyMaterial::~QQuick3DSpecularGlossyMaterial()
{
}
 
QQuick3DSpecularGlossyMaterial::Lighting QQuick3DSpecularGlossyMaterial::lighting() const
{
    return m_lighting;
}
 
QQuick3DSpecularGlossyMaterial::BlendMode QQuick3DSpecularGlossyMaterial::blendMode() const
{
    return m_blendMode;
}
 
QColor QQuick3DSpecularGlossyMaterial::albedoColor() const
{
    return m_albedo;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::albedoMap() const
{
    return m_albedoMap;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::emissiveMap() const
{
    return m_emissiveMap;
}
 
QVector3D QQuick3DSpecularGlossyMaterial::emissiveFactor() const
{
    return m_emissiveFactor;
}
 
float QQuick3DSpecularGlossyMaterial::glossiness() const
{
    return m_glossiness;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::glossinessMap() const
{
    return m_glossinessMap;
}
 
float QQuick3DSpecularGlossyMaterial::opacity() const
{
    return m_opacity;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::opacityMap() const
{
    return m_opacityMap;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::normalMap() const
{
    return m_normalMap;
}
 
QColor QQuick3DSpecularGlossyMaterial::specularColor() const
{
    return m_specular;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::specularMap() const
{
    return m_specularMap;
}
 
float QQuick3DSpecularGlossyMaterial::normalStrength() const
{
    return m_normalStrength;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::occlusionMap() const
{
    return m_occlusionMap;
}
 
float QQuick3DSpecularGlossyMaterial::occlusionAmount() const
{
    return m_occlusionAmount;
}
 
QQuick3DSpecularGlossyMaterial::AlphaMode QQuick3DSpecularGlossyMaterial::alphaMode() const
{
    return m_alphaMode;
}
 
float QQuick3DSpecularGlossyMaterial::alphaCutoff() const
{
    return m_alphaCutoff;
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::glossinessChannel() const
{
    return m_glossinessChannel;
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::opacityChannel() const
{
    return m_opacityChannel;
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::occlusionChannel() const
{
    return m_occlusionChannel;
}
 
float QQuick3DSpecularGlossyMaterial::pointSize() const
{
    return m_pointSize;
}
 
float QQuick3DSpecularGlossyMaterial::lineWidth() const
{
    return m_lineWidth;
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::heightMap() const
{
    return m_heightMap;
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::heightChannel() const
{
    return m_heightChannel;
}
 
float QQuick3DSpecularGlossyMaterial::heightAmount() const
{
    return m_heightAmount;
}
 
int QQuick3DSpecularGlossyMaterial::minHeightMapSamples() const
{
    return m_minHeightMapSamples;
}
 
int QQuick3DSpecularGlossyMaterial::maxHeightMapSamples() const
{
    return m_maxHeightMapSamples;
}
 
void QQuick3DSpecularGlossyMaterial::markAllDirty()
{
    m_dirtyAttributes = 0xffffffff;
    QQuick3DMaterial::markAllDirty();
}
 
void QQuick3DSpecularGlossyMaterial::setLighting(QQuick3DSpecularGlossyMaterial::Lighting lighting)
{
    if (m_lighting == lighting)
        return;
 
    m_lighting = lighting;
    emit lightingChanged();
    markDirty(LightingModeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setBlendMode(QQuick3DSpecularGlossyMaterial::BlendMode blendMode)
{
    if (m_blendMode == blendMode)
        return;
 
    m_blendMode = blendMode;
    emit blendModeChanged();
    markDirty(BlendModeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setAlbedoColor(const QColor &diffuseColor)
{
    if (m_albedo == diffuseColor)
        return;
 
    m_albedo = diffuseColor;
    emit albedoColorChanged();
    markDirty(AlbedoDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setAlbedoMap(QQuick3DTexture *albedoMap)
{
    if (m_albedoMap == albedoMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setAlbedoMap, albedoMap, m_albedoMap);
 
    m_albedoMap = albedoMap;
    emit albedoMapChanged();
    markDirty(AlbedoDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setEmissiveMap(QQuick3DTexture *emissiveMap)
{
    if (m_emissiveMap == emissiveMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setEmissiveMap, emissiveMap, m_emissiveMap);
 
    m_emissiveMap = emissiveMap;
    emit emissiveMapChanged();
    markDirty(EmissiveDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setEmissiveFactor(const QVector3D &emissiveFactor)
{
    if (m_emissiveFactor == emissiveFactor)
        return;
 
    m_emissiveFactor = emissiveFactor;
    emit emissiveFactorChanged();
    markDirty(EmissiveDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setGlossiness(float glossiness)
{
    glossiness = ensureNormalized(glossiness);
    if (qFuzzyCompare(m_glossiness, glossiness))
        return;
 
    m_glossiness = glossiness;
    emit glossinessChanged();
    markDirty(GlossyDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setGlossinessMap(QQuick3DTexture *glossinessMap)
{
    if (m_glossinessMap == glossinessMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setGlossinessMap, glossinessMap, m_glossinessMap);
 
    m_glossinessMap = glossinessMap;
    emit glossinessMapChanged();
    markDirty(GlossyDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOpacity(float opacity)
{
    opacity = ensureNormalized(opacity);
    if (qFuzzyCompare(m_opacity, opacity))
        return;
 
    m_opacity = opacity;
    emit opacityChanged();
    markDirty(OpacityDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOpacityMap(QQuick3DTexture *opacityMap)
{
    if (m_opacityMap == opacityMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setOpacityMap, opacityMap, m_opacityMap);
 
    m_opacityMap = opacityMap;
    emit opacityMapChanged();
    markDirty(OpacityDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setNormalMap(QQuick3DTexture *normalMap)
{
    if (m_normalMap == normalMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setNormalMap, normalMap, m_normalMap);
 
    m_normalMap = normalMap;
    emit normalMapChanged();
    markDirty(NormalDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setSpecularColor(const QColor &specular)
{
    if (m_specular == specular)
        return;
 
    m_specular = specular;
    emit specularColorChanged();
    markDirty(SpecularDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setSpecularMap(QQuick3DTexture *specularMap)
{
    if (m_specularMap == specularMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setSpecularMap, specularMap, m_specularMap);
 
    m_specularMap = specularMap;
    emit specularMapChanged();
    markDirty(SpecularDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setNormalStrength(float factor)
{
    factor = ensureNormalized(factor);
    if (qFuzzyCompare(m_normalStrength, factor))
        return;
 
    m_normalStrength = factor;
    emit normalStrengthChanged();
    markDirty(NormalDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOcclusionMap(QQuick3DTexture *occlusionMap)
{
    if (m_occlusionMap == occlusionMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setOcclusionMap, occlusionMap, m_occlusionMap);
 
    m_occlusionMap = occlusionMap;
    emit occlusionMapChanged();
    markDirty(OcclusionDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOcclusionAmount(float occlusionAmount)
{
    if (qFuzzyCompare(m_occlusionAmount, occlusionAmount))
        return;
 
    m_occlusionAmount = occlusionAmount;
    emit occlusionAmountChanged();
    markDirty(OcclusionDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setAlphaMode(QQuick3DSpecularGlossyMaterial::AlphaMode alphaMode)
{
    if (m_alphaMode == alphaMode)
        return;
 
    m_alphaMode = alphaMode;
    emit alphaModeChanged();
    markDirty(AlphaModeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setAlphaCutoff(float alphaCutoff)
{
    if (qFuzzyCompare(m_alphaCutoff, alphaCutoff))
        return;
 
    m_alphaCutoff = alphaCutoff;
    emit alphaCutoffChanged();
    markDirty(AlphaModeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setGlossinessChannel(TextureChannelMapping channel)
{
    if (m_glossinessChannel == channel)
        return;
 
    m_glossinessChannel = channel;
    emit glossinessChannelChanged();
    markDirty(GlossyDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOpacityChannel(TextureChannelMapping channel)
{
    if (m_opacityChannel == channel)
        return;
 
    m_opacityChannel = channel;
    emit opacityChannelChanged();
    markDirty(OpacityDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setOcclusionChannel(TextureChannelMapping channel)
{
    if (m_occlusionChannel == channel)
        return;
 
    m_occlusionChannel = channel;
    emit occlusionChannelChanged();
    markDirty(OcclusionDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setPointSize(float size)
{
    if (qFuzzyCompare(m_pointSize, size))
        return;
    m_pointSize = size;
    emit pointSizeChanged();
    markDirty(PointSizeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setLineWidth(float width)
{
    if (qFuzzyCompare(m_lineWidth, width))
        return;
    m_lineWidth = width;
    emit lineWidthChanged();
    markDirty(LineWidthDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setHeightMap(QQuick3DTexture *heightMap)
{
    if (m_heightMap == heightMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setHeightMap, heightMap, m_heightMap);
 
    m_heightMap = heightMap;
    emit heightMapChanged();
    markDirty(HeightDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setHeightChannel(QQuick3DMaterial::TextureChannelMapping channel)
{
    if (m_heightChannel == channel)
        return;
 
    m_heightChannel = channel;
    emit heightChannelChanged();
    markDirty(HeightDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setHeightAmount(float heightAmount)
{
    if (qFuzzyCompare(m_heightAmount, heightAmount))
        return;
 
    m_heightAmount = heightAmount;
    emit heightAmountChanged();
    markDirty(HeightDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setMinHeightMapSamples(int samples)
{
    if (m_minHeightMapSamples == samples)
        return;
 
    m_minHeightMapSamples = samples;
    emit minHeightMapSamplesChanged();
    markDirty(HeightDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setMaxHeightMapSamples(int samples)
{
    if (m_maxHeightMapSamples == samples)
        return;
 
    m_maxHeightMapSamples = samples;
    emit maxHeightMapSamplesChanged();
    markDirty(HeightDirty);
}
 
QSSGRenderGraphObject *QQuick3DSpecularGlossyMaterial::updateSpatialNode(QSSGRenderGraphObject *node)
{
    static const auto channelMapping = [](TextureChannelMapping mapping) {
        return QSSGRenderDefaultMaterial::TextureChannelMapping(mapping);
    };
 
    if (!node) {
        markAllDirty();
        node = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::SpecularGlossyMaterial);
    }
 
    // Set common material properties
    QQuick3DMaterial::updateSpatialNode(node);
 
    QSSGRenderDefaultMaterial *material = static_cast<QSSGRenderDefaultMaterial *>(node);
 
    material->specularModel = QSSGRenderDefaultMaterial::MaterialSpecularModel::KGGX;
 
    if (m_dirtyAttributes & LightingModeDirty)
        material->lighting = QSSGRenderDefaultMaterial::MaterialLighting(m_lighting);
 
    if (m_dirtyAttributes & BlendModeDirty)
        material->blendMode = QSSGRenderDefaultMaterial::MaterialBlendMode(m_blendMode);
 
    if (m_dirtyAttributes & AlbedoDirty) {
        if (!m_albedoMap)
            material->colorMap = nullptr;
        else
            material->colorMap = m_albedoMap->getRenderImage();
 
        material->color = color::sRGBToLinear(m_albedo);
    }
 
    if (m_dirtyAttributes & EmissiveDirty) {
        if (!m_emissiveMap)
            material->emissiveMap = nullptr;
        else
            material->emissiveMap = m_emissiveMap->getRenderImage();
 
        material->emissiveColor = m_emissiveFactor;
    }
 
    material->fresnelPower = 5.0f;
    material->vertexColorsEnabled = false;
 
    if (m_dirtyAttributes & GlossyDirty) {
        if (!m_glossinessMap)
            material->roughnessMap = nullptr;
        else
            material->roughnessMap = m_glossinessMap->getRenderImage();
 
        material->specularRoughness = m_glossiness;
        material->roughnessChannel = channelMapping(m_glossinessChannel);
    }
 
    if (m_dirtyAttributes & SpecularDirty) {
        if (!m_specularMap)
            material->specularMap = nullptr;
        else
            material->specularMap = m_specularMap->getRenderImage();
 
        material->specularTint = color::sRGBToLinear(m_specular).toVector3D();
    }
 
    if (m_dirtyAttributes & OpacityDirty) {
        if (!m_opacityMap)
            material->opacityMap = nullptr;
        else
            material->opacityMap = m_opacityMap->getRenderImage();
 
        material->opacity = m_opacity;
        material->opacityChannel = channelMapping(m_opacityChannel);
    }
 
    if (m_dirtyAttributes & NormalDirty) {
        if (!m_normalMap)
            material->normalMap = nullptr;
        else
            material->normalMap = m_normalMap->getRenderImage();
 
        material->bumpAmount = m_normalStrength;
    }
 
    if (m_dirtyAttributes & OcclusionDirty) {
        if (!m_occlusionMap)
            material->occlusionMap = nullptr;
        else
            material->occlusionMap = m_occlusionMap->getRenderImage();
        material->occlusionAmount = m_occlusionAmount;
        material->occlusionChannel = channelMapping(m_occlusionChannel);
    }
 
    if (m_dirtyAttributes & AlphaModeDirty) {
        material->alphaMode = QSSGRenderDefaultMaterial::MaterialAlphaMode(m_alphaMode);
        material->alphaCutoff = m_alphaCutoff;
    }
 
    if (m_dirtyAttributes & PointSizeDirty)
        material->pointSize = m_pointSize;
 
    if (m_dirtyAttributes & LineWidthDirty)
        material->lineWidth = m_lineWidth;
 
    if (m_dirtyAttributes & HeightDirty) {
        if (!m_heightMap)
            material->heightMap = nullptr;
        else
            material->heightMap = m_heightMap->getRenderImage();
        material->heightAmount = m_heightAmount;
        material->minHeightSamples = m_minHeightMapSamples;
        material->maxHeightSamples = m_maxHeightMapSamples;
        material->heightChannel = channelMapping(m_heightChannel);
    }
 
    if (m_dirtyAttributes & ClearcoatDirty) {
        material->clearcoatAmount = m_clearcoatAmount;
        if (!m_clearcoatMap)
            material->clearcoatMap = nullptr;
        else
            material->clearcoatMap = m_clearcoatMap->getRenderImage();
        material->clearcoatChannel = channelMapping(m_clearcoatChannel);
        material->clearcoatRoughnessAmount = m_clearcoatRoughnessAmount;
        if (!m_clearcoatRoughnessMap)
            material->clearcoatRoughnessMap = nullptr;
        else
            material->clearcoatRoughnessMap = m_clearcoatRoughnessMap->getRenderImage();
        material->clearcoatRoughnessChannel = channelMapping(m_clearcoatRoughnessChannel);
        if (!m_clearcoatNormalMap)
            material->clearcoatNormalMap = nullptr;
        else
            material->clearcoatNormalMap = m_clearcoatNormalMap->getRenderImage();
    }
 
    if (m_dirtyAttributes & TransmissionDirty) {
        material->transmissionFactor = m_transmissionFactor;
        if (!m_transmissionMap)
            material->transmissionMap = nullptr;
        else
            material->transmissionMap = m_transmissionMap->getRenderImage();
        material->transmissionChannel = channelMapping(m_transmissionChannel);
    }
 
    if (m_dirtyAttributes & VolumeDirty) {
        material->thicknessFactor = m_thicknessFactor;
        if (!m_thicknessMap)
            material->thicknessMap = nullptr;
        else
            material->thicknessMap = m_thicknessMap->getRenderImage();
        material->thicknessChannel = channelMapping(m_thicknessChannel);
 
        material->attenuationDistance = m_attenuationDistance;
        material->attenuationColor = color::sRGBToLinear(m_attenuationColor).toVector3D();
    }
 
    if (m_dirtyAttributes & VertexColorsDirty)
        material->vertexColorsEnabled = m_vertexColorsEnabled;
 
    m_dirtyAttributes = 0;
 
    return node;
}
 
void QQuick3DSpecularGlossyMaterial::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
{
    if (change == QQuick3DObject::ItemSceneChange)
        updateSceneManager(value.sceneManager);
}
 
void QQuick3DSpecularGlossyMaterial::updateSceneManager(QQuick3DSceneManager *sceneManager)
{
    // Check all the resource value's scene manager, and update as necessary.
    if (sceneManager) {
        QQuick3DObjectPrivate::refSceneManager(m_albedoMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_emissiveMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_glossinessMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_opacityMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_normalMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_specularMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_occlusionMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_heightMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_clearcoatMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_clearcoatRoughnessMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_clearcoatNormalMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_transmissionMap, *sceneManager);
        QQuick3DObjectPrivate::refSceneManager(m_thicknessMap, *sceneManager);
    } else {
        QQuick3DObjectPrivate::derefSceneManager(m_albedoMap);
        QQuick3DObjectPrivate::derefSceneManager(m_emissiveMap);
        QQuick3DObjectPrivate::derefSceneManager(m_glossinessMap);
        QQuick3DObjectPrivate::derefSceneManager(m_opacityMap);
        QQuick3DObjectPrivate::derefSceneManager(m_normalMap);
        QQuick3DObjectPrivate::derefSceneManager(m_specularMap);
        QQuick3DObjectPrivate::derefSceneManager(m_occlusionMap);
        QQuick3DObjectPrivate::derefSceneManager(m_heightMap);
        QQuick3DObjectPrivate::derefSceneManager(m_clearcoatMap);
        QQuick3DObjectPrivate::derefSceneManager(m_clearcoatRoughnessMap);
        QQuick3DObjectPrivate::derefSceneManager(m_clearcoatNormalMap);
        QQuick3DObjectPrivate::derefSceneManager(m_transmissionMap);
        QQuick3DObjectPrivate::derefSceneManager(m_thicknessMap);
    }
}
 
void QQuick3DSpecularGlossyMaterial::markDirty(QQuick3DSpecularGlossyMaterial::DirtyType type)
{
    if (!(m_dirtyAttributes & quint32(type))) {
        m_dirtyAttributes |= quint32(type);
        update();
    }
}
 
float QQuick3DSpecularGlossyMaterial::clearcoatAmount() const
{
    return m_clearcoatAmount;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatAmount(float newClearcoatAmount)
{
    if (qFuzzyCompare(m_clearcoatAmount, newClearcoatAmount))
        return;
    m_clearcoatAmount = newClearcoatAmount;
    emit clearcoatAmountChanged();
    markDirty(ClearcoatDirty);
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::clearcoatMap() const
{
    return m_clearcoatMap;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatMap(QQuick3DTexture *newClearcoatMap)
{
    if (m_clearcoatMap == newClearcoatMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setClearcoatMap, newClearcoatMap, m_clearcoatMap);
 
    m_clearcoatMap = newClearcoatMap;
    emit clearcoatMapChanged();
    markDirty(ClearcoatDirty);
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::clearcoatChannel() const
{
    return m_clearcoatChannel;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatChannel(QQuick3DMaterial::TextureChannelMapping newClearcoatChannel)
{
    if (m_clearcoatChannel == newClearcoatChannel)
        return;
    m_clearcoatChannel = newClearcoatChannel;
    emit clearcoatChannelChanged();
    markDirty(ClearcoatDirty);
}
 
float QQuick3DSpecularGlossyMaterial::clearcoatRoughnessAmount() const
{
    return m_clearcoatRoughnessAmount;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessAmount(float newClearcoatRoughnessAmount)
{
    if (qFuzzyCompare(m_clearcoatRoughnessAmount, newClearcoatRoughnessAmount))
        return;
    m_clearcoatRoughnessAmount = newClearcoatRoughnessAmount;
    emit clearcoatRoughnessAmountChanged();
    markDirty(ClearcoatDirty);
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::clearcoatRoughnessChannel() const
{
    return m_clearcoatRoughnessChannel;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessChannel(QQuick3DMaterial::TextureChannelMapping newClearcoatRoughnessChannel)
{
    if (m_clearcoatRoughnessChannel == newClearcoatRoughnessChannel)
        return;
    m_clearcoatRoughnessChannel = newClearcoatRoughnessChannel;
    emit clearcoatRoughnessChannelChanged();
    markDirty(ClearcoatDirty);
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::clearcoatRoughnessMap() const
{
    return m_clearcoatRoughnessMap;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessMap(QQuick3DTexture *newClearcoatRoughnessMap)
{
    if (m_clearcoatRoughnessMap == newClearcoatRoughnessMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setClearcoatRoughnessMap, newClearcoatRoughnessMap, m_clearcoatRoughnessMap);
 
    m_clearcoatRoughnessMap = newClearcoatRoughnessMap;
    emit clearcoatRoughnessMapChanged();
    markDirty(ClearcoatDirty);
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::clearcoatNormalMap() const
{
    return m_clearcoatNormalMap;
}
 
void QQuick3DSpecularGlossyMaterial::setClearcoatNormalMap(QQuick3DTexture *newClearcoatNormalMap)
{
    if (m_clearcoatNormalMap == newClearcoatNormalMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setClearcoatNormalMap, newClearcoatNormalMap, m_clearcoatNormalMap);
 
    m_clearcoatNormalMap = newClearcoatNormalMap;
    emit clearcoatNormalMapChanged();
    markDirty(ClearcoatDirty);
}
 
float QQuick3DSpecularGlossyMaterial::transmissionFactor() const
{
    return m_transmissionFactor;
}
 
void QQuick3DSpecularGlossyMaterial::setTransmissionFactor(float newTransmissionFactor)
{
    if (qFuzzyCompare(m_transmissionFactor, newTransmissionFactor))
        return;
    m_transmissionFactor = newTransmissionFactor;
    emit transmissionFactorChanged();
    markDirty(TransmissionDirty);
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::transmissionMap() const
{
    return m_transmissionMap;
}
 
void QQuick3DSpecularGlossyMaterial::setTransmissionMap(QQuick3DTexture *newTransmissionMap)
{
    if (m_transmissionMap == newTransmissionMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setTransmissionMap, newTransmissionMap, m_transmissionMap);
 
    m_transmissionMap = newTransmissionMap;
    emit transmissionMapChanged();
    markDirty(TransmissionDirty);
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::transmissionChannel() const
{
    return m_transmissionChannel;
}
 
void QQuick3DSpecularGlossyMaterial::setTransmissionChannel(QQuick3DMaterial::TextureChannelMapping newTransmissionChannel)
{
    if (m_transmissionChannel == newTransmissionChannel)
        return;
    m_transmissionChannel = newTransmissionChannel;
    emit transmissionChannelChanged();
    markDirty(TransmissionDirty);
}
 
float QQuick3DSpecularGlossyMaterial::thicknessFactor() const
{
    return m_thicknessFactor;
}
 
void QQuick3DSpecularGlossyMaterial::setThicknessFactor(float newThicknessFactor)
{
    if (qFuzzyCompare(m_thicknessFactor, newThicknessFactor))
        return;
    m_thicknessFactor = newThicknessFactor;
    emit thicknessFactorChanged();
    markDirty(VolumeDirty);
}
 
QQuick3DTexture *QQuick3DSpecularGlossyMaterial::thicknessMap() const
{
    return m_thicknessMap;
}
 
void QQuick3DSpecularGlossyMaterial::setThicknessMap(QQuick3DTexture *newThicknessMap)
{
    if (m_thicknessMap == newThicknessMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSpecularGlossyMaterial::setThicknessMap, newThicknessMap, m_thicknessMap);
 
    m_thicknessMap = newThicknessMap;
    emit thicknessMapChanged();
    markDirty(VolumeDirty);
}
 
QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::thicknessChannel() const
{
    return m_thicknessChannel;
}
 
void QQuick3DSpecularGlossyMaterial::setThicknessChannel(QQuick3DMaterial::TextureChannelMapping newThicknessChannel)
{
    if (m_thicknessChannel == newThicknessChannel)
        return;
    m_thicknessChannel = newThicknessChannel;
    emit thicknessChannelChanged();
    markDirty(VolumeDirty);
}
 
float QQuick3DSpecularGlossyMaterial::attenuationDistance() const
{
    return m_attenuationDistance;
}
 
void QQuick3DSpecularGlossyMaterial::setAttenuationDistance(float newAttenuationDistance)
{
    if (qFuzzyCompare(m_attenuationDistance, newAttenuationDistance))
        return;
    m_attenuationDistance = newAttenuationDistance;
    emit attenuationDistanceChanged();
    markDirty(VolumeDirty);
}
 
QColor QQuick3DSpecularGlossyMaterial::attenuationColor() const
{
    return m_attenuationColor;
}
 
bool QQuick3DSpecularGlossyMaterial::vertexColorsEnabled() const
{
    return m_vertexColorsEnabled;
}
 
void QQuick3DSpecularGlossyMaterial::setAttenuationColor(const QColor &newAttenuationColor)
{
    if (m_attenuationColor == newAttenuationColor)
        return;
    m_attenuationColor = newAttenuationColor;
    emit attenuationColorChanged();
    markDirty(VolumeDirty);
}
 
void QQuick3DSpecularGlossyMaterial::setVertexColorsEnabled(bool vertexColors)
{
    if (m_vertexColorsEnabled == vertexColors)
        return;
 
    m_vertexColorsEnabled = vertexColors;
    emit vertexColorsEnabledChanged(m_vertexColorsEnabled);
    markDirty(VertexColorsDirty);
}
 
QT_END_NAMESPACE