qquick3dsceneenvironment.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
 
#include "qquick3dsceneenvironment_p.h"
#include "qquick3dobject_p.h"
#include "qquick3dtexture_p.h"
#include "qquick3dcubemaptexture_p.h"
#include "qquick3ddebugsettings_p.h"
 
QT_BEGIN_NAMESPACE
 
QQuick3DSceneEnvironment::QQuick3DSceneEnvironment(QQuick3DObject *parent)
    : QQuick3DObject(*(new QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::SceneEnvironment)), parent)
{
    m_debugSettings = new QQuick3DDebugSettings(this);
    m_debugSettingsSignalConnection = QObject::connect(m_debugSettings, &QQuick3DDebugSettings::changed, this,
                                                       [this] { update(); });
    QObject::connect(m_debugSettings, &QObject::destroyed, this,
                     [this](QObject *obj) {
        if (m_debugSettings == obj) {
            m_debugSettings = nullptr;
            update();
        }
    });
}
 
QQuick3DSceneEnvironment::~QQuick3DSceneEnvironment()
{
}
 
QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues QQuick3DSceneEnvironment::antialiasingMode() const
{
    return m_antialiasingMode;
}
 
QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues QQuick3DSceneEnvironment::antialiasingQuality() const
{
    return m_antialiasingQuality;
}
 
QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes QQuick3DSceneEnvironment::backgroundMode() const
{
    return m_backgroundMode;
}
 
QColor QQuick3DSceneEnvironment::clearColor() const
{
    return m_clearColor;
}
 
float QQuick3DSceneEnvironment::aoStrength() const
{
    return m_aoStrength;
}
 
float QQuick3DSceneEnvironment::aoDistance() const
{
    return m_aoDistance;
}
 
float QQuick3DSceneEnvironment::aoSoftness() const
{
    return m_aoSoftness;
}
 
bool QQuick3DSceneEnvironment::aoDither() const
{
    return m_aoDither;
}
 
int QQuick3DSceneEnvironment::aoSampleRate() const
{
    return m_aoSampleRate;
}
 
float QQuick3DSceneEnvironment::aoBias() const
{
    return m_aoBias;
}
 
QQuick3DTexture *QQuick3DSceneEnvironment::lightProbe() const
{
    return m_lightProbe;
}
 
float QQuick3DSceneEnvironment::probeExposure() const
{
    return m_probeExposure;
}
 
float QQuick3DSceneEnvironment::probeHorizon() const
{
    return m_probeHorizon;
}
 
QVector3D QQuick3DSceneEnvironment::probeOrientation() const
{
    return m_probeOrientation;
}
 
bool QQuick3DSceneEnvironment::temporalAAEnabled() const
{
    return m_temporalAAEnabled;
}
 
float QQuick3DSceneEnvironment::temporalAAStrength() const
{
    return m_temporalAAStrength;
}
 
bool QQuick3DSceneEnvironment::specularAAEnabled() const
{
    return m_specularAAEnabled;
}
 
bool QQuick3DSceneEnvironment::depthTestEnabled() const
{
    return m_depthTestEnabled;
}
bool QQuick3DSceneEnvironment::depthPrePassEnabled() const
{
    return m_depthPrePassEnabled;
}
 
QQmlListProperty<QQuick3DEffect> QQuick3DSceneEnvironment::effects()
{
    return QQmlListProperty<QQuick3DEffect>(this,
                                            nullptr,
                                            QQuick3DSceneEnvironment::qmlAppendEffect,
                                            QQuick3DSceneEnvironment::qmlEffectsCount,
                                            QQuick3DSceneEnvironment::qmlEffectAt,
                                            QQuick3DSceneEnvironment::qmlClearEffects);
}
 
QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes QQuick3DSceneEnvironment::tonemapMode() const
{
    return m_tonemapMode;
}
 
float QQuick3DSceneEnvironment::skyboxBlurAmount() const
{
    return m_skyboxBlurAmount;
}
 
QQuick3DDebugSettings *QQuick3DSceneEnvironment::debugSettings() const
{
    return m_debugSettings;
}
 
QRect QQuick3DSceneEnvironment::scissorRect() const
{
    return m_scissorRect;
}
 
