← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/frame_capture_utils_autogen.h

  • Committer: mmach
  • Date: 2023-06-16 17:21:37 UTC
  • Revision ID: netbit73@gmail.com-20230616172137-2rqx6yr96ga9g3kp
1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/ThirdParty/ANGLE/src/libANGLE/frame_capture_utils_autogen.h
 
1
// GENERATED FILE - DO NOT EDIT.
 
2
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
 
3
//
 
4
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
 
5
// Use of this source code is governed by a BSD-style license that can be
 
6
// found in the LICENSE file.
 
7
//
 
8
// frame_capture_utils_autogen.h:
 
9
//   ANGLE Frame capture types and helper functions.
 
10
 
 
11
#ifndef LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
 
12
#define LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_
 
13
 
 
14
#include "common/PackedEnums.h"
 
15
 
 
16
namespace angle
 
17
{
 
18
enum class ParamType
 
19
{
 
20
    TAlphaTestFunc,
 
21
    TBufferBinding,
 
22
    TBufferID,
 
23
    TBufferIDConstPointer,
 
24
    TBufferIDPointer,
 
25
    TBufferUsage,
 
26
    TClientVertexArrayType,
 
27
    TCullFaceMode,
 
28
    TDrawElementsType,
 
29
    TFenceNVID,
 
30
    TFenceNVIDConstPointer,
 
31
    TFenceNVIDPointer,
 
32
    TFramebufferID,
 
33
    TFramebufferIDConstPointer,
 
34
    TFramebufferIDPointer,
 
35
    TGLDEBUGPROC,
 
36
    TGLDEBUGPROCKHR,
 
37
    TGLbitfield,
 
38
    TGLboolean,
 
39
    TGLbooleanConstPointer,
 
40
    TGLbooleanPointer,
 
41
    TGLbyte,
 
42
    TGLbyteConstPointer,
 
43
    TGLcharConstPointer,
 
44
    TGLcharConstPointerPointer,
 
45
    TGLcharPointer,
 
46
    TGLclampx,
 
47
    TGLdouble,
 
48
    TGLdoubleConstPointer,
 
49
    TGLdoublePointer,
 
50
    TGLeglImageOES,
 
51
    TGLenum,
 
52
    TGLenumConstPointer,
 
53
    TGLenumPointer,
 
54
    TGLfixed,
 
55
    TGLfixedConstPointer,
 
56
    TGLfixedPointer,
 
57
    TGLfloat,
 
58
    TGLfloatConstPointer,
 
59
    TGLfloatPointer,
 
60
    TGLint,
 
61
    TGLint64Pointer,
 
62
    TGLintConstPointer,
 
63
    TGLintPointer,
 
64
    TGLintptr,
 
65
    TGLintptrConstPointer,
 
66
    TGLshort,
 
67
    TGLshortConstPointer,
 
68
    TGLsizei,
 
69
    TGLsizeiConstPointer,
 
70
    TGLsizeiPointer,
 
71
    TGLsizeiptr,
 
72
    TGLsizeiptrConstPointer,
 
73
    TGLsync,
 
74
    TGLubyte,
 
75
    TGLubyteConstPointer,
 
76
    TGLubytePointer,
 
77
    TGLuint,
 
78
    TGLuint64,
 
79
    TGLuint64ConstPointer,
 
80
    TGLuint64Pointer,
 
81
    TGLuintConstPointer,
 
82
    TGLuintPointer,
 
83
    TGLushort,
 
84
    TGLushortConstPointer,
 
85
    TGLushortPointer,
 
86
    TGLvoidConstPointer,
 
87
    TGLvoidConstPointerPointer,
 
88
    TGraphicsResetStatus,
 
89
    THandleType,
 
90
    TLightParameter,
 
91
    TLogicalOperation,
 
92
    TMaterialParameter,
 
93
    TMatrixType,
 
94
    TMemoryObjectID,
 
95
    TMemoryObjectIDConstPointer,
 
96
    TMemoryObjectIDPointer,
 
97
    TPathID,
 
98
    TPointParameter,
 
99
    TPrimitiveMode,
 
100
    TProgramPipelineID,
 
101
    TProgramPipelineIDConstPointer,
 
102
    TProgramPipelineIDPointer,
 
103
    TProvokingVertexConvention,
 
104
    TQueryID,
 
105
    TQueryIDConstPointer,
 
106
    TQueryIDPointer,
 
107
    TQueryType,
 
108
    TRenderbufferID,
 
109
    TRenderbufferIDConstPointer,
 
110
    TRenderbufferIDPointer,
 
111
    TSamplerID,
 
112
    TSamplerIDConstPointer,
 
113
    TSamplerIDPointer,
 
114
    TSemaphoreID,
 
115
    TSemaphoreIDConstPointer,
 
116
    TSemaphoreIDPointer,
 
117
    TShaderProgramID,
 
118
    TShaderProgramIDConstPointer,
 
119
    TShaderProgramIDPointer,
 
120
    TShaderType,
 
121
    TShadingModel,
 
122
    TTextureEnvParameter,
 
123
    TTextureEnvTarget,
 
124
    TTextureID,
 
125
    TTextureIDConstPointer,
 
126
    TTextureIDPointer,
 
127
    TTextureTarget,
 
128
    TTextureType,
 
129
    TTransformFeedbackID,
 
130
    TTransformFeedbackIDConstPointer,
 
131
    TTransformFeedbackIDPointer,
 
132
    TVertexArrayID,
 
133
    TVertexArrayIDConstPointer,
 
134
    TVertexArrayIDPointer,
 
135
    TVertexAttribType,
 
136
    TvoidConstPointer,
 
137
    TvoidConstPointerPointer,
 
138
    TvoidPointer,
 
139
    TvoidPointerPointer,
 
140
};
 
141
 
 
142
constexpr uint32_t kParamTypeCount = 120;
 
143
 
 
144
union ParamValue
 
145
{
 
146
    gl::AlphaTestFunc AlphaTestFuncVal;
 
147
    gl::BufferBinding BufferBindingVal;
 
148
    gl::BufferID BufferIDVal;
 
149
    const gl::BufferID *BufferIDConstPointerVal;
 
150
    gl::BufferID *BufferIDPointerVal;
 
151
    gl::BufferUsage BufferUsageVal;
 
152
    gl::ClientVertexArrayType ClientVertexArrayTypeVal;
 
153
    gl::CullFaceMode CullFaceModeVal;
 
154
    gl::DrawElementsType DrawElementsTypeVal;
 
155
    gl::FenceNVID FenceNVIDVal;
 
156
    const gl::FenceNVID *FenceNVIDConstPointerVal;
 
157
    gl::FenceNVID *FenceNVIDPointerVal;
 
158
    gl::FramebufferID FramebufferIDVal;
 
159
    const gl::FramebufferID *FramebufferIDConstPointerVal;
 
160
    gl::FramebufferID *FramebufferIDPointerVal;
 
161
    GLDEBUGPROC GLDEBUGPROCVal;
 
162
    GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
 
163
    GLbitfield GLbitfieldVal;
 
164
    GLboolean GLbooleanVal;
 
165
    const GLboolean *GLbooleanConstPointerVal;
 
166
    GLboolean *GLbooleanPointerVal;
 
167
    GLbyte GLbyteVal;
 
168
    const GLbyte *GLbyteConstPointerVal;
 
169
    const GLchar *GLcharConstPointerVal;
 
170
    const GLchar *const *GLcharConstPointerPointerVal;
 
171
    GLchar *GLcharPointerVal;
 
172
    GLclampx GLclampxVal;
 
173
    GLdouble GLdoubleVal;
 
174
    const GLdouble *GLdoubleConstPointerVal;
 
175
    GLdouble *GLdoublePointerVal;
 
176
    GLeglImageOES GLeglImageOESVal;
 
177
    GLenum GLenumVal;
 
178
    const GLenum *GLenumConstPointerVal;
 
179
    GLenum *GLenumPointerVal;
 
180
    GLfixed GLfixedVal;
 
181
    const GLfixed *GLfixedConstPointerVal;
 
182
    GLfixed *GLfixedPointerVal;
 
183
    GLfloat GLfloatVal;
 
184
    const GLfloat *GLfloatConstPointerVal;
 
185
    GLfloat *GLfloatPointerVal;
 
186
    GLint GLintVal;
 
187
    GLint64 *GLint64PointerVal;
 
188
    const GLint *GLintConstPointerVal;
 
189
    GLint *GLintPointerVal;
 
190
    GLintptr GLintptrVal;
 
191
    const GLintptr *GLintptrConstPointerVal;
 
192
    GLshort GLshortVal;
 
193
    const GLshort *GLshortConstPointerVal;
 
194
    GLsizei GLsizeiVal;
 
195
    const GLsizei *GLsizeiConstPointerVal;
 
196
    GLsizei *GLsizeiPointerVal;
 
197
    GLsizeiptr GLsizeiptrVal;
 
198
    const GLsizeiptr *GLsizeiptrConstPointerVal;
 
199
    GLsync GLsyncVal;
 
200
    GLubyte GLubyteVal;
 
201
    const GLubyte *GLubyteConstPointerVal;
 
202
    GLubyte *GLubytePointerVal;
 
203
    GLuint GLuintVal;
 
204
    GLuint64 GLuint64Val;
 
205
    const GLuint64 *GLuint64ConstPointerVal;
 
206
    GLuint64 *GLuint64PointerVal;
 
207
    const GLuint *GLuintConstPointerVal;
 
208
    GLuint *GLuintPointerVal;
 
209
    GLushort GLushortVal;
 
210
    const GLushort *GLushortConstPointerVal;
 
211
    GLushort *GLushortPointerVal;
 
212
    const GLvoid *GLvoidConstPointerVal;
 
213
    const GLvoid *const *GLvoidConstPointerPointerVal;
 
214
    gl::GraphicsResetStatus GraphicsResetStatusVal;
 
215
    gl::HandleType HandleTypeVal;
 
216
    gl::LightParameter LightParameterVal;
 
217
    gl::LogicalOperation LogicalOperationVal;
 
218
    gl::MaterialParameter MaterialParameterVal;
 
219
    gl::MatrixType MatrixTypeVal;
 
220
    gl::MemoryObjectID MemoryObjectIDVal;
 
221
    const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
 
222
    gl::MemoryObjectID *MemoryObjectIDPointerVal;
 
223
    gl::PathID PathIDVal;
 
224
    gl::PointParameter PointParameterVal;
 
225
    gl::PrimitiveMode PrimitiveModeVal;
 
226
    gl::ProgramPipelineID ProgramPipelineIDVal;
 
227
    const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
 
228
    gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
 
229
    gl::ProvokingVertexConvention ProvokingVertexConventionVal;
 
230
    gl::QueryID QueryIDVal;
 
231
    const gl::QueryID *QueryIDConstPointerVal;
 
232
    gl::QueryID *QueryIDPointerVal;
 
233
    gl::QueryType QueryTypeVal;
 
234
    gl::RenderbufferID RenderbufferIDVal;
 
235
    const gl::RenderbufferID *RenderbufferIDConstPointerVal;
 
236
    gl::RenderbufferID *RenderbufferIDPointerVal;
 
237
    gl::SamplerID SamplerIDVal;
 
238
    const gl::SamplerID *SamplerIDConstPointerVal;
 
239
    gl::SamplerID *SamplerIDPointerVal;
 
240
    gl::SemaphoreID SemaphoreIDVal;
 
241
    const gl::SemaphoreID *SemaphoreIDConstPointerVal;
 
242
    gl::SemaphoreID *SemaphoreIDPointerVal;
 
243
    gl::ShaderProgramID ShaderProgramIDVal;
 
244
    const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
 
245
    gl::ShaderProgramID *ShaderProgramIDPointerVal;
 
246
    gl::ShaderType ShaderTypeVal;
 
247
    gl::ShadingModel ShadingModelVal;
 
248
    gl::TextureEnvParameter TextureEnvParameterVal;
 
249
    gl::TextureEnvTarget TextureEnvTargetVal;
 
250
    gl::TextureID TextureIDVal;
 
251
    const gl::TextureID *TextureIDConstPointerVal;
 
252
    gl::TextureID *TextureIDPointerVal;
 
253
    gl::TextureTarget TextureTargetVal;
 
254
    gl::TextureType TextureTypeVal;
 
255
    gl::TransformFeedbackID TransformFeedbackIDVal;
 
256
    const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
 
257
    gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
 
258
    gl::VertexArrayID VertexArrayIDVal;
 
259
    const gl::VertexArrayID *VertexArrayIDConstPointerVal;
 
260
    gl::VertexArrayID *VertexArrayIDPointerVal;
 
261
    gl::VertexAttribType VertexAttribTypeVal;
 
262
    const void *voidConstPointerVal;
 
263
    const void *const *voidConstPointerPointerVal;
 
264
    void *voidPointerVal;
 
265
    void **voidPointerPointerVal;
 
266
};
 
267
 
 
268
template <ParamType PType, typename T>
 
269
T GetParamVal(const ParamValue &value);
 
270
 
 
271
template <>
 
272
inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
 
273
    const ParamValue &value)
 
