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 "qquick3ddefaultmaterial_p.h"
#include "qquick3dobject_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrenderdefaultmaterial_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
QT_BEGIN_NAMESPACE
/*!
\qmltype DefaultMaterial
\inherits Material
\inqmlmodule QtQuick3D
\brief Lets you define a material for 3D items using the specular/glossiness workflow.
\deprecated [6.4] Prefer using the \l PrincipledMaterial or \l SpecularGlossyMaterial instead.
\warning This material is only provided for compatibility reasons, and should not be used in new code.
Prefer using the \l SpecularGlossyMaterial for creating materials using the specular/glossiness
workflow or the \l PrincipledMaterial for creating materials 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 DefaultMaterial is an easy to
use material that lets you describe your material using a specular/glossiness type workflow.
The material has sensible default and can be used to shade a model without changing any properties.
\section1 Specular/Glossiness workflow
The Default material provides a way to create materials using a specular/glossiness
type workflow. The main properties of the material are controlled through the
\l {DefaultMaterial::specularMap} {specular}, \l {DefaultMaterial::roughnessMap} {roughness},
and the \l {DefaultMaterial::diffuseMap} {diffuse color} property.
\section2 Specular
The \l {DefaultMaterial::specularMap} {specular reflectivity} describes the specular
amount and color of an object's surface. For reflective materials the main color
contribution, comes from this property.
\section2 Glossiness (Roughness)
The glossiness of a surface depends on how smooth or irregular the surface is.
A smooth surface will have a more intense light reflection then a rough surface, where
the light reflection will be more spread out. In the Default material the material's glossiness
is controlled through the \l {DefaultMaterial::roughnessMap} {roughness} property.
\section2 Diffuse color
The \l {DefaultMaterial::diffuseMap} {diffuse color} property describes the basic color
of the material, and unlike the \l {PrincipledMaterial}'s base color, the diffuse color
does not contain any information about the material reflectance. However, for
reflective surfaces the diffuse color should be set to a black tint, as that will allow
for the specular color to contribute.
*/
/*!
\qmlproperty enumeration DefaultMaterial::lighting
This property defines which lighting method is used when generating this
material.
The default value is \c DefaultMaterial.FragmentLighting
When using \c DefaultMaterial.FragmentLighting, diffuse and specular lighting are
calculated for each rendered pixel. Certain effects (such as a Fresnel or bump map) require
\c DefaultMaterial.FragmentLighting to work.
When using \c DefaultMaterial.NoLighting no lighting is calculated. This
mode is (predictably) very fast, and quite effective when image maps are
used that do not need to be shaded by lighting.
\value DefaultMaterial.NoLighting No lighting is calculated.
\value DefaultMaterial.FragmentLighting Per-fragment lighting is calculated.
*/
/*!
\qmlproperty enumeration DefaultMaterial::blendMode
This property determines how the colors of the model rendered blend with
those behind it.
\value DefaultMaterial.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} and there are no
texture maps in the material with semi-transparent pixels in them, 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 DefaultMaterial.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 \e popping as faces
or models sort differently, using Screen blending is one way to produce
results without popping.
\value DefaultMaterial.Multiply Colors are blended using a multiply,
producing a darker result. This blend mode is also order-independent.
\sa {Qt Quick 3D Architecture}
*/
/*!
\qmlproperty color DefaultMaterial::diffuseColor
This property determines the diffuse color (albedo) for the material. Setting the
diffuse color to a black tint will create a purely-specular material (e.g. metals or mirrors).
*/
/*!
\qmlproperty Texture DefaultMaterial::diffuseMap
This property defines a Texture to apply to the material. Using Texture
with transparency will also apply the alpha channel as an opacity map.
*/
/*!
\qmlproperty vector3d DefaultMaterial::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 DefaultMaterial::emissiveMap
This property sets a RGB Texture to be used to specify the intensity of the
emissive color.
\sa emissiveFactor
*/
/*!
\qmlproperty Texture DefaultMaterial::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 DefaultMaterial::specularMap
This 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.
*/
/*!
\qmlproperty enumeration DefaultMaterial::specularModel
This property determines which functions are used to calculate specular
highlights for lights in the scene.
\value DefaultMaterial.Default Specular lighting uses default lighting model.
\value DefaultMaterial.KGGX Specular lighting uses GGX lighting model.
*/
/*!
\qmlproperty color DefaultMaterial::specularTint
This property defines a color used to adjust the specular reflections.
Use white for no effect
*/
/*!
\qmlproperty real DefaultMaterial::indexOfRefraction
This property controls what angles of reflections are affected by the
fresnelPower. The default is \c 1.45. The value must be greater or equal to \c 1.0.
\note No known material in the world have ior much greater than \c 3.0.
*/
/*!
\qmlproperty real DefaultMaterial::fresnelPower
This property decreases head-on reflections (looking directly at the
surface) while maintaining reflections seen at grazing angles.
The default value is \c 0 disabling the fresnel effect.
*/
/*!
\qmlproperty real DefaultMaterial::specularAmount
This property controls the strength of specularity (highlights and
reflections). The default value is \c 0 disabling the specularity. The range is [0.0, 1.0].
\note This property does not affect the \l specularReflectionMap, but does
affect the amount of reflections from a scene's SceneEnvironment::lightProbe.
\note Unless your mesh is high resolution, you may need to use
\c DefaultMaterial.FragmentLighting to get good specular highlights from scene
lights.
*/
/*!
\qmlproperty real DefaultMaterial::specularRoughness
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 DefaultMaterial::roughnessMap
This property defines a Texture to control the specular roughness of the
material. If the texture contains multiple channels(RGBA), then the correct channel
can be set using the roughnessChannel property.
*/
/*!
\qmlproperty enumeration DefaultMaterial::roughnessChannel
This property defines the texture channel used to read the roughness value from roughnessMap.
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 DefaultMaterial::opacity
This property drops the opacity of just this material, separate from the model.
The default is \c 1.0. The range is [0.0, 1.0].
*/
/*!
\qmlproperty Texture DefaultMaterial::opacityMap
This property defines a Texture used to control the opacity differently for
different parts of the material.
*/
/*!
\qmlproperty enumeration DefaultMaterial::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 DefaultMaterial::bumpMap
This property defines a grayscale Texture to simulate fine geometry
displacement across the surface of the material. Brighter pixels indicate
raised regions. The amount of the effect is controlled by the
\l bumpAmount property.
\note bump maps will not affect the silhouette of a model.
*/
/*!
\qmlproperty real DefaultMaterial::bumpAmount
This property controls the amount of simulated displacement for the
\l bumpMap or \l normalMap. The default value is \c 0 disabling the bump effect.
The range is [0, 1].
*/
/*!
\qmlproperty Texture DefaultMaterial::normalMap
This property defines a RGB image used to simulate fine geometry
displacement across the surface of the material. The RGB channels indicate
XYZ normal deviations. The amount of the effect is controlled by the
\l bumpAmount property.
\note Normal maps will not affect the silhouette of a model.
*/
/*!
\qmlproperty Texture DefaultMaterial::translucencyMap
This property defines a grayscale Texture controlling how much light can
pass through the material from behind.
*/
/*!
\qmlproperty enumeration DefaultMaterial::translucencyChannel
This property defines the texture channel used to read the translucency value from translucencyMap.
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 real DefaultMaterial::translucentFalloff
This property defines the amount of falloff for the translucency based on the
angle of the normals of the object to the light source.
*/
/*!
\qmlproperty real DefaultMaterial::diffuseLightWrap
This property determines the amount of light wrap for the translucency map.
A value of 0 will not wrap the light at all, while a value of 1 will wrap
the light all around the object.
*/
/*!
\qmlproperty bool DefaultMaterial::vertexColorsEnabled
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.
*/
/*!
\qmlproperty real DefaultMaterial::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 DefaultMaterial::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.
\note Unlike most other material properties, the line width is under the
hood baked in to a graphics pipeline object, similarly to blendMode.
Therefore, a different value leads to having to create a new pipeline
object, which over time can become costly (performance and resource usage)
if the property is frequently changed to many different values. For
example, animating this property is possible, but should be avoided.
*/
QQuick3DDefaultMaterial::QQuick3DDefaultMaterial(QQuick3DObject *parent)
: QQuick3DMaterial(*(new QQuick3DObjectPrivate(QQuick3DObjectPrivate::Type::DefaultMaterial)), parent)
, m_diffuseColor(Qt::white)
, m_specularTint(Qt::white)
{}
QQuick3DDefaultMaterial::~QQuick3DDefaultMaterial()
{
}
QQuick3DDefaultMaterial::Lighting QQuick3DDefaultMaterial::lighting() const
{
return m_lighting;
}
QQuick3DDefaultMaterial::BlendMode QQuick3DDefaultMaterial::blendMode() const
{
return m_blendMode;
}
QColor QQuick3DDefaultMaterial::diffuseColor() const
{
return m_diffuseColor;
}
QQuick3DTexture *QQuick3DDefaultMaterial::diffuseMap() const
{
return m_diffuseMap;
}
QVector3D QQuick3DDefaultMaterial::emissiveFactor() const
{
return m_emissiveFactor;
}
QQuick3DTexture *QQuick3DDefaultMaterial::emissiveMap() const
{
return m_emissiveMap;
}
QQuick3DTexture *QQuick3DDefaultMaterial::specularReflectionMap() const
{
return m_specularReflectionMap;
}
QQuick3DTexture *QQuick3DDefaultMaterial::specularMap() const
{
return m_specularMap;
}
QQuick3DDefaultMaterial::SpecularModel QQuick3DDefaultMaterial::specularModel() const
{
return m_specularModel;
}
QColor QQuick3DDefaultMaterial::specularTint() const
{
return m_specularTint;
}
float QQuick3DDefaultMaterial::indexOfRefraction() const
{
return m_indexOfRefraction;
}
float QQuick3DDefaultMaterial::fresnelPower() const
{
return m_fresnelPower;
}
float QQuick3DDefaultMaterial::specularAmount() const
{
return m_specularAmount;
}
float QQuick3DDefaultMaterial::specularRoughness() const
{
return m_specularRoughness;
}
QQuick3DTexture *QQuick3DDefaultMaterial::roughnessMap() const
{
return m_roughnessMap;
}
float QQuick3DDefaultMaterial::opacity() const
{
return m_opacity;
}
QQuick3DTexture *QQuick3DDefaultMaterial::opacityMap() const
{
return m_opacityMap;
}
QQuick3DTexture *QQuick3DDefaultMaterial::bumpMap() const
{
return m_bumpMap;
}
float QQuick3DDefaultMaterial::bumpAmount() const
{
return m_bumpAmount;
}
QQuick3DTexture *QQuick3DDefaultMaterial::normalMap() const
{
return m_normalMap;
}
QQuick3DTexture *QQuick3DDefaultMaterial::translucencyMap() const
{
return m_translucencyMap;
}
float QQuick3DDefaultMaterial::translucentFalloff() const
{
return m_translucentFalloff;
}
float QQuick3DDefaultMaterial::diffuseLightWrap() const
{
return m_diffuseLightWrap;
}
bool QQuick3DDefaultMaterial::vertexColorsEnabled() const
{
return m_vertexColorsEnabled;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DDefaultMaterial::roughnessChannel() const
{
return m_roughnessChannel;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DDefaultMaterial::opacityChannel() const
{
return m_opacityChannel;
}
QQuick3DMaterial::TextureChannelMapping QQuick3DDefaultMaterial::translucencyChannel() const
{
return m_translucencyChannel;
}
float QQuick3DDefaultMaterial::pointSize() const
{
return m_pointSize;
}
float QQuick3DDefaultMaterial::lineWidth() const
{
return m_lineWidth;
}
void QQuick3DDefaultMaterial::markAllDirty()
{
m_dirtyAttributes = 0xffffffff;
QQuick3DMaterial::markAllDirty();
}
void QQuick3DDefaultMaterial::setLighting(QQuick3DDefaultMaterial::Lighting lighting)
{
if (m_lighting == lighting)
return;
m_lighting = lighting;
emit lightingChanged(m_lighting);
markDirty(LightingModeDirty);
}
void QQuick3DDefaultMaterial::setBlendMode(QQuick3DDefaultMaterial::BlendMode blendMode)
{
if (m_blendMode == blendMode)
return;
m_blendMode = blendMode;
emit blendModeChanged(m_blendMode);
markDirty(BlendModeDirty);
}
void QQuick3DDefaultMaterial::setDiffuseColor(QColor diffuseColor)
{
if (m_diffuseColor == diffuseColor)
return;
m_diffuseColor = diffuseColor;
emit diffuseColorChanged(m_diffuseColor);
markDirty(DiffuseDirty);
}
void QQuick3DDefaultMaterial::setDiffuseMap(QQuick3DTexture *diffuseMap)
{
if (m_diffuseMap == diffuseMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setDiffuseMap, diffuseMap, m_diffuseMap);
m_diffuseMap = diffuseMap;
emit diffuseMapChanged(m_diffuseMap);
markDirty(DiffuseDirty);
}
void QQuick3DDefaultMaterial::setEmissiveFactor(QVector3D emissiveFactor)
{
if (m_emissiveFactor == emissiveFactor)
return;
m_emissiveFactor = emissiveFactor;
emit emissiveFactorChanged(m_emissiveFactor);
markDirty(EmissiveDirty);
}
void QQuick3DDefaultMaterial::setEmissiveMap(QQuick3DTexture *emissiveMap)
{
if (m_emissiveMap == emissiveMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setEmissiveMap, emissiveMap, m_emissiveMap);
m_emissiveMap = emissiveMap;
emit emissiveMapChanged(m_emissiveMap);
markDirty(EmissiveDirty);
}
void QQuick3DDefaultMaterial::setSpecularReflectionMap(QQuick3DTexture *specularReflectionMap)
{
if (m_specularReflectionMap == specularReflectionMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setSpecularReflectionMap, specularReflectionMap, m_specularReflectionMap);
m_specularReflectionMap = specularReflectionMap;
emit specularReflectionMapChanged(m_specularReflectionMap);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setSpecularMap(QQuick3DTexture *specularMap)
{
if (m_specularMap == specularMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setSpecularMap, specularMap, m_specularMap);
m_specularMap = specularMap;
emit specularMapChanged(m_specularMap);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setSpecularModel(QQuick3DDefaultMaterial::SpecularModel specularModel)
{
if (m_specularModel == specularModel)
return;
m_specularModel = specularModel;
emit specularModelChanged(m_specularModel);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setSpecularTint(QColor specularTint)
{
if (m_specularTint == specularTint)
return;
m_specularTint = specularTint;
emit specularTintChanged(m_specularTint);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setIndexOfRefraction(float indexOfRefraction)
{
if (qFuzzyCompare(m_indexOfRefraction, indexOfRefraction))
return;
m_indexOfRefraction = indexOfRefraction;
emit indexOfRefractionChanged(m_indexOfRefraction);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setFresnelPower(float fresnelPower)
{
if (qFuzzyCompare(m_fresnelPower, fresnelPower))
return;
m_fresnelPower = fresnelPower;
emit fresnelPowerChanged(m_fresnelPower);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setSpecularAmount(float specularAmount)
{
if (qFuzzyCompare(m_specularAmount, specularAmount))
return;
m_specularAmount = specularAmount;
emit specularAmountChanged(m_specularAmount);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setSpecularRoughness(float specularRoughness)
{
if (qFuzzyCompare(m_specularRoughness, specularRoughness))
return;
m_specularRoughness = specularRoughness;
emit specularRoughnessChanged(m_specularRoughness);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setRoughnessMap(QQuick3DTexture *roughnessMap)
{
if (m_roughnessMap == roughnessMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setRoughnessMap, roughnessMap, m_roughnessMap);
m_roughnessMap = roughnessMap;
emit roughnessMapChanged(m_roughnessMap);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setOpacity(float opacity)
{
if (qFuzzyCompare(m_opacity, opacity))
return;
if (opacity > 1.0f)
opacity = 1.0f;
if (opacity < 0.0f)
opacity = 0.0f;
m_opacity = opacity;
emit opacityChanged(m_opacity);
markDirty(OpacityDirty);
}
void QQuick3DDefaultMaterial::setOpacityMap(QQuick3DTexture *opacityMap)
{
if (m_opacityMap == opacityMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setOpacityMap, opacityMap, m_opacityMap);
m_opacityMap = opacityMap;
emit opacityMapChanged(m_opacityMap);
markDirty(OpacityDirty);
}
void QQuick3DDefaultMaterial::setBumpMap(QQuick3DTexture *bumpMap)
{
if (m_bumpMap == bumpMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setBumpMap, bumpMap, m_bumpMap);
m_bumpMap = bumpMap;
emit bumpMapChanged(m_bumpMap);
markDirty(BumpDirty);
}
void QQuick3DDefaultMaterial::setBumpAmount(float bumpAmount)
{
if (qFuzzyCompare(m_bumpAmount, bumpAmount))
return;
m_bumpAmount = bumpAmount;
emit bumpAmountChanged(m_bumpAmount);
markDirty(BumpDirty);
}
void QQuick3DDefaultMaterial::setNormalMap(QQuick3DTexture *normalMap)
{
if (m_normalMap == normalMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setNormalMap, normalMap, m_normalMap);
m_normalMap = normalMap;
emit normalMapChanged(m_normalMap);
markDirty(NormalDirty);
}
void QQuick3DDefaultMaterial::setTranslucencyMap(QQuick3DTexture *translucencyMap)
{
if (m_translucencyMap == translucencyMap)
return;
QQuick3DObjectPrivate::attachWatcher(this, &QQuick3DDefaultMaterial::setTranslucencyMap, translucencyMap, m_translucencyMap);
m_translucencyMap = translucencyMap;
emit translucencyMapChanged(m_translucencyMap);
markDirty(TranslucencyDirty);
}
void QQuick3DDefaultMaterial::setTranslucentFalloff(float translucentFalloff)
{
if (qFuzzyCompare(m_translucentFalloff, translucentFalloff))
return;
m_translucentFalloff = translucentFalloff;
emit translucentFalloffChanged(m_translucentFalloff);
markDirty(TranslucencyDirty);
}
void QQuick3DDefaultMaterial::setDiffuseLightWrap(float diffuseLightWrap)
{
if (qFuzzyCompare(m_diffuseLightWrap, diffuseLightWrap))
return;
m_diffuseLightWrap = diffuseLightWrap;
emit diffuseLightWrapChanged(m_diffuseLightWrap);
markDirty(DiffuseDirty);
}
void QQuick3DDefaultMaterial::setVertexColorsEnabled(bool vertexColors)
{
if (m_vertexColorsEnabled == vertexColors)
return;
m_vertexColorsEnabled = vertexColors;
emit vertexColorsEnabledChanged(m_vertexColorsEnabled);
markDirty(VertexColorsDirty);
}
void QQuick3DDefaultMaterial::setRoughnessChannel(TextureChannelMapping channel)
{
if (m_roughnessChannel == channel)
return;
m_roughnessChannel = channel;
emit roughnessChannelChanged(channel);
markDirty(SpecularDirty);
}
void QQuick3DDefaultMaterial::setOpacityChannel(TextureChannelMapping channel)
{
if (m_opacityChannel == channel)
return;
m_opacityChannel = channel;
emit opacityChannelChanged(channel);
markDirty(OpacityDirty);
}
void QQuick3DDefaultMaterial::setTranslucencyChannel(TextureChannelMapping channel)
{
if (m_translucencyChannel == channel)
return;
m_translucencyChannel = channel;
emit translucencyChannelChanged(channel);
markDirty(TranslucencyDirty);
}
void QQuick3DDefaultMaterial::setPointSize(float size)
{
if (qFuzzyCompare(m_pointSize, size))
return;
m_pointSize = size;
emit pointSizeChanged();
markDirty(PointSizeDirty);
}
void QQuick3DDefaultMaterial::setLineWidth(float width)
{
if (qFuzzyCompare(m_lineWidth, width))
return;
m_lineWidth = width;
emit lineWidthChanged();
markDirty(LineWidthDirty);
}
QSSGRenderGraphObject *QQuick3DDefaultMaterial::updateSpatialNode(QSSGRenderGraphObject *node)
{
if (!node) {
markAllDirty();
node = new QSSGRenderDefaultMaterial(QSSGRenderGraphObject::Type::DefaultMaterial);
}
static const auto channelMapping = [](TextureChannelMapping mapping) {
return QSSGRenderDefaultMaterial::TextureChannelMapping(mapping);
};
// Set common material properties
QQuick3DMaterial::updateSpatialNode(node);
QSSGRenderDefaultMaterial *material = static_cast<QSSGRenderDefaultMaterial *>(node);
if (m_dirtyAttributes & LightingModeDirty) {
material->lighting = QSSGRenderDefaultMaterial::MaterialLighting(m_lighting);
// If the lighthing mode changes it affects the emissive property
m_dirtyAttributes |= EmissiveDirty;
}
if (m_dirtyAttributes & BlendModeDirty)
material->blendMode = QSSGRenderDefaultMaterial::MaterialBlendMode(m_blendMode);
if (m_dirtyAttributes & DiffuseDirty) {
material->color = QSSGUtils::color::sRGBToLinear(m_diffuseColor);
if (!m_diffuseMap)
material->colorMap = nullptr;
else
material->colorMap = m_diffuseMap->getRenderImage();
material->diffuseLightWrap = m_diffuseLightWrap;
material->diffuseModel = QSSGRenderDefaultMaterial::MaterialDiffuseModel::Lambert;
}
if (m_dirtyAttributes & EmissiveDirty) {
if (!m_emissiveMap)
material->emissiveMap = nullptr;
else
material->emissiveMap = m_emissiveMap->getRenderImage();
material->emissiveColor = m_emissiveFactor;
}
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->specularModel = QSSGRenderDefaultMaterial::MaterialSpecularModel(m_specularModel);
material->specularTint = QSSGUtils::color::sRGBToLinear(m_specularTint).toVector3D();
material->ior = m_indexOfRefraction;
material->fresnelPower = m_fresnelPower;
material->specularAmount = m_specularAmount;
material->specularRoughness = m_specularRoughness;
material->roughnessChannel = channelMapping(m_roughnessChannel);
if (!m_roughnessMap)
material->roughnessMap = nullptr;
else
material->roughnessMap = m_roughnessMap->getRenderImage();
}
if (m_dirtyAttributes & OpacityDirty) {
material->opacity = m_opacity;
material->opacityChannel = channelMapping(m_opacityChannel);
if (!m_opacityMap)
material->opacityMap = nullptr;
else
material->opacityMap = m_opacityMap->getRenderImage();
}
if (m_dirtyAttributes & BumpDirty) {
if (!m_bumpMap)
material->bumpMap = nullptr;
else
material->bumpMap = m_bumpMap->getRenderImage();
material->bumpAmount = m_bumpAmount;
}
if (m_dirtyAttributes & NormalDirty) {
if (!m_normalMap)
material->normalMap = nullptr;
else
material->normalMap = m_normalMap->getRenderImage();
}
if (m_dirtyAttributes & TranslucencyDirty) {
if (!m_translucencyMap)
material->translucencyMap = nullptr;
else
material->translucencyMap = m_translucencyMap->getRenderImage();
material->translucentFalloff = m_translucentFalloff;
material->translucencyChannel = channelMapping(m_translucencyChannel);
}
if (m_dirtyAttributes & VertexColorsDirty)
material->vertexColorsEnabled = m_vertexColorsEnabled;
if (m_dirtyAttributes & PointSizeDirty)
material->pointSize = m_pointSize;
if (m_dirtyAttributes & LineWidthDirty)
material->lineWidth = m_lineWidth;
m_dirtyAttributes = 0;
return node;
}
void QQuick3DDefaultMaterial::itemChange(QQuick3DObject::ItemChange change, const QQuick3DObject::ItemChangeData &value)
{
if (change == QQuick3DObject::ItemSceneChange)
updateSceneManager(value.sceneManager);
}
void QQuick3DDefaultMaterial::updateSceneManager(QQuick3DSceneManager *sceneManager)
{
// Check all the resource value's windows, and update as necessary
if (sceneManager) {
QQuick3DObjectPrivate::refSceneManager(m_diffuseMap, *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_bumpMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_normalMap, *sceneManager);
QQuick3DObjectPrivate::refSceneManager(m_translucencyMap, *sceneManager);
} else {
QQuick3DObjectPrivate::derefSceneManager(m_diffuseMap);
QQuick3DObjectPrivate::derefSceneManager(m_emissiveMap);
QQuick3DObjectPrivate::derefSceneManager(m_specularReflectionMap);
QQuick3DObjectPrivate::derefSceneManager(m_specularMap);
QQuick3DObjectPrivate::derefSceneManager(m_roughnessMap);
QQuick3DObjectPrivate::derefSceneManager(m_opacityMap);
QQuick3DObjectPrivate::derefSceneManager(m_bumpMap);
QQuick3DObjectPrivate::derefSceneManager(m_normalMap);
QQuick3DObjectPrivate::derefSceneManager(m_translucencyMap);
}
}
void QQuick3DDefaultMaterial::markDirty(QQuick3DDefaultMaterial::DirtyType type)
{
if (!(m_dirtyAttributes & quint32(type))) {
m_dirtyAttributes |= quint32(type);
update();
}
}
QT_END_NAMESPACE