Revision control
++ // Copyright (C) 2022 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++
++ #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
++
++ /*!
++ \qmltype SpecularGlossyMaterial
++ \inherits Material
++ \inqmlmodule QtQuick3D
++ \brief Lets you define a material for 3D items using the specular/glossiness workflow.
++
++ Before a Model can be rendered in a scene, it must have at least one material attached
++ to it that describes how the mesh should be shaded. The SpecularGlossyMaterial is a PBR
++ specular/glossiness material that aims at being an easy to use material with a minimal
++ set of parameters.
++ In addition to having few parameters, all input values are strictly normalized
++ between 0 and 1 and have sensible defaults, meaning even without changing any values,
++ the material can be used to shader a model. For an introduction on how the
++ different properties of the SpecularGlossyMaterial affects how a model is shaded,
++ see the \l{Qt Quick 3D - Principled Material Example}{Principled Material example} which
++ provides a mode for using the Specular/Glossy workflow.
++
++ Alternatively to use the metallic/roughness workflow instead use \l {PrincipledMaterial}.
++
++ \section1 Specular/Glossiness workflow
++
++ The SpecularGlossyMaterial provides a way to create materials using a specular/glossiness
++ type workflow. The main properties of the material is controlled through
++ the \l {SpecularGlossyMaterial::specularMap} {specular},
++ \l {SpecularGlossyMaterial::glossinessMap} {glossiness},
++ and \l {SpecularGlossyMaterial::albedoMap} {albedo} properties.
++
++ \section2 Specular
++
++ The \l {SpecularGlossyMaterial::specularMap} {specularColor} property describes the specular
++ amount and color of an object's surface. For reflective materials the main color
++ contribution, comes from this property.
++
++ \section2 Glossiness
++
++ The \l {SpecularGlossyMaterial::glossinessMap} {glossiness} of a material describes the
++ condition of an object's surface. A high \c glossiness value means the object has a smooth
++ surface and therefore be more reflective then a material with a lower \c glossiness value.
++
++ \section2 Albedo
++
++ The \l {SpecularGlossyMaterial::albedoMap} {albedoColor} property describes the diffuse color
++ of the material, and unlike the \l {PrincipledMaterial}'s base color, the albedo
++ does not contain any information about the material reflectance. That means that for
++ reflective surfaces the albedo's color value should be set to a black tint, as that
++ will allow for the specular color to contribute.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::lighting
++
++ This property defines which lighting method is used when generating this
++ material.
++
++ The default value is \c SpecularGlossyMaterial.FragmentLighting
++
++ \value SpecularGlossyMaterial.FragmentLighting Diffuse and specular lighting is
++ calculated for each rendered pixel. Certain effects (such as a Fresnel or normal map) require
++ \c SpecularGlossyMaterial.FragmentLighting to work.
++
++ \value SpecularGlossyMaterial.NoLighting No lighting is calculated. This
++ mode is (predictably) very fast, and is quite effective when image maps are
++ used that you do not need to be shaded by lighting. All other shading
++ properties except albedo values, alpha values, and vertex colors will be
++ ignored.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::blendMode
++
++ This property determines how the colors of the model rendered blends with
++ those behind it.
++
++ \value SpecularGlossyMaterial.SourceOver Default blend mode. Opaque objects
++ occlude objects behind them. This default mode does not guarantee alpha
++ blending in the rendering pipeline on its own for models that use this
++ material, but rather makes the decision dependent on a number of factors:
++ if the object's and material's total opacity is \c{1.0}, there is no
++ opacity map in the material, and \l alphaMode is not set to a value that
++ enforces alpha blending, then the model is treated as opaque, meaning it is
++ rendered with depth testing and depth write enabled, together with other
++ opaque objects, with blending disabled. Otherwise the model is treated as
++ semi-transparent, and is rendered after the opaque objects, together with
++ other semi-transparent objects in a back-to-front order based on their
++ center's distance from the camera, with alpha blending enabled.
++
++ \value SpecularGlossyMaterial.Screen Colors are blended using an inverted
++ multiply, producing a lighter result. This blend mode is order-independent;
++ if you are using semi-opaque objects and experiencing 'popping' as faces or
++ models sort differently, using Screen blending is one way to produce
++ results without popping.
++
++ \value SpecularGlossyMaterial.Multiply Colors are blended using a multiply,
++ producing a darker result. This blend mode is also order-independent.
++
++ \sa alphaMode, {Qt Quick 3D Architecture}
++ */
++
++ /*!
++ \qmlproperty color SpecularGlossyMaterial::albedoColor
++
++ This property sets the albedo color for the material. Setting the
++ diffuse color to a black tint will create a purely-specular material
++ (e.g. metals or mirrors).
++
++ \sa albedoMap, alphaMode
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::albedoMap
++
++ This property defines the texture used to set the albedo color of the material.
++
++ \sa albedo, alphaMode
++ */
++
++ /*!
++ \qmlproperty bool SpecularGlossyMaterial::albedoSingleChannelEnabled
++ \since 6.8
++
++ When this property is enabled, the material will use the single value of the albedoChannel from
++ the albedoMap as RGB value and use 1.0 as alpha value.
++ The default value is false.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::albedoChannel
++ \since 6.8
++
++ This property defines the texture channel used to read the albedo color value from albedoMap.
++ In order to use a single texture channel as color you have to enable the albedoSingleChannelEnabled
++ The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty color SpecularGlossyMaterial::specularColor
++
++ This property defines the specular RGB color. If an alpha value is provided it
++ will be ignored.
++
++ The default value is \c Qt.White
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::specularMap
++
++ This property sets a Texture to be used to set the specular color for the
++ different parts of the material. Only the RGB channels are used.
++ */
++
++ /*!
++ \qmlproperty bool SpecularGlossyMaterial::specularSingleChannelEnabled
++ \since 6.8
++
++ When this property is enabled, the material will use the single value of the specularChannel from
++ the specularMap as RGB value.
++ The default value is false.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::specularChannel
++ \since 6.8
++
++ This property defines the texture channel used to read the specular color value from specularMap.
++ In order to use a single texture channel as color you have to enable the specularSingleChannelEnabled
++ The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::glossiness
++
++ This property controls the size of the specular highlight generated from
++ lights, and the clarity of reflections in general. Smaller values increase
++ the roughness, softening specular highlights and blurring reflections.
++ The range is [0.0, 1.0]. The default value is \c 1.0.
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::glossinessMap
++
++ This property defines a Texture to control the glossiness of the
++ material.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::glossinessChannel
++
++ This property defines the texture channel used to read the glossiness value
++ from glossinessMap.
++ The default value is \c Material.A.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty bool SpecularGlossyMaterial::emissiveSingleChannelEnabled
++ \since 6.8
++
++ When this property is enabled, the material will use the single value of the emissiveChannel from
++ the emissiveMap as RGB value.
++ The default value is false.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::emissiveChannel
++ \since 6.8
++
++ This property defines the texture channel used to read the emissive color value from emissiveMap.
++ In order to use a single texture channel as color you have to enable the emissiveSingleChannelEnabled
++ The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::emissiveMap
++
++ This property sets a RGB Texture to be used to specify the intensity of the
++ emissive color.
++ */
++
++ /*!
++ \qmlproperty vector3d SpecularGlossyMaterial::emissiveFactor
++
++ This property determines the color of self-illumination for this material.
++ If an emissive map is set, the x, y, and z components are used as factors
++ (multipliers) for the R, G and B channels of the texture, respectively.
++ The default value is (0, 0, 0) and it means no emissive contribution at all.
++
++ \note Setting the lightingMode to DefaultMaterial.NoLighting means emissive
++ Factor does not have an effect on the scene.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::opacity
++
++ This property drops the opacity of just this material, separate from the
++ model.
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::opacityMap
++
++ This property defines a Texture used to control the opacity differently for
++ different parts of the material.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::invertOpacityMapValue
++ \since 6.8
++
++ This property inverts the opacity value of the opacityMap.
++ The default value is \c false.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::opacityChannel
++
++ This property defines the texture channel used to read the opacity value from opacityMap.
++ The default value is \c Material.A.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::normalMap
++
++ This property defines an RGB image used to simulate fine geometry
++ displacement across the surface of the material. The RGB channels indicate
++ XYZ normal deviations.
++
++ \note Normal maps will not affect the silhouette of a model.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::normalStrength
++
++ This property controls the amount of simulated displacement for the normalMap.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::occlusionAmount
++
++ This property contains the factor used to modify the values from the \l occlusionMap texture.
++ The value should be between 0.0 to 1.0. The default is 1.0
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::occlusionMap
++
++ This property defines a texture used to determine how much indirect light the different areas of the
++ material should receive. Values are expected to be linear from 0.0 to 1.0, where 0.0 means no indirect lighting
++ and 1.0 means the effect of the indirect lighting is left unchanged.
++
++ \sa occlusionAmount
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::occlusionChannel
++
++ This property defines the texture channel used to read the occlusion value from occlusionMap.
++ The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::alphaMode
++
++ This property specifies how the alpha color value from \l albedoColor and the
++ alpha channel of a \l{albedoMap}{albedo map} are used.
++
++ \note The alpha cutoff test only considers the albedo color alpha. \l opacity
++ and \l [QtQuick3D] {Node::opacity} are not taken into account there.
++
++ \note When sampling an albedo color map, the effective alpha value is the
++ sampled alpha multiplied by the \l albedoColor alpha.
++
++ \value SpecularGlossyMaterial.Default No test is applied, the effective alpha
++ value is passed on as-is. Note that a \l albedoColor or \l albedoMap alpha
++ less than \c 1.0 does not automatically imply alpha blending, the object
++ with the material may still be treated as opaque, if no other relevant
++ properties (such as, an opacity less than 1, the presence of an opacity
++ map, or a non-default \l blendMode value) trigger treating the object as
++ semi-transparent. To ensure alpha blending happens regardless of any other
++ object or material property, set \c Blend instead.
++
++ \value SpecularGlossyMaterial.Blend No cutoff test is applied, but guarantees
++ that alpha blending happens. The object with this material will therefore
++ never be treated as opaque by the renderer.
++
++ \value SpecularGlossyMaterial.Opaque No cutoff test is applied and the rendered
++ object is assumed to be fully opaque, meaning the alpha values in the
++ vertex color, albedo color, and albedo color map are ignored and a value of 1.0
++ is substituted instead. This mode does not guarantee alpha blending does
++ not happen. If relevant properties (such as, an opacity less than 1, an
++ opacity map, or a non-default \l blendMode) say so, then the object will
++ still be treated as semi-transparent by the rendering pipeline, just like
++ with the \c Default alphaMode.
++
++ \value SpecularGlossyMaterial.Mask A test based on \l alphaCutoff is applied.
++ If the effective alpha value falls below \l alphaCutoff, the fragment is
++ changed to fully transparent and is discarded (with all implications of
++ discarding: the depth buffer is not written for that fragment). Otherwise
++ the alpha is changed to 1.0, so that the fragment will become fully opaque.
++ When it comes to alpha blending, the behavior of this mode is identical to
++ \c Opaque, regardless of the cutoff test's result. This means that the
++ 2 spec's alpha coverage} Implementation Notes are fulfilled. Objects with
++ alpha cutoff tests can also cast shadows since they behave like opaque
++ objects by default, unless the relevant properties (such as, an opacity
++ less than 1, an opacity map, or a non-default \l blendMode) imply otherwise
++ (in which case casting shadows will not be possible).
++
++ \sa alphaCutoff, blendMode
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::alphaCutoff
++
++ The alphaCutoff property can be used to specify the cutoff value when using
++ the \l{alphaMode}{Mask alphaMode}. Fragments where the alpha value falls
++ below the threshold will be rendered fully transparent (\c{0.0} for all
++ color channels). When the alpha value is equal or greater than the cutoff
++ value, the color will not be affected in any way.
++
++ The default value is 0.5.
++
++ \sa alphaMode
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::pointSize
++
++ This property determines the size of the points rendered, when the geometry
++ is using a primitive type of points. The default value is 1.0. This
++ property is not relevant when rendering other types of geometry, such as,
++ triangle meshes.
++
++ \warning Point sizes other than 1 may not be supported at run time,
++ depending on the underyling graphics API. For example, setting a size other
++ than 1 has no effect with Direct 3D.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::lineWidth
++
++ This property determines the width of the lines rendered, when the geometry
++ is using a primitive type of lines or line strips. The default value is
++ 1.0. This property is not relevant when rendering other types of geometry,
++ such as, triangle meshes.
++
++ \warning Line widths other than 1 may not be suported at run time,
++ depending on the underlying graphics API. When that is the case, the
++ request to change the width is ignored. For example, none of the following
++ can be expected to support wide lines: Direct3D, Metal, OpenGL with core
++ profile contexts.
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::heightMap
++
++ This property defines a texture used to determine the height the texture
++ will be displaced when rendered through the use of Parallax Mapping. Values
++ are expected to be linear from 0.0 to 1.0, where 0.0 means no displacement
++ and 1.0 means means maximum displacement.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::heightChannel
++
++ This property defines the texture channel used to read the height value
++ from heightMap. The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::heightAmount
++
++ This property contains the factor used to modify the values from the
++ \l heightMap texture. The value should be between 0.0 to 1.0. The default
++ value is 0.0 which means that height displacement will be disabled, even
++ if a height map set.
++ */
++
++ /*!
++ \qmlproperty int SpecularGlossyMaterial::minHeightMapSamples
++
++ This property defines the minimum number of samples used for performing
++ Parallex Occlusion Mapping using the \l heightMap. The minHeightMapSamples
++ value is the number of samples of the heightMap are used when looking directly
++ at a surface (when the camera view is perpendicular to the fragment).
++ The default value is 8.
++
++ The actual number of samples used for each fragment will be between
++ \l minHeightMapSamples and \l maxHeightMapSamples depending on the angle of
++ the camera relative to the surface being rendered.
++
++ \note This value should only be adjusted to fine tune materials using a
++ \l heightMap in the case undesired artifacts are present.
++ */
++
++ /*!
++ \qmlproperty int SpecularGlossyMaterial::maxHeightMapSamples
++
++ This property defines the maximum number of samples used for performing
++ Parallex Occlusion Mapping using the \l heightMap. The maxHeightMapSamples
++ value is the number of samples of the heightMap are used when looking
++ parallel to a surface.
++ The default value is 32.
++
++ The actual number of samples used for each fragment will be between
++ \l minHeightMapSamples and \l maxHeightMapSamples depending on the angle of
++ the camera relative to the surface being rendered.
++
++ \note This value should only be adjusted to fine tune materials using a
++ \l heightMap in the case undesired artifacts are present.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatAmount
++
++ This property defines the intensity of the clearcoat layer.
++
++ The default value is \c 0.0
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::clearcoatMap
++
++ This property defines a texture used to determine the intensity of the
++ clearcoat layer. The value of\l clearcoatAmount will be multiplied by
++ the value read from this texture.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::clearcoatChannel
++
++ This property defines the texture channel used to read the clearcoat amount
++ value from \l clearcoatMap. The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatRoughnessAmount
++
++ This property defines the roughness of the clearcoat layer.
++ The default value is \c 0.0
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::clearcoatRoughnessMap
++
++ This property defines a texture used to determine the roughness of the
++ clearcoat layer. The value of\l clearcoatRoughnessAmount will be
++ multiplied by the value read from this texture.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::clearcoatRoughnessChannel
++
++ This property defines the texture channel used to read the clearcoat
++ roughness amount from \l clearcoatRoughnessMap.
++ The default value is \c Material.G.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::clearcoatNormalMap
++
++ This property defines a texture used to determine the normal mapping
++ applied to the clearcoat layer.
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::transmissionFactor
++
++ This property defines the percentage of light that is transmitted through
++ the material's surface.
++ The default value is \c 0.0
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::transmissionMap
++
++ This property defines a texture used to determine percentage of light that
++ is transmitted through the surface.. The value of
++ \l transmissionFactor will be multiplied by the value read from this
++ texture.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::transmissionChannel
++
++ This property defines the texture channel used to read the transmission
++ percentage from \l transmissionMap.
++ The default value is \c Material.R.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::thicknessFactor
++
++ This property defines the thickness of the volume beneath the surface.
++ Unlike many other properties of SpecularGlossyMaterial, the value in defined
++ in thicknessFactor is a value from 0.0 to +infinity for thickness in the
++ models coordinate space. A value of 0.0 means that the material is
++ thin-walled.
++ The default value is \c 0.0
++ */
++
++ /*!
++ \qmlproperty Texture SpecularGlossyMaterial::thicknessMap
++
++ This property defines a texture used to define the thickness of a
++ material volume. The value of \l thicknessFactor will be multiplied by the
++ value read from this texture.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::thicknessChannel
++
++ This property defines the texture channel used to read the thickness
++ amount from \l transmissionMap.
++ The default value is \c Material.G.
++
++ \value Material.R Read value from texture R channel.
++ \value Material.G Read value from texture G channel.
++ \value Material.B Read value from texture B channel.
++ \value Material.A Read value from texture A channel.
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::attenuationDistance
++
++ This property defines the Density of the medium given as the average
++ distance that light travels in the medium before interacting with a
++ particle. The value is given in world space.
++ The default value is \c +infinity.
++ */
++
++ /*!
++ \qmlproperty color SpecularGlossyMaterial::attenuationColor
++
++ This property defines the color that white lights turns into due to
++ absorption when reaching the attenuation distance.
++ The default value is \c Qt.White
++
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::fresnelScaleBiasEnabled
++
++ By Setting the value to true the material will take Fresnel Scale and Fresnel Bias into account.
++ The default value is \c false.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::fresnelScale
++
++ This property scale head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ In order to affect changes to the material you have to enable fresnelScaleBiasEnabled.
++ The default value is \c 1.0.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::fresnelBias
++
++ This property push forward head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ In order to affect changes to the material you have to enable fresnelScaleBiasEnabled.
++ The default value is \c 0.0.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::fresnelPower
++
++ This property decreases head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ The default value is \c 5.0.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatFresnelScaleBiasEnabled
++
++ By Setting the value to true the material will take Clearcoat Fresnel Scale and Clearcoat Fresnel Bias into account.
++ The default value is \c false.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatFresnelScale
++
++ This property scale head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ In order to affect changes to the material you have to enable clearcoatFresnelScaleBiasEnabled.
++ The default value is \c 1.0.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatFresnelBias
++
++ This property push forward head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ In order to affect changes to the material you have to enable clearcoatFresnelScaleBiasEnabled.
++ The default value is \c 0.0.
++ */
++
++ /*!
++ \qmlproperty real SpecularGlossyMaterial::clearcoatFresnelPower
++
++ This property decreases head-on reflections (looking directly at the
++ surface) while maintaining reflections seen at grazing angles.
++ The default value is \c 5.0.
++ */
++
++ /*!
++ \qmlproperty bool SpecularGlossyMaterial::vertexColorsEnabled
++ \since 6.5
++
++ When this property is enabled, the material will use vertex colors from the
++ mesh. These will be multiplied by any other colors specified for the
++ material. The default value is true.
++ */
++
++ /*!
++ \qmlproperty bool SpecularGlossyMaterial::vertexColorsMaskEnabled
++ \since 6.8
++
++ When this property is enabled, the material will use vertex colors from the
++ mesh as mask of various properties e.g Glossiness, OcclusionAmount, ... .
++ The default value is false.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::vertexColorRedMask
++ \since 6.8
++
++ This property defines the vertex color red channel used as the specifies mask.
++ The value is a bit-wise combination of flags.
++ The default value is \c SpecularGlossyMaterial.NoMask.
++
++ \value SpecularGlossyMaterial.NoMask.
++ \value SpecularGlossyMaterial.GlossinessMask.
++ \value SpecularGlossyMaterial.NormalStrengthMask.
++ \value SpecularGlossyMaterial.ClearcoatAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatRoughnessAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatNormalStrengthMask.
++ \value SpecularGlossyMaterial.HeightAmountMask.
++ \value SpecularGlossyMaterial.OcclusionAmountMask.
++ \value SpecularGlossyMaterial.ThicknessFactorMask.
++ \value SpecularGlossyMaterial.TransmissionFactorMask.
++
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::vertexColorGreenMask
++ \since 6.8
++
++ This property defines the vertex color green channel used as the specifies mask.
++ The value is a bit-wise combination of flags.
++ The default value is \c SpecularGlossyMaterial.NoMask.
++
++ \value SpecularGlossyMaterial.NoMask.
++ \value SpecularGlossyMaterial.GlossinessMask.
++ \value SpecularGlossyMaterial.NormalStrengthMask.
++ \value SpecularGlossyMaterial.ClearcoatAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatRoughnessAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatNormalStrengthMask.
++ \value SpecularGlossyMaterial.HeightAmountMask.
++ \value SpecularGlossyMaterial.OcclusionAmountMask.
++ \value SpecularGlossyMaterial.ThicknessFactorMask.
++ \value SpecularGlossyMaterial.TransmissionFactorMask.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::vertexColorBlueMask
++ \since 6.8
++
++ This property defines the vertex color blue channel used as the specifies mask.
++ The value is a bit-wise combination of flags.
++ The default value is \c SpecularGlossyMaterial.NoMask.
++
++ \value SpecularGlossyMaterial.NoMask.
++ \value SpecularGlossyMaterial.GlossinessMask.
++ \value SpecularGlossyMaterial.NormalStrengthMask.
++ \value SpecularGlossyMaterial.ClearcoatAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatRoughnessAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatNormalStrengthMask.
++ \value SpecularGlossyMaterial.HeightAmountMask.
++ \value SpecularGlossyMaterial.OcclusionAmountMask.
++ \value SpecularGlossyMaterial.ThicknessFactorMask.
++ \value SpecularGlossyMaterial.TransmissionFactorMask.
++ */
++
++ /*!
++ \qmlproperty enumeration SpecularGlossyMaterial::vertexColorAlphaMask
++ \since 6.8
++
++ This property defines the vertex color alpha channel used as the specifies mask.
++ The value is a bit-wise combination of flags.
++ The default value is \c SpecularGlossyMaterial.NoMask.
++
++ \value SpecularGlossyMaterial.NoMask.
++ \value SpecularGlossyMaterial.GlossinessMask.
++ \value SpecularGlossyMaterial.NormalStrengthMask.
++ \value SpecularGlossyMaterial.ClearcoatAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatRoughnessAmountMask.
++ \value SpecularGlossyMaterial.ClearcoatNormalStrengthMask.
++ \value SpecularGlossyMaterial.HeightAmountMask.
++ \value SpecularGlossyMaterial.OcclusionAmountMask.
++ \value SpecularGlossyMaterial.ThicknessFactorMask.
++ \value SpecularGlossyMaterial.TransmissionFactorMask.
++ */
++
++ 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;
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::albedoSingleChannelEnabled() const
++ {
++ return m_albedoSingleChannelEnabled;
++ }
++
++ QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::albedoChannel() const
++ {
++ return m_albedoChannel;
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::specularSingleChannelEnabled() const
++ {
++ return m_specularSingleChannelEnabled;
++ }
++
++ QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::specularChannel() const
++ {
++ return m_specularChannel;
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::emissiveSingleChannelEnabled() const
++ {
++ return m_emissiveSingleChannelEnabled;
++ }
++
++ QQuick3DMaterial::TextureChannelMapping QQuick3DSpecularGlossyMaterial::emissiveChannel() const
++ {
++ return m_emissiveChannel;
++ }
++
++ 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;
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::invertOpacityMapValue() const
++ {
++ return m_invertOpacityMapValue;
++ }
++
++ 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::setAlbedoSingleChannelEnabled(bool albedoSingleChannelEnabled)
++ {
++ if (m_albedoSingleChannelEnabled == albedoSingleChannelEnabled)
++ return;
++
++ m_albedoSingleChannelEnabled = albedoSingleChannelEnabled;
++ emit albedoSingleChannelEnabledChanged();
++ markDirty(AlbedoDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setAlbedoChannel(TextureChannelMapping channel)
++ {
++ if (m_albedoChannel == channel)
++ return;
++
++ m_albedoChannel = channel;
++ emit albedoChannelChanged();
++ markDirty(AlbedoDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setSpecularSingleChannelEnabled(bool specularSingleChannelEnabled)
++ {
++ if (m_specularSingleChannelEnabled == specularSingleChannelEnabled)
++ return;
++
++ m_specularSingleChannelEnabled = specularSingleChannelEnabled;
++ emit specularSingleChannelEnabledChanged();
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setSpecularChannel(TextureChannelMapping channel)
++ {
++ if (m_specularChannel == channel)
++ return;
++
++ m_specularChannel = channel;
++ emit specularChannelChanged();
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setEmissiveSingleChannelEnabled(bool emissiveSingleChannelEnabled)
++ {
++ if (m_emissiveSingleChannelEnabled == emissiveSingleChannelEnabled)
++ return;
++
++ m_emissiveSingleChannelEnabled = emissiveSingleChannelEnabled;
++ emit emissiveSingleChannelEnabledChanged();
++ markDirty(EmissiveDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setEmissiveChannel(TextureChannelMapping channel)
++ {
++ if (m_emissiveChannel == channel)
++ return;
++
++ m_emissiveChannel = channel;
++ emit emissiveChannelChanged();
++ markDirty(EmissiveDirty);
++ }
++
++ 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::setInvertOpacityMapValue(bool invertOpacityMapValue)
++ {
++ if (invertOpacityMapValue == m_invertOpacityMapValue)
++ return;
++
++ m_invertOpacityMapValue = invertOpacityMapValue;
++ emit invertOpacityMapValueChanged();
++ markDirty(OpacityDirty);
++ }
++
++ 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::SchlickGGX;
++
++ 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 = QSSGUtils::color::sRGBToLinear(m_albedo);
++ material->baseColorSingleChannelEnabled = m_albedoSingleChannelEnabled;
++ material->baseColorChannel = channelMapping(m_albedoChannel);
++ }
++
++ if (m_dirtyAttributes & EmissiveDirty) {
++ if (!m_emissiveMap)
++ material->emissiveMap = nullptr;
++ else
++ material->emissiveMap = m_emissiveMap->getRenderImage();
++
++ material->emissiveColor = m_emissiveFactor;
++ material->emissiveSingleChannelEnabled = m_emissiveSingleChannelEnabled;
++ material->emissiveChannel = channelMapping(m_emissiveChannel);
++ }
++
++ 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 = QSSGUtils::color::sRGBToLinear(m_specular).toVector3D();
++ material->fresnelScaleBiasEnabled = m_fresnelScaleBiasEnabled;
++ material->fresnelScale = m_fresnelScale;
++ material->fresnelBias = m_fresnelBias;
++ material->fresnelPower = m_fresnelPower;
++ material->specularAmountSingleChannelEnabled = m_specularSingleChannelEnabled;
++ material->specularAmountChannel = channelMapping(m_specularChannel);
++ }
++
++ if (m_dirtyAttributes & OpacityDirty) {
++ if (!m_opacityMap)
++ material->opacityMap = nullptr;
++ else
++ material->opacityMap = m_opacityMap->getRenderImage();
++
++ material->invertOpacityMapValue = m_invertOpacityMapValue;
++ 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();
++ material->clearcoatNormalStrength = m_clearcoatNormalStrength;
++ material->clearcoatFresnelScaleBiasEnabled = m_clearcoatFresnelScaleBiasEnabled;
++ material->clearcoatFresnelScale = m_clearcoatFresnelScale;
++ material->clearcoatFresnelBias = m_clearcoatFresnelBias;
++ material->clearcoatFresnelPower = m_clearcoatFresnelPower;
++ }
++
++ 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 = QSSGUtils::color::sRGBToLinear(m_attenuationColor).toVector3D();
++ }
++
++ if (m_dirtyAttributes & VertexColorsDirty) {
++ material->vertexColorsEnabled = m_vertexColorsEnabled;
++ material->vertexColorsMaskEnabled = m_vertexColorsMaskEnabled;
++ material->vertexColorRedMask = QSSGRenderDefaultMaterial::VertexColorMaskFlags::fromInt(m_vertexColorRedMask);
++ material->vertexColorGreenMask = QSSGRenderDefaultMaterial::VertexColorMaskFlags::fromInt(m_vertexColorGreenMask);
++ material->vertexColorBlueMask = QSSGRenderDefaultMaterial::VertexColorMaskFlags::fromInt(m_vertexColorBlueMask);
++ material->vertexColorAlphaMask = QSSGRenderDefaultMaterial::VertexColorMaskFlags::fromInt(m_vertexColorAlphaMask);
++ }
++
++ 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::clearcoatNormalStrength() const
++ {
++ return m_clearcoatNormalStrength;
++ }
++
++
++ void QQuick3DSpecularGlossyMaterial::setClearcoatNormalStrength(float newClearcoatNormalStrength)
++ {
++ if (qFuzzyCompare(m_clearcoatNormalStrength, newClearcoatNormalStrength))
++ return;
++ m_clearcoatNormalStrength = newClearcoatNormalStrength;
++ emit clearcoatNormalStrengthChanged();
++ 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::fresnelScaleBiasEnabled() const
++ {
++ return m_fresnelScaleBiasEnabled;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::fresnelScale() const
++ {
++ return m_fresnelScale;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::fresnelBias() const
++ {
++ return m_fresnelBias;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::fresnelPower() const
++ {
++ return m_fresnelPower;
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::clearcoatFresnelScaleBiasEnabled() const
++ {
++ return m_clearcoatFresnelScaleBiasEnabled;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::clearcoatFresnelScale() const
++ {
++ return m_clearcoatFresnelScale;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::clearcoatFresnelBias() const
++ {
++ return m_clearcoatFresnelBias;
++ }
++
++ float QQuick3DSpecularGlossyMaterial::clearcoatFresnelPower() const
++ {
++ return m_clearcoatFresnelPower;
++ }
++
++ 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::setFresnelScaleBiasEnabled(bool fresnelScaleBiasEnabled)
++ {
++ if (m_fresnelScaleBiasEnabled == fresnelScaleBiasEnabled)
++ return;
++
++ m_fresnelScaleBiasEnabled = fresnelScaleBiasEnabled;
++ emit fresnelScaleBiasEnabledChanged(m_fresnelScaleBiasEnabled);
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setFresnelScale(float fresnelScale)
++ {
++ if (qFuzzyCompare(m_fresnelScale, fresnelScale))
++ return;
++
++ m_fresnelScale = fresnelScale;
++ emit fresnelScaleChanged(m_fresnelScale);
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setFresnelBias(float fresnelBias)
++ {
++ if (qFuzzyCompare(m_fresnelBias, fresnelBias))
++ return;
++
++ m_fresnelBias = fresnelBias;
++ emit fresnelBiasChanged(m_fresnelBias);
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setFresnelPower(float fresnelPower)
++ {
++ if (qFuzzyCompare(m_fresnelPower, fresnelPower))
++ return;
++
++ m_fresnelPower = fresnelPower;
++ emit fresnelPowerChanged(m_fresnelPower);
++ markDirty(SpecularDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setClearcoatFresnelScaleBiasEnabled(bool clearcoatFresnelScaleBiasEnabled)
++ {
++ if (m_clearcoatFresnelScaleBiasEnabled == clearcoatFresnelScaleBiasEnabled)
++ return;
++
++ m_clearcoatFresnelScaleBiasEnabled = clearcoatFresnelScaleBiasEnabled;
++ emit clearcoatFresnelScaleBiasEnabledChanged(m_clearcoatFresnelScaleBiasEnabled);
++ markDirty(ClearcoatDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setClearcoatFresnelScale(float clearcoatFresnelScale)
++ {
++ if (qFuzzyCompare(m_clearcoatFresnelScale, clearcoatFresnelScale))
++ return;
++
++ m_clearcoatFresnelScale = clearcoatFresnelScale;
++ emit clearcoatFresnelScaleChanged(m_clearcoatFresnelScale);
++ markDirty(ClearcoatDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setClearcoatFresnelBias(float clearcoatFresnelBias)
++ {
++ if (qFuzzyCompare(m_clearcoatFresnelBias, clearcoatFresnelBias))
++ return;
++
++ m_clearcoatFresnelBias = clearcoatFresnelBias;
++ emit clearcoatFresnelBiasChanged(m_clearcoatFresnelBias);
++ markDirty(ClearcoatDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setClearcoatFresnelPower(float clearcoatFresnelPower)
++ {
++ if (qFuzzyCompare(m_clearcoatFresnelPower, clearcoatFresnelPower))
++ return;
++
++ m_clearcoatFresnelPower = clearcoatFresnelPower;
++ emit clearcoatFresnelPowerChanged(m_clearcoatFresnelPower);
++ markDirty(ClearcoatDirty);
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorsEnabled(bool vertexColors)
++ {
++ if (m_vertexColorsEnabled == vertexColors)
++ return;
++
++ m_vertexColorsEnabled = vertexColors;
++ emit vertexColorsEnabledChanged(m_vertexColorsEnabled);
++ markDirty(VertexColorsDirty);
++ }
++
++ bool QQuick3DSpecularGlossyMaterial::vertexColorsMaskEnabled() const
++ {
++ return m_vertexColorsMaskEnabled;
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorsMaskEnabled(bool vertexColorsMaskEnabled)
++ {
++ if (m_vertexColorsMaskEnabled == vertexColorsMaskEnabled)
++ return;
++ m_vertexColorsMaskEnabled = vertexColorsMaskEnabled;
++ emit vertexColorsMaskEnabledChanged();
++ markDirty(VertexColorsDirty);
++ }
++
++ QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags QQuick3DSpecularGlossyMaterial::vertexColorRedMask() const
++ {
++ return m_vertexColorRedMask;
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorRedMask(QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags vertexColorRedMask)
++ {
++ if (m_vertexColorRedMask == vertexColorRedMask)
++ return;
++ m_vertexColorRedMask = vertexColorRedMask;
++ emit vertexColorRedMaskChanged();
++ markDirty(VertexColorsDirty);
++ }
++
++ QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags QQuick3DSpecularGlossyMaterial::vertexColorGreenMask() const
++ {
++ return m_vertexColorGreenMask;
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorGreenMask(QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags vertexColorGreenMask)
++ {
++ if (m_vertexColorGreenMask == vertexColorGreenMask)
++ return;
++ m_vertexColorGreenMask = vertexColorGreenMask;
++ emit vertexColorGreenMaskChanged();
++ markDirty(VertexColorsDirty);
++ }
++
++ QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags QQuick3DSpecularGlossyMaterial::vertexColorBlueMask() const
++ {
++ return m_vertexColorBlueMask;
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorBlueMask(QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags vertexColorBlueMask)
++ {
++ if (m_vertexColorBlueMask == vertexColorBlueMask)
++ return;
++ m_vertexColorBlueMask = vertexColorBlueMask;
++ emit vertexColorBlueMaskChanged();
++ markDirty(VertexColorsDirty);
++ }
++
++ QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags QQuick3DSpecularGlossyMaterial::vertexColorAlphaMask() const
++ {
++ return m_vertexColorAlphaMask;
++ }
++
++ void QQuick3DSpecularGlossyMaterial::setVertexColorAlphaMask(QQuick3DSpecularGlossyMaterial::VertexColorMaskFlags vertexColorAlphaMask)
++ {
++ if (m_vertexColorAlphaMask == vertexColorAlphaMask)
++ return;
++ m_vertexColorAlphaMask = vertexColorAlphaMask;
++ emit vertexColorAlphaMaskChanged();
++ markDirty(VertexColorsDirty);
++ }
++
++ QT_END_NAMESPACE