274
{
 
275
    return value.AlphaTestFuncVal;
 
276
}
 
277
 
 
278
template <>
 
279
inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
 
280
    const ParamValue &value)
 
281
{
 
282
    return value.BufferBindingVal;
 
283
}
 
284
 
 
285
template <>
 
286
inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
 
287
{
 
288
    return value.BufferIDVal;
 
289
}
 
290
 
 
291
template <>
 
292
inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
 
293
    const ParamValue &value)
 
294
{
 
295
    return value.BufferIDConstPointerVal;
 
296
}
 
297
 
 
298
template <>
 
299
inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
 
300
    const ParamValue &value)
 
301
{
 
302
    return value.BufferIDPointerVal;
 
303
}
 
304
 
 
305
template <>
 
306
inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
 
307
    const ParamValue &value)
 
308
{
 
309
    return value.BufferUsageVal;
 
310
}
 
311
 
 
312
template <>
 
313
inline gl::ClientVertexArrayType
 
314
GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
 
315
{
 
316
    return value.ClientVertexArrayTypeVal;
 
317
}
 
318
 
 
319
template <>
 
320
inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
 
321
    const ParamValue &value)
 
322
{
 
323
    return value.CullFaceModeVal;
 
324
}
 
325
 
 
326
template <>
 
327
inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
 
328
    const ParamValue &value)
 
329
{
 
330
    return value.DrawElementsTypeVal;
 
331
}
 
332
 
 
333
template <>
 
334
inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
 
335
{
 
336
    return value.FenceNVIDVal;
 
337
}
 
338
 
 
339
template <>
 
340
inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
 
341
    const ParamValue &value)
 
342
{
 
343
    return value.FenceNVIDConstPointerVal;
 
344
}
 
345
 
 
346
template <>
 
347
inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
 
348
    const ParamValue &value)
 
349
{
 
350
    return value.FenceNVIDPointerVal;
 
351
}
 
352
 
 
353
template <>
 
354
inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
 
355
    const ParamValue &value)
 
356
{
 
357
    return value.FramebufferIDVal;
 
358
}
 
359
 
 
360
template <>
 
361
inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
 
362
                                            const gl::FramebufferID *>(const ParamValue &value)
 
363
{
 
364
    return value.FramebufferIDConstPointerVal;
 
365
}
 
366
 
 
367
template <>
 
368
inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
 
369
    const ParamValue &value)
 
370
{
 
371
    return value.FramebufferIDPointerVal;
 
372
}
 
373
 
 
374
template <>
 
375
inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
 
376
{
 
377
    return value.GLDEBUGPROCVal;
 
378
}
 
379
 
 
380
template <>
 
381
inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
 
382
    const ParamValue &value)
 
383
{
 
384
    return value.GLDEBUGPROCKHRVal;
 
385
}
 
386
 
 
387
template <>
 
388
inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
 
389
{
 
390
    return value.GLbitfieldVal;
 
391
}
 
392
 
 
393
template <>
 
394
inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
 
395
{
 
396
    return value.GLbooleanVal;
 
397
}
 
398
 
 
399
template <>
 
400
inline const GLboolean *GetParamVal<ParamType::TGLbooleanConstPointer, const GLboolean *>(
 
401
    const ParamValue &value)
 
402
{
 
403
    return value.GLbooleanConstPointerVal;
 
404
}
 
405
 
 
406
template <>
 
407
inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
 
408
{
 
409
    return value.GLbooleanPointerVal;
 
410
}
 
411
 
 
412
template <>
 
413
inline GLbyte GetParamVal<ParamType::TGLbyte, GLbyte>(const ParamValue &value)
 
414
{
 
415
    return value.GLbyteVal;
 
416
}
 
417
 
 
418
template <>
 
419
inline const GLbyte *GetParamVal<ParamType::TGLbyteConstPointer, const GLbyte *>(
 
420
    const ParamValue &value)
 
421
{
 
422
    return value.GLbyteConstPointerVal;
 
423
}
 
424
 
 
425
template <>
 
426
inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
 
427
    const ParamValue &value)
 
428
{
 
429
    return value.GLcharConstPointerVal;
 
430
}
 
431
 
 
432
template <>
 
433
inline const GLchar *const *
 
434
GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
 
435
{
 
436
    return value.GLcharConstPointerPointerVal;
 
437
}
 
438
 
 
439
template <>
 
440
inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
 
441
{
 
442
    return value.GLcharPointerVal;
 
443
}
 
444
 
 
445
template <>
 
446
inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
 
447
{
 
448
    return value.GLclampxVal;
 
449
}
 
450
 
 
451
template <>
 
452
inline GLdouble GetParamVal<ParamType::TGLdouble, GLdouble>(const ParamValue &value)
 
453
{
 
454
    return value.GLdoubleVal;
 
455
}
 
456
 
 
457
template <>
 
458
inline const GLdouble *GetParamVal<ParamType::TGLdoubleConstPointer, const GLdouble *>(
 
459
    const ParamValue &value)
 
460
{
 
461
    return value.GLdoubleConstPointerVal;
 
462
}
 
463
 
 
464
template <>
 
465
inline GLdouble *GetParamVal<ParamType::TGLdoublePointer, GLdouble *>(const ParamValue &value)
 
466
{
 
467
    return value.GLdoublePointerVal;
 
468
}
 
469
 
 
470
template <>
 
471
inline GLeglImageOES GetParamVal<ParamType::TGLeglImageOES, GLeglImageOES>(const ParamValue &value)
 
472
{
 
473
    return value.GLeglImageOESVal;
 
474
}
 
475
 
 
476
template <>
 
477
inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
 
478
{
 
479
    return value.GLenumVal;
 
480
}
 
481
 
 
482
template <>
 
483
inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
 
484
    const ParamValue &value)
 
485
{
 
486
    return value.GLenumConstPointerVal;
 
487
}
 
488
 
 
489
template <>
 
490
inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
 
491
{
 
492
    return value.GLenumPointerVal;
 
493
}
 
494
 
 
495
template <>
 
496
inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
 
497
{
 
498
    return value.GLfixedVal;
 
499
}
 
500
 
 
501
template <>
 
502
inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
 
503
    const ParamValue &value)
 
504
{
 
505
    return value.GLfixedConstPointerVal;
 
506
}
 
507
 
 
508
template <>
 
509
inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
 
510
{
 
511
    return value.GLfixedPointerVal;
 
512
}
 
513
 
 
514
template <>
 
515
inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
 
516
{
 
517
    return value.GLfloatVal;
 
518
}
 
519
 
 
520
template <>
 
521
inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
 
522
    const ParamValue &value)
 
523
{
 
524
    return value.GLfloatConstPointerVal;
 
525
}
 
526
 
 
527
template <>
 
528
inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
 
529
{
 
530
    return value.GLfloatPointerVal;
 
531
}
 
532
 
 
533
template <>
 
534
inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
 
535
{
 
536
    return value.GLintVal;
 
537
}
 
538
 
 
539
template <>
 
540
inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
 
541
{
 
542
    return value.GLint64PointerVal;
 
543
}
 
544
 
 
545
template <>
 
546
inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
 
547
    const ParamValue &value)
 
548
{
 
549
    return value.GLintConstPointerVal;
 
550
}
 
551
 
 
552
template <>
 
553
inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
 
554
{
 
555
    return value.GLintPointerVal;
 
556
}
 
557
 
 
558
template <>
 
559
inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
 
560
{
 
561
    return value.GLintptrVal;
 
562
}
 
563
 
 
564
template <>
 
565
inline const GLintptr *GetParamVal<ParamType::TGLintptrConstPointer, const GLintptr *>(
 
566
    const ParamValue &value)
 
567
{
 
568
    return value.GLintptrConstPointerVal;
 
569
}
 
570
 
 
571
template <>
 
572
inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
 
573
{
 
574
    return value.GLshortVal;
 
575
}
 
576
 
 
577
template <>
 
578
inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
 
579
    const ParamValue &value)
 
580
{
 
581
    return value.GLshortConstPointerVal;
 
582
}
 
583
 
 
584
template <>
 
585
inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
 
586
{
 
587
    return value.GLsizeiVal;
 
588
}
 
589
 
 
590
template <>
 
591
inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
 
592
    const ParamValue &value)
 
593
{
 
594
    return value.GLsizeiConstPointerVal;
 
595
}
 
596
 
 
597
template <>
 
598
inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
 
599
{
 
600
    return value.GLsizeiPointerVal;
 
601
}
 
602
 
 
603
template <>
 
604
inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
 
605
{
 
606
    return value.GLsizeiptrVal;
 
607
}
 
608
 
 
609
template <>
 
610
inline const GLsizeiptr *GetParamVal<ParamType::TGLsizeiptrConstPointer, const GLsizeiptr *>(
 
611
    const ParamValue &value)
 
