1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
|
/****************************************************************************
**
** Copyright (C) 2008-2012 NVIDIA Corporation.
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt 3D Studio.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#pragma once
#ifndef QT3DS_RENDER_SHADER_PROGRAM_H
#define QT3DS_RENDER_SHADER_PROGRAM_H
#include "foundation/Qt3DSFoundation.h"
#include "foundation/Qt3DSAtomic.h"
#include "render/Qt3DSRenderShaderConstant.h"
#include "EASTL/string.h"
#include "EASTL/utility.h"
namespace qt3ds {
namespace render {
using namespace foundation;
///< forward declarations
class NVRenderContextImpl;
class NVRenderVertexShader;
class NVRenderFragmentShader;
class NVRenderTessControlShader;
class NVRenderTessEvaluationShader;
class NVRenderGeometryShader;
class NVRenderShaderConstantBase;
class NVRenderShaderBufferBase;
class NVRenderComputeShader;
typedef nvhash_map<CRegisteredString, NVRenderShaderConstantBase *> TShaderConstantMap;
typedef nvhash_map<CRegisteredString, NVRenderShaderBufferBase *> TShaderBufferMap;
///< A shader program is an object composed of a multiple shaders (vertex, fragment,
///geometry,....)
class QT3DS_AUTOTEST_EXPORT NVRenderShaderProgram : public NVRefCounted
{
public:
struct ProgramType
{
enum Enum { Graphics, Compute };
};
private:
NVRenderContextImpl &m_Context; ///< pointer to context
NVFoundationBase &m_Foundation; ///< pointer to foundation
volatile QT3DSI32 mRefCount; ///< Using foundations' naming convention to ease implementation
NVRenderBackend *m_Backend; ///< pointer to backend
const char *m_ProgramName; /// Name of the program
NVRenderBackend::NVRenderBackendShaderProgramObject
m_ProgramHandle; ///< opaque backend handle
TShaderConstantMap m_Constants; ///< map of shader constants
TShaderBufferMap m_ShaderBuffers; ///< map of shader buffers
ProgramType::Enum m_ProgramType; ///< shader type
eastl::string m_ErrorMessage; ///< contains the error message if linking fails
/**
* @brief create vertex shader
*
* @param[in] context Pointer to render context
* @param[in] vertexShaderSource Fragment shader source code
* @param[in] binaryProgram True if binary program
*
* @return pointer to vertex shader object
*/
static Option<NVRenderVertexShader *>
createVertexShader(NVRenderContextImpl &context, NVConstDataRef<QT3DSI8> vertexShaderSource,
bool binaryProgram = false);
/**
* @brief create fragment shader
*
* @param[in] context Pointer to render context
* @param[in] fragmentShaderSource Fragment shader source code
* @param[in] binaryProgram True if binary program
*
* @return pointer to fragment shader object
*/
static Option<NVRenderFragmentShader *>
createFragmentShader(NVRenderContextImpl &context,
NVConstDataRef<QT3DSI8> fragmentShaderSource, bool binaryProgram = false);
/**
* @brief create tesselation control shader
*
* @param[in] context Pointer to render context
* @param[in] tessControlShaderSource Tessellation control shader source code
* @param[in] binaryProgram True if binary program
*
* @return pointer to tessellation control shader
*/
static Option<NVRenderTessControlShader *>
createTessControlShader(NVRenderContextImpl &context,
NVConstDataRef<QT3DSI8> tessControlShaderSource,
bool binaryProgram = false);
/**
* @brief create tesselation evaluation shader
*
* @param[in] context Pointer to render context
* @param[in] tessEvaluationShaderSource Tessellation evaluation shader source code
* @param[in] binaryProgram True if binary program
*
* @return pointer to tessellation evaluation shader
*/
static Option<NVRenderTessEvaluationShader *>
createTessEvaluationShader(NVRenderContextImpl &context,
NVConstDataRef<QT3DSI8> tessEvaluationShaderSource,
bool binaryProgram = false);
/**
* @brief create geometry shader
*
* @param[in] context Pointer to render context
* @param[in] geometryShaderSource Geometry shader source code
* @param[in] binaryProgram True if binary program
*
* @return pointer to geometry shader
*/
static Option<NVRenderGeometryShader *>
createGeometryShader(NVRenderContextImpl &context,
NVConstDataRef<QT3DSI8> geometryShaderSource, bool binaryProgram = false);
public:
/**
* @brief constructor
*
* @param[in] context Pointer to render context
* @param[in] fnd Pointer to foundation
* @param[in] programName Pointer to string of program name
* @param[in] separableProgram True if this is a separable program
*
* @return No return.
*/
NVRenderShaderProgram(NVRenderContextImpl &context, NVFoundationBase &fnd,
const char *programName, bool separableProgram);
/// destructor
~NVRenderShaderProgram();
// define refcount functions
QT3DS_IMPLEMENT_REF_COUNT_ADDREF_RELEASE(m_Foundation)
/**
* @brief attach a shader to the program
*
* @param[in] pShader Pointer to shader object
*
* @return No return.
*/
template <typename TShaderObject>
void Attach(TShaderObject *pShader);
/**
* @brief detach a shader from the program
*
* @param[in] pShader Pointer to shader object
*
* @return No return.
*/
template <typename TShaderObject>
void Detach(TShaderObject *pShader);
/**
* @brief link a program
*
*
* @return true if succesfuly linked.
*/
bool Link();
/**
* @brief set a shader type
*
* @param[in] type shader type ( graphics or compute )
*
* @return No return.
*/
void SetProgramType(ProgramType::Enum type) { m_ProgramType = type; }
ProgramType::Enum GetProgramType() const { return m_ProgramType; }
/**
* @brief Get Error Message
*
* @param[out] messageLength Pointer to error string
* @param[out] messageLength Size of error meesage
*
* @return no return.
*/
void GetErrorMessage(QT3DSI32 *messageLength, const char *errorMessage);
/**
* @brief Get Error Message
*
*
* @return error message.
*/
const char *GetErrorMessage();
/**
* @brief Query constant class
*
* @param[in] constantName Pointer to constant name
*
* @return return a pointer to a constant class.
*/
NVRenderShaderConstantBase *GetShaderConstant(const char *constantName);
/**
* @brief Query a shader buffer (constant, ... )
*
* @param[in] bufferName Pointer to constant name
*
* @return return a pointer to a constant class.
*/
NVRenderShaderBufferBase *GetShaderBuffer(const char *bufferName);
// concrete set functions
void SetConstantValue(NVRenderShaderConstantBase *inConstant, QT3DSI32 inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSI32_2 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSI32_3 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSI32_4 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, QT3DSRenderBool inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const bool_2 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const bool_3 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const bool_4 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSF32 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSVec2 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSVec3 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSVec4 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSU32 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSU32_2 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSU32_3 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSU32_4 &inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSMat33 &inValue,
const QT3DSI32 inCount, bool inTranspose = false);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, const QT3DSMat44 &inValue,
const QT3DSI32 inCount, bool inTranspose = false);
void SetConstantValue(NVRenderShaderConstantBase *inConstant,
const NVConstDataRef<QT3DSMat44> inValue, const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderTexture2D *inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderTexture2D **inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant,
NVRenderTexture2DArray *inValue, const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderTextureCube *inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderTextureCube **inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderImage2D *inValue,
const QT3DSI32 inCount);
void SetConstantValue(NVRenderShaderConstantBase *inConstant, NVRenderDataBuffer *inValue,
const QT3DSI32 inCount);
/**
* @brief Template to set constant value via name
*
* @param[in] inConstantName Pointer to constant name
* @param[in] inValue Pointer to data
* @param[in] inCount Number of elements (array count)
*
* @return return a pointer to a constant class.
*/
template <typename TDataType>
void SetPropertyValue(const char *inConstantName, const TDataType &inValue,
const QT3DSI32 inCount = 1)
{
NVRenderShaderConstantBase *theConstant = GetShaderConstant(inConstantName);
if (theConstant) {
if (theConstant->GetShaderConstantType()
== NVDataTypeToShaderDataTypeMap<TDataType>::GetType()) {
SetConstantValue(theConstant, inValue, inCount);
} else {
// Types don't match or property not found
QT3DS_ASSERT(false);
}
}
}
/**
* @brief Template to set constant value shader constant object
*
* @param[in] inConstant Pointer shader constant object
* @param[in] inValue Pointer to data
* @param[in] inCount Number of elements (array count)
*
* @return return a pointer to a constant class.
*/
template <typename TDataType>
void SetPropertyValue(NVRenderShaderConstantBase *inConstant, const TDataType &inValue,
const QT3DSI32 inCount = 1)
{
if (inConstant) {
if (inConstant->GetShaderConstantType()
== NVDataTypeToShaderDataTypeMap<TDataType>::GetType()) {
SetConstantValue(inConstant, inValue, inCount);
} else {
// Types don't match or property not found
QT3DS_ASSERT(false);
}
}
}
virtual void BindComputeInput(NVRenderDataBuffer *inBuffer, QT3DSU32 inIndex);
/**
* @brief get the backend object handle
*
* @return the backend object handle.
*/
NVRenderBackend::NVRenderBackendShaderProgramObject GetShaderProgramHandle() const
{
return m_ProgramHandle;
}
/**
* @brief get the context object
*
* @return context which this shader belongs to.
*/
NVRenderContextImpl &GetRenderContext();
/**
* @brief Create a shader program
*
* @param[in] context Pointer to context
* @param[in] programName Name of the program
* @param[in] vertShaderSource Vertex shader source code
* @param[in] fragShaderSource Fragment shader source code
* @param[in] tessControlShaderSource tessellation control shader source code
* @param[in] tessEvaluationShaderSource tessellation evaluation shader source code
* @param[in] separateProgram True if this will we a separate
* program
* @param[in] type Binary program type
* @param[in] binaryProgram True if program is binary
*
* @return a render result
*/
static NVRenderVertFragCompilationResult Create(
NVRenderContextImpl &context, const char *programName,
NVConstDataRef<QT3DSI8> vertShaderSource, NVConstDataRef<QT3DSI8> fragShaderSource,
NVConstDataRef<QT3DSI8> tessControlShaderSource = NVConstDataRef<QT3DSI8>(),
NVConstDataRef<QT3DSI8> tessEvaluationShaderSource = NVConstDataRef<QT3DSI8>(),
NVConstDataRef<QT3DSI8> geometryShaderSource = NVConstDataRef<QT3DSI8>(),
bool separateProgram = false,
NVRenderShaderProgramBinaryType::Enum type = NVRenderShaderProgramBinaryType::Unknown,
bool binaryProgram = false);
/**
* @brief Create a compute shader program
*
* @param[in] context Pointer to context
* @param[in] programName Name of the program
* @param[in] computeShaderSource Compute shader source code
*
* @return a render result
*/
static NVRenderVertFragCompilationResult
CreateCompute(NVRenderContextImpl &context, const char *programName,
NVConstDataRef<QT3DSI8> computeShaderSource);
};
// Helper class to cache the lookup of shader properties and apply them quickly in a typesafe
// way.
template <typename TDataType>
struct NVRenderCachedShaderProperty
{
NVRenderShaderProgram *m_Shader; ///< pointer to shader program
NVRenderShaderConstantBase *m_Constant; ///< poiner to shader constant object
NVRenderCachedShaderProperty(const QString &inConstantName, NVRenderShaderProgram &inShader)
: NVRenderCachedShaderProperty(qPrintable(inConstantName), inShader)
{
}
NVRenderCachedShaderProperty(const char *inConstantName, NVRenderShaderProgram &inShader)
: m_Shader(&inShader)
, m_Constant(NULL)
{
NVRenderShaderConstantBase *theConstant = inShader.GetShaderConstant(inConstantName);
if (theConstant) {
if (theConstant->GetShaderConstantType()
== NVDataTypeToShaderDataTypeMap<TDataType>::GetType()) {
m_Constant = theConstant;
} else {
// Property types do not match, this probably indicates that the shader changed
// while the
// code creating this object did not change.
QT3DS_ASSERT(false);
}
}
}
NVRenderCachedShaderProperty()
: m_Shader(NULL)
, m_Constant(NULL)
{
}
void Set(const TDataType &inValue)
{
if (m_Constant)
m_Shader->SetPropertyValue(m_Constant, inValue);
}
bool IsValid() const { return m_Constant != 0; }
};
template <typename TDataType, int size>
struct NVRenderCachedShaderPropertyArray
{
NVRenderShaderProgram *m_Shader; ///< pointer to shader program
NVRenderShaderConstantBase *m_Constant; ///< poiner to shader constant object
TDataType m_array[size];
NVRenderCachedShaderPropertyArray(const QString &inConstantName,
NVRenderShaderProgram &inShader)
: NVRenderCachedShaderPropertyArray(qPrintable(inConstantName), inShader)
{
}
NVRenderCachedShaderPropertyArray(const char *inConstantName,
NVRenderShaderProgram &inShader)
: m_Shader(&inShader)
, m_Constant(nullptr)
{
memset(m_array, 0, sizeof(m_array));
NVRenderShaderConstantBase *theConstant = inShader.GetShaderConstant(inConstantName);
if (theConstant) {
if (theConstant->m_ElementCount > 1 && theConstant->m_ElementCount <= size &&
theConstant->GetShaderConstantType()
== NVDataTypeToShaderDataTypeMap<TDataType*>::GetType()) {
m_Constant = theConstant;
} else {
// Property types do not match, this probably indicates that the shader changed
// while the code creating this object did not change.
QT3DS_ASSERT(false);
}
}
}
NVRenderCachedShaderPropertyArray()
: m_Shader(nullptr)
, m_Constant(nullptr)
{
memset(m_array, 0, sizeof(m_array));
}
void Set(int count)
{
if (m_Constant)
m_Shader->SetPropertyValue(m_Constant, (TDataType*)m_array, qMin(size, count));
}
bool IsValid() const { return m_Constant != 0; }
};
// Helper class to cache the lookup of shader properties and apply them quickly in a typesafe
// way.
template <typename TDataType>
struct NVRenderCachedShaderBuffer
{
NVRenderShaderProgram *m_Shader; ///< pointer to shader program
TDataType m_ShaderBuffer; ///< poiner to shader buffer object
NVRenderCachedShaderBuffer(const char *inShaderBufferName, NVRenderShaderProgram &inShader)
: m_Shader(&inShader)
, m_ShaderBuffer(NULL)
{
TDataType theShaderBuffer =
static_cast<TDataType>(inShader.GetShaderBuffer(inShaderBufferName));
if (theShaderBuffer) {
m_ShaderBuffer = theShaderBuffer;
}
}
NVRenderCachedShaderBuffer()
: m_Shader(NULL)
, m_ShaderBuffer(NULL)
{
}
void Set()
{
if (m_ShaderBuffer) {
m_ShaderBuffer->Validate(m_Shader);
m_ShaderBuffer->Update();
m_ShaderBuffer->BindToProgram(m_Shader);
}
}
bool IsValid() const { return m_ShaderBuffer != 0; }
};
}
}
#endif
|