void QQuick3DSceneEnvironment::setAntialiasingMode(QQuick3DSceneEnvironment::QQuick3DEnvironmentAAModeValues antialiasingMode)
{
    if (m_antialiasingMode == antialiasingMode)
        return;
 
    m_antialiasingMode = antialiasingMode;
    emit antialiasingModeChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAntialiasingQuality(QQuick3DSceneEnvironment::QQuick3DEnvironmentAAQualityValues antialiasingQuality)
{
    if (m_antialiasingQuality == antialiasingQuality)
        return;
 
    m_antialiasingQuality = antialiasingQuality;
    emit antialiasingQualityChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setBackgroundMode(QQuick3DSceneEnvironment::QQuick3DEnvironmentBackgroundTypes backgroundMode)
{
    if (m_backgroundMode == backgroundMode)
        return;
 
    m_backgroundMode = backgroundMode;
    emit backgroundModeChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setClearColor(const QColor &clearColor)
{
    if (m_clearColor == clearColor)
        return;
 
    m_clearColor = clearColor;
    emit clearColorChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoStrength(float aoStrength)
{
    if (qFuzzyCompare(m_aoStrength, aoStrength))
        return;
 
    m_aoStrength = aoStrength;
 
    const bool aoEnabled = !(qFuzzyIsNull(m_aoStrength) || qFuzzyIsNull(m_aoDistance));
    setAoEnabled(aoEnabled);
 
    emit aoStrengthChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoDistance(float aoDistance)
{
    if (qFuzzyCompare(m_aoDistance, aoDistance))
        return;
 
    m_aoDistance = aoDistance;
 
    const bool aoEnabled = !(qFuzzyIsNull(m_aoStrength) || qFuzzyIsNull(m_aoDistance));
    setAoEnabled(aoEnabled);
 
    emit aoDistanceChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoSoftness(float aoSoftness)
{
    if (qFuzzyCompare(m_aoSoftness, aoSoftness))
        return;
 
    m_aoSoftness = aoSoftness;
    emit aoSoftnessChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoDither(bool aoDither)
{
    if (m_aoDither == aoDither)
        return;
 
    m_aoDither = aoDither;
    emit aoDitherChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoSampleRate(int aoSampleRate)
{
    if (m_aoSampleRate == aoSampleRate)
        return;
 
    m_aoSampleRate = aoSampleRate;
    emit aoSampleRateChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setAoBias(float aoBias)
{
    if (qFuzzyCompare(m_aoBias, aoBias))
        return;
 
    m_aoBias = aoBias;
    emit aoBiasChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setLightProbe(QQuick3DTexture *lightProbe)
{
    if (m_lightProbe == lightProbe)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSceneEnvironment::setLightProbe, lightProbe, m_lightProbe);
 
    m_lightProbe = lightProbe;
    emit lightProbeChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setProbeExposure(float probeExposure)
{
    if (qFuzzyCompare(m_probeExposure, probeExposure))
        return;
 
    m_probeExposure = probeExposure;
    emit probeExposureChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setProbeHorizon(float probeHorizon)
{
    // clamp value to expected range
    probeHorizon = qBound(0.0f, probeHorizon, 1.0f);
 
    if (qFuzzyCompare(m_probeHorizon, probeHorizon))
        return;
 
    m_probeHorizon = probeHorizon;
    emit probeHorizonChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setProbeOrientation(const QVector3D &orientation)
{
    if (qFuzzyCompare(m_probeOrientation, orientation))
        return;
 
    m_probeOrientation = orientation;
    emit probeOrientationChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setDepthTestEnabled(bool depthTestEnabled)
{
    if (m_depthTestEnabled == depthTestEnabled)
        return;
 
    m_depthTestEnabled = depthTestEnabled;
    emit depthTestEnabledChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setDepthPrePassEnabled(bool depthPrePassEnabled)
{
    if (m_depthPrePassEnabled == depthPrePassEnabled)
        return;
 
    m_depthPrePassEnabled = depthPrePassEnabled;
    emit depthPrePassEnabledChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setTonemapMode(QQuick3DSceneEnvironment::QQuick3DEnvironmentTonemapModes tonemapMode)
{
    if (m_tonemapMode == tonemapMode)
        return;
 
    m_tonemapMode = tonemapMode;
    emit tonemapModeChanged();
    update();
}
 
bool QQuick3DSceneEnvironment::useBuiltinTonemapper() const
{
    return true;
}
 
QSSGRenderGraphObject *QQuick3DSceneEnvironment::updateSpatialNode(QSSGRenderGraphObject *node)
{
    // Don't do anything, these properties get set by the scene renderer
    return node;
}
 
void QQuick3DSceneEnvironment::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
{
    if (change == QQuick3DObject::ItemSceneChange)
        updateSceneManager(value.sceneManager);
}
 
const QVector<QQuick3DEffect *> &QQuick3DSceneEnvironment::effectList() const
{
    return m_effects;
}
 
void QQuick3DSceneEnvironment::updateSceneManager(QQuick3DSceneManager *manager)
{
    if (manager) {
        QQuick3DObjectPrivate::refSceneManager(m_lightProbe, *manager);
        QQuick3DObjectPrivate::refSceneManager(m_skyBoxCubeMap, *manager);
    } else {
        QQuick3DObjectPrivate::derefSceneManager(m_lightProbe);
        QQuick3DObjectPrivate::derefSceneManager(m_skyBoxCubeMap);
    }
}
 
void QQuick3DSceneEnvironment::setTemporalAAEnabled(bool temporalAAEnabled)
{
    if (m_temporalAAEnabled == temporalAAEnabled)
        return;
 
    m_temporalAAEnabled = temporalAAEnabled;
    emit temporalAAEnabledChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setTemporalAAStrength(float strength)
{
    if (qFuzzyCompare(m_temporalAAStrength, strength))
        return;
 
    m_temporalAAStrength = strength;
    emit temporalAAStrengthChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setSpecularAAEnabled(bool enabled)
{
    if (m_specularAAEnabled == enabled)
        return;
 
    m_specularAAEnabled = enabled;
    emit specularAAEnabledChanged();
    update();
}
 
void QQuick3DSceneEnvironment::qmlAppendEffect(QQmlListProperty<QQuick3DEffect> *list, QQuick3DEffect *effect)
{
    if (effect == nullptr)
        return;
    QQuick3DSceneEnvironment *self = static_cast<QQuick3DSceneEnvironment *>(list->object);
    self->m_effects.push_back(effect);
 
    if (effect->parentItem() == nullptr)
        effect->setParentItem(self);
 
    for (QQuick3DEffect *e : self->m_effects)
        e->effectChainDirty();
 
    self->update();
}
 
QQuick3DEffect *QQuick3DSceneEnvironment::qmlEffectAt(QQmlListProperty<QQuick3DEffect> *list, qsizetype index)
{
    QQuick3DSceneEnvironment *self = static_cast<QQuick3DSceneEnvironment *>(list->object);
    return self->m_effects.at(index);
}
 
qsizetype QQuick3DSceneEnvironment::qmlEffectsCount(QQmlListProperty<QQuick3DEffect> *list)
{
    QQuick3DSceneEnvironment *self = static_cast<QQuick3DSceneEnvironment *>(list->object);
    return self->m_effects.size();
}
 
void QQuick3DSceneEnvironment::qmlClearEffects(QQmlListProperty<QQuick3DEffect> *list)
{
    QQuick3DSceneEnvironment *self = static_cast<QQuick3DSceneEnvironment *>(list->object);
    self->m_effects.clear();
    self->update();
}
 
void QQuick3DSceneEnvironment::setSkyboxBlurAmount(float newSkyboxBlurAmount)
{
    newSkyboxBlurAmount = qBound(0.0f, newSkyboxBlurAmount, 1.0f);
 
    if (qFuzzyCompare(m_skyboxBlurAmount, newSkyboxBlurAmount))
        return;
 
    m_skyboxBlurAmount = newSkyboxBlurAmount;
    emit skyboxBlurAmountChanged();
    update();
}
 
QQuick3DLightmapper *QQuick3DSceneEnvironment::lightmapper() const
{
    return m_lightmapper;
}
 
void QQuick3DSceneEnvironment::setLightmapper(QQuick3DLightmapper *lightmapper)
{
    if (m_lightmapper == lightmapper)
        return;
 
    if (m_lightmapper)
        m_lightmapper->disconnect(m_lightmapperSignalConnection);
 
    m_lightmapper = lightmapper;
 
    m_lightmapperSignalConnection = QObject::connect(m_lightmapper, &QQuick3DLightmapper::changed, this,
                                                     [this] { update(); });
 
    QObject::connect(m_lightmapper, &QObject::destroyed, this,
                     [this](QObject *obj)
    {
        if (m_lightmapper == obj) {
            m_lightmapper = nullptr;
            update();
        }
    });
 
    emit lightmapperChanged();
    update();
}
 
QQuick3DCubeMapTexture *QQuick3DSceneEnvironment::skyBoxCubeMap() const
{
    return m_skyBoxCubeMap;
}
 
void QQuick3DSceneEnvironment::setSkyBoxCubeMap(QQuick3DCubeMapTexture *newSkyBoxCubeMap)
{
    if (m_skyBoxCubeMap == newSkyBoxCubeMap)
        return;
 
    QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DSceneEnvironment::setSkyBoxCubeMap, newSkyBoxCubeMap, m_skyBoxCubeMap);
 
    m_skyBoxCubeMap = newSkyBoxCubeMap;
    emit skyBoxCubeMapChanged();
}
 
void QQuick3DSceneEnvironment::setDebugSettings(QQuick3DDebugSettings *newDebugSettings)
{
    if (m_debugSettings == newDebugSettings)
        return;
 
    if (m_debugSettings)
        m_debugSettings->disconnect(m_debugSettingsSignalConnection);
 
    m_debugSettings = newDebugSettings;
 
    m_debugSettingsSignalConnection = QObject::connect(m_debugSettings, &QQuick3DDebugSettings::changed, this,
                                                       [this] { update(); });
    QObject::connect(m_debugSettings, &QObject::destroyed, this,
                     [this](QObject *obj) {
        if (m_debugSettings == obj) {
            m_debugSettings = nullptr;
            update();
        }
    });
 
    emit debugSettingsChanged();
    update();
}
 
void QQuick3DSceneEnvironment::setScissorRect(QRect rect)
{
    if (m_scissorRect == rect)
        return;
 
    m_scissorRect = rect;
    emit scissorRectChanged();
    update();
}
 
bool QQuick3DSceneEnvironment::gridEnabled() const
{
    return m_gridEnabled;
}
 
void QQuick3DSceneEnvironment::setGridEnabled(bool newGridEnabled)
{
    if (m_gridEnabled == newGridEnabled)
        return;
    m_gridEnabled = newGridEnabled;
    update();
}
 
float QQuick3DSceneEnvironment::gridScale() const
{
    return m_gridScale;
}
 
void QQuick3DSceneEnvironment::setGridScale(float newGridScale)
{
    if (qFuzzyCompare(m_gridScale, newGridScale))
        return;
    m_gridScale = newGridScale;
    update();
}
 
uint QQuick3DSceneEnvironment::gridFlags() const
{
    return m_gridFlags;
}
 
void QQuick3DSceneEnvironment::setGridFlags(uint newGridFlags)
{
    if (m_gridFlags == newGridFlags)
        return;
    m_gridFlags = newGridFlags;
    update();
}
 
bool QQuick3DSceneEnvironment::aoEnabled() const
{
    return m_aoEnabled;
}
 
void QQuick3DSceneEnvironment::setAoEnabled(bool newAoEnabled)
{
    if (m_aoEnabled == newAoEnabled)
        return;
 
    m_aoEnabled = newAoEnabled;
 
    if (m_aoEnabled) {
        if (qFuzzyIsNull(m_aoStrength))
            setAoStrength(100.0f);
        if (qFuzzyIsNull(m_aoDistance))
            setAoDistance(defaultAoDistance());
    }
 
    emit aoEnabledChanged();
    update();
}
 
QQuick3DFog *QQuick3DSceneEnvironment::fog() const
{
    return m_fog;
}
 
void QQuick3DSceneEnvironment::setFog(QQuick3DFog *fog)
{
    if (m_fog == fog)
        return;
 
    if (m_fog)
        m_fog->disconnect(m_fogSignalConnection);
 
    m_fog = fog;
 
    m_fogSignalConnection = QObject::connect(m_fog, &QQuick3DFog::changed, this, [this] { update(); });
 
    QObject::connect(m_fog, &QObject::destroyed, this,
                     [this](QObject *obj)
    {
        if (m_fog == obj) {
            m_fog = nullptr;
            update();
        }
    });
 
    emit fogChanged();
    update();
}
 
QT_END_NAMESPACE