612
{
 
613
    return value.GLsizeiptrConstPointerVal;
 
614
}
 
615
 
 
616
template <>
 
617
inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
 
618
{
 
619
    return value.GLsyncVal;
 
620
}
 
621
 
 
622
template <>
 
623
inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
 
624
{
 
625
    return value.GLubyteVal;
 
626
}
 
627
 
 
628
template <>
 
629
inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
 
630
    const ParamValue &value)
 
631
{
 
632
    return value.GLubyteConstPointerVal;
 
633
}
 
634
 
 
635
template <>
 
636
inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
 
637
{
 
638
    return value.GLubytePointerVal;
 
639
}
 
640
 
 
641
template <>
 
642
inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
 
643
{
 
644
    return value.GLuintVal;
 
645
}
 
646
 
 
647
template <>
 
648
inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
 
649
{
 
650
    return value.GLuint64Val;
 
651
}
 
652
 
 
653
template <>
 
654
inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
 
655
    const ParamValue &value)
 
656
{
 
657
    return value.GLuint64ConstPointerVal;
 
658
}
 
659
 
 
660
template <>
 
661
inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
 
662
{
 
663
    return value.GLuint64PointerVal;
 
664
}
 
665
 
 
666
template <>
 
667
inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
 
668
    const ParamValue &value)
 
669
{
 
670
    return value.GLuintConstPointerVal;
 
671
}
 
672
 
 
673
template <>
 
674
inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
 
675
{
 
676
    return value.GLuintPointerVal;
 
677
}
 
678
 
 
679
template <>
 
680
inline GLushort GetParamVal<ParamType::TGLushort, GLushort>(const ParamValue &value)
 
681
{
 
682
    return value.GLushortVal;
 
683
}
 
684
 
 
685
template <>
 
686
inline const GLushort *GetParamVal<ParamType::TGLushortConstPointer, const GLushort *>(
 
687
    const ParamValue &value)
 
688
{
 
689
    return value.GLushortConstPointerVal;
 
690
}
 
691
 
 
692
template <>
 
693
inline GLushort *GetParamVal<ParamType::TGLushortPointer, GLushort *>(const ParamValue &value)
 
694
{
 
695
    return value.GLushortPointerVal;
 
696
}
 
697
 
 
698
template <>
 
699
inline const GLvoid *GetParamVal<ParamType::TGLvoidConstPointer, const GLvoid *>(
 
700
    const ParamValue &value)
 
701
{
 
702
    return value.GLvoidConstPointerVal;
 
703
}
 
704
 
 
705
template <>
 
706
inline const GLvoid *const *
 
707
GetParamVal<ParamType::TGLvoidConstPointerPointer, const GLvoid *const *>(const ParamValue &value)
 
708
{
 
709
    return value.GLvoidConstPointerPointerVal;
 
710
}
 
711
 
 
712
template <>
 
713
inline gl::GraphicsResetStatus
 
714
GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
 
715
{
 
716
    return value.GraphicsResetStatusVal;
 
717
}
 
718
 
 
719
template <>
 
720
inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
 
721
{
 
722
    return value.HandleTypeVal;
 
723
}
 
724
 
 
725
template <>
 
726
inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
 
727
    const ParamValue &value)
 
728
{
 
729
    return value.LightParameterVal;
 
730
}
 
731
 
 
732
template <>
 
733
inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
 
734
    const ParamValue &value)
 
735
{
 
736
    return value.LogicalOperationVal;
 
737
}
 
738
 
 
739
template <>
 
740
inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
 
741
    const ParamValue &value)
 
742
{
 
743
    return value.MaterialParameterVal;
 
744
}
 
745
 
 
746
template <>
 
747
inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
 
748
{
 
749
    return value.MatrixTypeVal;
 
750
}
 
751
 
 
752
template <>
 
753
inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
 
754
    const ParamValue &value)
 
755
{
 
756
    return value.MemoryObjectIDVal;
 
757
}
 
758
 
 
759
template <>
 
760
inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
 
761
                                             const gl::MemoryObjectID *>(const ParamValue &value)
 
762
{
 
763
    return value.MemoryObjectIDConstPointerVal;
 
764
}
 
765
 
 
766
template <>
 
767
inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
 
768
    const ParamValue &value)
 
769
{
 
770
    return value.MemoryObjectIDPointerVal;
 
771
}
 
772
 
 
773
template <>
 
774
inline gl::PathID GetParamVal<ParamType::TPathID, gl::PathID>(const ParamValue &value)
 
775
{
 
776
    return value.PathIDVal;
 
777
}
 
778
 
 
779
template <>
 
780
inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
 
781
    const ParamValue &value)
 
782
{
 
783
    return value.PointParameterVal;
 
784
}
 
785
 
 
786
template <>
 
787
inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
 
788
    const ParamValue &value)
 
789
{
 
790
    return value.PrimitiveModeVal;
 
791
}
 
792
 
 
793
template <>
 
794
inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
 
795
    const ParamValue &value)
 
796
{
 
797
    return value.ProgramPipelineIDVal;
 
798
}
 
799
 
 
800
template <>
 
801
inline const gl::ProgramPipelineID *
 
802
GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
 
803
    const ParamValue &value)
 
804
{
 
805
    return value.ProgramPipelineIDConstPointerVal;
 
806
}
 
807
 
 
808
template <>
 
809
inline gl::ProgramPipelineID *
 
810
GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
 
811
{
 
812
    return value.ProgramPipelineIDPointerVal;
 
813
}
 
814
 
 
815
template <>
 
816
inline gl::ProvokingVertexConvention
 
817
GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
 
818
    const ParamValue &value)
 
819
{
 
820
    return value.ProvokingVertexConventionVal;
 
821
}
 
822
 
 
823
template <>
 
824
inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
 
825
{
 
826
    return value.QueryIDVal;
 
827
}
 
828
 
 
829
template <>
 
830
inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
 
831
    const ParamValue &value)
 
832
{
 
833
    return value.QueryIDConstPointerVal;
 
834
}
 
835
 
 
836
template <>
 
837
inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
 
838
{
 
839
    return value.QueryIDPointerVal;
 
840
}
 
841
 
 
842
template <>
 
843
inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
 
844
{
 
845
    return value.QueryTypeVal;
 
846
}
 
847
 
 
848
template <>
 
849
inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
 
850
    const ParamValue &value)
 
851
{
 
852
    return value.RenderbufferIDVal;
 
853
}
 
854
 
 
855
template <>
 
856
inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
 
857
                                             const gl::RenderbufferID *>(const ParamValue &value)
 
858
{
 
859
    return value.RenderbufferIDConstPointerVal;
 
860
}
 
861
 
 
862
template <>
 
863
inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
 
864
    const ParamValue &value)
 
865
{
 
866
    return value.RenderbufferIDPointerVal;
 
867
}
 
868
 
 
869
template <>
 
870
inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
 
871
{
 
872
    return value.SamplerIDVal;
 
873
}
 
874
 
 
875
template <>
 
876
inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
 
877
    const ParamValue &value)
 
878
{
 
879
    return value.SamplerIDConstPointerVal;
 
880
}
 
881
 
 
882
template <>
 
883
inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
 
884
    const ParamValue &value)
 
885
{
 
886
    return value.SamplerIDPointerVal;
 
887
}
 
888
 
 
889
template <>
 
890
inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
 
891
    const ParamValue &value)
 
892
{
 
893
    return value.SemaphoreIDVal;
 
894
}
 
895
 
 
896
template <>
 
897
inline const gl::SemaphoreID *
 
898
GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
 
899
{
 
900
    return value.SemaphoreIDConstPointerVal;
 
901
}
 
902
 
 
903
template <>
 
904
inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
 
905
    const ParamValue &value)
 
906
{
 
907
    return value.SemaphoreIDPointerVal;
 
908
}
 
909
 
 
910
template <>
 
911
inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
 
912
    const ParamValue &value)
 
913
{
 
914
    return value.ShaderProgramIDVal;
 
915
}
 
916
 
 
917
template <>
 
918
inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
 
919
                                              const gl::ShaderProgramID *>(const ParamValue &value)
 
920
{
 
921
    return value.ShaderProgramIDConstPointerVal;
 
922
}
 
923
 
 
924
template <>
 
925
inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
 
926
    const ParamValue &value)
 
927
{
 
928
    return value.ShaderProgramIDPointerVal;
 
929
}
 
930
 
 
931
template <>
 
932
inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
 
933
{
 
934
    return value.ShaderTypeVal;
 
935
}
 
936
 
 
937
template <>
 
938
inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
 
939
    const ParamValue &value)
 
940
{
 
941
    return value.ShadingModelVal;
 
942
}
 
943
 
 
944
template <>
 
945
inline gl::TextureEnvParameter
 
946
GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
 
947
{
 
948
    return value.TextureEnvParameterVal;
 
949
}
 
950
 
 
951
template <>
 
952
inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
 
953
    const ParamValue &value)
 
954
{
 
955
    return value.TextureEnvTargetVal;
 
956
}
 
957
 
 
958
template <>
 
959
inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
 
960
{
 
961
    return value.TextureIDVal;
 
962
}
 
963
 
 
964
template <>
 
965
inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
 
966
    const ParamValue &value)
 
967
{
 
968
    return value.TextureIDConstPointerVal;
 
969
}
 
970
 
 
971
template <>
 
972
inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
 
973
    const ParamValue &value)
 
974
{
 
975
    return value.TextureIDPointerVal;
 
976
}
 
977
 
 
978
template <>
 
979
inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
 
980
    const ParamValue &value)
 
981
{
 
982
    return value.TextureTargetVal;
 
983
}
 
984
 
 
985
template <>
 
986
inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
 
987
    const ParamValue &value)
 
988
{
 
989
    return value.TextureTypeVal;
 
990
}
 
991
 
 
992
template <>
 
993
inline gl::TransformFeedbackID
 
994
GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
 
995
{
 
996
    return value.TransformFeedbackIDVal;
 
997
}
 
998
 
 
999
template <>
 
1000
inline const gl::TransformFeedbackID *
 
1001
GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
 
1002
    const ParamValue &value)
 
1003
{
 
1004
    return value.TransformFeedbackIDConstPointerVal;
 
1005
}
 
1006
 
 
1007
template <>
 
1008
inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
 
1009
                                            gl::TransformFeedbackID *>(const ParamValue &value)
 
1010
{
 
1011
    return value.TransformFeedbackIDPointerVal;
 
1012
}
 
1013
 
 
1014
template <>
 
1015
inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
 
1016
    const ParamValue &value)
 
1017
{
 
1018
    return value.VertexArrayIDVal;
 
1019
}
 
1020
 
 
1021
template <>
 
1022
inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
 
1023
                                            const gl::VertexArrayID *>(const ParamValue &value)
 
1024
{
 
1025
    return value.VertexArrayIDConstPointerVal;
 
1026
}
 
