Revision control
Copy as Markdown
// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qquick3dprincipledmaterial_p.h"
#include "qquick3dobject_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
QT_BEGIN_NAMESPACE
/*!
\qmltype PrincipledMaterial
\inherits Material
\inqmlmodule QtQuick3D
\brief Lets you define a material for 3D items using the metal/roughness 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 PrincipledMaterial is a PBR
metal/roughness 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 principled material affects how a model is shaded,
see the \l{Qt Quick 3D - Principled Material Example}{Principled Material example}.
\section1 Metal/Roughness workflow
The Principled material is what's known as a metal/roughness material, in essence
that means the main characteristics of the material is controlled through
the \l {PrincipledMaterial::metalnessMap} {metallness}, \l {PrincipledMaterial::roughnessMap} {roughness},
and the \l {PrincipledMaterial::baseColorMap} {base color} property.
\section2 Metalness
Real world materials are put into two main categories, metals and dielectrics (non-metals).
In the Principled material, the category a material belongs to is decided by the
\c metalness value. Setting the \c metalness value to 0, means the material is a dialectric,
while everything above 0 is a considered to be a metal. In reality metals will have
a \c metalness value of 1, but values between 0 and 1 are possible, and usually used
for metals with reduced reflectance. For example, to render corrosion, or similar,
on a material, the \c metalness of the material should be reduced to give the output
properties more similar to a dielectric material.
Since the \c metalness value affects the reflectance of the material it might be tempting to
use the metalness to adjust glossiness, but consider what type of material you want
to describe first. Increasing the \c metalness value to give a dielectric material
a more polished look, will introduce properties that are not accurate for a dielectric
material, so consider if it would be more appropriate to adjust, for example,
the \c roughness value instead.
\section2 Roughness
The \c roughness of a material describes the condition of an object's surface.
A low \c roughness value means the object has a smooth surface and therefore be more
reflective then a material with a higher \c roughness value.
\section2 Base color
The \l {PrincipledMaterial::baseColorMap} {base color} of a metal/roughness material
contains both the diffuse and the specular data, how much the base color is interpreted
as one or the other is primarily dictated by the \c metalness value. For example,
a material with a metalness value of 1, will have most of its base color interpreted
as specular color, while the diffuse color would be a black tint. The opposite would
happen for a material with a metalness value of 0. This is of course a bit simplified,
but gives a rough idea how the \l {PrincipledMaterial::baseColor} {base color} and
\c metalness value interacts. For those more familiar with a Specular/Glossiness workflow,
there's a clear difference here which is worth noting, namely that the color data of the
two materials are not directly compatible, since in a Specular/Glossiness
\l {DefaultMaterial} {material}, the diffuse and specular color comes from separate inputs.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::lighting
This property defines which lighting method is used when generating this
material.
The default value is \c PrincipledMaterial.FragmentLighting
When using \c PrincipledMaterial.FragmentLighting, diffuse and specular lighting is
calculated for each rendered pixel. Certain effects (such as a Fresnel or normal map) require
\c PrincipledMaterial.FragmentLighting to work.
When using \c PrincipledMaterial.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 baseColor values, alpha values, and vertex colors will be
ignored.
\value PrincipledMaterial.NoLighting
\value PrincipledMaterial.FragmentLighting
*/
/*!
\qmlproperty enumeration PrincipledMaterial::blendMode
This property determines how the colors of the model rendered blends with
those behind it.
\value PrincipledMaterial.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 PrincipledMaterial.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 PrincipledMaterial.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 PrincipledMaterial::baseColor
This property sets the base color for the material. Depending on the type
of material specified (metal or dielectric) the diffuse and specular channels will be
set appropriately. For example, a dielectric material will have a diffuse color equal to
the base color, while it's specular color, depending on the specular amount, will have a
bright specular color. For metals the diffuse and specular channels will be mixed from
the base color and have a dark diffuse channel and a specular channel close to the base color.
\sa baseColorMap, alphaMode
*/
/*!
\qmlproperty Texture PrincipledMaterial::baseColorMap
This property defines the texture used to set the base color of the material.
\sa baseColor, alphaMode
*/
/*!
\qmlproperty bool PrincipledMaterial::baseColorSingleChannelEnabled
\since 6.8
When this property is enabled, the material will use the single value of the baseColorChannel from
the baseColorMap as RGB value and use 1.0 as alpha value.
The default value is false.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::baseColorChannel
\since 6.8
This property defines the texture channel used to read the baseColor value from baseColorMap.
In order to use a single texture channel as color you have to enable the baseColorSingleChannelEnabled
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 PrincipledMaterial::metalness
The metalness property defines the \e metalness of the the material. The value
is normalized, where 0.0 means the material is a \e dielectric (non-metallic) material and
a value of 1.0 means the material is a metal.
\note In principle, materials are either dielectrics with a metalness of 0, or metals with a
metalness of 1. Metalness values between 0 and 1 are still allowed and will give a material that
is a blend between the different models.
The range is [0.0, 1.0]. The default value is 0.
*/
/*!
\qmlproperty Texture PrincipledMaterial::metalnessMap
This property sets a Texture to be used to set the metalness amount for the
different parts of the material.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::metalnessChannel
This property defines the texture channel used to read the metalness value from metalnessMap.
The default value is \c Material.B.
\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 PrincipledMaterial::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 PrincipledMaterial::emissiveChannel
\since 6.8
This property defines the texture channel used to read the emissive 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 PrincipledMaterial::emissiveMap
This property sets a RGB Texture to be used to specify the intensity of the
emissive color.
*/
/*!
\qmlproperty vector3d PrincipledMaterial::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 Texture PrincipledMaterial::specularReflectionMap
This property sets a Texture used for specular highlights on the material.
This is typically used to perform environment mapping: as the model is
rotated, the map will appear as though it is reflecting from the
environment. For this to work as expected, the Texture's
\l{Texture::mappingMode}{mappingMode} needs to be set to
Texture.Environment. Specular reflection maps are an easy way to add a
high-quality look with a relatively low cost.
\note Associating a \l{SceneEnvironment::lightProbe}{light probe} with the
\l SceneEnvironment, and thus relying on image-based lighting, can achieve
similar environmental reflection effects. Light probes are however a
conceptually different, and when it comes to performance, potentially more
expensive solution. Each approaches have their own specific uses, and the
one to use needs to be decided on a case by case basis. When it comes to
the Texture set to the property, specularReflectionMap has an advantage,
because it presents no limitations and supports all types of textures,
including ones that source their data from a Qt Quick sub-scene via
\l{Texture::sourceItem}{sourceItem}.
\note Crisp images cause your material to look very glossy; the more you
blur your image the softer your material will appear.
\sa Texture::mappingMode
*/
/*!
\qmlproperty Texture PrincipledMaterial::specularMap
The property defines a RGB Texture to modulate the amount and the color of
specularity across the surface of the material. These values are multiplied
by the specularAmount.
\note The specular map will be ignored unless the material is dielectric.
*/
/*!
\qmlproperty bool PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::specularTint
This property defines how much of the base color contributes to the specular reflections.
\note This property does only apply to dielectric materials.
*/
/*!
\qmlproperty real PrincipledMaterial::specularAmount
This property controls the strength of specularity (highlights and
reflections).
The range is [0.0, 1.0]. The default value is \c 1.0.
\note For non-dielectrics (metals) this property has no effect.
\note This property does not affect the specularReflectionMap, but does affect the amount of
reflections from a scenes SceneEnvironment::lightProbe.
*/
/*!
\qmlproperty real PrincipledMaterial::roughness
This property controls the size of the specular highlight generated from
lights, and the clarity of reflections in general. Larger values increase
the roughness, softening specular highlights and blurring reflections.
The range is [0.0, 1.0]. The default value is 0.
*/
/*!
\qmlproperty Texture PrincipledMaterial::roughnessMap
This property defines a Texture to control the specular roughness of the
material.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::roughnessChannel
This property defines the texture channel used to read the roughness value from roughnessMap.
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 PrincipledMaterial::opacity
This property drops the opacity of just this material, separate from the
model.
*/
/*!
\qmlproperty Texture PrincipledMaterial::opacityMap
This property defines a Texture used to control the opacity differently for
different parts of the material.
*/
/*!
\qmlproperty real PrincipledMaterial::invertOpacityMapValue
\since 6.8
This property inverts the opacity value of the opacityMap.
The default value is \c false.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::normalStrength
This property controls the amount of simulated displacement for the normalMap.
*/
/*!
\qmlproperty real PrincipledMaterial::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 PrincipledMaterial::occlusionMap
This property defines a texture used to determine how much 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 lighting and 1.0 means the
effect of the lighting is left unchanged.
\sa occlusionAmount
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial::alphaMode
This property specifies how the alpha color value from \l baseColor and the
alpha channel of a \l{baseColorMap}{base color map} are used.
\note The alpha cutoff test only considers the base color alpha. \l opacity
and \l [QtQuick3D] {Node::opacity} are not taken into account there.
\note When sampling a base color map, the effective alpha value is the
sampled alpha multiplied by the \l baseColor alpha.
\value PrincipledMaterial.Default No test is applied, the effective alpha
value is passed on as-is. Note that a \l baseColor or \l baseColorMap 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 PrincipledMaterial.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 PrincipledMaterial.Opaque No cutoff test is applied and the rendered
object is assumed to be fully opaque, meaning the alpha values in the
vertex color, base color, and base 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 PrincipledMaterial.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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::clearcoatAmount
This property defines the intensity of the clearcoat layer.
The default value is \c 0.0
*/
/*!
\qmlproperty Texture PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::clearcoatRoughnessAmount
This property defines the roughness of the clearcoat layer.
The default value is \c 0.0
*/
/*!
\qmlproperty Texture PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::clearcoatNormalMap
This property defines a texture used to determine the normal mapping
applied to the clearcoat layer.
*/
/*!
\qmlproperty real PrincipledMaterial::clearcoatNormalStrength
This property controls the amount of simulated displacement for the clearcoatNormalMap.
*/
/*!
\qmlproperty color PrincipledMaterial::sheenColor
\since 6.13
This property defines the color and intensity of the sheen layer, a soft
retroreflective highlight at grazing angles that is characteristic of
cloth and fabric.
The sheen layer is disabled while this color is black, so setting a color
is what enables sheen. Note that \l sheenColorMap is multiplied with this
value, which means the map has no effect while the color is black.
The sheen layer is applied underneath the clearcoat layer and reduces the
energy of the layers below it, so enabling sheen darkens the base
material slightly.
The default value is \c "black", which disables sheen.
\sa sheenColorMap, sheenRoughness
*/
/*!
\qmlproperty Texture PrincipledMaterial::sheenColorMap
\since 6.13
This property defines a texture used to set the color of the sheen layer
per fragment. The RGB channels of the texture are multiplied with
\l sheenColor, so a \l sheenColor must be set for this map to have any
effect.
\note Texture maps are optional. Materials that use a large number of
maps at the same time can exceed the number of texture samplers
available to a fragment shader on some graphics APIs.
\sa sheenColor
*/
/*!
\qmlproperty real PrincipledMaterial::sheenRoughness
\since 6.13
This property defines how soft and spread out the sheen highlight is.
Lower values give a tight highlight close to the silhouette, higher
values spread the sheen across the whole surface.
The value is in the range \c 0.0 to \c 1.0. The default value is \c 0.0.
\sa sheenRoughnessMap, sheenColor
*/
/*!
\qmlproperty Texture PrincipledMaterial::sheenRoughnessMap
\since 6.13
This property defines a texture used to set the sheen roughness per
fragment. The value read from the texture is multiplied with
\l sheenRoughness.
\sa sheenRoughness, sheenRoughnessChannel
*/
/*!
\qmlproperty enumeration PrincipledMaterial::sheenRoughnessChannel
\since 6.13
This property defines the texture channel used to read the sheen
roughness value from \l sheenRoughnessMap. The default value is
\c Material.A, which is the channel the glTF
\c KHR_materials_sheen extension packs sheen roughness into.
\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.
\sa sheenRoughnessMap
*/
/*!
\qmlproperty real PrincipledMaterial::anisotropyStrength
\since 6.13
This property defines how strongly the specular highlight is stretched
along one direction of the surface, which is what gives brushed metal,
hair and vinyl their characteristic streaked reflections.
A value of \c 0.0, the default, means the highlight is round and the
material behaves exactly as before. Increasing the value stretches the
highlight perpendicular to the anisotropy direction, up to \c 1.0.
For anisotropy to be oriented meaningfully the mesh should provide tangent
data, or the material should use a \l normalMap, since both establish a
tangent frame. If neither is available a stable tangent frame is derived
from the surface normal instead, in which case the highlight still stretches
but its direction across the surface is arbitrary.
\sa anisotropyRotation, anisotropyMap
*/
/*!
\qmlproperty real PrincipledMaterial::anisotropyRotation
\since 6.13
This property rotates the anisotropy direction within the tangent plane of
the surface, in degrees. The default value is \c 0, which aligns the
direction with the tangent of the mesh.
\note The glTF \c KHR_materials_anisotropy extension expresses this angle
in radians. This property is in degrees, matching the other angles in the
Qt Quick 3D API, and the asset importer converts on import.
\sa anisotropyStrength, anisotropyMap
*/
/*!
\qmlproperty Texture PrincipledMaterial::anisotropyMap
\since 6.13
This property defines a texture used to vary the anisotropy across the
surface. Unlike the other maps this one has a fixed channel layout, so
there is no channel property to go with it:
\list
\li The red and green channels hold the anisotropy direction in tangent
space, encoded so that \c 0.0 to \c 1.0 maps to \c -1.0 to \c 1.0.
The direction is then rotated by \l anisotropyRotation.
\li The blue channel is multiplied with \l anisotropyStrength.
\endlist
Since the blue channel scales the strength, this map has no effect while
\l anisotropyStrength is \c 0.0.
\note Texture maps are optional. Materials that use a large number of
maps at the same time can exceed the number of texture samplers
available to a fragment shader on some graphics APIs.
\sa anisotropyStrength, anisotropyRotation
*/
/*!
\qmlproperty real PrincipledMaterial::iridescenceFactor
\since 6.13
This property defines the strength of a thin film of material over the
surface, which produces the shifting colors of a soap bubble, an oil slick
or a beetle shell. Light reflecting off the two faces of the film
interferes with itself, and which wavelengths cancel out depends on the
thickness of the film and the angle it is viewed from, so the hue changes
as the surface curves away.
The value is in the range \c 0.0 to \c 1.0 and blends between the
material without and with the film. The default value is \c 0.0, which
disables iridescence.
\sa iridescenceMap, iridescenceIndexOfRefraction, iridescenceThicknessMaximum
*/
/*!
\qmlproperty Texture PrincipledMaterial::iridescenceMap
\since 6.13
This property defines a texture used to vary the strength of the
iridescence across the surface. The value read from the texture is
multiplied with \l iridescenceFactor, so a non-zero
\l iridescenceFactor is needed for this map to have any effect.
\note Texture maps are optional. Materials that use a large number of
maps at the same time can exceed the number of texture samplers
available to a fragment shader on some graphics APIs.
\sa iridescenceFactor, iridescenceChannel
*/
/*!
\qmlproperty enumeration PrincipledMaterial::iridescenceChannel
\since 6.13
This property defines the texture channel used to read the iridescence
strength from \l iridescenceMap. 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.
\sa iridescenceMap
*/
/*!
\qmlproperty real PrincipledMaterial::iridescenceIndexOfRefraction
\since 6.13
This property defines the index of refraction of the thin film itself,
which together with the thickness decides which colors the film produces.
The default value is \c 1.3, which is roughly that of a soap film.
Note that this is the index of refraction of the film, not of the material
underneath it. The latter is \l indexOfRefraction.
\sa iridescenceFactor, indexOfRefraction
*/
/*!
\qmlproperty real PrincipledMaterial::iridescenceThicknessMinimum
\since 6.13
This property defines the thickness of the thin film in nanometers where
\l iridescenceThicknessMap reads \c 0.0. The default value is \c 100.
It has no effect unless an \l iridescenceThicknessMap is set, since
without one the film is uniformly
\l iridescenceThicknessMaximum thick.
\sa iridescenceThicknessMaximum, iridescenceThicknessMap
*/
/*!
\qmlproperty real PrincipledMaterial::iridescenceThicknessMaximum
\since 6.13
This property defines the thickness of the thin film in nanometers where
\l iridescenceThicknessMap reads \c 1.0, and the thickness of the whole
film when no thickness map is set. The default value is \c 400.
Thickness is what selects the hue, so varying this across the range of
visible light, roughly \c 200 to \c 800 nanometers, sweeps through the
colors the film can produce.
\sa iridescenceThicknessMinimum, iridescenceThicknessMap
*/
/*!
\qmlproperty Texture PrincipledMaterial::iridescenceThicknessMap
\since 6.13
This property defines a texture used to vary the thickness of the thin
film across the surface, and with it the color. The value read from the
texture interpolates between \l iridescenceThicknessMinimum and
\l iridescenceThicknessMaximum.
When no map is set the film is uniformly
\l iridescenceThicknessMaximum thick.
\sa iridescenceThicknessMinimum, iridescenceThicknessMaximum, iridescenceThicknessChannel
*/
/*!
\qmlproperty enumeration PrincipledMaterial::iridescenceThicknessChannel
\since 6.13
This property defines the texture channel used to read the film thickness
from \l iridescenceThicknessMap. The default value is \c Material.G,
which is the channel the glTF \c KHR_materials_iridescence extension
packs the thickness into.
\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.
\sa iridescenceThicknessMap
*/
/*!
\qmlproperty real PrincipledMaterial::dispersion
\since 6.13
This property defines how much the index of refraction varies across
wavelengths, which splits light refracted through the material into color
fringes, as a prism does.
Dispersion only affects light refracted through the volume of the material,
so it has no effect unless \l transmissionFactor and \l thicknessFactor
are set. It does not affect the reflected specular highlight.
Following the glTF \c KHR_materials_dispersion extension the value is
given as 20 divided by the Abbe number of the material, so \c 1.0
corresponds to an Abbe number of 20, about as dispersive as ordinary
materials get. Window glass is roughly \c 0.3, and a lead crystal or a
diamond closer to \c 1.0. The default value is \c 0.0, which disables
dispersion.
\note Each of the three color channels is refracted separately, so
enabling dispersion triples the cost of the refraction lookup.
\sa transmissionFactor, thicknessFactor, indexOfRefraction
*/
/*!
\qmlproperty real PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::thicknessFactor
This property defines the thickness of the volume beneath the surface.
Unlike many other properties of PrincipledMaterial, 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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::indexOfRefraction
This property defines the index of refraction of the material. The default
value of \c 1.5 will be the ideal value for materials like plastics or glass
but other materials like water, asphalt, sapphire, or diamond would require
and adjusted value to look more realistic. For realistic materials the
indexOfRefraction should usually be between \c 1.0 and \c 3.0
Some examples of common materials' index of refractions are:
\table
\header
\li Material
\li Index of Refraction
\row
\li Air
\li 1.0
\row
\li Water
\li 1.33
\row
\li Glass
\li 1.55
\row
\li Sapphire
\li 1.76
\row
\li Diamond
\li 2.42
\endtable
\note No known material in the world have ior much greater than \c 3.0.
*/
/*!
\qmlproperty real PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 PrincipledMaterial::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 RoughnessAmount, SpecularAmount, ... .
The default value is false.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial.NoMask.
\value PrincipledMaterial.NoMask.
\value PrincipledMaterial.ClearcoatAmountMask.
\value PrincipledMaterial.ClearcoatRoughnessAmountMask.
\value PrincipledMaterial.ClearcoatNormalStrengthMask.
\value PrincipledMaterial.HeightAmountMask.
\value PrincipledMaterial.MetalnessMask.
\value PrincipledMaterial.RoughnessMask.
\value PrincipledMaterial.NormalStrengthMask.
\value PrincipledMaterial.OcclusionAmountMask.
\value PrincipledMaterial.SpecularAmountMask.
\value PrincipledMaterial.ThicknessFactorMask.
\value PrincipledMaterial.TransmissionFactorMask.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial.NoMask.
\value PrincipledMaterial.NoMask.
\value PrincipledMaterial.ClearcoatAmountMask.
\value PrincipledMaterial.ClearcoatRoughnessAmountMask.
\value PrincipledMaterial.ClearcoatNormalStrengthMask.
\value PrincipledMaterial.HeightAmountMask.
\value PrincipledMaterial.MetalnessMask.
\value PrincipledMaterial.RoughnessMask.
\value PrincipledMaterial.NormalStrengthMask.
\value PrincipledMaterial.OcclusionAmountMask.
\value PrincipledMaterial.SpecularAmountMask.
\value PrincipledMaterial.ThicknessFactorMask.
\value PrincipledMaterial.TransmissionFactorMask.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial.NoMask.
\value PrincipledMaterial.NoMask.
\value PrincipledMaterial.ClearcoatAmountMask.
\value PrincipledMaterial.ClearcoatRoughnessAmountMask.
\value PrincipledMaterial.ClearcoatNormalStrengthMask.
\value PrincipledMaterial.HeightAmountMask.
\value PrincipledMaterial.MetalnessMask.
\value PrincipledMaterial.RoughnessMask.
\value PrincipledMaterial.NormalStrengthMask.
\value PrincipledMaterial.OcclusionAmountMask.
\value PrincipledMaterial.SpecularAmountMask.
\value PrincipledMaterial.ThicknessFactorMask.
\value PrincipledMaterial.TransmissionFactorMask.
*/
/*!
\qmlproperty enumeration PrincipledMaterial::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 PrincipledMaterial.NoMask.
\value PrincipledMaterial.NoMask.
\value PrincipledMaterial.ClearcoatAmountMask.
\value PrincipledMaterial.ClearcoatRoughnessAmountMask.
\value PrincipledMaterial.ClearcoatNormalStrengthMask.
\value PrincipledMaterial.HeightAmountMask.
\value PrincipledMaterial.MetalnessMask.
\value PrincipledMaterial.RoughnessMask.
\value PrincipledMaterial.NormalStrengthMask.
\value PrincipledMaterial.OcclusionAmountMask.
\value PrincipledMaterial.SpecularAmountMask.
\value PrincipledMaterial.ThicknessFactorMask.
\value PrincipledMaterial.TransmissionFactorMask.
*/
QQuick3DPrincipledMaterial::QQuick3DPrincipledMaterial(QQuick3DObject *parent)
: QQuick3DMaterial(*(new QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::PrincipledMaterial)), parent)
{}
QQuick3DPrincipledMaterial::~QQuick3DPrincipledMaterial()
{
}
QQuick3DPrincipledMaterial::Lighting QQuick3DPrincipledMaterial::lighting() const
{
return m_lighting;
}
QQuick3DPrincipledMaterial::BlendMode QQuick3DPrincipledMaterial::blendMode() const
{
return m_blendMode;
}
QColor QQuick3DPrincipledMaterial::baseColor() const
{
return m_baseColor;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::baseColorMap() const
{
return m_baseColorMap;
}
bool QQuick3DPrincipledMaterial::baseColorSingleChannelEnabled() const
{
return m_baseColorSingleChannelEnabled;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::baseColorChannel() const
{
return m_baseColorChannel;
}
bool QQuick3DPrincipledMaterial::specularSingleChannelEnabled() const
{
return m_specularSingleChannelEnabled;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::specularChannel() const
{
return m_specularChannel;
}
bool QQuick3DPrincipledMaterial::emissiveSingleChannelEnabled() const
{
return m_emissiveSingleChannelEnabled;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::emissiveChannel() const
{
return m_emissiveChannel;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::emissiveMap() const
{
return m_emissiveMap;
}
QVector3D QQuick3DPrincipledMaterial::emissiveFactor() const
{
return m_emissiveFactor;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::specularReflectionMap() const
{
return m_specularReflectionMap;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::specularMap() const
{
return m_specularMap;
}
float QQuick3DPrincipledMaterial::specularTint() const
{
return m_specularTint;
}
float QQuick3DPrincipledMaterial::specularAmount() const
{
return m_specularAmount;
}
float QQuick3DPrincipledMaterial::roughness() const
{
return m_roughness;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::roughnessMap() const
{
return m_roughnessMap;
}
bool QQuick3DPrincipledMaterial::invertOpacityMapValue() const
{
return m_invertOpacityMapValue;
}
float QQuick3DPrincipledMaterial::opacity() const
{
return m_opacity;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::opacityMap() const
{
return m_opacityMap;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::normalMap() const
{
return m_normalMap;
}
float QQuick3DPrincipledMaterial::metalness() const
{
return m_metalnessAmount;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::metalnessMap() const
{
return m_metalnessMap;
}
float QQuick3DPrincipledMaterial::normalStrength() const
{
return m_normalStrength;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::occlusionMap() const
{
return m_occlusionMap;
}
float QQuick3DPrincipledMaterial::occlusionAmount() const
{
return m_occlusionAmount;
}
QQuick3DPrincipledMaterial::AlphaMode QQuick3DPrincipledMaterial::alphaMode() const
{
return m_alphaMode;
}
float QQuick3DPrincipledMaterial::alphaCutoff() const
{
return m_alphaCutoff;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::roughnessChannel() const
{
return m_roughnessChannel;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::opacityChannel() const
{
return m_opacityChannel;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::metalnessChannel() const
{
return m_metalnessChannel;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::occlusionChannel() const
{
return m_occlusionChannel;
}
float QQuick3DPrincipledMaterial::pointSize() const
{
return m_pointSize;
}
float QQuick3DPrincipledMaterial::lineWidth() const
{
return m_lineWidth;
}
QQuick3DTexture *QQuick3DPrincipledMaterial::heightMap() const
{
return m_heightMap;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::heightChannel() const
{
return m_heightChannel;
}
float QQuick3DPrincipledMaterial::heightAmount() const
{
return m_heightAmount;
}
int QQuick3DPrincipledMaterial::minHeightMapSamples() const
{
return m_minHeightMapSamples;
}
int QQuick3DPrincipledMaterial::maxHeightMapSamples() const
{
return m_maxHeightMapSamples;
}
void QQuick3DPrincipledMaterial::markAllDirty()
{
m_dirtyAttributes = 0xffffffff;
QQuick3DMaterial::markAllDirty();
}
void QQuick3DPrincipledMaterial::setLighting(QQuick3DPrincipledMaterial::Lighting lighting)
{
if (m_lighting == lighting)
return;
m_lighting = lighting;
emit lightingChanged(m_lighting);
markDirty(LightingModeDirty);
}
void QQuick3DPrincipledMaterial::setBlendMode(QQuick3DPrincipledMaterial::BlendMode blendMode)
{
if (m_blendMode == blendMode)
return;
m_blendMode = blendMode;
emit blendModeChanged(m_blendMode);
markDirty(BlendModeDirty);
}
void QQuick3DPrincipledMaterial::setBaseColor(QColor diffuseColor)
{
if (m_baseColor == diffuseColor)
return;
m_baseColor = diffuseColor;
emit baseColorChanged(m_baseColor);
markDirty(BaseColorDirty);
}
void QQuick3DPrincipledMaterial::setBaseColorMap(QQuick3DTexture *baseColorMap)
{
if (m_baseColorMap == baseColorMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setBaseColorMap, baseColorMap, m_baseColorMap);
m_baseColorMap = baseColorMap;
emit baseColorMapChanged(m_baseColorMap);
markDirty(BaseColorDirty);
}
void QQuick3DPrincipledMaterial::setBaseColorSingleChannelEnabled(bool baseColorSingleChannelEnabled)
{
if (m_baseColorSingleChannelEnabled == baseColorSingleChannelEnabled)
return;
m_baseColorSingleChannelEnabled = baseColorSingleChannelEnabled;
emit baseColorSingleChannelEnabledChanged(baseColorSingleChannelEnabled);
markDirty(BaseColorDirty);
}
void QQuick3DPrincipledMaterial::setBaseColorChannel(TextureChannelMapping channel)
{
if (m_baseColorChannel == channel)
return;
m_baseColorChannel = channel;
emit baseColorChannelChanged(channel);
markDirty(BaseColorDirty);
}
void QQuick3DPrincipledMaterial::setSpecularSingleChannelEnabled(bool specularSingleChannelEnabled)
{
if (m_specularSingleChannelEnabled == specularSingleChannelEnabled)
return;
m_specularSingleChannelEnabled = specularSingleChannelEnabled;
emit specularSingleChannelEnabledChanged(specularSingleChannelEnabled);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setSpecularChannel(TextureChannelMapping channel)
{
if (m_specularChannel == channel)
return;
m_specularChannel = channel;
emit specularChannelChanged(channel);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setEmissiveSingleChannelEnabled(bool emissiveSingleChannelEnabled)
{
if (m_emissiveSingleChannelEnabled == emissiveSingleChannelEnabled)
return;
m_emissiveSingleChannelEnabled = emissiveSingleChannelEnabled;
emit emissiveSingleChannelEnabledChanged(emissiveSingleChannelEnabled);
markDirty(EmissiveDirty);
}
void QQuick3DPrincipledMaterial::setEmissiveChannel(TextureChannelMapping channel)
{
if (m_emissiveChannel == channel)
return;
m_emissiveChannel = channel;
emit emissiveChannelChanged(channel);
markDirty(EmissiveDirty);
}
void QQuick3DPrincipledMaterial::setEmissiveMap(QQuick3DTexture *emissiveMap)
{
if (m_emissiveMap == emissiveMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setEmissiveMap, emissiveMap, m_emissiveMap);
m_emissiveMap = emissiveMap;
emit emissiveMapChanged(m_emissiveMap);
markDirty(EmissiveDirty);
}
void QQuick3DPrincipledMaterial::setEmissiveFactor(QVector3D emissiveFactor)
{
if (m_emissiveFactor == emissiveFactor)
return;
m_emissiveFactor = emissiveFactor;
emit emissiveFactorChanged(m_emissiveFactor);
markDirty(EmissiveDirty);
}
void QQuick3DPrincipledMaterial::setSpecularReflectionMap(QQuick3DTexture *specularReflectionMap)
{
if (m_specularReflectionMap == specularReflectionMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setSpecularReflectionMap, specularReflectionMap, m_specularReflectionMap);
m_specularReflectionMap = specularReflectionMap;
emit specularReflectionMapChanged(m_specularReflectionMap);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setSpecularMap(QQuick3DTexture *specularMap)
{
if (m_specularMap == specularMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setSpecularMap, specularMap, m_specularMap);
m_specularMap = specularMap;
emit specularMapChanged(m_specularMap);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setSpecularTint(float specularTint)
{
specularTint = ensureNormalized(specularTint);
if (qFuzzyCompare(m_specularTint, specularTint))
return;
m_specularTint = specularTint;
emit specularTintChanged(m_specularTint);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setSpecularAmount(float specularAmount)
{
specularAmount = ensureNormalized(specularAmount);
if (qFuzzyCompare(m_specularAmount, specularAmount))
return;
m_specularAmount = specularAmount;
emit specularAmountChanged(m_specularAmount);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setRoughness(float roughness)
{
roughness = ensureNormalized(roughness);
if (qFuzzyCompare(m_roughness, roughness))
return;
m_roughness = roughness;
emit roughnessChanged(m_roughness);
markDirty(RoughnessDirty);
}
void QQuick3DPrincipledMaterial::setRoughnessMap(QQuick3DTexture *roughnessMap)
{
if (m_roughnessMap == roughnessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setRoughnessMap, roughnessMap, m_roughnessMap);
m_roughnessMap = roughnessMap;
emit roughnessMapChanged(m_roughnessMap);
markDirty(RoughnessDirty);
}
void QQuick3DPrincipledMaterial::setInvertOpacityMapValue(bool invertOpacityMapValue)
{
if (invertOpacityMapValue == m_invertOpacityMapValue)
return;
m_invertOpacityMapValue = invertOpacityMapValue;
emit invertOpacityMapValueChanged(m_invertOpacityMapValue);
markDirty(OpacityDirty);
}
void QQuick3DPrincipledMaterial::setOpacity(float opacity)
{
opacity = ensureNormalized(opacity);
if (qFuzzyCompare(m_opacity, opacity))
return;
m_opacity = opacity;
emit opacityChanged(m_opacity);
markDirty(OpacityDirty);
}
void QQuick3DPrincipledMaterial::setOpacityMap(QQuick3DTexture *opacityMap)
{
if (m_opacityMap == opacityMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &::QQuick3DPrincipledMaterial::setOpacityMap, opacityMap, m_opacityMap);
m_opacityMap = opacityMap;
emit opacityMapChanged(m_opacityMap);
markDirty(OpacityDirty);
}
void QQuick3DPrincipledMaterial::setNormalMap(QQuick3DTexture *normalMap)
{
if (m_normalMap == normalMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setNormalMap, normalMap, m_normalMap);
m_normalMap = normalMap;
emit normalMapChanged(m_normalMap);
markDirty(NormalDirty);
}
void QQuick3DPrincipledMaterial::setMetalness(float metalnessAmount)
{
metalnessAmount = ensureNormalized(metalnessAmount);
if (qFuzzyCompare(m_metalnessAmount, metalnessAmount))
return;
m_metalnessAmount = metalnessAmount;
emit metalnessChanged(m_metalnessAmount);
markDirty(MetalnessDirty);
}
void QQuick3DPrincipledMaterial::setMetalnessMap(QQuick3DTexture *metallicMap)
{
if (m_metalnessMap == metallicMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setMetalnessMap, metallicMap, m_metalnessMap);
m_metalnessMap = metallicMap;
emit metalnessMapChanged(m_metalnessMap);
markDirty(MetalnessDirty);
}
void QQuick3DPrincipledMaterial::setNormalStrength(float factor)
{
factor = ensureNormalized(factor);
if (qFuzzyCompare(m_normalStrength, factor))
return;
m_normalStrength = factor;
emit normalStrengthChanged(m_normalStrength);
markDirty(NormalDirty);
}
void QQuick3DPrincipledMaterial::setOcclusionMap(QQuick3DTexture *occlusionMap)
{
if (m_occlusionMap == occlusionMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setOcclusionMap, occlusionMap, m_occlusionMap);
m_occlusionMap = occlusionMap;
emit occlusionMapChanged(m_occlusionMap);
markDirty(OcclusionDirty);
}
void QQuick3DPrincipledMaterial::setOcclusionAmount(float occlusionAmount)
{
if (qFuzzyCompare(m_occlusionAmount, occlusionAmount))
return;
m_occlusionAmount = occlusionAmount;
emit occlusionAmountChanged(m_occlusionAmount);
markDirty(OcclusionDirty);
}
void QQuick3DPrincipledMaterial::setAlphaMode(QQuick3DPrincipledMaterial::AlphaMode alphaMode)
{
if (m_alphaMode == alphaMode)
return;
m_alphaMode = alphaMode;
emit alphaModeChanged(m_alphaMode);
markDirty(AlphaModeDirty);
}
void QQuick3DPrincipledMaterial::setAlphaCutoff(float alphaCutoff)
{
if (qFuzzyCompare(m_alphaCutoff, alphaCutoff))
return;
m_alphaCutoff = alphaCutoff;
emit alphaCutoffChanged(m_alphaCutoff);
markDirty(AlphaModeDirty);
}
void QQuick3DPrincipledMaterial::setMetalnessChannel(TextureChannelMapping channel)
{
if (m_metalnessChannel == channel)
return;
m_metalnessChannel = channel;
emit metalnessChannelChanged(channel);
markDirty(MetalnessDirty);
}
void QQuick3DPrincipledMaterial::setRoughnessChannel(TextureChannelMapping channel)
{
if (m_roughnessChannel == channel)
return;
m_roughnessChannel = channel;
emit roughnessChannelChanged(channel);
markDirty(RoughnessDirty);
}
void QQuick3DPrincipledMaterial::setOpacityChannel(TextureChannelMapping channel)
{
if (m_opacityChannel == channel)
return;
m_opacityChannel = channel;
emit opacityChannelChanged(channel);
markDirty(OpacityDirty);
}
void QQuick3DPrincipledMaterial::setOcclusionChannel(TextureChannelMapping channel)
{
if (m_occlusionChannel == channel)
return;
m_occlusionChannel = channel;
emit occlusionChannelChanged(channel);
markDirty(OcclusionDirty);
}
void QQuick3DPrincipledMaterial::setPointSize(float size)
{
if (qFuzzyCompare(m_pointSize, size))
return;
m_pointSize = size;
emit pointSizeChanged();
markDirty(PointSizeDirty);
}
void QQuick3DPrincipledMaterial::setLineWidth(float width)
{
if (qFuzzyCompare(m_lineWidth, width))
return;
m_lineWidth = width;
emit lineWidthChanged();
markDirty(LineWidthDirty);
}
void QQuick3DPrincipledMaterial::setHeightMap(QQuick3DTexture *heightMap)
{
if (m_heightMap == heightMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setHeightMap, heightMap, m_heightMap);
m_heightMap = heightMap;
emit heightMapChanged(m_heightMap);
markDirty(HeightDirty);
}
void QQuick3DPrincipledMaterial::setHeightChannel(QQuick3DMaterial::TextureChannelMapping channel)
{
if (m_heightChannel == channel)
return;
m_heightChannel = channel;
emit heightChannelChanged(m_heightChannel);
markDirty(HeightDirty);
}
void QQuick3DPrincipledMaterial::setHeightAmount(float heightAmount)
{
if (m_heightAmount == heightAmount)
return;
m_heightAmount = heightAmount;
emit heightAmountChanged(m_heightAmount);
markDirty(HeightDirty);
}
void QQuick3DPrincipledMaterial::setMinHeightMapSamples(int samples)
{
if (m_minHeightMapSamples == samples)
return;
m_minHeightMapSamples = samples;
emit minHeightMapSamplesChanged(samples);
markDirty(HeightDirty);
}
void QQuick3DPrincipledMaterial::setMaxHeightMapSamples(int samples)
{
if (m_maxHeightMapSamples == samples)
return;
m_maxHeightMapSamples = samples;
emit maxHeightMapSamplesChanged(samples);
markDirty(HeightDirty);
}
QSSGRenderGraphObject *QQuick3DPrincipledMaterial::updateSpatialNode(QSSGRenderGraphObject *node)
{
static const auto channelMapping = [](TextureChannelMapping mapping) {
return QSSGRenderDefaultMaterial::TextureChannelMapping(mapping);
};
if (!node) {
markAllDirty();
node = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::PrincipledMaterial);
}
// 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 & BaseColorDirty) {
if (!m_baseColorMap)
material->colorMap = nullptr;
else
material->colorMap = m_baseColorMap->getRenderImage();
material->color = QSSGUtils::color::sRGBToLinear(m_baseColor);
material->baseColorSingleChannelEnabled = m_baseColorSingleChannelEnabled;
material->baseColorChannel = channelMapping(m_baseColorChannel);
}
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 & RoughnessDirty) {
if (!m_roughnessMap)
material->roughnessMap = nullptr;
else
material->roughnessMap = m_roughnessMap->getRenderImage();
material->specularRoughness = m_roughness;
material->roughnessChannel = channelMapping(m_roughnessChannel);
}
if (m_dirtyAttributes & MetalnessDirty) {
if (!m_metalnessMap)
material->metalnessMap = nullptr;
else
material->metalnessMap = m_metalnessMap->getRenderImage();
material->metalnessAmount = m_metalnessAmount;
material->metalnessChannel = channelMapping(m_metalnessChannel);
}
if (m_dirtyAttributes & SpecularDirty) {
if (!m_specularReflectionMap)
material->specularReflection = nullptr;
else
material->specularReflection = m_specularReflectionMap->getRenderImage();
if (!m_specularMap) {
material->specularMap = nullptr;
} else {
material->specularMap = m_specularMap->getRenderImage();
}
material->specularAmount = m_specularAmount;
material->specularTint = QVector3D(m_specularTint, m_specularTint, m_specularTint);
material->ior = m_indexOfRefraction;
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) {
material->opacity = m_opacity;
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 & SheenDirty) {
material->sheenColor = QSSGUtils::color::sRGBToLinear(m_sheenColor).toVector3D();
if (!m_sheenColorMap)
material->sheenColorMap = nullptr;
else
material->sheenColorMap = m_sheenColorMap->getRenderImage();
material->sheenRoughness = m_sheenRoughness;
if (!m_sheenRoughnessMap)
material->sheenRoughnessMap = nullptr;
else
material->sheenRoughnessMap = m_sheenRoughnessMap->getRenderImage();
material->sheenRoughnessChannel = channelMapping(m_sheenRoughnessChannel);
}
if (m_dirtyAttributes & AnisotropyDirty) {
material->anisotropyStrength = m_anisotropyStrength;
// The shader works in radians; degrees is only the QML facing unit
material->anisotropyRotation = qDegreesToRadians(m_anisotropyRotation);
if (!m_anisotropyMap)
material->anisotropyMap = nullptr;
else
material->anisotropyMap = m_anisotropyMap->getRenderImage();
}
if (m_dirtyAttributes & IridescenceDirty) {
material->iridescenceFactor = m_iridescenceFactor;
if (!m_iridescenceMap)
material->iridescenceMap = nullptr;
else
material->iridescenceMap = m_iridescenceMap->getRenderImage();
material->iridescenceChannel = channelMapping(m_iridescenceChannel);
material->iridescenceIndexOfRefraction = m_iridescenceIndexOfRefraction;
material->iridescenceThicknessMinimum = m_iridescenceThicknessMinimum;
material->iridescenceThicknessMaximum = m_iridescenceThicknessMaximum;
if (!m_iridescenceThicknessMap)
material->iridescenceThicknessMap = nullptr;
else
material->iridescenceThicknessMap = m_iridescenceThicknessMap->getRenderImage();
material->iridescenceThicknessChannel = channelMapping(m_iridescenceThicknessChannel);
}
if (m_dirtyAttributes & DispersionDirty)
material->dispersion = m_dispersion;
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 QQuick3DPrincipledMaterial::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
{
if (change == QQuick3DObject::ItemSceneChange)
updateSceneManager(value.sceneManager);
}
void QQuick3DPrincipledMaterial::updateSceneManager(QQuick3DSceneManager *sceneManager)
{
// Check all the resource value's scene manager, and update as necessary.
if (sceneManager) {
QQuick3DObjectPrivate::refSceneManager(m_baseColorMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_emissiveMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_specularReflectionMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_specularMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_roughnessMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_opacityMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_normalMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_metalnessMap, *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_sheenColorMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_sheenRoughnessMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_anisotropyMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_iridescenceMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_iridescenceThicknessMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_transmissionMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_thicknessMap, *sceneManager);
} else {
QQuick3DObjectPrivate::derefSceneManager(m_baseColorMap);
QQuick3DObjectPrivate::derefSceneManager(m_emissiveMap);
QQuick3DObjectPrivate::derefSceneManager(m_specularReflectionMap);
QQuick3DObjectPrivate::derefSceneManager(m_specularMap);
QQuick3DObjectPrivate::derefSceneManager(m_roughnessMap);
QQuick3DObjectPrivate::derefSceneManager(m_opacityMap);
QQuick3DObjectPrivate::derefSceneManager(m_normalMap);
QQuick3DObjectPrivate::derefSceneManager(m_metalnessMap);
QQuick3DObjectPrivate::derefSceneManager(m_occlusionMap);
QQuick3DObjectPrivate::derefSceneManager(m_heightMap);
QQuick3DObjectPrivate::derefSceneManager(m_clearcoatMap);
QQuick3DObjectPrivate::derefSceneManager(m_clearcoatRoughnessMap);
QQuick3DObjectPrivate::derefSceneManager(m_clearcoatNormalMap);
QQuick3DObjectPrivate::derefSceneManager(m_sheenColorMap);
QQuick3DObjectPrivate::derefSceneManager(m_sheenRoughnessMap);
QQuick3DObjectPrivate::derefSceneManager(m_anisotropyMap);
QQuick3DObjectPrivate::derefSceneManager(m_iridescenceMap);
QQuick3DObjectPrivate::derefSceneManager(m_iridescenceThicknessMap);
QQuick3DObjectPrivate::derefSceneManager(m_transmissionMap);
QQuick3DObjectPrivate::derefSceneManager(m_thicknessMap);
}
}
void QQuick3DPrincipledMaterial::markDirty(QQuick3DPrincipledMaterial::DirtyType type)
{
if (!(m_dirtyAttributes & quint32(type))) {
m_dirtyAttributes |= quint32(type);
update();
}
}
float QQuick3DPrincipledMaterial::clearcoatAmount() const
{
return m_clearcoatAmount;
}
void QQuick3DPrincipledMaterial::setClearcoatAmount(float newClearcoatAmount)
{
if (qFuzzyCompare(m_clearcoatAmount, newClearcoatAmount))
return;
m_clearcoatAmount = newClearcoatAmount;
emit clearcoatAmountChanged(m_clearcoatAmount);
markDirty(ClearcoatDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::clearcoatMap() const
{
return m_clearcoatMap;
}
void QQuick3DPrincipledMaterial::setClearcoatMap(QQuick3DTexture *newClearcoatMap)
{
if (m_clearcoatMap == newClearcoatMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setClearcoatMap, newClearcoatMap, m_clearcoatMap);
m_clearcoatMap = newClearcoatMap;
emit clearcoatMapChanged(m_clearcoatMap);
markDirty(ClearcoatDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::clearcoatChannel() const
{
return m_clearcoatChannel;
}
void QQuick3DPrincipledMaterial::setClearcoatChannel(QQuick3DMaterial::TextureChannelMapping newClearcoatChannel)
{
if (m_clearcoatChannel == newClearcoatChannel)
return;
m_clearcoatChannel = newClearcoatChannel;
emit clearcoatChannelChanged(m_clearcoatChannel);
markDirty(ClearcoatDirty);
}
float QQuick3DPrincipledMaterial::clearcoatRoughnessAmount() const
{
return m_clearcoatRoughnessAmount;
}
void QQuick3DPrincipledMaterial::setClearcoatRoughnessAmount(float newClearcoatRoughnessAmount)
{
if (qFuzzyCompare(m_clearcoatRoughnessAmount, newClearcoatRoughnessAmount))
return;
m_clearcoatRoughnessAmount = newClearcoatRoughnessAmount;
emit clearcoatRoughnessAmountChanged(m_clearcoatRoughnessAmount);
markDirty(ClearcoatDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::clearcoatRoughnessChannel() const
{
return m_clearcoatRoughnessChannel;
}
void QQuick3DPrincipledMaterial::setClearcoatRoughnessChannel(QQuick3DMaterial::TextureChannelMapping newClearcoatRoughnessChannel)
{
if (m_clearcoatRoughnessChannel == newClearcoatRoughnessChannel)
return;
m_clearcoatRoughnessChannel = newClearcoatRoughnessChannel;
emit clearcoatRoughnessChannelChanged(m_clearcoatRoughnessChannel);
markDirty(ClearcoatDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::clearcoatRoughnessMap() const
{
return m_clearcoatRoughnessMap;
}
void QQuick3DPrincipledMaterial::setClearcoatRoughnessMap(QQuick3DTexture *newClearcoatRoughnessMap)
{
if (m_clearcoatRoughnessMap == newClearcoatRoughnessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setClearcoatRoughnessMap, newClearcoatRoughnessMap, m_clearcoatRoughnessMap);
m_clearcoatRoughnessMap = newClearcoatRoughnessMap;
emit clearcoatRoughnessMapChanged(m_clearcoatRoughnessMap);
markDirty(ClearcoatDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::clearcoatNormalMap() const
{
return m_clearcoatNormalMap;
}
void QQuick3DPrincipledMaterial::setClearcoatNormalMap(QQuick3DTexture *newClearcoatNormalMap)
{
if (m_clearcoatNormalMap == newClearcoatNormalMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setClearcoatNormalMap, newClearcoatNormalMap, m_clearcoatNormalMap);
m_clearcoatNormalMap = newClearcoatNormalMap;
emit clearcoatNormalMapChanged(m_clearcoatNormalMap);
markDirty(ClearcoatDirty);
}
float QQuick3DPrincipledMaterial::clearcoatNormalStrength() const
{
return m_clearcoatNormalStrength;
}
void QQuick3DPrincipledMaterial::setClearcoatNormalStrength(float newClearcoatNormalStrength)
{
if (qFuzzyCompare(m_clearcoatNormalStrength, newClearcoatNormalStrength))
return;
m_clearcoatNormalStrength = newClearcoatNormalStrength;
emit clearcoatNormalStrengthChanged(m_clearcoatNormalStrength);
markDirty(ClearcoatDirty);
}
const QColor &QQuick3DPrincipledMaterial::sheenColor() const
{
return m_sheenColor;
}
void QQuick3DPrincipledMaterial::setSheenColor(const QColor &newSheenColor)
{
if (m_sheenColor == newSheenColor)
return;
m_sheenColor = newSheenColor;
emit sheenColorChanged(m_sheenColor);
markDirty(SheenDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::sheenColorMap() const
{
return m_sheenColorMap;
}
void QQuick3DPrincipledMaterial::setSheenColorMap(QQuick3DTexture *newSheenColorMap)
{
if (m_sheenColorMap == newSheenColorMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setSheenColorMap, newSheenColorMap, m_sheenColorMap);
m_sheenColorMap = newSheenColorMap;
emit sheenColorMapChanged(m_sheenColorMap);
markDirty(SheenDirty);
}
float QQuick3DPrincipledMaterial::sheenRoughness() const
{
return m_sheenRoughness;
}
void QQuick3DPrincipledMaterial::setSheenRoughness(float newSheenRoughness)
{
newSheenRoughness = ensureNormalized(newSheenRoughness);
if (qFuzzyCompare(m_sheenRoughness, newSheenRoughness))
return;
m_sheenRoughness = newSheenRoughness;
emit sheenRoughnessChanged(m_sheenRoughness);
markDirty(SheenDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::sheenRoughnessMap() const
{
return m_sheenRoughnessMap;
}
void QQuick3DPrincipledMaterial::setSheenRoughnessMap(QQuick3DTexture *newSheenRoughnessMap)
{
if (m_sheenRoughnessMap == newSheenRoughnessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setSheenRoughnessMap, newSheenRoughnessMap, m_sheenRoughnessMap);
m_sheenRoughnessMap = newSheenRoughnessMap;
emit sheenRoughnessMapChanged(m_sheenRoughnessMap);
markDirty(SheenDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::sheenRoughnessChannel() const
{
return m_sheenRoughnessChannel;
}
void QQuick3DPrincipledMaterial::setSheenRoughnessChannel(QQuick3DMaterial::TextureChannelMapping newSheenRoughnessChannel)
{
if (m_sheenRoughnessChannel == newSheenRoughnessChannel)
return;
m_sheenRoughnessChannel = newSheenRoughnessChannel;
emit sheenRoughnessChannelChanged(m_sheenRoughnessChannel);
markDirty(SheenDirty);
}
float QQuick3DPrincipledMaterial::anisotropyStrength() const
{
return m_anisotropyStrength;
}
void QQuick3DPrincipledMaterial::setAnisotropyStrength(float newAnisotropyStrength)
{
newAnisotropyStrength = ensureNormalized(newAnisotropyStrength);
if (qFuzzyCompare(m_anisotropyStrength, newAnisotropyStrength))
return;
m_anisotropyStrength = newAnisotropyStrength;
emit anisotropyStrengthChanged(m_anisotropyStrength);
markDirty(AnisotropyDirty);
}
float QQuick3DPrincipledMaterial::anisotropyRotation() const
{
return m_anisotropyRotation;
}
void QQuick3DPrincipledMaterial::setAnisotropyRotation(float newAnisotropyRotation)
{
if (qFuzzyCompare(m_anisotropyRotation, newAnisotropyRotation))
return;
// Not clamped: the rotation is periodic, so any angle is meaningful
m_anisotropyRotation = newAnisotropyRotation;
emit anisotropyRotationChanged(m_anisotropyRotation);
markDirty(AnisotropyDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::anisotropyMap() const
{
return m_anisotropyMap;
}
void QQuick3DPrincipledMaterial::setAnisotropyMap(QQuick3DTexture *newAnisotropyMap)
{
if (m_anisotropyMap == newAnisotropyMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setAnisotropyMap, newAnisotropyMap, m_anisotropyMap);
m_anisotropyMap = newAnisotropyMap;
emit anisotropyMapChanged(m_anisotropyMap);
markDirty(AnisotropyDirty);
}
float QQuick3DPrincipledMaterial::iridescenceFactor() const
{
return m_iridescenceFactor;
}
void QQuick3DPrincipledMaterial::setIridescenceFactor(float newIridescenceFactor)
{
newIridescenceFactor = ensureNormalized(newIridescenceFactor);
if (qFuzzyCompare(m_iridescenceFactor, newIridescenceFactor))
return;
m_iridescenceFactor = newIridescenceFactor;
emit iridescenceFactorChanged(m_iridescenceFactor);
markDirty(IridescenceDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::iridescenceMap() const
{
return m_iridescenceMap;
}
void QQuick3DPrincipledMaterial::setIridescenceMap(QQuick3DTexture *newIridescenceMap)
{
if (m_iridescenceMap == newIridescenceMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setIridescenceMap, newIridescenceMap, m_iridescenceMap);
m_iridescenceMap = newIridescenceMap;
emit iridescenceMapChanged(m_iridescenceMap);
markDirty(IridescenceDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::iridescenceChannel() const
{
return m_iridescenceChannel;
}
void QQuick3DPrincipledMaterial::setIridescenceChannel(QQuick3DMaterial::TextureChannelMapping newIridescenceChannel)
{
if (m_iridescenceChannel == newIridescenceChannel)
return;
m_iridescenceChannel = newIridescenceChannel;
emit iridescenceChannelChanged(m_iridescenceChannel);
markDirty(IridescenceDirty);
}
float QQuick3DPrincipledMaterial::iridescenceIndexOfRefraction() const
{
return m_iridescenceIndexOfRefraction;
}
void QQuick3DPrincipledMaterial::setIridescenceIndexOfRefraction(float newIridescenceIndexOfRefraction)
{
if (qFuzzyCompare(m_iridescenceIndexOfRefraction, newIridescenceIndexOfRefraction))
return;
m_iridescenceIndexOfRefraction = newIridescenceIndexOfRefraction;
emit iridescenceIndexOfRefractionChanged(m_iridescenceIndexOfRefraction);
markDirty(IridescenceDirty);
}
float QQuick3DPrincipledMaterial::iridescenceThicknessMinimum() const
{
return m_iridescenceThicknessMinimum;
}
void QQuick3DPrincipledMaterial::setIridescenceThicknessMinimum(float newIridescenceThicknessMinimum)
{
if (qFuzzyCompare(m_iridescenceThicknessMinimum, newIridescenceThicknessMinimum))
return;
m_iridescenceThicknessMinimum = newIridescenceThicknessMinimum;
emit iridescenceThicknessMinimumChanged(m_iridescenceThicknessMinimum);
markDirty(IridescenceDirty);
}
float QQuick3DPrincipledMaterial::iridescenceThicknessMaximum() const
{
return m_iridescenceThicknessMaximum;
}
void QQuick3DPrincipledMaterial::setIridescenceThicknessMaximum(float newIridescenceThicknessMaximum)
{
if (qFuzzyCompare(m_iridescenceThicknessMaximum, newIridescenceThicknessMaximum))
return;
m_iridescenceThicknessMaximum = newIridescenceThicknessMaximum;
emit iridescenceThicknessMaximumChanged(m_iridescenceThicknessMaximum);
markDirty(IridescenceDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::iridescenceThicknessMap() const
{
return m_iridescenceThicknessMap;
}
void QQuick3DPrincipledMaterial::setIridescenceThicknessMap(QQuick3DTexture *newIridescenceThicknessMap)
{
if (m_iridescenceThicknessMap == newIridescenceThicknessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setIridescenceThicknessMap, newIridescenceThicknessMap, m_iridescenceThicknessMap);
m_iridescenceThicknessMap = newIridescenceThicknessMap;
emit iridescenceThicknessMapChanged(m_iridescenceThicknessMap);
markDirty(IridescenceDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::iridescenceThicknessChannel() const
{
return m_iridescenceThicknessChannel;
}
void QQuick3DPrincipledMaterial::setIridescenceThicknessChannel(QQuick3DMaterial::TextureChannelMapping newIridescenceThicknessChannel)
{
if (m_iridescenceThicknessChannel == newIridescenceThicknessChannel)
return;
m_iridescenceThicknessChannel = newIridescenceThicknessChannel;
emit iridescenceThicknessChannelChanged(m_iridescenceThicknessChannel);
markDirty(IridescenceDirty);
}
float QQuick3DPrincipledMaterial::dispersion() const
{
return m_dispersion;
}
void QQuick3DPrincipledMaterial::setDispersion(float newDispersion)
{
// 20 / Abbe number, which has no upper bound
newDispersion = qMax(0.0f, newDispersion);
if (qFuzzyCompare(m_dispersion, newDispersion))
return;
m_dispersion = newDispersion;
emit dispersionChanged(m_dispersion);
markDirty(DispersionDirty);
}
float QQuick3DPrincipledMaterial::transmissionFactor() const
{
return m_transmissionFactor;
}
void QQuick3DPrincipledMaterial::setTransmissionFactor(float newTransmissionFactor)
{
if (qFuzzyCompare(m_transmissionFactor, newTransmissionFactor))
return;
m_transmissionFactor = newTransmissionFactor;
emit transmissionFactorChanged(m_transmissionFactor);
markDirty(TransmissionDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::transmissionMap() const
{
return m_transmissionMap;
}
void QQuick3DPrincipledMaterial::setTransmissionMap(QQuick3DTexture *newTransmissionMap)
{
if (m_transmissionMap == newTransmissionMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setTransmissionMap, newTransmissionMap, m_transmissionMap);
m_transmissionMap = newTransmissionMap;
emit transmissionMapChanged(m_transmissionMap);
markDirty(TransmissionDirty);
}
QQuick3DMaterial::TextureChannelMapping QQuick3DPrincipledMaterial::transmissionChannel() const
{
return m_transmissionChannel;
}
float QQuick3DPrincipledMaterial::indexOfRefraction() const
{
return m_indexOfRefraction;
}
bool QQuick3DPrincipledMaterial::fresnelScaleBiasEnabled() const
{
return m_fresnelScaleBiasEnabled;
}
float QQuick3DPrincipledMaterial::fresnelScale() const
{
return m_fresnelScale;
}
float QQuick3DPrincipledMaterial::fresnelBias() const
{
return m_fresnelBias;
}
float QQuick3DPrincipledMaterial::fresnelPower() const
{
return m_fresnelPower;
}
bool QQuick3DPrincipledMaterial::clearcoatFresnelScaleBiasEnabled() const
{
return m_clearcoatFresnelScaleBiasEnabled;
}
float QQuick3DPrincipledMaterial::clearcoatFresnelScale() const
{
return m_clearcoatFresnelScale;
}
float QQuick3DPrincipledMaterial::clearcoatFresnelBias() const
{
return m_clearcoatFresnelBias;
}
float QQuick3DPrincipledMaterial::clearcoatFresnelPower() const
{
return m_clearcoatFresnelPower;
}
bool QQuick3DPrincipledMaterial::vertexColorsEnabled() const
{
return m_vertexColorsEnabled;
}
void QQuick3DPrincipledMaterial::setTransmissionChannel(QQuick3DMaterial::TextureChannelMapping newTransmissionChannel)
{
if (m_transmissionChannel == newTransmissionChannel)
return;
m_transmissionChannel = newTransmissionChannel;
emit transmissionChannelChanged(m_transmissionChannel);
markDirty(TransmissionDirty);
}
float QQuick3DPrincipledMaterial::thicknessFactor() const
{
return m_thicknessFactor;
}
void QQuick3DPrincipledMaterial::setThicknessFactor(float newThicknessFactor)
{
if (qFuzzyCompare(m_thicknessFactor, newThicknessFactor))
return;
m_thicknessFactor = newThicknessFactor;
emit thicknessFactorChanged(m_thicknessFactor);
markDirty(VolumeDirty);
}
QQuick3DTexture *QQuick3DPrincipledMaterial::thicknessMap() const
{
return m_thicknessMap;
}
void QQuick3DPrincipledMaterial::setThicknessMap(QQuick3DTexture *newThicknessMap)
{
if (m_thicknessMap == newThicknessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DPrincipledMaterial::setThicknessMap, newThicknessMap, m_thicknessMap);
m_thicknessMap = newThicknessMap;
emit thicknessMapChanged(m_thicknessMap);
markDirty(VolumeDirty);
}
const QQuick3DMaterial::TextureChannelMapping &QQuick3DPrincipledMaterial::thicknessChannel() const
{
return m_thicknessChannel;
}
void QQuick3DPrincipledMaterial::setThicknessChannel(const QQuick3DMaterial::TextureChannelMapping &newThicknessChannel)
{
if (m_thicknessChannel == newThicknessChannel)
return;
m_thicknessChannel = newThicknessChannel;
emit thicknessChannelChanged(m_thicknessChannel);
markDirty(VolumeDirty);
}
float QQuick3DPrincipledMaterial::attenuationDistance() const
{
return m_attenuationDistance;
}
void QQuick3DPrincipledMaterial::setAttenuationDistance(float newAttenuationDistance)
{
if (qFuzzyCompare(m_attenuationDistance, newAttenuationDistance))
return;
m_attenuationDistance = newAttenuationDistance;
emit attenuationDistanceChanged(m_attenuationDistance);
markDirty(VolumeDirty);
}
const QColor &QQuick3DPrincipledMaterial::attenuationColor() const
{
return m_attenuationColor;
}
void QQuick3DPrincipledMaterial::setAttenuationColor(const QColor &newAttenuationColor)
{
if (m_attenuationColor == newAttenuationColor)
return;
m_attenuationColor = newAttenuationColor;
emit attenuationColorChanged(m_attenuationColor);
markDirty(VolumeDirty);
}
void QQuick3DPrincipledMaterial::setIndexOfRefraction(float indexOfRefraction)
{
if (qFuzzyCompare(m_indexOfRefraction, indexOfRefraction))
return;
m_indexOfRefraction = indexOfRefraction;
emit indexOfRefractionChanged(m_indexOfRefraction);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setFresnelScaleBiasEnabled(bool fresnelScaleBiasEnabled)
{
if (m_fresnelScaleBiasEnabled == fresnelScaleBiasEnabled)
return;
m_fresnelScaleBiasEnabled = fresnelScaleBiasEnabled;
emit fresnelScaleBiasEnabledChanged(m_fresnelScaleBiasEnabled);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setFresnelScale(float fresnelScale)
{
if (qFuzzyCompare(m_fresnelScale, fresnelScale))
return;
m_fresnelScale = fresnelScale;
emit fresnelScaleChanged(m_fresnelScale);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setFresnelBias(float fresnelBias)
{
if (qFuzzyCompare(m_fresnelBias, fresnelBias))
return;
m_fresnelBias = fresnelBias;
emit fresnelBiasChanged(m_fresnelBias);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setFresnelPower(float fresnelPower)
{
if (qFuzzyCompare(m_fresnelPower, fresnelPower))
return;
m_fresnelPower = fresnelPower;
emit fresnelPowerChanged(m_fresnelPower);
markDirty(SpecularDirty);
}
void QQuick3DPrincipledMaterial::setClearcoatFresnelScaleBiasEnabled(bool clearcoatFresnelScaleBiasEnabled)
{
if (m_clearcoatFresnelScaleBiasEnabled == clearcoatFresnelScaleBiasEnabled)
return;
m_clearcoatFresnelScaleBiasEnabled = clearcoatFresnelScaleBiasEnabled;
emit clearcoatFresnelScaleBiasEnabledChanged(m_clearcoatFresnelScaleBiasEnabled);
markDirty(ClearcoatDirty);
}
void QQuick3DPrincipledMaterial::setClearcoatFresnelScale(float clearcoatFresnelScale)
{
if (qFuzzyCompare(m_clearcoatFresnelScale, clearcoatFresnelScale))
return;
m_clearcoatFresnelScale = clearcoatFresnelScale;
emit clearcoatFresnelScaleChanged(m_clearcoatFresnelScale);
markDirty(ClearcoatDirty);
}
void QQuick3DPrincipledMaterial::setClearcoatFresnelBias(float clearcoatFresnelBias)
{
if (qFuzzyCompare(m_clearcoatFresnelBias, clearcoatFresnelBias))
return;
m_clearcoatFresnelBias = clearcoatFresnelBias;
emit clearcoatFresnelBiasChanged(m_clearcoatFresnelBias);
markDirty(ClearcoatDirty);
}
void QQuick3DPrincipledMaterial::setClearcoatFresnelPower(float clearcoatFresnelPower)
{
if (qFuzzyCompare(m_clearcoatFresnelPower, clearcoatFresnelPower))
return;
m_clearcoatFresnelPower = clearcoatFresnelPower;
emit clearcoatFresnelPowerChanged(m_clearcoatFresnelPower);
markDirty(ClearcoatDirty);
}
void QQuick3DPrincipledMaterial::setVertexColorsEnabled(bool vertexColors)
{
if (m_vertexColorsEnabled == vertexColors)
return;
m_vertexColorsEnabled = vertexColors;
emit vertexColorsEnabledChanged(m_vertexColorsEnabled);
markDirty(VertexColorsDirty);
}
bool QQuick3DPrincipledMaterial::vertexColorsMaskEnabled() const
{
return m_vertexColorsMaskEnabled;
}
void QQuick3DPrincipledMaterial::setVertexColorsMaskEnabled(bool vertexColorsMaskEnabled)
{
if (m_vertexColorsMaskEnabled == vertexColorsMaskEnabled)
return;
m_vertexColorsMaskEnabled = vertexColorsMaskEnabled;
emit vertexColorsMaskEnabledChanged();
markDirty(VertexColorsDirty);
}
QQuick3DPrincipledMaterial::VertexColorMaskFlags QQuick3DPrincipledMaterial::vertexColorRedMask() const
{
return m_vertexColorRedMask;
}
void QQuick3DPrincipledMaterial::setVertexColorRedMask(QQuick3DPrincipledMaterial::VertexColorMaskFlags vertexColorRedMask)
{
if (m_vertexColorRedMask == vertexColorRedMask)
return;
m_vertexColorRedMask = vertexColorRedMask;
emit vertexColorRedMaskChanged();
markDirty(VertexColorsDirty);
}
QQuick3DPrincipledMaterial::VertexColorMaskFlags QQuick3DPrincipledMaterial::vertexColorGreenMask() const
{
return m_vertexColorGreenMask;
}
void QQuick3DPrincipledMaterial::setVertexColorGreenMask(QQuick3DPrincipledMaterial::VertexColorMaskFlags vertexColorGreenMask)
{
if (m_vertexColorGreenMask == vertexColorGreenMask)
return;
m_vertexColorGreenMask = vertexColorGreenMask;
emit vertexColorGreenMaskChanged();
markDirty(VertexColorsDirty);
}
QQuick3DPrincipledMaterial::VertexColorMaskFlags QQuick3DPrincipledMaterial::vertexColorBlueMask() const
{
return m_vertexColorBlueMask;
}
void QQuick3DPrincipledMaterial::setVertexColorBlueMask(QQuick3DPrincipledMaterial::VertexColorMaskFlags vertexColorBlueMask)
{
if (m_vertexColorBlueMask == vertexColorBlueMask)
return;
m_vertexColorBlueMask = vertexColorBlueMask;
emit vertexColorBlueMaskChanged();
markDirty(VertexColorsDirty);
}
QQuick3DPrincipledMaterial::VertexColorMaskFlags QQuick3DPrincipledMaterial::vertexColorAlphaMask() const
{
return m_vertexColorAlphaMask;
}
void QQuick3DPrincipledMaterial::setVertexColorAlphaMask(QQuick3DPrincipledMaterial::VertexColorMaskFlags vertexColorAlphaMask)
{
if (m_vertexColorAlphaMask == vertexColorAlphaMask)
return;
m_vertexColorAlphaMask = vertexColorAlphaMask;
emit vertexColorAlphaMaskChanged();
markDirty(VertexColorsDirty);
}
QT_END_NAMESPACE