QGIS API Documentation 4.1.0-Master (3fcefe620d1)
Loading...
Searching...
No Matches
qgsmetalroughmaterial.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsmetalroughmaterial.cpp
3 --------------------------------------
4 Date : December 2023
5 Copyright : (C) 2023 by Nyall Dawson
6 Email : nyall dot dawson at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgsmetalroughmaterial.h"
17
18#include "qgs3dutils.h"
19
20#include <QString>
21#include <Qt3DRender/QAbstractTexture>
22#include <Qt3DRender/QGraphicsApiFilter>
23#include <Qt3DRender/QParameter>
24#include <Qt3DRender/QRenderPass>
25#include <Qt3DRender/QSeamlessCubemap>
26#include <Qt3DRender/QShaderProgramBuilder>
27#include <Qt3DRender/QTechnique>
28#include <Qt3DRender/QTexture>
29
30#include "moc_qgsmetalroughmaterial.cpp"
31
32using namespace Qt::StringLiterals;
33
35QgsMetalRoughMaterial::QgsMetalRoughMaterial( QNode *parent )
36 : QgsMaterial( parent )
37 , mBaseColorParameter( new Qt3DRender::QParameter( u"baseColor"_s, Qgs3DUtils::srgbToLinear( QColor( "grey" ) ), this ) )
38 , mMetalnessParameter( new Qt3DRender::QParameter( u"metalness"_s, 0.0f, this ) )
39 , mRoughnessParameter( new Qt3DRender::QParameter( u"roughness"_s, 0.0f, this ) )
40 , mReflectanceParameter( new Qt3DRender::QParameter( u"reflectance"_s, 0.5f, this ) )
41 , mAnisotropyParameter( new Qt3DRender::QParameter( u"anisotropy"_s, 0.0f, this ) )
42 , mAnisotropyRotationParameter( new Qt3DRender::QParameter( u"anisotropyRotation"_s, 0.0f, this ) )
43 , mBaseColorMapParameter( new Qt3DRender::QParameter( u"baseColorMap"_s, QVariant(), this ) )
44 , mMetalnessMapParameter( new Qt3DRender::QParameter( u"metalnessMap"_s, QVariant(), this ) )
45 , mRoughnessMapParameter( new Qt3DRender::QParameter( u"roughnessMap"_s, QVariant(), this ) )
46 , mAmbientOcclusionMapParameter( new Qt3DRender::QParameter( u"ambientOcclusionMap"_s, QVariant(), this ) )
47 , mNormalMapParameter( new Qt3DRender::QParameter( u"normalMap"_s, QVariant(), this ) )
48 , mHeightMapParameter( new Qt3DRender::QParameter( u"heightMap"_s, QVariant(), this ) )
49 , mParallaxScaleParameter( new Qt3DRender::QParameter( u"parallaxScale"_s, 0.1f, this ) )
50 , mEmissionMapParameter( new Qt3DRender::QParameter( u"emissionMap"_s, QVariant(), this ) )
51 , mEmissiveColorParameter( new Qt3DRender::QParameter( u"emissiveColor"_s, Qgs3DUtils::srgbToLinear( QColor( 0, 0, 0 ) ), this ) )
52 , mEmissionFactorParameter( new Qt3DRender::QParameter( u"emissiveFactor"_s, 1.0f, this ) )
53 , mClearCoatFactorParameter( new Qt3DRender::QParameter( u"clearCoatFactor"_s, 0.0f, this ) )
54 , mClearCoatRoughnessParameter( new Qt3DRender::QParameter( u"clearCoatRoughness"_s, 0.0f, this ) )
55 , mTextureScaleParameter( new Qt3DRender::QParameter( u"texCoordScale"_s, 1.0f, this ) )
56 , mTextureRotationParameter( new Qt3DRender::QParameter( u"texCoordRotation"_s, 0.0f, this ) )
57 , mTextureOffsetParameter( new Qt3DRender::QParameter( u"texCoordOffset"_s, QVariant::fromValue( QVector2D( 0, 0 ) ), this ) )
58 , mOpacityParameter( new Qt3DRender::QParameter( u"opacity"_s, 1.0f ) )
59 , mMetalRoughEffect( new Qt3DRender::QEffect( this ) )
60 , mMetalRoughGL3Technique( new Qt3DRender::QTechnique( this ) )
61 , mMetalRoughGL3RenderPass( new Qt3DRender::QRenderPass( this ) )
62 , mMetalRoughGL3Shader( new Qt3DRender::QShaderProgram( this ) )
63 , mFilterKey( new Qt3DRender::QFilterKey( this ) )
64 , mTransformParameter( new Qt3DRender::QParameter( u"meshMatrix"_s, QVariant::fromValue( QMatrix4x4() ), this ) )
65 , mNormalTransformParameter( new Qt3DRender::QParameter( u"meshNormalMatrix"_s, QVariant::fromValue( QMatrix3x3() ), this ) )
66{
67 init();
68}
69
70QgsMetalRoughMaterial::~QgsMetalRoughMaterial() = default;
71
72void QgsMetalRoughMaterial::setBaseColor( const QColor &baseColor )
73{
74 mBaseColorParameter->setValue( Qgs3DUtils::srgbToLinear( baseColor ) );
75 bool oldUsingBaseColorMap = mUsingBaseColorMap;
76
77 mUsingBaseColorMap = false;
78 if ( mMetalRoughEffect->parameters().contains( mBaseColorMapParameter ) )
79 mMetalRoughEffect->removeParameter( mBaseColorMapParameter );
80 mMetalRoughEffect->addParameter( mBaseColorParameter );
81
82 if ( oldUsingBaseColorMap != mUsingBaseColorMap )
83 {
84 updateShaders();
85 }
86}
87
88void QgsMetalRoughMaterial::setBaseColorTexture( Qt3DRender::QAbstractTexture *baseColor )
89{
90 mBaseColorMapParameter->setValue( QVariant::fromValue( baseColor ) );
91 bool oldUsingBaseColorMap = mUsingBaseColorMap;
92
93 mUsingBaseColorMap = true;
94 mMetalRoughEffect->addParameter( mBaseColorMapParameter );
95 if ( mMetalRoughEffect->parameters().contains( mBaseColorParameter ) )
96 mMetalRoughEffect->removeParameter( mBaseColorParameter );
97
98 if ( oldUsingBaseColorMap != mUsingBaseColorMap )
99 {
100 updateShaders();
101 }
102}
103
104void QgsMetalRoughMaterial::setMetalness( float metalness )
105{
106 mMetalnessParameter->setValue( metalness );
107 bool oldUsingMetalnessMap = mUsingMetalnessMap;
108
109 mUsingMetalnessMap = false;
110 if ( mMetalRoughEffect->parameters().contains( mMetalnessMapParameter ) )
111 mMetalRoughEffect->removeParameter( mMetalnessMapParameter );
112 mMetalRoughEffect->addParameter( mMetalnessParameter );
113
114 if ( oldUsingMetalnessMap != mUsingMetalnessMap )
115 {
116 updateShaders();
117 }
118}
119
120void QgsMetalRoughMaterial::setMetalnessTexture( Qt3DRender::QAbstractTexture *metalness )
121{
122 mMetalnessMapParameter->setValue( QVariant::fromValue( metalness ) );
123 bool oldUsingMetalnessMap = mUsingMetalnessMap;
124
125 mUsingMetalnessMap = true;
126 mMetalRoughEffect->addParameter( mMetalnessMapParameter );
127 if ( mMetalRoughEffect->parameters().contains( mMetalnessParameter ) )
128 mMetalRoughEffect->removeParameter( mMetalnessParameter );
129
130 if ( oldUsingMetalnessMap != mUsingMetalnessMap )
131 {
132 updateShaders();
133 }
134}
135
136void QgsMetalRoughMaterial::setRoughness( float roughness )
137{
138 mRoughnessParameter->setValue( roughness );
139 bool oldUsingRoughnessMap = mUsingRoughnessMap;
140
141 mUsingRoughnessMap = false;
142 if ( mMetalRoughEffect->parameters().contains( mRoughnessMapParameter ) )
143 mMetalRoughEffect->removeParameter( mRoughnessMapParameter );
144 mMetalRoughEffect->addParameter( mRoughnessParameter );
145
146 if ( oldUsingRoughnessMap != mUsingRoughnessMap )
147 {
148 updateShaders();
149 }
150}
151
152void QgsMetalRoughMaterial::setRoughnessTexture( Qt3DRender::QAbstractTexture *roughness )
153{
154 mRoughnessMapParameter->setValue( QVariant::fromValue( roughness ) );
155 bool oldUsingRoughnessMap = mUsingRoughnessMap;
156
157 mUsingRoughnessMap = true;
158 mMetalRoughEffect->addParameter( mRoughnessMapParameter );
159 if ( mMetalRoughEffect->parameters().contains( mRoughnessParameter ) )
160 mMetalRoughEffect->removeParameter( mRoughnessParameter );
161
162 if ( oldUsingRoughnessMap != mUsingRoughnessMap )
163 {
164 updateShaders();
165 }
166}
167
168void QgsMetalRoughMaterial::setReflectance( float reflectance )
169{
170 mReflectanceParameter->setValue( QVariant::fromValue( reflectance ) );
171}
172
173void QgsMetalRoughMaterial::setAnisotropy( float anisotropy )
174{
175 const bool oldUsingAnisotropy = mMetalRoughEffect->parameters().contains( mAnisotropyParameter );
176 mAnisotropyParameter->setValue( anisotropy );
177 const bool newUsingAnisotropy = anisotropy > 0;
178 if ( newUsingAnisotropy )
179 {
180 if ( !oldUsingAnisotropy )
181 {
182 mMetalRoughEffect->addParameter( mAnisotropyParameter );
183 mMetalRoughEffect->addParameter( mAnisotropyRotationParameter );
184 }
185 }
186 else if ( oldUsingAnisotropy )
187 {
188 mMetalRoughEffect->removeParameter( mAnisotropyParameter );
189 mMetalRoughEffect->removeParameter( mAnisotropyRotationParameter );
190 }
191
192 if ( oldUsingAnisotropy != newUsingAnisotropy )
193 {
194 updateShaders();
195 }
196}
197
198void QgsMetalRoughMaterial::setAnisotropyRotation( float rotation )
199{
200 mAnisotropyRotationParameter->setValue( M_PI * rotation / 180.0 );
201}
202
203void QgsMetalRoughMaterial::setAmbientOcclusionTexture( Qt3DRender::QAbstractTexture *ambientOcclusion )
204{
205 bool oldUsingAmbientOcclusionMap = mUsingAmbientOcclusionMap;
206
207 if ( ambientOcclusion )
208 {
209 mAmbientOcclusionMapParameter->setValue( QVariant::fromValue( ambientOcclusion ) );
210 mUsingAmbientOcclusionMap = true;
211 mMetalRoughEffect->addParameter( mAmbientOcclusionMapParameter );
212 }
213 else
214 {
215 mAmbientOcclusionMapParameter->setValue( QVariant() );
216 mUsingAmbientOcclusionMap = false;
217 if ( mMetalRoughEffect->parameters().contains( mAmbientOcclusionMapParameter ) )
218 mMetalRoughEffect->removeParameter( mAmbientOcclusionMapParameter );
219 }
220
221 if ( oldUsingAmbientOcclusionMap != mUsingAmbientOcclusionMap )
222 {
223 updateShaders();
224 }
225}
226
227void QgsMetalRoughMaterial::setNormalTexture( Qt3DRender::QAbstractTexture *normal )
228{
229 bool oldUsingNormalMap = mUsingNormalMap;
230
231 if ( normal )
232 {
233 mNormalMapParameter->setValue( QVariant::fromValue( normal ) );
234 mUsingNormalMap = true;
235 mMetalRoughEffect->addParameter( mNormalMapParameter );
236 }
237 else
238 {
239 mNormalMapParameter->setValue( QVariant() );
240 mUsingNormalMap = false;
241 if ( mMetalRoughEffect->parameters().contains( mNormalMapParameter ) )
242 mMetalRoughEffect->removeParameter( mNormalMapParameter );
243 }
244
245 if ( oldUsingNormalMap != mUsingNormalMap )
246 {
247 updateShaders();
248 }
249}
250
251void QgsMetalRoughMaterial::setHeightTexture( Qt3DRender::QAbstractTexture *height )
252{
253 bool oldUsingHeightMap = mUsingHeightMap;
254
255 if ( height )
256 {
257 mHeightMapParameter->setValue( QVariant::fromValue( height ) );
258 mUsingHeightMap = true;
259 mMetalRoughEffect->addParameter( mHeightMapParameter );
260 }
261 else
262 {
263 mHeightMapParameter->setValue( QVariant() );
264 mUsingHeightMap = false;
265 if ( mMetalRoughEffect->parameters().contains( mHeightMapParameter ) )
266 mMetalRoughEffect->removeParameter( mHeightMapParameter );
267 }
268
269 if ( oldUsingHeightMap != mUsingHeightMap )
270 {
271 updateShaders();
272 }
273}
274
275void QgsMetalRoughMaterial::setParallaxScale( double scale )
276{
277 mParallaxScaleParameter->setValue( scale );
278}
279
280void QgsMetalRoughMaterial::setEmissionColor( const QColor &color )
281{
282 mEmissiveColorParameter->setValue( Qgs3DUtils::srgbToLinear( color ) );
283 const bool oldUsingEmissionMap = mUsingEmissionMap;
284
285 mUsingEmissionMap = false;
286 if ( mMetalRoughEffect->parameters().contains( mEmissionMapParameter ) )
287 mMetalRoughEffect->removeParameter( mEmissionMapParameter );
288 mMetalRoughEffect->addParameter( mEmissiveColorParameter );
289
290 if ( oldUsingEmissionMap != mUsingEmissionMap )
291 {
292 updateShaders();
293 }
294}
295
296void QgsMetalRoughMaterial::setEmissionTexture( Qt3DRender::QAbstractTexture *emission )
297{
298 const bool oldUsingEmissionMap = mUsingEmissionMap;
299
300 if ( emission )
301 {
302 mEmissionMapParameter->setValue( QVariant::fromValue( emission ) );
303 mUsingEmissionMap = true;
304 mMetalRoughEffect->addParameter( mEmissionMapParameter );
305 if ( mMetalRoughEffect->parameters().contains( mEmissiveColorParameter ) )
306 mMetalRoughEffect->removeParameter( mEmissiveColorParameter );
307 }
308 else
309 {
310 mEmissionMapParameter->setValue( QVariant() );
311 mUsingEmissionMap = false;
312 if ( mMetalRoughEffect->parameters().contains( mEmissionMapParameter ) )
313 mMetalRoughEffect->removeParameter( mEmissionMapParameter );
314 mMetalRoughEffect->addParameter( mEmissiveColorParameter );
315 }
316
317 if ( oldUsingEmissionMap != mUsingEmissionMap )
318 {
319 updateShaders();
320 }
321}
322
323void QgsMetalRoughMaterial::setEmissionFactor( double factor )
324{
325 mEmissionFactorParameter->setValue( factor );
326}
327
328void QgsMetalRoughMaterial::setClearCoatFactor( float factor )
329{
330 mClearCoatFactorParameter->setValue( factor );
331 const bool oldUsingClearCoat = mMetalRoughEffect->parameters().contains( mClearCoatFactorParameter );
332 const bool newUsingClearCoat = factor > 0;
333 if ( newUsingClearCoat )
334 {
335 if ( !oldUsingClearCoat )
336 {
337 mMetalRoughEffect->addParameter( mClearCoatFactorParameter );
338 mMetalRoughEffect->addParameter( mClearCoatRoughnessParameter );
339 }
340 }
341 else if ( oldUsingClearCoat )
342 {
343 mMetalRoughEffect->removeParameter( mClearCoatFactorParameter );
344 mMetalRoughEffect->removeParameter( mClearCoatRoughnessParameter );
345 }
346
347 if ( oldUsingClearCoat != newUsingClearCoat )
348 {
349 updateShaders();
350 }
351}
352
353void QgsMetalRoughMaterial::setClearCoatRoughness( float roughness )
354{
355 mClearCoatRoughnessParameter->setValue( roughness );
356}
357
358void QgsMetalRoughMaterial::setTextureScale( float textureScale )
359{
360 mTextureScaleParameter->setValue( textureScale );
361}
362
363void QgsMetalRoughMaterial::setTextureRotation( float textureRotation )
364{
365 mTextureRotationParameter->setValue( textureRotation );
366}
367
368void QgsMetalRoughMaterial::setTextureOffset( float textureOffsetX, float textureOffsetY )
369{
370 mTextureOffsetParameter->setValue( QVariant::fromValue( QVector2D( textureOffsetX, textureOffsetY ) ) );
371}
372
373void QgsMetalRoughMaterial::init()
374{
375 mMetalRoughGL3Technique->graphicsApiFilter()->setApi( Qt3DRender::QGraphicsApiFilter::OpenGL );
376 mMetalRoughGL3Technique->graphicsApiFilter()->setMajorVersion( 3 );
377 mMetalRoughGL3Technique->graphicsApiFilter()->setMinorVersion( 3 );
378 mMetalRoughGL3Technique->graphicsApiFilter()->setProfile( Qt3DRender::QGraphicsApiFilter::CoreProfile );
379
380 mFilterKey->setParent( this );
381 mFilterKey->setName( u"renderingStyle"_s );
382 mFilterKey->setValue( u"forward"_s );
383
384 mMetalRoughGL3Technique->addFilterKey( mFilterKey );
385 mMetalRoughGL3RenderPass->setShaderProgram( mMetalRoughGL3Shader );
386 mMetalRoughGL3Technique->addRenderPass( mMetalRoughGL3RenderPass );
387 mMetalRoughEffect->addTechnique( mMetalRoughGL3Technique );
388
389 // ensure IBL cubemaps are seamless -- this should be safe to do here, the only cubemap
390 // lookups happening in the metalrough shader is for IBL
391 mMetalRoughGL3RenderPass->addRenderState( new Qt3DRender::QSeamlessCubemap( this ) );
392
393 // Given parameters a parent
394 mBaseColorMapParameter->setParent( mMetalRoughEffect );
395 mMetalnessMapParameter->setParent( mMetalRoughEffect );
396 mRoughnessMapParameter->setParent( mMetalRoughEffect );
397 mNormalMapParameter->setParent( mMetalRoughEffect );
398 mHeightMapParameter->setParent( mMetalRoughEffect );
399 mAmbientOcclusionMapParameter->setParent( mMetalRoughEffect );
400 mEmissionMapParameter->setParent( mMetalRoughEffect );
401
402 mMetalRoughEffect->addParameter( mBaseColorParameter );
403 mMetalRoughEffect->addParameter( mMetalnessParameter );
404 mMetalRoughEffect->addParameter( mRoughnessParameter );
405 mMetalRoughEffect->addParameter( mReflectanceParameter );
406 mMetalRoughEffect->addParameter( mParallaxScaleParameter );
407 mMetalRoughEffect->addParameter( mEmissiveColorParameter );
408 mMetalRoughEffect->addParameter( mEmissionFactorParameter );
409 mMetalRoughEffect->addParameter( mTextureScaleParameter );
410 mMetalRoughEffect->addParameter( mTextureRotationParameter );
411 mMetalRoughEffect->addParameter( mTextureOffsetParameter );
412 mMetalRoughEffect->addParameter( mOpacityParameter );
413 mMetalRoughEffect->addParameter( mTransformParameter );
414 mMetalRoughEffect->addParameter( mNormalTransformParameter );
415
416 setEffect( mMetalRoughEffect );
417
418 updateShaders();
419}
420
421void QgsMetalRoughMaterial::updateShaders()
422{
423 QByteArray fragmentShaderCode = Qt3DRender::QShaderProgram::loadSource( QUrl( u"qrc:/shaders/metalrough.frag"_s ) );
424
425 // pre-process fragment shader and add #defines based on whether using maps for some properties
426 QStringList fragShaderDefines;
427 if ( mUsingBaseColorMap )
428 fragShaderDefines += "BASE_COLOR_MAP";
429 if ( mUsingMetalnessMap )
430 fragShaderDefines += "METALNESS_MAP";
431 if ( mUsingRoughnessMap )
432 fragShaderDefines += "ROUGHNESS_MAP";
433 if ( mUsingAmbientOcclusionMap )
434 fragShaderDefines += "AMBIENT_OCCLUSION_MAP";
435 if ( mUsingNormalMap )
436 fragShaderDefines += "NORMAL_MAP";
437 if ( mUsingHeightMap )
438 fragShaderDefines += "HEIGHT_MAP";
439 if ( mUsingEmissionMap )
440 fragShaderDefines += "EMISSION_MAP";
441 if ( mFlatShading )
442 fragShaderDefines += "FLAT_SHADING";
443 if ( mMetalRoughEffect->parameters().contains( mAnisotropyParameter ) )
444 fragShaderDefines += "ANISOTROPY";
445 if ( mMetalRoughEffect->parameters().contains( mClearCoatFactorParameter ) )
446 fragShaderDefines += "CLEAR_COAT";
447 if ( mEnableEnvironmentalLighting )
448 fragShaderDefines += "ENABLE_IBL";
449
450 if ( mInstanced )
451 {
452 QStringList defines = { u"HAS_TEXTURE"_s, u"HAS_TANGENT"_s };
453 if ( mInstanceFlags.testFlag( Qgis::InstancedMaterialFlag::DataDefinedScale ) )
454 defines << u"USE_INSTANCE_SCALE"_s;
455 if ( mInstanceFlags.testFlag( Qgis::InstancedMaterialFlag::DataDefinedRotation ) )
456 defines << u"USE_INSTANCE_ROTATION"_s;
457 const QByteArray vertCode = Qt3DRender::QShaderProgram::loadSource( QUrl( u"qrc:/shaders/instanced.vert"_s ) );
458 mMetalRoughGL3Shader->setVertexShaderCode( Qgs3DUtils::addDefinesToShaderCode( vertCode, defines ) );
459 }
460 else if ( mDataDefinedEnabled )
461 {
462 fragShaderDefines += "DATA_DEFINED";
463 mMetalRoughGL3Shader->setShaderCode( Qt3DRender::QShaderProgram::Vertex, Qt3DRender::QShaderProgram::loadSource( QUrl( u"qrc:/shaders/metalroughDataDefined.vert"_s ) ) );
464 }
465 else
466 {
467 const QByteArray vertexShaderCode = Qt3DRender::QShaderProgram::loadSource( QUrl( u"qrc:/shaders/default.vert"_s ) );
468 QStringList defines { u"TEXTURE_ROTATION"_s, u"TEXTURE_OFFSET"_s };
469 if ( mDataDefinedTextureTransformEnabled )
470 defines << u"DATA_DEFINED_TEXTURE_TRANSFORMS"_s;
471
472 const QByteArray finalVertexShaderCode = Qgs3DUtils::addDefinesToShaderCode( vertexShaderCode, defines );
473 mMetalRoughGL3Shader->setVertexShaderCode( finalVertexShaderCode );
474 }
475
476 const QByteArray finalShaderCode = Qgs3DUtils::addDefinesToShaderCode( fragmentShaderCode, fragShaderDefines );
477 mMetalRoughGL3Shader->setFragmentShaderCode( finalShaderCode );
478}
479
480void QgsMetalRoughMaterial::setFlatShadingEnabled( bool enabled )
481{
482 if ( enabled != mFlatShading )
483 {
484 mFlatShading = enabled;
485 updateShaders();
486 }
487}
488
489void QgsMetalRoughMaterial::setOpacity( float opacity )
490{
491 mOpacityParameter->setValue( opacity );
492}
493
494void QgsMetalRoughMaterial::setDataDefinedEnabled( bool enabled )
495{
496 if ( enabled != mDataDefinedEnabled )
497 {
498 mDataDefinedEnabled = enabled;
499 updateShaders();
500 }
501}
502
503void QgsMetalRoughMaterial::setDataDefinedTextureTransformEnabled( bool enabled )
504{
505 if ( enabled != mDataDefinedTextureTransformEnabled )
506 {
507 mDataDefinedTextureTransformEnabled = enabled;
508 updateShaders();
509 }
510}
511
512void QgsMetalRoughMaterial::setEnvironmentalLightingEnabled( bool enabled )
513{
514 if ( enabled != mEnableEnvironmentalLighting )
515 {
516 mEnableEnvironmentalLighting = enabled;
517 updateShaders();
518 }
519}
520
521void QgsMetalRoughMaterial::setInstancingEnabled( bool enabled, Qgis::InstancedMaterialFlags flags )
522{
523 mInstanced = enabled;
524 mInstanceFlags = flags;
525 updateShaders();
526}
527
528void QgsMetalRoughMaterial::setInstancingMeshTransform( const QMatrix4x4 &transform )
529{
530 const QMatrix3x3 normalTransform = transform.normalMatrix();
531 mTransformParameter->setValue( QVariant::fromValue( transform ) );
532 mNormalTransformParameter->setValue( QVariant::fromValue( normalTransform ) );
533}
534
Qgis::InstancedMaterialFlags
QFlags< InstancedMaterialFlag > InstancedMaterialFlags
Definition qgis.h:4398
Qgis::InstancedMaterialFlag::DataDefinedRotation
@ DataDefinedRotation
Per-instance data-defined rotation.
Definition qgis.h:4395
Qgis::InstancedMaterialFlag::DataDefinedScale
@ DataDefinedScale
Per-instance data-defined scale.
Definition qgis.h:4394
Qgs3DUtils
Miscellaneous utility functions used from 3D code.
Definition qgs3dutils.h:83
Qgs3DUtils::addDefinesToShaderCode
static QByteArray addDefinesToShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Inserts some define macros into a shader source code.
Definition qgs3dutils.cpp:991
Qgs3DUtils::srgbToLinear
static QColor srgbToLinear(const QColor &color)
Converts a SRGB color to a linear color.
Definition qgs3dutils.cpp:533
QgsMaterial
Base class for all materials used within QGIS 3D views.
Definition qgsmaterial.h:40
Generated on for QGIS API Documentation by doxygen 1.15.0