1027
 
 
1028
template <>
 
1029
inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
 
1030
    const ParamValue &value)
 
1031
{
 
1032
    return value.VertexArrayIDPointerVal;
 
1033
}
 
1034
 
 
1035
template <>
 
1036
inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
 
1037
    const ParamValue &value)
 
1038
{
 
1039
    return value.VertexAttribTypeVal;
 
1040
}
 
1041
 
 
1042
template <>
 
1043
inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
 
1044
{
 
1045
    return value.voidConstPointerVal;
 
1046
}
 
1047
 
 
1048
template <>
 
1049
inline const void *const *GetParamVal<ParamType::TvoidConstPointerPointer, const void *const *>(
 
1050
    const ParamValue &value)
 
1051
{
 
1052
    return value.voidConstPointerPointerVal;
 
1053
}
 
1054
 
 
1055
template <>
 
1056
inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
 
1057
{
 
1058
    return value.voidPointerVal;
 
1059
}
 
1060
 
 
1061
template <>
 
1062
inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
 
1063
{
 
1064
    return value.voidPointerPointerVal;
 
1065
}
 
1066
 
 
1067
template <ParamType PType, typename T>
 
1068
T GetParamVal(const ParamValue &value)
 
1069
{
 
1070
    UNREACHABLE();
 
1071
    return T();
 
1072
}
 
1073
 
 
1074
template <typename T>
 
1075
T AccessParamValue(ParamType paramType, const ParamValue &value)
 
1076
{
 
1077
    switch (paramType)
 
1078
    {
 
1079
        case ParamType::TAlphaTestFunc:
 
1080
            return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
 
1081
        case ParamType::TBufferBinding:
 
1082
            return GetParamVal<ParamType::TBufferBinding, T>(value);
 
1083
        case ParamType::TBufferID:
 
1084
            return GetParamVal<ParamType::TBufferID, T>(value);
 
1085
        case ParamType::TBufferIDConstPointer:
 
1086
            return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
 
1087
        case ParamType::TBufferIDPointer:
 
1088
            return GetParamVal<ParamType::TBufferIDPointer, T>(value);
 
1089
        case ParamType::TBufferUsage:
 
1090
            return GetParamVal<ParamType::TBufferUsage, T>(value);
 
1091
        case ParamType::TClientVertexArrayType:
 
1092
            return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
 
1093
        case ParamType::TCullFaceMode:
 
1094
            return GetParamVal<ParamType::TCullFaceMode, T>(value);
 
1095
        case ParamType::TDrawElementsType:
 
1096
            return GetParamVal<ParamType::TDrawElementsType, T>(value);
 
1097
        case ParamType::TFenceNVID:
 
1098
            return GetParamVal<ParamType::TFenceNVID, T>(value);
 
1099
        case ParamType::TFenceNVIDConstPointer:
 
1100
            return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
 
1101
        case ParamType::TFenceNVIDPointer:
 
1102
            return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
 
1103
        case ParamType::TFramebufferID:
 
1104
            return GetParamVal<ParamType::TFramebufferID, T>(value);
 
1105
        case ParamType::TFramebufferIDConstPointer:
 
1106
            return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
 
1107
        case ParamType::TFramebufferIDPointer:
 
1108
            return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
 
1109
        case ParamType::TGLDEBUGPROC:
 
1110
            return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
 
1111
        case ParamType::TGLDEBUGPROCKHR:
 
1112
            return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
 
1113
        case ParamType::TGLbitfield:
 
1114
            return GetParamVal<ParamType::TGLbitfield, T>(value);
 
1115
        case ParamType::TGLboolean:
 
1116
            return GetParamVal<ParamType::TGLboolean, T>(value);
 
1117
        case ParamType::TGLbooleanConstPointer:
 
1118
            return GetParamVal<ParamType::TGLbooleanConstPointer, T>(value);
 
1119
        case ParamType::TGLbooleanPointer:
 
1120
            return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
 
1121
        case ParamType::TGLbyte:
 
1122
            return GetParamVal<ParamType::TGLbyte, T>(value);
 
1123
        case ParamType::TGLbyteConstPointer:
 
1124
            return GetParamVal<ParamType::TGLbyteConstPointer, T>(value);
 
1125
        case ParamType::TGLcharConstPointer:
 
1126
            return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
 
1127
        case ParamType::TGLcharConstPointerPointer:
 
1128
            return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
 
1129
        case ParamType::TGLcharPointer:
 
1130
            return GetParamVal<ParamType::TGLcharPointer, T>(value);
 
1131
        case ParamType::TGLclampx:
 
1132
            return GetParamVal<ParamType::TGLclampx, T>(value);
 
1133
        case ParamType::TGLdouble:
 
1134
            return GetParamVal<ParamType::TGLdouble, T>(value);
 
1135
        case ParamType::TGLdoubleConstPointer:
 
1136
            return GetParamVal<ParamType::TGLdoubleConstPointer, T>(value);
 
1137
        case ParamType::TGLdoublePointer:
 
1138
            return GetParamVal<ParamType::TGLdoublePointer, T>(value);
 
1139
        case ParamType::TGLeglImageOES:
 
1140
            return GetParamVal<ParamType::TGLeglImageOES, T>(value);
 
1141
        case ParamType::TGLenum:
 
1142
            return GetParamVal<ParamType::TGLenum, T>(value);
 
1143
        case ParamType::TGLenumConstPointer:
 
1144
            return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
 
1145
        case ParamType::TGLenumPointer:
 
1146
            return GetParamVal<ParamType::TGLenumPointer, T>(value);
 
1147
        case ParamType::TGLfixed:
 
1148
            return GetParamVal<ParamType::TGLfixed, T>(value);
 
1149
        case ParamType::TGLfixedConstPointer:
 
1150
            return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
 
1151
        case ParamType::TGLfixedPointer:
 
1152
            return GetParamVal<ParamType::TGLfixedPointer, T>(value);
 
1153
        case ParamType::TGLfloat:
 
1154
            return GetParamVal<ParamType::TGLfloat, T>(value);
 
1155
        case ParamType::TGLfloatConstPointer:
 
1156
            return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
 
1157
        case ParamType::TGLfloatPointer:
 
1158
            return GetParamVal<ParamType::TGLfloatPointer, T>(value);
 
1159
        case ParamType::TGLint:
 
1160
            return GetParamVal<ParamType::TGLint, T>(value);
 
1161
        case ParamType::TGLint64Pointer:
 
1162
            return GetParamVal<ParamType::TGLint64Pointer, T>(value);
 
1163
        case ParamType::TGLintConstPointer:
 
1164
            return GetParamVal<ParamType::TGLintConstPointer, T>(value);
 
1165
        case ParamType::TGLintPointer:
 
1166
            return GetParamVal<ParamType::TGLintPointer, T>(value);
 
1167
        case ParamType::TGLintptr:
 
1168
            return GetParamVal<ParamType::TGLintptr, T>(value);
 
1169
        case ParamType::TGLintptrConstPointer:
 
1170
            return GetParamVal<ParamType::TGLintptrConstPointer, T>(value);
 
1171
        case ParamType::TGLshort:
 
1172
            return GetParamVal<ParamType::TGLshort, T>(value);
 
1173
        case ParamType::TGLshortConstPointer:
 
1174
            return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
 
1175
        case ParamType::TGLsizei:
 
1176
            return GetParamVal<ParamType::TGLsizei, T>(value);
 
1177
        case ParamType::TGLsizeiConstPointer:
 
1178
            return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
 
1179
        case ParamType::TGLsizeiPointer:
 
1180
            return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
 
1181
        case ParamType::TGLsizeiptr:
 
1182
            return GetParamVal<ParamType::TGLsizeiptr, T>(value);
 
1183
        case ParamType::TGLsizeiptrConstPointer:
 
1184
            return GetParamVal<ParamType::TGLsizeiptrConstPointer, T>(value);
 
1185
        case ParamType::TGLsync:
 
1186
            return GetParamVal<ParamType::TGLsync, T>(value);
 
1187
        case ParamType::TGLubyte:
 
1188
            return GetParamVal<ParamType::TGLubyte, T>(value);
 
1189
        case ParamType::TGLubyteConstPointer:
 
1190
            return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
 
1191
        case ParamType::TGLubytePointer:
 
1192
            return GetParamVal<ParamType::TGLubytePointer, T>(value);
 
1193
        case ParamType::TGLuint:
 
1194
            return GetParamVal<ParamType::TGLuint, T>(value);
 
1195
        case ParamType::TGLuint64:
 
1196
            return GetParamVal<ParamType::TGLuint64, T>(value);
 
1197
        case ParamType::TGLuint64ConstPointer:
 
1198
            return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
 
1199
        case ParamType::TGLuint64Pointer:
 
1200
            return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
 
1201
        case ParamType::TGLuintConstPointer:
 
1202
            return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
 
1203
        case ParamType::TGLuintPointer:
 
1204
            return GetParamVal<ParamType::TGLuintPointer, T>(value);
 
1205
        case ParamType::TGLushort:
 
1206
            return GetParamVal<ParamType::TGLushort, T>(value);
 
1207
        case ParamType::TGLushortConstPointer:
 
1208
            return GetParamVal<ParamType::TGLushortConstPointer, T>(value);
 
1209
        case ParamType::TGLushortPointer:
 
1210
            return GetParamVal<ParamType::TGLushortPointer, T>(value);
 
1211
        case ParamType::TGLvoidConstPointer:
 
1212
            return GetParamVal<ParamType::TGLvoidConstPointer, T>(value);
 
1213
        case ParamType::TGLvoidConstPointerPointer:
 
1214
            return GetParamVal<ParamType::TGLvoidConstPointerPointer, T>(value);
 
1215
        case ParamType::TGraphicsResetStatus:
 
1216
            return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
 
1217
        case ParamType::THandleType:
 
1218
            return GetParamVal<ParamType::THandleType, T>(value);
 
1219
        case ParamType::TLightParameter:
 
1220
            return GetParamVal<ParamType::TLightParameter, T>(value);
 
1221
        case ParamType::TLogicalOperation:
 
1222
            return GetParamVal<ParamType::TLogicalOperation, T>(value);
 
1223
        case ParamType::TMaterialParameter:
 
1224
            return GetParamVal<ParamType::TMaterialParameter, T>(value);
 
1225
        case ParamType::TMatrixType:
 
1226
            return GetParamVal<ParamType::TMatrixType, T>(value);
 
1227
        case ParamType::TMemoryObjectID:
 
1228
            return GetParamVal<ParamType::TMemoryObjectID, T>(value);
 
1229
        case ParamType::TMemoryObjectIDConstPointer:
 
1230
            return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
 
1231
        case ParamType::TMemoryObjectIDPointer:
 
1232
            return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
 
1233
        case ParamType::TPathID:
 
1234
            return GetParamVal<ParamType::TPathID, T>(value);
 
1235
        case ParamType::TPointParameter:
 
1236
            return GetParamVal<ParamType::TPointParameter, T>(value);
 
1237
        case ParamType::TPrimitiveMode:
 
1238
            return GetParamVal<ParamType::TPrimitiveMode, T>(value);
 
1239
        case ParamType::TProgramPipelineID:
 
1240
            return GetParamVal<ParamType::TProgramPipelineID, T>(value);
 
1241
        case ParamType::TProgramPipelineIDConstPointer:
 
1242
            return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
 
1243
        case ParamType::TProgramPipelineIDPointer:
 
1244
            return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
 
1245
        case ParamType::TProvokingVertexConvention:
 
1246
            return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
 
1247
        case ParamType::TQueryID:
 
1248
            return GetParamVal<ParamType::TQueryID, T>(value);
 
1249
        case ParamType::TQueryIDConstPointer:
 
1250
            return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
 
1251
        case ParamType::TQueryIDPointer:
 
1252
            return GetParamVal<ParamType::TQueryIDPointer, T>(value);
 
1253
        case ParamType::TQueryType:
 
1254
            return GetParamVal<ParamType::TQueryType, T>(value);
 
1255
        case ParamType::TRenderbufferID:
 
1256
            return GetParamVal<ParamType::TRenderbufferID, T>(value);
 
1257
        case ParamType::TRenderbufferIDConstPointer:
 
1258
            return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
 
1259
        case ParamType::TRenderbufferIDPointer:
 
1260
            return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
 
1261
        case ParamType::TSamplerID:
 
1262
            return GetParamVal<ParamType::TSamplerID, T>(value);
 
1263
        case ParamType::TSamplerIDConstPointer:
 
1264
            return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
 
1265
        case ParamType::TSamplerIDPointer:
 
1266
            return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
 
1267
        case ParamType::TSemaphoreID:
 
1268
            return GetParamVal<ParamType::TSemaphoreID, T>(value);
 
1269
        case ParamType::TSemaphoreIDConstPointer:
 
1270
            return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
 
1271
        case ParamType::TSemaphoreIDPointer:
 
1272
            return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
 
1273
        case ParamType::TShaderProgramID:
 
1274
            return GetParamVal<ParamType::TShaderProgramID, T>(value);
 
1275
        case ParamType::TShaderProgramIDConstPointer:
 
1276
            return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
 
1277
        case ParamType::TShaderProgramIDPointer:
 
1278
            return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
 
1279
        case ParamType::TShaderType:
 
1280
            return GetParamVal<ParamType::TShaderType, T>(value);
 
1281
        case ParamType::TShadingModel:
 
1282
            return GetParamVal<ParamType::TShadingModel, T>(value);
 
1283
        case ParamType::TTextureEnvParameter:
 
1284
            return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
 
1285
        case ParamType::TTextureEnvTarget:
 
1286
            return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
 
1287
        case ParamType::TTextureID:
 
1288
            return GetParamVal<ParamType::TTextureID, T>(value);
 
1289
        case ParamType::TTextureIDConstPointer:
 
1290
            return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
 
1291
        case ParamType::TTextureIDPointer:
 
1292
            return GetParamVal<ParamType::TTextureIDPointer, T>(value);
 
1293
        case ParamType::TTextureTarget:
 
1294
            return GetParamVal<ParamType::TTextureTarget, T>(value);
 
1295
        case ParamType::TTextureType:
 
1296
            return GetParamVal<ParamType::TTextureType, T>(value);
 
1297
        case ParamType::TTransformFeedbackID:
 
1298
            return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
 
1299
        case ParamType::TTransformFeedbackIDConstPointer:
 
1300
            return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
 
1301
        case ParamType::TTransformFeedbackIDPointer:
 
1302
            return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
 
1303
        case ParamType::TVertexArrayID:
 
1304
            return GetParamVal<ParamType::TVertexArrayID, T>(value);
 
1305
        case ParamType::TVertexArrayIDConstPointer:
 
1306
            return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
 
1307
        case ParamType::TVertexArrayIDPointer:
 
1308
            return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
 
1309
        case ParamType::TVertexAttribType:
 
1310
            return GetParamVal<ParamType::TVertexAttribType, T>(value);
 
1311
        case ParamType::TvoidConstPointer:
 
1312
            return GetParamVal<ParamType::TvoidConstPointer, T>(value);
 
1313
        case ParamType::TvoidConstPointerPointer:
 
1314
            return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
 
1315
        case ParamType::TvoidPointer:
 
1316
            return GetParamVal<ParamType::TvoidPointer, T>(value);
 
1317
        case ParamType::TvoidPointerPointer:
 
1318
            return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
 
1319
    }
 
1320
}
 
