Revision control
++ // Copyright (C) 2025 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "defaultmaterialshaderproperties.h"
++
++ DefaultMaterialShaderProperties::DefaultMaterialShaderProperties() {}
++
++ QSSGShaderDefaultMaterialKeyProperties DefaultMaterialShaderProperties::properties() const
++ {
++ return m_properties;
++ }
++
++ QSSGShaderDefaultMaterialKey DefaultMaterialShaderProperties::key() const
++ {
++ return m_key;
++ }
++
++ bool DefaultMaterialShaderProperties::hasLighting() const
++ {
++ return m_properties.m_hasLighting.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHasLighting(bool newHasLighting)
++ {
++ if (this->hasLighting() == newHasLighting)
++ return;
++
++ m_properties.m_hasLighting.setValue(m_key, newHasLighting);
++ emit hasLightingChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::hasIbl() const
++ {
++ return m_properties.m_hasIbl.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHasIbl(bool newHasIbl)
++ {
++ if (this->hasIbl() == newHasIbl)
++ return;
++
++ m_properties.m_hasIbl.setValue(m_key, newHasIbl);
++ emit hasIblChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::fresnelScaleBiasEnabled() const
++ {
++ return m_properties.m_fresnelScaleBiasEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setFresnelScaleBiasEnabled(bool newFresnelScaleBiasEnabled)
++ {
++ if (fresnelScaleBiasEnabled() == newFresnelScaleBiasEnabled)
++ return;
++ m_properties.m_fresnelScaleBiasEnabled.setValue(m_key, newFresnelScaleBiasEnabled);
++ emit fresnelScaleBiasEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::clearcoatFresnelScaleBiasEnabled() const
++ {
++ return m_properties.m_clearcoatFresnelScaleBiasEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatFresnelScaleBiasEnabled(bool newClearcoatFresnelScaleBiasEnabled)
++ {
++ if (clearcoatFresnelScaleBiasEnabled() == newClearcoatFresnelScaleBiasEnabled)
++ return;
++ m_properties.m_clearcoatFresnelScaleBiasEnabled.setValue(m_key, newClearcoatFresnelScaleBiasEnabled);
++ emit clearcoatFresnelScaleBiasEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::fresnelEnabled() const
++ {
++ return m_properties.m_fresnelEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setFresnelEnabled(bool newFresnelEnabled)
++ {
++ if (fresnelEnabled() == newFresnelEnabled)
++ return;
++ m_properties.m_fresnelEnabled.setValue(m_key, newFresnelEnabled);
++ emit fresnelEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::baseColorSingleChannelEnabled() const
++ {
++ return m_properties.m_baseColorSingleChannelEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBaseColorSingleChannelEnabled(bool newBaseColorSingleChannelEnabled)
++ {
++ if (baseColorSingleChannelEnabled() == newBaseColorSingleChannelEnabled)
++ return;
++ m_properties.m_baseColorSingleChannelEnabled.setValue(m_key, newBaseColorSingleChannelEnabled);
++ emit baseColorSingleChannelEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::specularSingleChannelEnabled() const
++ {
++ return m_properties.m_specularSingleChannelEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularSingleChannelEnabled(bool newSpecularSingleChannelEnabled)
++ {
++ if (specularSingleChannelEnabled() == newSpecularSingleChannelEnabled)
++ return;
++ m_properties.m_specularSingleChannelEnabled.setValue(m_key, newSpecularSingleChannelEnabled);
++ emit specularSingleChannelEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::emissiveSingleChannelEnabled() const
++ {
++ return m_properties.m_emissiveSingleChannelEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setEmissiveSingleChannelEnabled(bool newEmissiveSingleChannelEnabled)
++ {
++ if (emissiveSingleChannelEnabled() == newEmissiveSingleChannelEnabled)
++ return;
++ m_properties.m_emissiveSingleChannelEnabled.setValue(m_key, newEmissiveSingleChannelEnabled);
++ emit emissiveSingleChannelEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::invertOpacityMapValue() const
++ {
++ return m_properties.m_invertOpacityMapValue.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setInvertOpacityMapValue(bool newInvertOpacityMapValue)
++ {
++ if (invertOpacityMapValue() == newInvertOpacityMapValue)
++ return;
++ m_properties.m_invertOpacityMapValue.setValue(m_key, newInvertOpacityMapValue);
++ emit invertOpacityMapValueChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::vertexColorsEnabled() const
++ {
++ return m_properties.m_vertexColorsEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorsEnabled(bool newVertexColorsEnabled)
++ {
++ if (vertexColorsEnabled() == newVertexColorsEnabled)
++ return;
++ m_properties.m_vertexColorsEnabled.setValue(m_key, newVertexColorsEnabled);
++ emit vertexColorsEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::vertexColorsMaskEnabled() const
++ {
++ return m_properties.m_vertexColorsMaskEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorsMaskEnabled(bool newVertexColorsMaskEnabled)
++ {
++ if (vertexColorsMaskEnabled() == newVertexColorsMaskEnabled)
++ return;
++ m_properties.m_vertexColorsMaskEnabled.setValue(m_key, newVertexColorsMaskEnabled);
++ emit vertexColorsMaskEnabledChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::vertexColorRedMask() const
++ {
++ return m_properties.m_vertexColorRedMask.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorRedMask(quint16 newVertexColorRedMask)
++ {
++ if (vertexColorRedMask() == newVertexColorRedMask)
++ return;
++ m_properties.m_vertexColorRedMask.setValue(m_key, newVertexColorRedMask);
++ emit vertexColorRedMaskChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::vertexColorGreenMask() const
++ {
++ return m_properties.m_vertexColorGreenMask.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorGreenMask(quint16 newVertexColorGreenMask)
++ {
++ if (vertexColorGreenMask() == newVertexColorGreenMask)
++ return;
++ m_properties.m_vertexColorGreenMask.setValue(m_key, newVertexColorGreenMask);
++ emit vertexColorGreenMaskChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::vertexColorBlueMask() const
++ {
++ return m_properties.m_vertexColorBlueMask.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorBlueMask(quint16 newVertexColorBlueMask)
++ {
++ if (vertexColorBlueMask() == newVertexColorBlueMask)
++ return;
++ m_properties.m_vertexColorBlueMask.setValue(m_key, newVertexColorBlueMask);
++ emit vertexColorBlueMaskChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::vertexColorAlphaMask() const
++ {
++ return m_properties.m_vertexColorAlphaMask.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexColorAlphaMask(quint16 newVertexColorAlphaMask)
++ {
++ if (vertexColorAlphaMask() == newVertexColorAlphaMask)
++ return;
++ m_properties.m_vertexColorAlphaMask.setValue(m_key, newVertexColorAlphaMask);
++ emit vertexColorAlphaMaskChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::boneCount() const
++ {
++ return m_properties.m_boneCount.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBoneCount(quint16 newBoneCount)
++ {
++ if (boneCount() == newBoneCount)
++ return;
++ m_properties.m_boneCount.setValue(m_key, newBoneCount);
++ emit boneCountChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::isDoubleSided() const
++ {
++ return m_properties.m_isDoubleSided.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setIsDoubleSided(bool newIsDoubleSided)
++ {
++ if (isDoubleSided() == newIsDoubleSided)
++ return;
++ m_properties.m_isDoubleSided.setValue(m_key, newIsDoubleSided);
++ emit isDoubleSidedChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::overridesPosition() const
++ {
++ return m_properties.m_overridesPosition.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOverridesPosition(bool newOverridesPosition)
++ {
++ if (overridesPosition() == newOverridesPosition)
++ return;
++ m_properties.m_overridesPosition.setValue(m_key, newOverridesPosition);
++ emit overridesPositionChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesProjectionMatrix() const
++ {
++ return m_properties.m_usesProjectionMatrix.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesProjectionMatrix(bool newUsesProjectionMatrix)
++ {
++ if (usesProjectionMatrix() == newUsesProjectionMatrix)
++ return;
++ m_properties.m_usesProjectionMatrix.setValue(m_key, newUsesProjectionMatrix);
++ emit usesProjectionMatrixChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesInverseProjectionMatrix() const
++ {
++ return m_properties.m_usesInverseProjectionMatrix.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesInverseProjectionMatrix(bool newUsesInverseProjectionMatrix)
++ {
++ if (usesInverseProjectionMatrix() == newUsesInverseProjectionMatrix)
++ return;
++ m_properties.m_usesInverseProjectionMatrix.setValue(m_key, newUsesInverseProjectionMatrix);
++ emit usesInverseProjectionMatrixChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesPointsTopology() const
++ {
++ return m_properties.m_usesPointsTopology.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesPointsTopology(bool newUsesPointsTopology)
++ {
++ if (usesPointsTopology() == newUsesPointsTopology)
++ return;
++ m_properties.m_usesPointsTopology.setValue(m_key, newUsesPointsTopology);
++ emit usesPointsTopologyChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesVarColor() const
++ {
++ return m_properties.m_usesVarColor.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesVarColor(bool newUsesVarColor)
++ {
++ if (usesVarColor() == newUsesVarColor)
++ return;
++ m_properties.m_usesVarColor.setValue(m_key, newUsesVarColor);
++ emit usesVarColorChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::alphaMode() const
++ {
++ return m_properties.m_alphaMode.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setAlphaMode(quint8 newAlphaMode)
++ {
++ if (alphaMode() == newAlphaMode)
++ return;
++ m_properties.m_alphaMode.setValue(m_key, newAlphaMode);
++ emit alphaModeChanged();
++ updated();
++ }
++
++ quint16 DefaultMaterialShaderProperties::vertexAttributes() const
++ {
++ return m_properties.m_vertexAttributes.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setVertexAttributes(quint16 newVertexAttributes)
++ {
++ if (vertexAttributes() == newVertexAttributes)
++ return;
++ m_properties.m_vertexAttributes.setValue(m_key, newVertexAttributes);
++ emit vertexAttributesChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesFloatJointIndices() const
++ {
++ return m_properties.m_usesFloatJointIndices.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesFloatJointIndices(bool newUsesFloatJointIndices)
++ {
++ if (usesFloatJointIndices() == newUsesFloatJointIndices)
++ return;
++ m_properties.m_usesFloatJointIndices.setValue(m_key, newUsesFloatJointIndices);
++ emit usesFloatJointIndicesChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesInstancing() const
++ {
++ return m_properties.m_usesInstancing.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesInstancing(bool newUsesInstancing)
++ {
++ if (usesInstancing() == newUsesInstancing)
++ return;
++ m_properties.m_usesInstancing.setValue(m_key, newUsesInstancing);
++ emit usesInstancingChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetCount() const
++ {
++ return m_properties.m_targetCount.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetCount(quint8 newTargetCount)
++ {
++ if (targetCount() == newTargetCount)
++ return;
++ m_properties.m_targetCount.setValue(m_key, newTargetCount);
++ emit targetCountChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetPositionOffset() const
++ {
++ return m_properties.m_targetPositionOffset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetPositionOffset(quint8 newTargetPositionOffset)
++ {
++ if (targetPositionOffset() == newTargetPositionOffset)
++ return;
++ m_properties.m_targetPositionOffset.setValue(m_key, newTargetPositionOffset);
++ emit targetPositionOffsetChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetTangentOffset() const
++ {
++ return m_properties.m_targetTangentOffset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetTangentOffset(quint8 newTargetTangentOffset)
++ {
++ if (targetTangentOffset() == newTargetTangentOffset)
++ return;
++ m_properties.m_targetTangentOffset.setValue(m_key, newTargetTangentOffset);
++ emit targetTangentOffsetChanged();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetNormalOffset() const
++ {
++ return m_properties.m_targetNormalOffset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetNormalOffset(quint8 newTargetNormalOffset)
++ {
++ if (targetNormalOffset() == newTargetNormalOffset)
++ return;
++ m_properties.m_targetNormalOffset.setValue(m_key, newTargetNormalOffset);
++ emit targetNormalOffsetChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetBinormalOffset() const
++ {
++ return m_properties.m_targetBinormalOffset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetBinormalOffset(quint8 newTargetBinormalOffset)
++ {
++ if (targetBinormalOffset() == newTargetBinormalOffset)
++ return;
++ m_properties.m_targetBinormalOffset.setValue(m_key, newTargetBinormalOffset);
++ emit targetBinormalOffsetChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetTexCoord0Offset() const
++ {
++ return m_properties.m_targetTexCoord0Offset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetTexCoord0Offset(quint8 newTargetTexCoord0Offset)
++ {
++ if (targetTexCoord0Offset() == newTargetTexCoord0Offset)
++ return;
++ m_properties.m_targetTexCoord0Offset.setValue(m_key, newTargetTexCoord0Offset);
++ emit targetTexCoord0OffsetChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetTexCoord1Offset() const
++ {
++ return m_properties.m_targetTexCoord1Offset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetTexCoord1Offset(quint8 newTargetTexCoord1Offset)
++ {
++ if (targetTexCoord1Offset() == newTargetTexCoord1Offset)
++ return;
++ m_properties.m_targetTexCoord1Offset.setValue(m_key, newTargetTexCoord1Offset);
++ emit targetTexCoord1OffsetChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::targetColorOffset() const
++ {
++ return m_properties.m_targetColorOffset.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTargetColorOffset(quint8 newTargetColorOffset)
++ {
++ if (targetColorOffset() == newTargetColorOffset)
++ return;
++ m_properties.m_targetColorOffset.setValue(m_key, newTargetColorOffset);
++ emit targetColorOffsetChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::blendParticles() const
++ {
++ return m_properties.m_blendParticles.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBlendParticles(bool newBlendParticles)
++ {
++ if (blendParticles() == newBlendParticles)
++ return;
++ m_properties.m_blendParticles.setValue(m_key, newBlendParticles);
++ emit blendParticlesChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::clearcoatEnabled() const
++ {
++ return m_properties.m_clearcoatEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatEnabled(bool newClearcoatEnabled)
++ {
++ if (clearcoatEnabled() == newClearcoatEnabled)
++ return;
++ m_properties.m_clearcoatEnabled.setValue(m_key, newClearcoatEnabled);
++ emit clearcoatEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::transmissionEnabled() const
++ {
++ return m_properties.m_transmissionEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTransmissionEnabled(bool newTransmissionEnabled)
++ {
++ if (transmissionEnabled() == newTransmissionEnabled)
++ return;
++ m_properties.m_transmissionEnabled.setValue(m_key, newTransmissionEnabled);
++ emit transmissionEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::specularAAEnabled() const
++ {
++ return m_properties.m_specularAAEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularAAEnabled(bool newSpecularAAEnabled)
++ {
++ if (specularAAEnabled() == newSpecularAAEnabled)
++ return;
++ m_properties.m_specularAAEnabled.setValue(m_key, newSpecularAAEnabled);
++ emit specularAAEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::lightmapEnabled() const
++ {
++ return m_properties.m_lightmapEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setLightmapEnabled(bool newLightmapEnabled)
++ {
++ if (lightmapEnabled() == newLightmapEnabled)
++ return;
++ m_properties.m_lightmapEnabled.setValue(m_key, newLightmapEnabled);
++ emit lightmapEnabledChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::debugMode() const
++ {
++ return m_properties.m_debugMode.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setDebugMode(quint8 newDebugMode)
++ {
++ if (debugMode() == newDebugMode)
++ return;
++ m_properties.m_debugMode.setValue(m_key, newDebugMode);
++ emit debugModeChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::fogEnabled() const
++ {
++ return m_properties.m_fogEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setFogEnabled(bool newFogEnabled)
++ {
++ if (fogEnabled() == newFogEnabled)
++ return;
++ m_properties.m_fogEnabled.setValue(m_key, newFogEnabled);
++ emit fogEnabledChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::viewCount() const
++ {
++ return m_properties.m_viewCount.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setViewCount(quint8 newViewCount)
++ {
++ if (viewCount() == newViewCount)
++ return;
++ m_properties.m_viewCount.setValue(m_key, newViewCount);
++ emit viewCountChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::usesViewIndex() const
++ {
++ return m_properties.m_usesViewIndex.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setUsesViewIndex(bool newUsesViewIndex)
++ {
++ if (usesViewIndex() == newUsesViewIndex)
++ return;
++ m_properties.m_usesViewIndex.setValue(m_key, newUsesViewIndex);
++ emit usesViewIndexChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::orderIndependentTransparency() const
++ {
++ return m_properties.m_orderIndependentTransparency.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOrderIndependentTransparency(quint8 newOrderIndependentTransparency)
++ {
++ if (orderIndependentTransparency() == newOrderIndependentTransparency)
++ return;
++ m_properties.m_orderIndependentTransparency.setValue(m_key, newOrderIndependentTransparency);
++ emit orderIndependentTransparencyChanged();
++ updated();
++ }
++
++ void DefaultMaterialShaderProperties::updated()
++ {
++ emit shaderKeyUpdated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::diffuseMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::DiffuseMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setDiffuseMap(quint8 newDiffuseMap)
++ {
++ if (diffuseMap() == newDiffuseMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::DiffuseMap].setValue(m_key, newDiffuseMap);
++ emit diffuseMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::emissiveMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::EmissiveMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setEmissiveMap(quint8 newEmissiveMap)
++ {
++ if (emissiveMap() == newEmissiveMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::EmissiveMap].setValue(m_key, newEmissiveMap);
++ emit emissiveMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::specularMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::SpecularMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularMap(quint8 newSpecularMap)
++ {
++ if (specularMap() == newSpecularMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::SpecularMap].setValue(m_key, newSpecularMap);
++ emit specularMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::baseColorMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::BaseColorMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBaseColorMap(quint8 newBaseColorMap)
++ {
++ if (baseColorMap() == newBaseColorMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::BaseColorMap].setValue(m_key, newBaseColorMap);
++ emit baseColorMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::bumpMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::BumpMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBumpMap(quint8 newBumpMap)
++ {
++ if (bumpMap() == newBumpMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::BumpMap].setValue(m_key, newBumpMap);
++ emit bumpMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::specularAmountMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::SpecularAmountMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularAmountMap(quint8 newSpecularAmountMap)
++ {
++ if (specularAmountMap() == newSpecularAmountMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::SpecularAmountMap].setValue(m_key, newSpecularAmountMap);
++ emit specularAmountMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::normalMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::NormalMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setNormalMap(quint8 newNormalMap)
++ {
++ if (normalMap() == newNormalMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::NormalMap].setValue(m_key, newNormalMap);
++ emit normalMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::clearcoatNormalMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatNormalMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatNormalMap(quint8 newClearcoatNormalMap)
++ {
++ if (clearcoatNormalMap() == newClearcoatNormalMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatNormalMap].setValue(m_key, newClearcoatNormalMap);
++ emit clearcoatNormalMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::opacityMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::OpacityMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOpacityMap(quint8 newOpacityMap)
++ {
++ if (opacityMap() == newOpacityMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::OpacityMap].setValue(m_key, newOpacityMap);
++ emit opacityMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::roughnessMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::RoughnessMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setRoughnessMap(quint8 newRoughnessMap)
++ {
++ if (roughnessMap() == newRoughnessMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::RoughnessMap].setValue(m_key, newRoughnessMap);
++ emit roughnessMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::metalnessMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::MetalnessMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setMetalnessMap(quint8 newMetalnessMap)
++ {
++ if (metalnessMap() == newMetalnessMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::MetalnessMap].setValue(m_key, newMetalnessMap);
++ emit metalnessMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::occlusionMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::OcclusionMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOcclusionMap(quint8 newOcclusionMap)
++ {
++ if (occlusionMap() == newOcclusionMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::OcclusionMap].setValue(m_key, newOcclusionMap);
++ emit occlusionMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::translucencyMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::TranslucencyMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTranslucencyMap(quint8 newTranslucencyMap)
++ {
++ if (translucencyMap() == newTranslucencyMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::TranslucencyMap].setValue(m_key, newTranslucencyMap);
++ emit translucencyMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::heightMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::HeightMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHeightMap(quint8 newHeightMap)
++ {
++ if (heightMap() == newHeightMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::HeightMap].setValue(m_key, newHeightMap);
++ emit heightMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::clearcoatMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatMap(quint8 newClearcoatMap)
++ {
++ if (clearcoatMap() == newClearcoatMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatMap].setValue(m_key, newClearcoatMap);
++ emit clearcoatMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::clearcoatRoughnessMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatRoughnessMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatRoughnessMap(quint8 newClearcoatRoughnessMap)
++ {
++ if (clearcoatRoughnessMap() == newClearcoatRoughnessMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ClearcoatRoughnessMap].setValue(m_key, newClearcoatRoughnessMap);
++ emit clearcoatRoughnessMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::transmissionMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::TransmissionMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTransmissionMap(quint8 newTransmissionMap)
++ {
++ if (transmissionMap() == newTransmissionMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::TransmissionMap].setValue(m_key, newTransmissionMap);
++ emit transmissionMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::thicknessMap() const
++ {
++ return m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ThicknessMap].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setThicknessMap(quint8 newThicknessMap)
++ {
++ if (thicknessMap() == newThicknessMap)
++ return;
++ m_properties.m_imageMaps[QSSGShaderDefaultMaterialKeyProperties::ThicknessMap].setValue(m_key, newThicknessMap);
++ emit thicknessMapChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::roughnessChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::RoughnessChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setRoughnessChannel(quint8 newRoughnessChannel)
++ {
++ if (roughnessChannel() == newRoughnessChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::RoughnessChannel].setValue(m_key, newRoughnessChannel);
++ emit roughnessChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::metalnessChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::MetalnessChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setMetalnessChannel(quint8 newMetalnessChannel)
++ {
++ if (metalnessChannel() == newMetalnessChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::MetalnessChannel].setValue(m_key, newMetalnessChannel);
++ emit metalnessChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::occlusionChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::OcclusionChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOcclusionChannel(quint8 newOcclusionChannel)
++ {
++ if (occlusionChannel() == newOcclusionChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::OcclusionChannel].setValue(m_key, newOcclusionChannel);
++ emit occlusionChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::translucencyChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::TranslucencyChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTranslucencyChannel(quint8 newTranslucencyChannel)
++ {
++ if (translucencyChannel() == newTranslucencyChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::TranslucencyChannel].setValue(m_key, newTranslucencyChannel);
++ emit translucencyChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::heightChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::HeightChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHeightChannel(quint8 newHeightChannel)
++ {
++ if (heightChannel() == newHeightChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::HeightChannel].setValue(m_key, newHeightChannel);
++ emit heightChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::clearcoatChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ClearcoatChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatChannel(quint8 newClearcoatChannel)
++ {
++ if (clearcoatChannel() == newClearcoatChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ClearcoatChannel].setValue(m_key, newClearcoatChannel);
++ emit clearcoatChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::clearcoatRoughnessChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ClearcoatRoughnessChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setClearcoatRoughnessChannel(quint8 newClearcoatRoughnessChannel)
++ {
++ if (clearcoatRoughnessChannel() == newClearcoatRoughnessChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ClearcoatRoughnessChannel].setValue(m_key, newClearcoatRoughnessChannel);
++ emit clearcoatRoughnessChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::transmissionChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::TransmissionChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setTransmissionChannel(quint8 newTransmissionChannel)
++ {
++ if (transmissionChannel() == newTransmissionChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::TransmissionChannel].setValue(m_key, newTransmissionChannel);
++ emit transmissionChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::thicknessChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ThicknessChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setThicknessChannel(quint8 newThicknessChannel)
++ {
++ if (thicknessChannel() == newThicknessChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::ThicknessChannel].setValue(m_key, newThicknessChannel);
++ emit thicknessChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::baseColorChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::BaseColorChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setBaseColorChannel(quint8 newBaseColorChannel)
++ {
++ if (baseColorChannel() == newBaseColorChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::BaseColorChannel].setValue(m_key, newBaseColorChannel);
++ emit baseColorChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::specularAmountChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::SpecularAmountChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularAmountChannel(quint8 newSpecularAmountChannel)
++ {
++ if (specularAmountChannel() == newSpecularAmountChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::SpecularAmountChannel].setValue(m_key, newSpecularAmountChannel);
++ emit specularAmountChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::emissiveChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::EmissiveChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setEmissiveChannel(quint8 newEmissiveChannel)
++ {
++ if (emissiveChannel() == newEmissiveChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::EmissiveChannel].setValue(m_key, newEmissiveChannel);
++ emit emissiveChannelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::opacityChannel() const
++ {
++ return m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::OpacityChannel].getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setOpacityChannel(quint8 newOpacityChannel)
++ {
++ if (opacityChannel() == newOpacityChannel)
++ return;
++ m_properties.m_textureChannels[QSSGShaderDefaultMaterialKeyProperties::OpacityChannel].setValue(m_key, newOpacityChannel);
++ emit opacityChannelChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::hasPunctualLights() const
++ {
++ return m_properties.m_hasPunctualLights.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHasPunctualLights(bool newHasPunctualLights)
++ {
++ if (hasPunctualLights() == newHasPunctualLights)
++ return;
++
++ m_properties.m_hasPunctualLights.setValue(m_key, newHasPunctualLights);
++ emit hasPunctualLightsChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::hasShadows() const
++ {
++ return m_properties.m_hasShadows.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setHasShadows(bool newHasShadows)
++ {
++ if (hasShadows() == newHasShadows)
++ return;
++
++ m_properties.m_hasShadows.setValue(m_key, newHasShadows);
++ emit hasShadowsChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::specularEnabled() const
++ {
++ return m_properties.m_specularEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularEnabled(bool newSpecularEnabled)
++ {
++ if (specularEnabled() == newSpecularEnabled)
++ return;
++
++ m_properties.m_specularEnabled.setValue(m_key, newSpecularEnabled);
++ emit specularEnabledChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::specularModel() const
++ {
++ return m_properties.m_specularModel.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularModel(quint8 newSpecularModel)
++ {
++ if (specularModel() == newSpecularModel)
++ return;
++ m_properties.m_specularModel.setValue(m_key, newSpecularModel);
++ emit specularModelChanged();
++ updated();
++ }
++
++ quint8 DefaultMaterialShaderProperties::diffuseModel() const
++ {
++ return m_properties.m_diffuseModel.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setDiffuseModel(quint8 newDiffuseModel)
++ {
++ if (diffuseModel() == newDiffuseModel)
++ return;
++ m_properties.m_diffuseModel.setValue(m_key, newDiffuseModel);
++ emit diffuseModelChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::specularGlossyEnabled() const
++ {
++ return m_properties.m_specularGlossyEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setSpecularGlossyEnabled(bool newSpecularGlossyEnabled)
++ {
++ if (specularGlossyEnabled() == newSpecularGlossyEnabled)
++ return;
++ m_properties.m_specularGlossyEnabled.setValue(m_key, newSpecularGlossyEnabled);
++ emit specularGlossyEnabledChanged();
++ updated();
++ }
++
++ bool DefaultMaterialShaderProperties::metallicRoughnessEnabled() const
++ {
++ return m_properties.m_metallicRoughnessEnabled.getValue(m_key);
++ }
++
++ void DefaultMaterialShaderProperties::setMetallicRoughnessEnabled(bool newMetallicRoughnessEnabled)
++ {
++ if (metallicRoughnessEnabled() == newMetallicRoughnessEnabled)
++ return;
++ m_properties.m_metallicRoughnessEnabled.setValue(m_key, newMetallicRoughnessEnabled);
++ emit metallicRoughnessEnabledChanged();
++ updated();
++ }