1/****************************************************************************
2**
3** Copyright (C) 2014 Klaralvdalens Datakonsult AB (KDAB).
4** Contact: https://www.qt.io/licensing/
5**
6** This file is part of the Qt3D module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and The Qt Company. For licensing terms
14** and conditions see https://www.qt.io/terms-conditions. For further
15** information use the contact form at https://www.qt.io/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 3 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL3 included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 3 requirements
23** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
24**
25** GNU General Public License Usage
26** Alternatively, this file may be used under the terms of the GNU
27** General Public License version 2.0 or (at your option) the GNU General
28** Public license version 3 or any later version approved by the KDE Free
29** Qt Foundation. The licenses are as published by the Free Software
30** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
31** included in the packaging of this file. Please review the following
32** information to ensure the GNU General Public License requirements will
33** be met: https://www.gnu.org/licenses/gpl-2.0.html and
34** https://www.gnu.org/licenses/gpl-3.0.html.
35**
36** $QT_END_LICENSE$
37**
38****************************************************************************/
39
40#include "qdiffusemapmaterial.h"
41#include "qdiffusemapmaterial_p.h"
42
43#include <Qt3DRender/qfilterkey.h>
44#include <Qt3DRender/qmaterial.h>
45#include <Qt3DRender/qeffect.h>
46#include <Qt3DRender/qtexture.h>
47#include <Qt3DRender/qtechnique.h>
48#include <Qt3DRender/qshaderprogram.h>
49#include <Qt3DRender/qshaderprogrambuilder.h>
50#include <Qt3DRender/qparameter.h>
51#include <Qt3DRender/qrenderpass.h>
52#include <Qt3DRender/qgraphicsapifilter.h>
53#include <QtCore/QUrl>
54#include <QtGui/QVector3D>
55#include <QtGui/QVector4D>
56
57QT_BEGIN_NAMESPACE
58
59using namespace Qt3DRender;
60
61namespace Qt3DExtras {
62
63QDiffuseMapMaterialPrivate::QDiffuseMapMaterialPrivate()
64 : QMaterialPrivate()
65 , m_diffuseMapEffect(new QEffect())
66 , m_diffuseTexture(new QTexture2D())
67 , m_ambientParameter(new QParameter(QStringLiteral("ka"), QColor::fromRgbF(r: 0.05f, g: 0.05f, b: 0.05f, a: 1.0f)))
68 , m_diffuseParameter(new QParameter(QStringLiteral("diffuseTexture"), m_diffuseTexture))
69 , m_specularParameter(new QParameter(QStringLiteral("ks"), QColor::fromRgbF(r: 0.01f, g: 0.01f, b: 0.01f, a: 1.0f)))
70 , m_shininessParameter(new QParameter(QStringLiteral("shininess"), 150.0f))
71 , m_textureScaleParameter(new QParameter(QStringLiteral("texCoordScale"), 1.0f))
72 , m_diffuseMapGL3Technique(new QTechnique())
73 , m_diffuseMapGL2Technique(new QTechnique())
74 , m_diffuseMapES2Technique(new QTechnique())
75 , m_diffuseMapRHITechnique(new QTechnique())
76 , m_diffuseMapGL3RenderPass(new QRenderPass())
77 , m_diffuseMapGL2RenderPass(new QRenderPass())
78 , m_diffuseMapES2RenderPass(new QRenderPass())
79 , m_diffuseMapRHIRenderPass(new QRenderPass())
80 , m_diffuseMapGL3Shader(new QShaderProgram())
81 , m_diffuseMapGL3ShaderBuilder(new QShaderProgramBuilder())
82 , m_diffuseMapGL2ES2Shader(new QShaderProgram())
83 , m_diffuseMapGL2ES2ShaderBuilder(new QShaderProgramBuilder())
84 , m_diffuseMapRHIShader(new QShaderProgram())
85 , m_diffuseMapRHIShaderBuilder(new QShaderProgramBuilder())
86 , m_filterKey(new QFilterKey)
87{
88 m_diffuseTexture->setMagnificationFilter(QAbstractTexture::Linear);
89 m_diffuseTexture->setMinificationFilter(QAbstractTexture::LinearMipMapLinear);
90 m_diffuseTexture->setWrapMode(QTextureWrapMode(QTextureWrapMode::Repeat));
91 m_diffuseTexture->setGenerateMipMaps(true);
92 m_diffuseTexture->setMaximumAnisotropy(16.0f);
93}
94
95void QDiffuseMapMaterialPrivate::init()
96{
97 Q_Q(QDiffuseMapMaterial);
98
99 connect(sender: m_ambientParameter, signal: &Qt3DRender::QParameter::valueChanged,
100 receiverPrivate: this, slot: &QDiffuseMapMaterialPrivate::handleAmbientChanged);
101 connect(sender: m_diffuseParameter, signal: &Qt3DRender::QParameter::valueChanged,
102 receiverPrivate: this, slot: &QDiffuseMapMaterialPrivate::handleDiffuseChanged);
103 connect(sender: m_specularParameter, signal: &Qt3DRender::QParameter::valueChanged,
104 receiverPrivate: this, slot: &QDiffuseMapMaterialPrivate::handleSpecularChanged);
105 connect(sender: m_shininessParameter, signal: &Qt3DRender::QParameter::valueChanged,
106 receiverPrivate: this, slot: &QDiffuseMapMaterialPrivate::handleShininessChanged);
107 connect(sender: m_textureScaleParameter, signal: &Qt3DRender::QParameter::valueChanged,
108 receiverPrivate: this, slot: &QDiffuseMapMaterialPrivate::handleTextureScaleChanged);
109
110 m_diffuseMapGL3Shader->setVertexShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl(QStringLiteral("qrc:/shaders/gl3/default.vert"))));
111 m_diffuseMapGL3ShaderBuilder->setParent(q);
112 m_diffuseMapGL3ShaderBuilder->setShaderProgram(m_diffuseMapGL3Shader);
113 m_diffuseMapGL3ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
114 m_diffuseMapGL3ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
115 QStringLiteral("specular"),
116 QStringLiteral("normal")});
117
118 m_diffuseMapGL2ES2Shader->setVertexShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl(QStringLiteral("qrc:/shaders/es2/default.vert"))));
119 m_diffuseMapGL2ES2ShaderBuilder->setParent(q);
120 m_diffuseMapGL2ES2ShaderBuilder->setShaderProgram(m_diffuseMapGL2ES2Shader);
121 m_diffuseMapGL2ES2ShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
122 m_diffuseMapGL2ES2ShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
123 QStringLiteral("specular"),
124 QStringLiteral("normal")});
125
126 m_diffuseMapRHIShader->setVertexShaderCode(QShaderProgram::loadSource(sourceUrl: QUrl(QStringLiteral("qrc:/shaders/rhi/default.vert"))));
127 m_diffuseMapRHIShaderBuilder->setParent(q);
128 m_diffuseMapRHIShaderBuilder->setShaderProgram(m_diffuseMapRHIShader);
129 m_diffuseMapRHIShaderBuilder->setFragmentShaderGraph(QUrl(QStringLiteral("qrc:/shaders/graphs/phong.frag.json")));
130 m_diffuseMapRHIShaderBuilder->setEnabledLayers({QStringLiteral("diffuseTexture"),
131 QStringLiteral("specular"),
132 QStringLiteral("normal")});
133
134 m_diffuseMapGL3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
135 m_diffuseMapGL3Technique->graphicsApiFilter()->setMajorVersion(3);
136 m_diffuseMapGL3Technique->graphicsApiFilter()->setMinorVersion(1);
137 m_diffuseMapGL3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);
138
139 m_diffuseMapGL2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
140 m_diffuseMapGL2Technique->graphicsApiFilter()->setMajorVersion(2);
141 m_diffuseMapGL2Technique->graphicsApiFilter()->setMinorVersion(0);
142 m_diffuseMapGL2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
143
144 m_diffuseMapES2Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGLES);
145 m_diffuseMapES2Technique->graphicsApiFilter()->setMajorVersion(2);
146 m_diffuseMapES2Technique->graphicsApiFilter()->setMinorVersion(0);
147 m_diffuseMapES2Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::NoProfile);
148
149 m_diffuseMapRHITechnique->graphicsApiFilter()->setApi(QGraphicsApiFilter::RHI);
150 m_diffuseMapRHITechnique->graphicsApiFilter()->setMajorVersion(1);
151 m_diffuseMapRHITechnique->graphicsApiFilter()->setMinorVersion(0);
152
153 m_filterKey->setParent(q);
154 m_filterKey->setName(QStringLiteral("renderingStyle"));
155 m_filterKey->setValue(QStringLiteral("forward"));
156
157 m_diffuseMapGL3Technique->addFilterKey(filterKey: m_filterKey);
158 m_diffuseMapGL2Technique->addFilterKey(filterKey: m_filterKey);
159 m_diffuseMapES2Technique->addFilterKey(filterKey: m_filterKey);
160 m_diffuseMapRHITechnique->addFilterKey(filterKey: m_filterKey);
161
162 m_diffuseMapGL3RenderPass->setShaderProgram(m_diffuseMapGL3Shader);
163 m_diffuseMapGL2RenderPass->setShaderProgram(m_diffuseMapGL2ES2Shader);
164 m_diffuseMapES2RenderPass->setShaderProgram(m_diffuseMapGL2ES2Shader);
165 m_diffuseMapRHIRenderPass->setShaderProgram(m_diffuseMapRHIShader);
166
167 m_diffuseMapGL3Technique->addRenderPass(pass: m_diffuseMapGL3RenderPass);
168 m_diffuseMapGL2Technique->addRenderPass(pass: m_diffuseMapGL2RenderPass);
169 m_diffuseMapES2Technique->addRenderPass(pass: m_diffuseMapES2RenderPass);
170 m_diffuseMapRHITechnique->addRenderPass(pass: m_diffuseMapRHIRenderPass);
171
172 m_diffuseMapEffect->addTechnique(t: m_diffuseMapGL3Technique);
173 m_diffuseMapEffect->addTechnique(t: m_diffuseMapGL2Technique);
174 m_diffuseMapEffect->addTechnique(t: m_diffuseMapES2Technique);
175 m_diffuseMapEffect->addTechnique(t: m_diffuseMapRHITechnique);
176
177 m_diffuseMapEffect->addParameter(parameter: m_ambientParameter);
178 m_diffuseMapEffect->addParameter(parameter: m_diffuseParameter);
179 m_diffuseMapEffect->addParameter(parameter: m_specularParameter);
180 m_diffuseMapEffect->addParameter(parameter: m_shininessParameter);
181 m_diffuseMapEffect->addParameter(parameter: m_textureScaleParameter);
182
183 q->setEffect(m_diffuseMapEffect);
184}
185
186void QDiffuseMapMaterialPrivate::handleAmbientChanged(const QVariant &var)
187{
188 Q_Q(QDiffuseMapMaterial);
189 emit q->ambientChanged(ambient: var.value<QColor>());
190}
191
192void QDiffuseMapMaterialPrivate::handleDiffuseChanged(const QVariant &var)
193{
194 Q_Q(QDiffuseMapMaterial);
195 emit q->diffuseChanged(diffuse: var.value<QAbstractTexture *>());
196}
197
198void QDiffuseMapMaterialPrivate::handleSpecularChanged(const QVariant &var)
199{
200 Q_Q(QDiffuseMapMaterial);
201 emit q->specularChanged(specular: var.value<QColor>());
202}
203
204void QDiffuseMapMaterialPrivate::handleShininessChanged(const QVariant &var)
205{
206 Q_Q(QDiffuseMapMaterial);
207 emit q->shininessChanged(shininess: var.toFloat());
208}
209
210void QDiffuseMapMaterialPrivate::handleTextureScaleChanged(const QVariant &var)
211{
212 Q_Q(QDiffuseMapMaterial);
213 emit q->textureScaleChanged(textureScale: var.toFloat());
214}
215
216/*!
217 \class Qt3DExtras::QDiffuseMapMaterial
218 \brief The QDiffuseMapMaterial provides a default implementation of the phong lighting effect
219 where the diffuse light component is read from a texture map.
220 \inmodule Qt3DExtras
221 \since 5.7
222 \inherits Qt3DRender::QMaterial
223
224 \deprecated
225 This class is deprecated; use Qt3DExtras::QDiffuseSpecularMaterial instead.
226
227 The specular lighting effect is based on the combination of 3 lighting components ambient,
228 diffuse and specular. The relative strengths of these components are controlled by means of
229 their reflectivity coefficients which are modelled as RGB triplets:
230
231 \list
232 \li Ambient is the color that is emitted by an object without any other light source.
233 \li Diffuse is the color that is emitted for rought surface reflections with the lights.
234 \li Specular is the color emitted for shiny surface reflections with the lights.
235 \li The shininess of a surface is controlled by a float property.
236 \endlist
237
238 This material uses an effect with a single render pass approach and performs per fragment
239 lighting. Techniques are provided for OpenGL 2, OpenGL 3 or above as well as OpenGL ES 2.
240*/
241
242/*!
243 Constructs a new QDiffuseMapMaterial instance with parent object \a parent.
244 */
245QDiffuseMapMaterial::QDiffuseMapMaterial(QNode *parent)
246 : QMaterial(*new QDiffuseMapMaterialPrivate, parent)
247{
248 Q_D(QDiffuseMapMaterial);
249 d->init();
250}
251
252/*!
253 Destroys the QDiffuseMapMaterial instance.
254*/
255QDiffuseMapMaterial::~QDiffuseMapMaterial()
256{
257}
258
259/*!
260 \property QDiffuseMapMaterial::ambient
261
262 Holds the current ambient color.
263*/
264
265QColor QDiffuseMapMaterial::ambient() const
266{
267 Q_D(const QDiffuseMapMaterial);
268 return d->m_ambientParameter->value().value<QColor>();
269}
270
271/*!
272 \property QDiffuseMapMaterial::specular
273
274 Holds the current specular color.
275*/
276QColor QDiffuseMapMaterial::specular() const
277{
278 Q_D(const QDiffuseMapMaterial);
279 return d->m_specularParameter->value().value<QColor>();
280}
281
282/*!
283 \property QDiffuseMapMaterial::shininess
284
285 Holds the current shininess as a float value.
286*/
287float QDiffuseMapMaterial::shininess() const
288{
289 Q_D(const QDiffuseMapMaterial);
290 return d->m_shininessParameter->value().toFloat();
291}
292
293/*!
294 \property QDiffuseMapMaterial::diffuse
295
296 Holds the current texture used as the diffuse map.
297
298 By default, the diffuse texture has the following properties:
299
300 \list
301 \li Linear minification and magnification filters
302 \li Linear mipmap with mipmapping enabled
303 \li Repeat wrap mode
304 \li Maximum anisotropy of 16.0
305 \endlist
306*/
307QAbstractTexture *QDiffuseMapMaterial::diffuse() const
308{
309 Q_D(const QDiffuseMapMaterial);
310 return d->m_diffuseParameter->value().value<QAbstractTexture *>();
311}
312
313/*!
314 \property QDiffuseMapMaterial::textureScale
315
316 Holds the current texture scale. It is applied as a multiplier to texture
317 coordinates at render time. Defaults to 1.0.
318
319 When used in conjunction with QTextureWrapMode::Repeat, textureScale provides a simple
320 way to tile a texture across a surface. For example, a texture scale of \c 4.0
321 would result in 16 (4x4) tiles.
322*/
323float QDiffuseMapMaterial::textureScale() const
324{
325 Q_D(const QDiffuseMapMaterial);
326 return d->m_textureScaleParameter->value().toFloat();
327}
328
329void QDiffuseMapMaterial::setAmbient(const QColor &ambient)
330{
331 Q_D(const QDiffuseMapMaterial);
332 d->m_ambientParameter->setValue(ambient);
333}
334
335void QDiffuseMapMaterial::setSpecular(const QColor &specular)
336{
337 Q_D(QDiffuseMapMaterial);
338 d->m_specularParameter->setValue(specular);
339}
340
341void QDiffuseMapMaterial::setShininess(float shininess)
342{
343 Q_D(QDiffuseMapMaterial);
344 d->m_shininessParameter->setValue(shininess);
345}
346
347void QDiffuseMapMaterial::setDiffuse(QAbstractTexture *diffuseMap)
348{
349 Q_D(QDiffuseMapMaterial);
350 d->m_diffuseParameter->setValue(QVariant::fromValue(value: diffuseMap));
351}
352
353void QDiffuseMapMaterial::setTextureScale(float textureScale)
354{
355 Q_D(QDiffuseMapMaterial);
356 d->m_textureScaleParameter->setValue(textureScale);
357}
358
359} // namespace Qt3DExtras
360
361QT_END_NAMESPACE
362

source code of qt3d/src/extras/defaults/qdiffusemapmaterial.cpp