1321
 
 
1322
template <ParamType PType, typename T>
 
1323
void SetParamVal(T valueIn, ParamValue *valueOut);
 
1324
 
 
1325
template <>
 
1326
inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
 
1327
{
 
1328
    valueOut->AlphaTestFuncVal = valueIn;
 
1329
}
 
1330
 
 
1331
template <>
 
1332
inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
 
1333
{
 
1334
    valueOut->BufferBindingVal = valueIn;
 
1335
}
 
1336
 
 
1337
template <>
 
1338
inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
 
1339
{
 
1340
    valueOut->BufferIDVal = valueIn;
 
1341
}
 
1342
 
 
1343
template <>
 
1344
inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
 
1345
                                                          ParamValue *valueOut)
 
1346
{
 
1347
    valueOut->BufferIDConstPointerVal = valueIn;
 
1348
}
 
1349
 
 
1350
template <>
 
1351
inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
 
1352
{
 
1353
    valueOut->BufferIDPointerVal = valueIn;
 
1354
}
 
1355
 
 
1356
template <>
 
1357
inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
 
1358
{
 
1359
    valueOut->BufferUsageVal = valueIn;
 
1360
}
 
1361
 
 
1362
template <>
 
1363
inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
 
1364
                                                           ParamValue *valueOut)
 
1365
{
 
1366
    valueOut->ClientVertexArrayTypeVal = valueIn;
 
1367
}
 
1368
 
 
1369
template <>
 
1370
inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
 
1371
{
 
1372
    valueOut->CullFaceModeVal = valueIn;
 
1373
}
 
1374
 
 
1375
template <>
 
1376
inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
 
1377
                                                      ParamValue *valueOut)
 
1378
{
 
1379
    valueOut->DrawElementsTypeVal = valueIn;
 
1380
}
 
1381
 
 
1382
template <>
 
1383
inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
 
1384
{
 
1385
    valueOut->FenceNVIDVal = valueIn;
 
1386
}
 
1387
 
 
1388
template <>
 
1389
inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
 
1390
                                                           ParamValue *valueOut)
 
1391
{
 
1392
    valueOut->FenceNVIDConstPointerVal = valueIn;
 
1393
}
 
1394
 
 
1395
template <>
 
1396
inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
 
1397
{
 
1398
    valueOut->FenceNVIDPointerVal = valueIn;
 
1399
}
 
1400
 
 
1401
template <>
 
1402
inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
 
1403
{
 
1404
    valueOut->FramebufferIDVal = valueIn;
 
1405
}
 
1406
 
 
1407
template <>
 
1408
inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
 
1409
                                                               ParamValue *valueOut)
 
1410
{
 
1411
    valueOut->FramebufferIDConstPointerVal = valueIn;
 
1412
}
 
1413
 
 
1414
template <>
 
1415
inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
 
1416
                                                          ParamValue *valueOut)
 
1417
{
 
1418
    valueOut->FramebufferIDPointerVal = valueIn;
 
1419
}
 
1420
 
 
1421
template <>
 
1422
inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
 
1423
{
 
1424
    valueOut->GLDEBUGPROCVal = valueIn;
 
1425
}
 
1426
 
 
1427
template <>
 
1428
inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
 
1429
{
 
1430
    valueOut->GLDEBUGPROCKHRVal = valueIn;
 
1431
}
 
1432
 
 
1433
template <>
 
1434
inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
 
1435
{
 
1436
    valueOut->GLbitfieldVal = valueIn;
 
1437
}
 
1438
 
 
1439
template <>
 
1440
inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
 
1441
{
 
1442
    valueOut->GLbooleanVal = valueIn;
 
1443
}
 
1444
 
 
1445
template <>
 
1446
inline void SetParamVal<ParamType::TGLbooleanConstPointer>(const GLboolean *valueIn,
 
1447
                                                           ParamValue *valueOut)
 
1448
{
 
1449
    valueOut->GLbooleanConstPointerVal = valueIn;
 
1450
}
 
1451
 
 
1452
template <>
 
1453
inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
 
1454
{
 
1455
    valueOut->GLbooleanPointerVal = valueIn;
 
1456
}
 
1457
 
 
1458
template <>
 
1459
inline void SetParamVal<ParamType::TGLbyte>(GLbyte valueIn, ParamValue *valueOut)
 
1460
{
 
1461
    valueOut->GLbyteVal = valueIn;
 
1462
}
 
1463
 
 
1464
template <>
 
1465
inline void SetParamVal<ParamType::TGLbyteConstPointer>(const GLbyte *valueIn, ParamValue *valueOut)
 
1466
{
 
1467
    valueOut->GLbyteConstPointerVal = valueIn;
 
1468
}
 
1469
 
 
1470
template <>
 
1471
inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
 
1472
{
 
1473
    valueOut->GLcharConstPointerVal = valueIn;
 
1474
}
 
1475
 
 
1476
template <>
 
1477
inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
 
1478
                                                               ParamValue *valueOut)
 
1479
{
 
1480
    valueOut->GLcharConstPointerPointerVal = valueIn;
 
1481
}
 
1482
 
 
1483
template <>
 
1484
inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
 
1485
{
 
1486
    valueOut->GLcharPointerVal = valueIn;
 
1487
}
 
1488
 
 
1489
template <>
 
1490
inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
 
1491
{
 
1492
    valueOut->GLclampxVal = valueIn;
 
1493
}
 
1494
 
 
1495
template <>
 
1496
inline void SetParamVal<ParamType::TGLdouble>(GLdouble valueIn, ParamValue *valueOut)
 
1497
{
 
1498
    valueOut->GLdoubleVal = valueIn;
 
1499
}
 
1500
 
 
1501
template <>
 
1502
inline void SetParamVal<ParamType::TGLdoubleConstPointer>(const GLdouble *valueIn,
 
1503
                                                          ParamValue *valueOut)
 
1504
{
 
1505
    valueOut->GLdoubleConstPointerVal = valueIn;
 
1506
}
 
1507
 
 
1508
template <>
 
1509
inline void SetParamVal<ParamType::TGLdoublePointer>(GLdouble *valueIn, ParamValue *valueOut)
 
1510
{
 
1511
    valueOut->GLdoublePointerVal = valueIn;
 
1512
}
 
1513
 
 
1514
template <>
 
1515
inline void SetParamVal<ParamType::TGLeglImageOES>(GLeglImageOES valueIn, ParamValue *valueOut)
 
1516
{
 
1517
    valueOut->GLeglImageOESVal = valueIn;
 
1518
}
 
1519
 
 
1520
template <>
 
1521
inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
 
1522
{
 
1523
    valueOut->GLenumVal = valueIn;
 
1524
}
 
1525
 
 
1526
template <>
 
1527
inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
 
1528
{
 
1529
    valueOut->GLenumConstPointerVal = valueIn;
 
1530
}
 
1531
 
 
1532
template <>
 
1533
inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
 
1534
{
 
1535
    valueOut->GLenumPointerVal = valueIn;
 
1536
}
 
1537
 
 
1538
template <>
 
1539
inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
 
1540
{
 
1541
    valueOut->GLfixedVal = valueIn;
 
1542
}
 
1543
 
 
1544
template <>
 
1545
inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
 
1546
                                                         ParamValue *valueOut)
 
1547
{
 
1548
    valueOut->GLfixedConstPointerVal = valueIn;
 
1549
}
 
1550
 
 
1551
template <>
 
1552
inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
 
1553
{
 
1554
    valueOut->GLfixedPointerVal = valueIn;
 
1555
}
 
1556
 
 
1557
template <>
 
1558
inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
 
1559
{
 
1560
    valueOut->GLfloatVal = valueIn;
 
1561
}
 
1562
 
 
1563
template <>
 
1564
inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
 
1565
                                                         ParamValue *valueOut)
 
1566
{
 
1567
    valueOut->GLfloatConstPointerVal = valueIn;
 
1568
}
 
1569
 
 
1570
template <>
 
1571
inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
 
1572
{
 
1573
    valueOut->GLfloatPointerVal = valueIn;
 
1574
}
 
1575
 
 
1576
template <>
 
1577
inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
 
1578
{
 
1579
    valueOut->GLintVal = valueIn;
 
1580
}
 
1581
 
 
1582
template <>
 
1583
inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
 
1584
{
 
1585
    valueOut->GLint64PointerVal = valueIn;
 
1586
}
 
1587
 
 
1588
template <>
 
1589
inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
 
1590
{
 
1591
    valueOut->GLintConstPointerVal = valueIn;
 
1592
}
 
1593
 
 
1594
template <>
 
1595
inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
 
1596
{
 
1597
    valueOut->GLintPointerVal = valueIn;
 
1598
}
 
1599
 
 
1600
template <>
 
1601
inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
 
1602
{
 
1603
    valueOut->GLintptrVal = valueIn;
 
1604
}
 
1605
 
 
1606
template <>
 
1607
inline void SetParamVal<ParamType::TGLintptrConstPointer>(const GLintptr *valueIn,
 
1608
                                                          ParamValue *valueOut)
 
1609
{
 
1610
    valueOut->GLintptrConstPointerVal = valueIn;
 
1611
}
 
1612
 
 
1613
template <>
 
1614
inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
 
1615
{
 
1616
    valueOut->GLshortVal = valueIn;
 
1617
}
 
1618
 
 
1619
template <>
 
1620
inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
 
1621
                                                         ParamValue *valueOut)
 
1622
{
 
1623
    valueOut->GLshortConstPointerVal = valueIn;
 
1624
}
 
1625
 
 
1626
template <>
 
1627
inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
 
1628
{
 
1629
    valueOut->GLsizeiVal = valueIn;
 
1630
}
 
1631
 
 
1632
template <>
 
1633
inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
 
1634
                                                         ParamValue *valueOut)
 
1635
{
 
1636
    valueOut->GLsizeiConstPointerVal = valueIn;
 
1637
}
 
1638
 
 
1639
template <>
 
1640
inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
 
1641
{
 
1642
    valueOut->GLsizeiPointerVal = valueIn;
 
1643
}
 
1644
 
 
1645
template <>
 
1646
inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
 
1647
{
 
1648
    valueOut->GLsizeiptrVal = valueIn;
 
1649
}
 
1650
 
 
1651
template <>
 
1652
inline void SetParamVal<ParamType::TGLsizeiptrConstPointer>(const GLsizeiptr *valueIn,
 
1653
                                                            ParamValue *valueOut)
 
1654
{
 
1655
    valueOut->GLsizeiptrConstPointerVal = valueIn;
 
1656
}
 
1657
 
 
1658
template <>
 
1659
inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
 
1660
{
 
1661
    valueOut->GLsyncVal = valueIn;
 
1662
}
 
1663
 
 
1664
template <>
 
1665
inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
 
1666
{
 
1667
    valueOut->GLubyteVal = valueIn;
 
1668
}
 
1669
 
 
1670
template <>
 
1671
inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
 
1672
                                                         ParamValue *valueOut)
 
1673
{
 
1674
    valueOut->GLubyteConstPointerVal = valueIn;
 
1675
}
 
1676
 
 
1677
template <>
 
1678
inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
 
1679
{
 
1680
    valueOut->GLubytePointerVal = valueIn;
 
1681
}
 
1682
 
 
1683
template <>
 
1684
inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
 
1685
{
 
1686
    valueOut->GLuintVal = valueIn;
 
1687
}
 
1688
 
 
1689
template <>
 
1690
inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
 
1691
{
 
1692
    valueOut->GLuint64Val = valueIn;
 
1693
}
 
1694
 
 
1695
template <>
 
1696
inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
 
1697
                                                          ParamValue *valueOut)
 
1698
{
 
1699
    valueOut->GLuint64ConstPointerVal = valueIn;
 
1700
}
 
1701
 
 
1702
template <>
 
1703
inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
 
1704
{
 
1705
    valueOut->GLuint64PointerVal = valueIn;
 
1706
}
 
1707
 
 
1708
template <>
 
1709
inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
 
1710
{
 
1711
    valueOut->GLuintConstPointerVal = valueIn;
 
1712
}
 
1713
 
 
1714
template <>
 
1715
inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
 
1716
{
 
1717
    valueOut->GLuintPointerVal = valueIn;
 
1718
}
 
1719
 
 
1720
template <>
 
1721
inline void SetParamVal<ParamType::TGLushort>(GLushort valueIn, ParamValue *valueOut)
 
1722
{
 
1723
    valueOut->GLushortVal = valueIn;
 
1724
}
 
1725
 
 
1726
template <>
 
1727
inline void SetParamVal<ParamType::TGLushortConstPointer>(const GLushort *valueIn,
 
1728
                                                          ParamValue *valueOut)
 
1729
{
 
1730
    valueOut->GLushortConstPointerVal = valueIn;
 
1731
}
 
1732
 
 
1733
template <>
 
1734
inline void SetParamVal<ParamType::TGLushortPointer>(GLushort *valueIn, ParamValue *valueOut)
 
1735
{
 
1736
    valueOut->GLushortPointerVal = valueIn;
 
1737
}
 
1738
 
 
1739
template <>
 
1740
inline void SetParamVal<ParamType::TGLvoidConstPointer>(const GLvoid *valueIn, ParamValue *valueOut)
 
1741
{
 
1742
    valueOut->GLvoidConstPointerVal = valueIn;
 
1743
}
 
1744
 
 
1745
template <>
 
1746
inline void SetParamVal<ParamType::TGLvoidConstPointerPointer>(const GLvoid *const *valueIn,
 
1747
                                                               ParamValue *valueOut)
 
1748
{
 
1749
    valueOut->GLvoidConstPointerPointerVal = valueIn;
 
1750
}
 
1751
 
 
1752
template <>
 
1753
inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
 
1754
                                                         ParamValue *valueOut)
 
1755
{
 
1756
    valueOut->GraphicsResetStatusVal = valueIn;
 
1757
}
 
1758
 
 
1759
template <>
 
1760
inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
 
1761
{
 
1762
    valueOut->HandleTypeVal = valueIn;
 
1763
}
 
1764
 
 
1765
template <>
 
1766
inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
 
1767
                                                    ParamValue *valueOut)
 
1768
{
 
1769
    valueOut->LightParameterVal = valueIn;
 
1770
}
 
1771
 
 
1772
template <>
 
1773
inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
 
1774
                                                      ParamValue *valueOut)
 
1775
{
 
1776
    valueOut->LogicalOperationVal = valueIn;
 
1777
}
 
1778
 
 
1779
template <>
 
1780
inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
 
1781
                                                       ParamValue *valueOut)
 
1782
{
 
1783
    valueOut->MaterialParameterVal = valueIn;
 
1784
}
 
1785
 
 
1786
template <>
 
1787
inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
 
1788
{
 
1789
    valueOut->MatrixTypeVal = valueIn;
 
1790
}
 
1791
 
 
1792
template <>
 
1793
inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
 
1794
                                                    ParamValue *valueOut)
 
1795
{
 
1796
    valueOut->MemoryObjectIDVal = valueIn;
 
1797
}
 
1798
 
 
1799
template <>
 
1800
inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
 
1801
                                                                ParamValue *valueOut)
 
1802
{
 
1803
    valueOut->MemoryObjectIDConstPointerVal = valueIn;
 
1804
}
 
1805
 
 
1806
template <>
 
1807
inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
 
1808
                                                           ParamValue *valueOut)
 
1809
{
 
1810
    valueOut->MemoryObjectIDPointerVal = valueIn;
 
1811
}
 
1812
 
 
1813
template <>
 
1814
inline void SetParamVal<ParamType::TPathID>(gl::PathID valueIn, ParamValue *valueOut)
 
1815
{
 
1816
    valueOut->PathIDVal = valueIn;
 
1817
}
 
1818
 
 
1819
template <>
 
1820
inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
 
1821
                                                    ParamValue *valueOut)
 
1822
{
 
1823
    valueOut->PointParameterVal = valueIn;
 
1824
}
 
1825
 
 
1826
template <>
 
1827
inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
 
1828
{
 
1829
    valueOut->PrimitiveModeVal = valueIn;
 
1830
}
 
1831
 
 
1832
template <>
 
1833
inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
 
1834
                                                       ParamValue *valueOut)
 
1835
{
 
1836
    valueOut->ProgramPipelineIDVal = valueIn;
 
1837
}
 
1838
 
 
1839
template <>
 
1840
inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
 
1841
    const gl::ProgramPipelineID *valueIn,
 
1842
    ParamValue *valueOut)
 
1843
{
 
1844
    valueOut->ProgramPipelineIDConstPointerVal = valueIn;
 
1845
}
 
1846
 
 
1847
template <>
 
1848
inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
 
1849
                                                              ParamValue *valueOut)
 
1850
{
 
1851
    valueOut->ProgramPipelineIDPointerVal = valueIn;
 
1852
}
 
1853
 
 
1854
template <>
 
1855
inline void SetParamVal<ParamType::TProvokingVertexConvention>(
 
1856
    gl::ProvokingVertexConvention valueIn,
 
1857
    ParamValue *valueOut)
 
1858
{
 
1859
    valueOut->ProvokingVertexConventionVal = valueIn;
 
1860
}
 
1861
 
 
1862
template <>
 
1863
inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
 
1864
{
 
1865
    valueOut->QueryIDVal = valueIn;
 
1866
}
 
1867
 
 
1868
template <>
 
1869
inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
 
1870
                                                         ParamValue *valueOut)
 
1871
{
 
1872
    valueOut->QueryIDConstPointerVal = valueIn;
 
1873
}
 
1874
 
 
1875
template <>
 
1876
inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
 
1877
{
 
1878
    valueOut->QueryIDPointerVal = valueIn;
 
1879
}
 
1880
 
 
1881
template <>
 
1882
inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
 
1883
{
 
1884
    valueOut->QueryTypeVal = valueIn;
 
1885
}
 
1886
 
 
1887
template <>
 
1888
inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
 
1889
                                                    ParamValue *valueOut)
 
1890
{
 
1891
    valueOut->RenderbufferIDVal = valueIn;
 
1892
}
 
1893
 
 
1894
template <>
 
1895
inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
 
1896
                                                                ParamValue *valueOut)
 
1897
{
 
1898
    valueOut->RenderbufferIDConstPointerVal = valueIn;
 
1899
}
 
1900
 
 
1901
template <>
 
1902
inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
 
1903
                                                           ParamValue *valueOut)
 
1904
{
 
1905
    valueOut->RenderbufferIDPointerVal = valueIn;
 
1906
}
 
1907
 
 
1908
template <>
 
1909
inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
 
1910
{
 
1911
    valueOut->SamplerIDVal = valueIn;
 
1912
}
 
1913
 
 
1914
template <>
 
1915
inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
 
1916
                                                           ParamValue *valueOut)
 
1917
{
 
1918
    valueOut->SamplerIDConstPointerVal = valueIn;
 
1919
}
 
1920
 
 
1921
template <>
 
1922
inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
 
1923
{
 
1924
    valueOut->SamplerIDPointerVal = valueIn;
 
1925
}
 
1926
 
 
1927
template <>
 
1928
inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
 
1929
{
 
1930
    valueOut->SemaphoreIDVal = valueIn;
 
1931
}
 
1932
 
 
1933
template <>
 
1934
inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
 
1935
                                                             ParamValue *valueOut)
 
1936
{
 
1937
    valueOut->SemaphoreIDConstPointerVal = valueIn;
 
1938
}
 
1939
 
 
1940
template <>
 
1941
inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
 
1942
                                                        ParamValue *valueOut)
 
1943
{
 
1944
    valueOut->SemaphoreIDPointerVal = valueIn;
 
1945
}
 
1946
 
 
1947
template <>
 
1948
inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
 
1949
                                                     ParamValue *valueOut)
 
1950
{
 
1951
    valueOut->ShaderProgramIDVal = valueIn;
 
1952
}
 
1953
 
 
1954
template <>
 
1955
inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
 
1956
                                                                 ParamValue *valueOut)
 
1957
{
 
1958
    valueOut->ShaderProgramIDConstPointerVal = valueIn;
 
1959
}
 
1960
 
 
1961
template <>
 
1962
inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
 
1963
                                                            ParamValue *valueOut)
 
1964
{
 
1965
    valueOut->ShaderProgramIDPointerVal = valueIn;
 
1966
}
 
1967
 
 
1968
template <>
 
1969
inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
 
1970
{
 
1971
    valueOut->ShaderTypeVal = valueIn;
 
1972
}
 
1973
 
 
1974
template <>
 
1975
inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
 
1976
{
 
1977
    valueOut->ShadingModelVal = valueIn;
 
1978
}
 
1979
 
 
1980
template <>
 
1981
inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
 
1982
                                                         ParamValue *valueOut)
 
1983
{
 
1984
    valueOut->TextureEnvParameterVal = valueIn;
 
1985
}
 
1986
 
 
1987
template <>
 
1988
inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
 
1989
                                                      ParamValue *valueOut)
 
1990
{
 
1991
    valueOut->TextureEnvTargetVal = valueIn;
 
1992
}
 
1993
 
 
1994
template <>
 
1995
inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
 
1996
{
 
1997
    valueOut->TextureIDVal = valueIn;
 
1998
}
 
1999
 
 
2000
template <>
 
2001
inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
 
2002
                                                           ParamValue *valueOut)
 
2003
{
 
2004
    valueOut->TextureIDConstPointerVal = valueIn;
 
2005
}
 
2006
 
 
2007
template <>
 
2008
inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
 
2009
{
 
2010
    valueOut->TextureIDPointerVal = valueIn;
 
2011
}
 
2012
 
 
2013
template <>
 
2014
inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
 
2015
{
 
2016
    valueOut->TextureTargetVal = valueIn;
 
2017
}
 
2018
 
 
2019
template <>
 
2020
inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
 
2021
{
 
2022
    valueOut->TextureTypeVal = valueIn;
 
2023
}
 
2024
 
 
2025
template <>
 
2026
inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
 
2027
                                                         ParamValue *valueOut)
 
2028
{
 
2029
    valueOut->TransformFeedbackIDVal = valueIn;
 
2030
}
 
2031
 
 
2032
template <>
 
2033
inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
 
2034
    const gl::TransformFeedbackID *valueIn,
 
2035
    ParamValue *valueOut)
 
2036
{
 
2037
    valueOut->TransformFeedbackIDConstPointerVal = valueIn;
 
2038
}
 
2039
 
 
2040
template <>
 
2041
inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
 
2042
                                                                ParamValue *valueOut)
 
2043
{
 
2044
    valueOut->TransformFeedbackIDPointerVal = valueIn;
 
2045
}
 
2046
 
 
2047
template <>
 
2048
inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
 
2049
{
 
2050
    valueOut->VertexArrayIDVal = valueIn;
 
2051
}
 
2052
 
 
2053
template <>
 
2054
inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
 
2055
                                                               ParamValue *valueOut)
 
2056
{
 
2057
    valueOut->VertexArrayIDConstPointerVal = valueIn;
 
2058
}
 
2059
 
 
2060
template <>
 
2061
inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
 
2062
                                                          ParamValue *valueOut)
 
2063
{
 
2064
    valueOut->VertexArrayIDPointerVal = valueIn;
 
2065
}
 
2066
 
 
2067
template <>
 
2068
inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
 
2069
                                                      ParamValue *valueOut)
 
2070
{
 
2071
    valueOut->VertexAttribTypeVal = valueIn;
 
2072
}
 
2073
 
 
2074
template <>
 
2075
inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
 
2076
{
 
2077
    valueOut->voidConstPointerVal = valueIn;
 
2078
}
 
2079
 
 
2080
template <>
 
2081
inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void *const *valueIn,
 
2082
                                                             ParamValue *valueOut)
 
2083
{
 
2084
    valueOut->voidConstPointerPointerVal = valueIn;
 
2085
}
 
2086
 
 
2087
template <>
 
2088
inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
 
2089
{
 
2090
    valueOut->voidPointerVal = valueIn;
 
2091
}
 
2092
 
 
2093
template <>
 
2094
inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
 
2095
{
 
2096
    valueOut->voidPointerPointerVal = valueIn;
 
2097
}
 
2098
 
 
2099
template <ParamType PType, typename T>
 
2100
void SetParamVal(T valueIn, ParamValue *valueOut)
 
2101
{
 
2102
    UNREACHABLE();
 
2103
}
 
2104
 
 
2105
template <typename T>
 
2106
void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
 
2107
{
 
2108
    switch (paramType)
 
2109
    {
 
2110
        case ParamType::TAlphaTestFunc:
 
2111
            SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
 
2112
            break;
 
2113
        case ParamType::TBufferBinding:
 
2114
            SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
 
2115
            break;
 
2116
        case ParamType::TBufferID:
 
2117
            SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
 
2118
            break;
 
2119
        case ParamType::TBufferIDConstPointer:
 
2120
            SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
 
2121
            break;
 
2122
        case ParamType::TBufferIDPointer:
 
2123
            SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
 
2124
            break;
 
2125
        case ParamType::TBufferUsage:
 
2126
            SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
 
2127
            break;
 
2128
        case ParamType::TClientVertexArrayType:
 
2129
            SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
 
2130
            break;
 
2131
        case ParamType::TCullFaceMode:
 
2132
            SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
 
2133
            break;
 
2134
        case ParamType::TDrawElementsType:
 
2135
            SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
 
2136
            break;
 
2137
        case ParamType::TFenceNVID:
 
2138
            SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
 
2139
            break;
 
2140
        case ParamType::TFenceNVIDConstPointer:
 
2141
            SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
 
2142
            break;
 
2143
        case ParamType::TFenceNVIDPointer:
 
2144
            SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
 
2145
            break;
 
2146
        case ParamType::TFramebufferID:
 
2147
            SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
 
2148
            break;
 
2149
        case ParamType::TFramebufferIDConstPointer:
 
2150
            SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
 
2151
            break;
 
2152
        case ParamType::TFramebufferIDPointer:
 
2153
            SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
 
2154
            break;
 
2155
        case ParamType::TGLDEBUGPROC:
 
2156
            SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
 
2157
            break;
 
2158
        case ParamType::TGLDEBUGPROCKHR:
 
2159
            SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
 
2160
            break;
 
2161
        case ParamType::TGLbitfield:
 
2162
            SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
 
2163
            break;
 
2164
        case ParamType::TGLboolean:
 
2165
            SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
 
2166
            break;
 
2167
        case ParamType::TGLbooleanConstPointer:
 
2168
            SetParamVal<ParamType::TGLbooleanConstPointer>(valueIn, valueOut);
 
2169
            break;
 
2170
        case ParamType::TGLbooleanPointer:
 
2171
            SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
 
2172
            break;
 
2173
        case ParamType::TGLbyte:
 
2174
            SetParamVal<ParamType::TGLbyte>(valueIn, valueOut);
 
2175
            break;
 
2176
        case ParamType::TGLbyteConstPointer:
 
2177
            SetParamVal<ParamType::TGLbyteConstPointer>(valueIn, valueOut);
 
2178
            break;
 
2179
        case ParamType::TGLcharConstPointer:
 
2180
            SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
 
2181
            break;
 
2182
        case ParamType::TGLcharConstPointerPointer:
 
2183
            SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
 
2184
            break;
 
2185
        case ParamType::TGLcharPointer:
 
2186
            SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
 
2187
            break;
 
2188
        case ParamType::TGLclampx:
 
2189
            SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
 
2190
            break;
 
2191
        case ParamType::TGLdouble:
 
2192
            SetParamVal<ParamType::TGLdouble>(valueIn, valueOut);
 
2193
            break;
 
2194
        case ParamType::TGLdoubleConstPointer:
 
2195
            SetParamVal<ParamType::TGLdoubleConstPointer>(valueIn, valueOut);
 
2196
            break;
 
2197
        case ParamType::TGLdoublePointer:
 
2198
            SetParamVal<ParamType::TGLdoublePointer>(valueIn, valueOut);
 
2199
            break;
 
2200
        case ParamType::TGLeglImageOES:
 
2201
            SetParamVal<ParamType::TGLeglImageOES>(valueIn, valueOut);
 
2202
            break;
 
2203
        case ParamType::TGLenum:
 
2204
            SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
 
2205
            break;
 
2206
        case ParamType::TGLenumConstPointer:
 
2207
            SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
 
2208
            break;
 
2209
        case ParamType::TGLenumPointer:
 
2210
            SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
 
2211
            break;
 
2212
        case ParamType::TGLfixed:
 
2213
            SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
 
2214
            break;
 
2215
        case ParamType::TGLfixedConstPointer:
 
2216
            SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
 
2217
            break;
 
2218
        case ParamType::TGLfixedPointer:
 
2219
            SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
 
2220
            break;
 
2221
        case ParamType::TGLfloat:
 
2222
            SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
 
2223
            break;
 
2224
        case ParamType::TGLfloatConstPointer:
 
2225
            SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
 
2226
            break;
 
2227
        case ParamType::TGLfloatPointer:
 
2228
            SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
 
2229
            break;
 
2230
        case ParamType::TGLint:
 
2231
            SetParamVal<ParamType::TGLint>(valueIn, valueOut);
 
2232
            break;
 
2233
        case ParamType::TGLint64Pointer:
 
2234
            SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
 
2235
            break;
 
2236
        case ParamType::TGLintConstPointer:
 
2237
            SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
 
2238
            break;
 
2239
        case ParamType::TGLintPointer:
 
2240
            SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
 
2241
            break;
 
2242
        case ParamType::TGLintptr:
 
2243
            SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
 
2244
            break;
 
2245
        case ParamType::TGLintptrConstPointer:
 
2246
            SetParamVal<ParamType::TGLintptrConstPointer>(valueIn, valueOut);
 
2247
            break;
 
2248
        case ParamType::TGLshort:
 
2249
            SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
 
2250
            break;
 
2251
        case ParamType::TGLshortConstPointer:
 
2252
            SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
 
2253
            break;
 
2254
        case ParamType::TGLsizei:
 
2255
            SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
 
2256
            break;
 
2257
        case ParamType::TGLsizeiConstPointer:
 
2258
            SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
 
2259
            break;
 
2260
        case ParamType::TGLsizeiPointer:
 
2261
            SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
 
2262
            break;
 
2263
        case ParamType::TGLsizeiptr:
 
2264
            SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
 
2265
            break;
 
2266
        case ParamType::TGLsizeiptrConstPointer:
 
2267
            SetParamVal<ParamType::TGLsizeiptrConstPointer>(valueIn, valueOut);
 
2268
            break;
 
2269
        case ParamType::TGLsync:
 
2270
            SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
 
2271
            break;
 
2272
        case ParamType::TGLubyte:
 
2273
            SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
 
2274
            break;
 
2275
        case ParamType::TGLubyteConstPointer:
 
2276
            SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
 
2277
            break;
 
2278
        case ParamType::TGLubytePointer:
 
2279
            SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
 
2280
            break;
 
2281
        case ParamType::TGLuint:
 
2282
            SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
 
2283
            break;
 
2284
        case ParamType::TGLuint64:
 
2285
            SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
 
2286
            break;
 
2287
        case ParamType::TGLuint64ConstPointer:
 
2288
            SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
 
2289
            break;
 
2290
        case ParamType::TGLuint64Pointer:
 
2291
            SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
 
2292
            break;
 
2293
        case ParamType::TGLuintConstPointer:
 
2294
            SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
 
2295
            break;
 
2296
        case ParamType::TGLuintPointer:
 
2297
            SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
 
2298
            break;
 
2299
        case ParamType::TGLushort:
 
2300
            SetParamVal<ParamType::TGLushort>(valueIn, valueOut);
 
2301
            break;
 
2302
        case ParamType::TGLushortConstPointer:
 
2303
            SetParamVal<ParamType::TGLushortConstPointer>(valueIn, valueOut);
 
2304
            break;
 
2305
        case ParamType::TGLushortPointer:
 
2306
            SetParamVal<ParamType::TGLushortPointer>(valueIn, valueOut);
 
2307
            break;
 
2308
        case ParamType::TGLvoidConstPointer:
 
2309
            SetParamVal<ParamType::TGLvoidConstPointer>(valueIn, valueOut);
 
2310
            break;
 
2311
        case ParamType::TGLvoidConstPointerPointer:
 
2312
            SetParamVal<ParamType::TGLvoidConstPointerPointer>(valueIn, valueOut);
 
2313
            break;
 
2314
        case ParamType::TGraphicsResetStatus:
 
2315
            SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
 
2316
            break;
 
2317
        case ParamType::THandleType:
 
2318
            SetParamVal<ParamType::THandleType>(valueIn, valueOut);
 
2319
            break;
 
2320
        case ParamType::TLightParameter:
 
2321
            SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
 
2322
            break;
 
2323
        case ParamType::TLogicalOperation:
 
2324
            SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
 
2325
            break;
 
2326
        case ParamType::TMaterialParameter:
 
2327
            SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
 
2328
            break;
 
2329
        case ParamType::TMatrixType:
 
2330
            SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
 
2331
            break;
 
2332
        case ParamType::TMemoryObjectID:
 
2333
            SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
 
2334
            break;
 
2335
        case ParamType::TMemoryObjectIDConstPointer:
 
2336
            SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
 
2337
            break;
 
2338
        case ParamType::TMemoryObjectIDPointer:
 
2339
            SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
 
2340
            break;
 
2341
        case ParamType::TPathID:
 
2342
            SetParamVal<ParamType::TPathID>(valueIn, valueOut);
 
2343
            break;
 
2344
        case ParamType::TPointParameter:
 
2345
            SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
 
2346
            break;
 
2347
        case ParamType::TPrimitiveMode:
 
2348
            SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
 
2349
            break;
 
2350
        case ParamType::TProgramPipelineID:
 
2351
            SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
 
2352
            break;
 
2353
        case ParamType::TProgramPipelineIDConstPointer:
 
2354
            SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
 
2355
            break;
 
2356
        case ParamType::TProgramPipelineIDPointer:
 
2357
            SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
 
2358
            break;
 
2359
        case ParamType::TProvokingVertexConvention:
 
2360
            SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
 
2361
            break;
 
2362
        case ParamType::TQueryID:
 
2363
            SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
 
2364
            break;
 
2365
        case ParamType::TQueryIDConstPointer:
 
2366
            SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
 
2367
            break;
 
2368
        case ParamType::TQueryIDPointer:
 
2369
            SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
 
2370
            break;
 
2371
        case ParamType::TQueryType:
 
2372
            SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
 
2373
            break;
 
2374
        case ParamType::TRenderbufferID:
 
2375
            SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
 
2376
            break;
 
2377
        case ParamType::TRenderbufferIDConstPointer:
 
2378
            SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
 
2379
            break;
 
2380
        case ParamType::TRenderbufferIDPointer:
 
2381
            SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
 
2382
            break;
 
2383
        case ParamType::TSamplerID:
 
2384
            SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
 
2385
            break;
 
2386
        case ParamType::TSamplerIDConstPointer:
 
2387
            SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
 
2388
            break;
 
2389
        case ParamType::TSamplerIDPointer:
 
2390
            SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
 
2391
            break;
 
2392
        case ParamType::TSemaphoreID:
 
2393
            SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
 
2394
            break;
 
2395
        case ParamType::TSemaphoreIDConstPointer:
 
2396
            SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
 
2397
            break;
 
2398
        case ParamType::TSemaphoreIDPointer:
 
2399
            SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
 
2400
            break;
 
2401
        case ParamType::TShaderProgramID:
 
2402
            SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
 
2403
            break;
 
2404
        case ParamType::TShaderProgramIDConstPointer:
 
2405
            SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
 
2406
            break;
 
2407
        case ParamType::TShaderProgramIDPointer:
 
2408
            SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
 
2409
            break;
 
2410
        case ParamType::TShaderType:
 
2411
            SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
 
2412
            break;
 
2413
        case ParamType::TShadingModel:
 
2414
            SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
 
2415
            break;
 
2416
        case ParamType::TTextureEnvParameter:
 
2417
            SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
 
2418
            break;
 
2419
        case ParamType::TTextureEnvTarget:
 
2420
            SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
 
2421
            break;
 
2422
        case ParamType::TTextureID:
 
2423
            SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
 
2424
            break;
 
2425
        case ParamType::TTextureIDConstPointer:
 
2426
            SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
 
2427
            break;
 
2428
        case ParamType::TTextureIDPointer:
 
2429
            SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
 
2430
            break;
 
2431
        case ParamType::TTextureTarget:
 
2432
            SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
 
2433
            break;
 
2434
        case ParamType::TTextureType:
 
2435
            SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
 
2436
            break;
 
2437
        case ParamType::TTransformFeedbackID:
 
2438
            SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
 
2439
            break;
 
2440
        case ParamType::TTransformFeedbackIDConstPointer:
 
2441
            SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
 
2442
            break;
 
2443
        case ParamType::TTransformFeedbackIDPointer:
 
2444
            SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
 
2445
            break;
 
2446
        case ParamType::TVertexArrayID:
 
2447
            SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
 
2448
            break;
 
2449
        case ParamType::TVertexArrayIDConstPointer:
 
2450
            SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
 
2451
            break;
 
2452
        case ParamType::TVertexArrayIDPointer:
 
2453
            SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
 
2454
            break;
 
2455
        case ParamType::TVertexAttribType:
 
2456
            SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
 
2457
            break;
 
2458
        case ParamType::TvoidConstPointer:
 
2459
            SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
 
2460
            break;
 
2461
        case ParamType::TvoidConstPointerPointer:
 
2462
            SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
 
2463
            break;
 
2464
        case ParamType::TvoidPointer:
 
2465
            SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
 
2466
            break;
 
2467
        case ParamType::TvoidPointerPointer:
 
2468
            SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
 
2469
            break;
 
2470
    }
 
2471
}
 
2472
 
 
2473
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue &paramValue);
 
2474
const char *ParamTypeToString(ParamType paramType);
 
2475
 
 
2476
enum class ResourceIDType
 
2477
{
 
2478
    Buffer,
 
2479
    FenceNV,
 
2480
    Framebuffer,
 
2481
    MemoryObject,
 
2482
    Path,
 
2483
    ProgramPipeline,
 
2484
    Query,
 
2485
    Renderbuffer,
 
2486
    Sampler,
 
2487
    Semaphore,
 
2488
    ShaderProgram,
 
2489
    Texture,
 
2490
    TransformFeedback,
 
2491
    VertexArray,
 
2492
    EnumCount,
 
2493
    InvalidEnum = EnumCount
 
2494
};
 
2495
 
 
2496
ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
 
2497
const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
 
2498
}  // namespace angle
 
2499
 
 
2500
#endif  // LIBANGLE_FRAME_CAPTURE_UTILS_AUTOGEN_H_