← 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.cpp

  • 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.cpp
 
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.cpp:
 
9
//   ANGLE Frame capture types and helper functions.
 
10
 
 
11
#include "libANGLE/frame_capture_utils_autogen.h"
 
12
 
 
13
#include "libANGLE/FrameCapture.h"
 
14
 
 
15
namespace angle
 
16
{
 
17
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue &paramValue)
 
18
{
 
19
    switch (paramType)
 
20
    {
 
21
        case ParamType::TAlphaTestFunc:
 
22
            WriteParamValueToStream<ParamType::TAlphaTestFunc>(os, paramValue.AlphaTestFuncVal);
 
23
            break;
 
24
        case ParamType::TBufferBinding:
 
25
            WriteParamValueToStream<ParamType::TBufferBinding>(os, paramValue.BufferBindingVal);
 
26
            break;
 
27
        case ParamType::TBufferID:
 
28
            WriteParamValueToStream<ParamType::TBufferID>(os, paramValue.BufferIDVal);
 
29
            break;
 
30
        case ParamType::TBufferIDConstPointer:
 
31
            WriteParamValueToStream<ParamType::TBufferIDConstPointer>(
 
32
                os, paramValue.BufferIDConstPointerVal);
 
33
            break;
 
34
        case ParamType::TBufferIDPointer:
 
35
            WriteParamValueToStream<ParamType::TBufferIDPointer>(os, paramValue.BufferIDPointerVal);
 
36
            break;
 
37
        case ParamType::TBufferUsage:
 
38
            WriteParamValueToStream<ParamType::TBufferUsage>(os, paramValue.BufferUsageVal);
 
39
            break;
 
40
        case ParamType::TClientVertexArrayType:
 
41
            WriteParamValueToStream<ParamType::TClientVertexArrayType>(
 
42
                os, paramValue.ClientVertexArrayTypeVal);
 
43
            break;
 
44
        case ParamType::TCullFaceMode:
 
45
            WriteParamValueToStream<ParamType::TCullFaceMode>(os, paramValue.CullFaceModeVal);
 
46
            break;
 
47
        case ParamType::TDrawElementsType:
 
48
            WriteParamValueToStream<ParamType::TDrawElementsType>(os,
 
49
                                                                  paramValue.DrawElementsTypeVal);
 
50
            break;
 
51
        case ParamType::TFenceNVID:
 
52
            WriteParamValueToStream<ParamType::TFenceNVID>(os, paramValue.FenceNVIDVal);
 
53
            break;
 
54
        case ParamType::TFenceNVIDConstPointer:
 
55
            WriteParamValueToStream<ParamType::TFenceNVIDConstPointer>(
 
56
                os, paramValue.FenceNVIDConstPointerVal);
 
57
            break;
 
58
        case ParamType::TFenceNVIDPointer:
 
59
            WriteParamValueToStream<ParamType::TFenceNVIDPointer>(os,
 
60
                                                                  paramValue.FenceNVIDPointerVal);
 
61
            break;
 
62
        case ParamType::TFramebufferID:
 
63
            WriteParamValueToStream<ParamType::TFramebufferID>(os, paramValue.FramebufferIDVal);
 
64
            break;
 
65
        case ParamType::TFramebufferIDConstPointer:
 
66
            WriteParamValueToStream<ParamType::TFramebufferIDConstPointer>(
 
67
                os, paramValue.FramebufferIDConstPointerVal);
 
68
            break;
 
69
        case ParamType::TFramebufferIDPointer:
 
70
            WriteParamValueToStream<ParamType::TFramebufferIDPointer>(
 
71
                os, paramValue.FramebufferIDPointerVal);
 
72
            break;
 
73
        case ParamType::TGLDEBUGPROC:
 
74
            WriteParamValueToStream<ParamType::TGLDEBUGPROC>(os, paramValue.GLDEBUGPROCVal);
 
75
            break;
 
76
        case ParamType::TGLDEBUGPROCKHR:
 
77
            WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(os, paramValue.GLDEBUGPROCKHRVal);
 
78
            break;
 
79
        case ParamType::TGLbitfield:
 
80
            WriteParamValueToStream<ParamType::TGLbitfield>(os, paramValue.GLbitfieldVal);
 
81
            break;
 
82
        case ParamType::TGLboolean:
 
83
            WriteParamValueToStream<ParamType::TGLboolean>(os, paramValue.GLbooleanVal);
 
84
            break;
 
85
        case ParamType::TGLbooleanConstPointer:
 
86
            WriteParamValueToStream<ParamType::TGLbooleanConstPointer>(
 
87
                os, paramValue.GLbooleanConstPointerVal);
 
88
            break;
 
89
        case ParamType::TGLbooleanPointer:
 
90
            WriteParamValueToStream<ParamType::TGLbooleanPointer>(os,
 
91
                                                                  paramValue.GLbooleanPointerVal);
 
92
            break;
 
93
        case ParamType::TGLbyte:
 
94
            WriteParamValueToStream<ParamType::TGLbyte>(os, paramValue.GLbyteVal);
 
95
            break;
 
96
        case ParamType::TGLbyteConstPointer:
 
97
            WriteParamValueToStream<ParamType::TGLbyteConstPointer>(
 
98
                os, paramValue.GLbyteConstPointerVal);
 
99
            break;
 
100
        case ParamType::TGLcharConstPointer:
 
101
            WriteParamValueToStream<ParamType::TGLcharConstPointer>(
 
102
                os, paramValue.GLcharConstPointerVal);
 
103
            break;
 
104
        case ParamType::TGLcharConstPointerPointer:
 
105
            WriteParamValueToStream<ParamType::TGLcharConstPointerPointer>(
 
106
                os, paramValue.GLcharConstPointerPointerVal);
 
107
            break;
 
108
        case ParamType::TGLcharPointer:
 
109
            WriteParamValueToStream<ParamType::TGLcharPointer>(os, paramValue.GLcharPointerVal);
 
110
            break;
 
111
        case ParamType::TGLclampx:
 
112
            WriteParamValueToStream<ParamType::TGLclampx>(os, paramValue.GLclampxVal);
 
113
            break;
 
114
        case ParamType::TGLdouble:
 
115
            WriteParamValueToStream<ParamType::TGLdouble>(os, paramValue.GLdoubleVal);
 
116
            break;
 
117
        case ParamType::TGLdoubleConstPointer:
 
118
            WriteParamValueToStream<ParamType::TGLdoubleConstPointer>(
 
119
                os, paramValue.GLdoubleConstPointerVal);
 
120
            break;
 
121
        case ParamType::TGLdoublePointer:
 
122
            WriteParamValueToStream<ParamType::TGLdoublePointer>(os, paramValue.GLdoublePointerVal);
 
123
            break;
 
124
        case ParamType::TGLeglImageOES:
 
125
            WriteParamValueToStream<ParamType::TGLeglImageOES>(os, paramValue.GLeglImageOESVal);
 
126
            break;
 
127
        case ParamType::TGLenum:
 
128
            WriteParamValueToStream<ParamType::TGLenum>(os, paramValue.GLenumVal);
 
129
            break;
 
130
        case ParamType::TGLenumConstPointer:
 
131
            WriteParamValueToStream<ParamType::TGLenumConstPointer>(
 
132
                os, paramValue.GLenumConstPointerVal);
 
133
            break;
 
134
        case ParamType::TGLenumPointer:
 
135
            WriteParamValueToStream<ParamType::TGLenumPointer>(os, paramValue.GLenumPointerVal);
 
136
            break;
 
137
        case ParamType::TGLfixed:
 
138
            WriteParamValueToStream<ParamType::TGLfixed>(os, paramValue.GLfixedVal);
 
139
            break;
 
140
        case ParamType::TGLfixedConstPointer:
 
141
            WriteParamValueToStream<ParamType::TGLfixedConstPointer>(
 
142
                os, paramValue.GLfixedConstPointerVal);
 
143
            break;
 
144
        case ParamType::TGLfixedPointer:
 
145
            WriteParamValueToStream<ParamType::TGLfixedPointer>(os, paramValue.GLfixedPointerVal);
 
146
            break;
 
147
        case ParamType::TGLfloat:
 
148
            WriteParamValueToStream<ParamType::TGLfloat>(os, paramValue.GLfloatVal);
 
149
            break;
 
150
        case ParamType::TGLfloatConstPointer:
 
151
            WriteParamValueToStream<ParamType::TGLfloatConstPointer>(
 
152
                os, paramValue.GLfloatConstPointerVal);
 
153
            break;
 
154
        case ParamType::TGLfloatPointer:
 
155
            WriteParamValueToStream<ParamType::TGLfloatPointer>(os, paramValue.GLfloatPointerVal);
 
156
            break;
 
157
        case ParamType::TGLint:
 
158
            WriteParamValueToStream<ParamType::TGLint>(os, paramValue.GLintVal);
 
159
            break;
 
160
        case ParamType::TGLint64Pointer:
 
161
            WriteParamValueToStream<ParamType::TGLint64Pointer>(os, paramValue.GLint64PointerVal);
 
162
            break;
 
163
        case ParamType::TGLintConstPointer:
 
164
            WriteParamValueToStream<ParamType::TGLintConstPointer>(os,
 
165
                                                                   paramValue.GLintConstPointerVal);
 
166
            break;
 
167
        case ParamType::TGLintPointer:
 
168
            WriteParamValueToStream<ParamType::TGLintPointer>(os, paramValue.GLintPointerVal);
 
169
            break;
 
170
        case ParamType::TGLintptr:
 
171
            WriteParamValueToStream<ParamType::TGLintptr>(os, paramValue.GLintptrVal);
 
172
            break;
 
173
        case ParamType::TGLintptrConstPointer:
 
174
            WriteParamValueToStream<ParamType::TGLintptrConstPointer>(
 
175
                os, paramValue.GLintptrConstPointerVal);
 
176
            break;
 
177
        case ParamType::TGLshort:
 
178
            WriteParamValueToStream<ParamType::TGLshort>(os, paramValue.GLshortVal);
 
179
            break;
 
180
        case ParamType::TGLshortConstPointer:
 
181
            WriteParamValueToStream<ParamType::TGLshortConstPointer>(
 
182
                os, paramValue.GLshortConstPointerVal);
 
183
            break;
 
184
        case ParamType::TGLsizei:
 
185
            WriteParamValueToStream<ParamType::TGLsizei>(os, paramValue.GLsizeiVal);
 
186
            break;
 
187
        case ParamType::TGLsizeiConstPointer:
 
188
            WriteParamValueToStream<ParamType::TGLsizeiConstPointer>(
 
189
                os, paramValue.GLsizeiConstPointerVal);
 
190
            break;
 
191
        case ParamType::TGLsizeiPointer:
 
192
            WriteParamValueToStream<ParamType::TGLsizeiPointer>(os, paramValue.GLsizeiPointerVal);
 
193
            break;
 
194
        case ParamType::TGLsizeiptr:
 
195
            WriteParamValueToStream<ParamType::TGLsizeiptr>(os, paramValue.GLsizeiptrVal);
 
196
            break;
 
197
        case ParamType::TGLsizeiptrConstPointer:
 
198
            WriteParamValueToStream<ParamType::TGLsizeiptrConstPointer>(
 
199
                os, paramValue.GLsizeiptrConstPointerVal);
 
200
            break;
 
201
        case ParamType::TGLsync:
 
202
            WriteParamValueToStream<ParamType::TGLsync>(os, paramValue.GLsyncVal);
 
203
            break;
 
204
        case ParamType::TGLubyte:
 
205
            WriteParamValueToStream<ParamType::TGLubyte>(os, paramValue.GLubyteVal);
 
206
            break;
 
207
        case ParamType::TGLubyteConstPointer:
 
208
            WriteParamValueToStream<ParamType::TGLubyteConstPointer>(
 
209
                os, paramValue.GLubyteConstPointerVal);
 
210
            break;
 
211
        case ParamType::TGLubytePointer:
 
212
            WriteParamValueToStream<ParamType::TGLubytePointer>(os, paramValue.GLubytePointerVal);
 
213
            break;
 
214
        case ParamType::TGLuint:
 
215
            WriteParamValueToStream<ParamType::TGLuint>(os, paramValue.GLuintVal);
 
216
            break;
 
217
        case ParamType::TGLuint64:
 
218
            WriteParamValueToStream<ParamType::TGLuint64>(os, paramValue.GLuint64Val);
 
219
            break;
 
220
        case ParamType::TGLuint64ConstPointer:
 
221
            WriteParamValueToStream<ParamType::TGLuint64ConstPointer>(
 
222
                os, paramValue.GLuint64ConstPointerVal);
 
223
            break;
 
224
        case ParamType::TGLuint64Pointer:
 
225
            WriteParamValueToStream<ParamType::TGLuint64Pointer>(os, paramValue.GLuint64PointerVal);
 
226
            break;
 
227
        case ParamType::TGLuintConstPointer:
 
228
            WriteParamValueToStream<ParamType::TGLuintConstPointer>(
 
229
                os, paramValue.GLuintConstPointerVal);
 
230
            break;
 
231
        case ParamType::TGLuintPointer:
 
232
            WriteParamValueToStream<ParamType::TGLuintPointer>(os, paramValue.GLuintPointerVal);
 
233
            break;
 
234
        case ParamType::TGLushort:
 
235
            WriteParamValueToStream<ParamType::TGLushort>(os, paramValue.GLushortVal);
 
236
            break;
 
237
        case ParamType::TGLushortConstPointer:
 
238
            WriteParamValueToStream<ParamType::TGLushortConstPointer>(
 
239
                os, paramValue.GLushortConstPointerVal);
 
240
            break;
 
241
        case ParamType::TGLushortPointer:
 
242
            WriteParamValueToStream<ParamType::TGLushortPointer>(os, paramValue.GLushortPointerVal);
 
243
            break;
 
244
        case ParamType::TGLvoidConstPointer:
 
245
            WriteParamValueToStream<ParamType::TGLvoidConstPointer>(
 
246
                os, paramValue.GLvoidConstPointerVal);
 
247
            break;
 
248
        case ParamType::TGLvoidConstPointerPointer:
 
249
            WriteParamValueToStream<ParamType::TGLvoidConstPointerPointer>(
 
250
                os, paramValue.GLvoidConstPointerPointerVal);
 
251
            break;
 
252
        case ParamType::TGraphicsResetStatus:
 
253
            WriteParamValueToStream<ParamType::TGraphicsResetStatus>(
 
254
                os, paramValue.GraphicsResetStatusVal);
 
255
            break;
 
256
        case ParamType::THandleType:
 
257
            WriteParamValueToStream<ParamType::THandleType>(os, paramValue.HandleTypeVal);
 
258
            break;
 
259
        case ParamType::TLightParameter:
 
260
            WriteParamValueToStream<ParamType::TLightParameter>(os, paramValue.LightParameterVal);
 
261
            break;
 
262
        case ParamType::TLogicalOperation:
 
263
            WriteParamValueToStream<ParamType::TLogicalOperation>(os,
 
264
                                                                  paramValue.LogicalOperationVal);
 
265
            break;
 
266
        case ParamType::TMaterialParameter:
 
267
            WriteParamValueToStream<ParamType::TMaterialParameter>(os,
 
268
                                                                   paramValue.MaterialParameterVal);
 
269
            break;
 
270
        case ParamType::TMatrixType:
 
271
            WriteParamValueToStream<ParamType::TMatrixType>(os, paramValue.MatrixTypeVal);
 
272
            break;
 
273
        case ParamType::TMemoryObjectID:
 
274
            WriteParamValueToStream<ParamType::TMemoryObjectID>(os, paramValue.MemoryObjectIDVal);
 
275
            break;
 
276
        case ParamType::TMemoryObjectIDConstPointer:
 
277
            WriteParamValueToStream<ParamType::TMemoryObjectIDConstPointer>(
 
278
                os, paramValue.MemoryObjectIDConstPointerVal);
 
279
            break;
 
280
        case ParamType::TMemoryObjectIDPointer:
 
281
            WriteParamValueToStream<ParamType::TMemoryObjectIDPointer>(
 
282
                os, paramValue.MemoryObjectIDPointerVal);
 
283
            break;
 
284
        case ParamType::TPathID:
 
285
            WriteParamValueToStream<ParamType::TPathID>(os, paramValue.PathIDVal);
 
286
            break;
 
287
        case ParamType::TPointParameter:
 
288
            WriteParamValueToStream<ParamType::TPointParameter>(os, paramValue.PointParameterVal);
 
289
            break;
 
290
        case ParamType::TPrimitiveMode:
 
291
            WriteParamValueToStream<ParamType::TPrimitiveMode>(os, paramValue.PrimitiveModeVal);
 
292
            break;
 
293
        case ParamType::TProgramPipelineID:
 
294
            WriteParamValueToStream<ParamType::TProgramPipelineID>(os,
 
295
                                                                   paramValue.ProgramPipelineIDVal);
 
296
            break;
 
297
        case ParamType::TProgramPipelineIDConstPointer:
 
298
            WriteParamValueToStream<ParamType::TProgramPipelineIDConstPointer>(
 
299
                os, paramValue.ProgramPipelineIDConstPointerVal);
 
300
            break;
 
301
        case ParamType::TProgramPipelineIDPointer:
 
302
            WriteParamValueToStream<ParamType::TProgramPipelineIDPointer>(
 
303
                os, paramValue.ProgramPipelineIDPointerVal);
 
304
            break;
 
305
        case ParamType::TProvokingVertexConvention:
 
306
            WriteParamValueToStream<ParamType::TProvokingVertexConvention>(
 
307
                os, paramValue.ProvokingVertexConventionVal);
 
308
            break;
 
309
        case ParamType::TQueryID:
 
310
            WriteParamValueToStream<ParamType::TQueryID>(os, paramValue.QueryIDVal);
 
311
            break;
 
312
        case ParamType::TQueryIDConstPointer:
 
313
            WriteParamValueToStream<ParamType::TQueryIDConstPointer>(
 
314
                os, paramValue.QueryIDConstPointerVal);
 
315
            break;
 
316
        case ParamType::TQueryIDPointer:
 
317
            WriteParamValueToStream<ParamType::TQueryIDPointer>(os, paramValue.QueryIDPointerVal);
 
318
            break;
 
319
        case ParamType::TQueryType:
 
320
            WriteParamValueToStream<ParamType::TQueryType>(os, paramValue.QueryTypeVal);
 
321
            break;
 
322
        case ParamType::TRenderbufferID:
 
323
            WriteParamValueToStream<ParamType::TRenderbufferID>(os, paramValue.RenderbufferIDVal);
 
324
            break;
 
325
        case ParamType::TRenderbufferIDConstPointer:
 
326
            WriteParamValueToStream<ParamType::TRenderbufferIDConstPointer>(
 
327
                os, paramValue.RenderbufferIDConstPointerVal);
 
328
            break;
 
329
        case ParamType::TRenderbufferIDPointer:
 
330
            WriteParamValueToStream<ParamType::TRenderbufferIDPointer>(
 
331
                os, paramValue.RenderbufferIDPointerVal);
 
332
            break;
 
333
        case ParamType::TSamplerID:
 
334
            WriteParamValueToStream<ParamType::TSamplerID>(os, paramValue.SamplerIDVal);
 
335
            break;
 
336
        case ParamType::TSamplerIDConstPointer:
 
337
            WriteParamValueToStream<ParamType::TSamplerIDConstPointer>(
 
338
                os, paramValue.SamplerIDConstPointerVal);
 
339
            break;
 
340
        case ParamType::TSamplerIDPointer:
 
341
            WriteParamValueToStream<ParamType::TSamplerIDPointer>(os,
 
342
                                                                  paramValue.SamplerIDPointerVal);
 
343
            break;
 
344
        case ParamType::TSemaphoreID:
 
345
            WriteParamValueToStream<ParamType::TSemaphoreID>(os, paramValue.SemaphoreIDVal);
 
346
            break;
 
347
        case ParamType::TSemaphoreIDConstPointer:
 
348
            WriteParamValueToStream<ParamType::TSemaphoreIDConstPointer>(
 
349
                os, paramValue.SemaphoreIDConstPointerVal);
 
350
            break;
 
351
        case ParamType::TSemaphoreIDPointer:
 
352
            WriteParamValueToStream<ParamType::TSemaphoreIDPointer>(
 
353
                os, paramValue.SemaphoreIDPointerVal);
 
354
            break;
 
355
        case ParamType::TShaderProgramID:
 
356
            WriteParamValueToStream<ParamType::TShaderProgramID>(os, paramValue.ShaderProgramIDVal);
 
357
            break;
 
358
        case ParamType::TShaderProgramIDConstPointer:
 
359
            WriteParamValueToStream<ParamType::TShaderProgramIDConstPointer>(
 
360
                os, paramValue.ShaderProgramIDConstPointerVal);
 
361
            break;
 
362
        case ParamType::TShaderProgramIDPointer:
 
363
            WriteParamValueToStream<ParamType::TShaderProgramIDPointer>(
 
364
                os, paramValue.ShaderProgramIDPointerVal);
 
365
            break;
 
366
        case ParamType::TShaderType:
 
367
            WriteParamValueToStream<ParamType::TShaderType>(os, paramValue.ShaderTypeVal);
 
368
            break;
 
369
        case ParamType::TShadingModel:
 
370
            WriteParamValueToStream<ParamType::TShadingModel>(os, paramValue.ShadingModelVal);
 
371
            break;
 
372
        case ParamType::TTextureEnvParameter:
 
373
            WriteParamValueToStream<ParamType::TTextureEnvParameter>(
 
374
                os, paramValue.TextureEnvParameterVal);
 
375
            break;
 
376
        case ParamType::TTextureEnvTarget:
 
377
            WriteParamValueToStream<ParamType::TTextureEnvTarget>(os,
 
378
                                                                  paramValue.TextureEnvTargetVal);
 
379
            break;
 
380
        case ParamType::TTextureID:
 
381
            WriteParamValueToStream<ParamType::TTextureID>(os, paramValue.TextureIDVal);
 
382
            break;
 
383
        case ParamType::TTextureIDConstPointer:
 
384
            WriteParamValueToStream<ParamType::TTextureIDConstPointer>(
 
385
                os, paramValue.TextureIDConstPointerVal);
 
386
            break;
 
387
        case ParamType::TTextureIDPointer:
 
388
            WriteParamValueToStream<ParamType::TTextureIDPointer>(os,
 
389
                                                                  paramValue.TextureIDPointerVal);
 
390
            break;
 
391
        case ParamType::TTextureTarget:
 
392
            WriteParamValueToStream<ParamType::TTextureTarget>(os, paramValue.TextureTargetVal);
 
393
            break;
 
394
        case ParamType::TTextureType:
 
395
            WriteParamValueToStream<ParamType::TTextureType>(os, paramValue.TextureTypeVal);
 
396
            break;
 
397
        case ParamType::TTransformFeedbackID:
 
398
            WriteParamValueToStream<ParamType::TTransformFeedbackID>(
 
399
                os, paramValue.TransformFeedbackIDVal);
 
400
            break;
 
401
        case ParamType::TTransformFeedbackIDConstPointer:
 
402
            WriteParamValueToStream<ParamType::TTransformFeedbackIDConstPointer>(
 
403
                os, paramValue.TransformFeedbackIDConstPointerVal);
 
404
            break;
 
405
        case ParamType::TTransformFeedbackIDPointer:
 
406
            WriteParamValueToStream<ParamType::TTransformFeedbackIDPointer>(
 
407
                os, paramValue.TransformFeedbackIDPointerVal);
 
408
            break;
 
409
        case ParamType::TVertexArrayID:
 
410
            WriteParamValueToStream<ParamType::TVertexArrayID>(os, paramValue.VertexArrayIDVal);
 
411
            break;
 
412
        case ParamType::TVertexArrayIDConstPointer:
 
413
            WriteParamValueToStream<ParamType::TVertexArrayIDConstPointer>(
 
414
                os, paramValue.VertexArrayIDConstPointerVal);
 
415
            break;
 
416
        case ParamType::TVertexArrayIDPointer:
 
417
            WriteParamValueToStream<ParamType::TVertexArrayIDPointer>(
 
418
                os, paramValue.VertexArrayIDPointerVal);
 
419
            break;
 
420
        case ParamType::TVertexAttribType:
 
421
            WriteParamValueToStream<ParamType::TVertexAttribType>(os,
 
422
                                                                  paramValue.VertexAttribTypeVal);
 
423
            break;
 
424
        case ParamType::TvoidConstPointer:
 
425
            WriteParamValueToStream<ParamType::TvoidConstPointer>(os,
 
426
                                                                  paramValue.voidConstPointerVal);
 
427
            break;
 
428
        case ParamType::TvoidConstPointerPointer:
 
429
            WriteParamValueToStream<ParamType::TvoidConstPointerPointer>(
 
430
                os, paramValue.voidConstPointerPointerVal);
 
431
            break;
 
432
        case ParamType::TvoidPointer:
 
433
            WriteParamValueToStream<ParamType::TvoidPointer>(os, paramValue.voidPointerVal);
 
434
            break;
 
435
        case ParamType::TvoidPointerPointer:
 
436
            WriteParamValueToStream<ParamType::TvoidPointerPointer>(
 
437
                os, paramValue.voidPointerPointerVal);
 
438
            break;
 
439
        default:
 
440
            os << "unknown";
 
441
            break;
 
442
    }
 
443
}
 
444
 
 
445
const char *ParamTypeToString(ParamType paramType)
 
446
{
 
447
    switch (paramType)
 
448
    {
 
449
        case ParamType::TAlphaTestFunc:
 
450
            return "GLenum";
 
451
        case ParamType::TBufferBinding:
 
452
            return "GLenum";
 
453
        case ParamType::TBufferID:
 
454
            return "GLuint";
 
455
        case ParamType::TBufferIDConstPointer:
 
456
            return "const GLuint *";
 
457
        case ParamType::TBufferIDPointer:
 
458
            return "GLuint *";
 
459
        case ParamType::TBufferUsage:
 
460
            return "GLenum";
 
461
        case ParamType::TClientVertexArrayType:
 
462
            return "GLenum";
 
463
        case ParamType::TCullFaceMode:
 
464
            return "GLenum";
 
465
        case ParamType::TDrawElementsType:
 
466
            return "GLenum";
 
467
        case ParamType::TFenceNVID:
 
468
            return "GLuint";
 
469
        case ParamType::TFenceNVIDConstPointer:
 
470
            return "const GLuint *";
 
471
        case ParamType::TFenceNVIDPointer:
 
472
            return "GLuint *";
 
473
        case ParamType::TFramebufferID:
 
474
            return "GLuint";
 
475
        case ParamType::TFramebufferIDConstPointer:
 
476
            return "const GLuint *";
 
477
        case ParamType::TFramebufferIDPointer:
 
478
            return "GLuint *";
 
479
        case ParamType::TGLDEBUGPROC:
 
480
            return "GLDEBUGPROC";
 
481
        case ParamType::TGLDEBUGPROCKHR:
 
482
            return "GLDEBUGPROCKHR";
 
483
        case ParamType::TGLbitfield:
 
484
            return "GLbitfield";
 
485
        case ParamType::TGLboolean:
 
486
            return "GLboolean";
 
487
        case ParamType::TGLbooleanConstPointer:
 
488
            return "const GLboolean *";
 
489
        case ParamType::TGLbooleanPointer:
 
490
            return "GLboolean *";
 
491
        case ParamType::TGLbyte:
 
492
            return "GLbyte";
 
493
        case ParamType::TGLbyteConstPointer:
 
494
            return "const GLbyte *";
 
495
        case ParamType::TGLcharConstPointer:
 
496
            return "const GLchar *";
 
497
        case ParamType::TGLcharConstPointerPointer:
 
498
            return "const GLchar * const *";
 
499
        case ParamType::TGLcharPointer:
 
500
            return "GLchar *";
 
501
        case ParamType::TGLclampx:
 
502
            return "GLclampx";
 
503
        case ParamType::TGLdouble:
 
504
            return "GLdouble";
 
505
        case ParamType::TGLdoubleConstPointer:
 
506
            return "const GLdouble *";
 
507
        case ParamType::TGLdoublePointer:
 
508
            return "GLdouble *";
 
509
        case ParamType::TGLeglImageOES:
 
510
            return "GLeglImageOES";
 
511
        case ParamType::TGLenum:
 
512
            return "GLenum";
 
513
        case ParamType::TGLenumConstPointer:
 
514
            return "const GLenum *";
 
515
        case ParamType::TGLenumPointer:
 
516
            return "GLenum *";
 
517
        case ParamType::TGLfixed:
 
518
            return "GLfixed";
 
519
        case ParamType::TGLfixedConstPointer:
 
520
            return "const GLfixed *";
 
521
        case ParamType::TGLfixedPointer:
 
522
            return "GLfixed *";
 
523
        case ParamType::TGLfloat:
 
524
            return "GLfloat";
 
525
        case ParamType::TGLfloatConstPointer:
 
526
            return "const GLfloat *";
 
527
        case ParamType::TGLfloatPointer:
 
528
            return "GLfloat *";
 
529
        case ParamType::TGLint:
 
530
            return "GLint";
 
531
        case ParamType::TGLint64Pointer:
 
532
            return "GLint64 *";
 
533
        case ParamType::TGLintConstPointer:
 
534
            return "const GLint *";
 
535
        case ParamType::TGLintPointer:
 
536
            return "GLint *";
 
537
        case ParamType::TGLintptr:
 
538
            return "GLintptr";
 
539
        case ParamType::TGLintptrConstPointer:
 
540
            return "const GLintptr *";
 
541
        case ParamType::TGLshort:
 
542
            return "GLshort";
 
543
        case ParamType::TGLshortConstPointer:
 
544
            return "const GLshort *";
 
545
        case ParamType::TGLsizei:
 
546
            return "GLsizei";
 
547
        case ParamType::TGLsizeiConstPointer:
 
548
            return "const GLsizei *";
 
549
        case ParamType::TGLsizeiPointer:
 
550
            return "GLsizei *";
 
551
        case ParamType::TGLsizeiptr:
 
552
            return "GLsizeiptr";
 
553
        case ParamType::TGLsizeiptrConstPointer:
 
554
            return "const GLsizeiptr *";
 
555
        case ParamType::TGLsync:
 
556
            return "GLsync";
 
557
        case ParamType::TGLubyte:
 
558
            return "GLubyte";
 
559
        case ParamType::TGLubyteConstPointer:
 
560
            return "const GLubyte *";
 
561
        case ParamType::TGLubytePointer:
 
562
            return "GLubyte *";
 
563
        case ParamType::TGLuint:
 
564
            return "GLuint";
 
565
        case ParamType::TGLuint64:
 
566
            return "GLuint64";
 
567
        case ParamType::TGLuint64ConstPointer:
 
568
            return "const GLuint64 *";
 
569
        case ParamType::TGLuint64Pointer:
 
570
            return "GLuint64 *";
 
571
        case ParamType::TGLuintConstPointer:
 
572
            return "const GLuint *";
 
573
        case ParamType::TGLuintPointer:
 
574
            return "GLuint *";
 
575
        case ParamType::TGLushort:
 
576
            return "GLushort";
 
577
        case ParamType::TGLushortConstPointer:
 
578
            return "const GLushort *";
 
579
        case ParamType::TGLushortPointer:
 
580
            return "GLushort *";
 
581
        case ParamType::TGLvoidConstPointer:
 
582
            return "const GLvoid *";
 
583
        case ParamType::TGLvoidConstPointerPointer:
 
584
            return "const GLvoid * const *";
 
585
        case ParamType::TGraphicsResetStatus:
 
586
            return "GLenum";
 
587
        case ParamType::THandleType:
 
588
            return "GLenum";
 
589
        case ParamType::TLightParameter:
 
590
            return "GLenum";
 
591
        case ParamType::TLogicalOperation:
 
592
            return "GLenum";
 
593
        case ParamType::TMaterialParameter:
 
594
            return "GLenum";
 
595
        case ParamType::TMatrixType:
 
596
            return "GLenum";
 
597
        case ParamType::TMemoryObjectID:
 
598
            return "GLuint";
 
599
        case ParamType::TMemoryObjectIDConstPointer:
 
600
            return "const GLuint *";
 
601
        case ParamType::TMemoryObjectIDPointer:
 
602
            return "GLuint *";
 
603
        case ParamType::TPathID:
 
604
            return "GLuint";
 
605
        case ParamType::TPointParameter:
 
606
            return "GLenum";
 
607
        case ParamType::TPrimitiveMode:
 
608
            return "GLenum";
 
609
        case ParamType::TProgramPipelineID:
 
610
            return "GLuint";
 
611
        case ParamType::TProgramPipelineIDConstPointer:
 
612
            return "const GLuint *";
 
613
        case ParamType::TProgramPipelineIDPointer:
 
614
            return "GLuint *";
 
615
        case ParamType::TProvokingVertexConvention:
 
616
            return "GLenum";
 
617
        case ParamType::TQueryID:
 
618
            return "GLuint";
 
619
        case ParamType::TQueryIDConstPointer:
 
620
            return "const GLuint *";
 
621
        case ParamType::TQueryIDPointer:
 
622
            return "GLuint *";
 
623
        case ParamType::TQueryType:
 
624
            return "GLenum";
 
625
        case ParamType::TRenderbufferID:
 
626
            return "GLuint";
 
627
        case ParamType::TRenderbufferIDConstPointer:
 
628
            return "const GLuint *";
 
629
        case ParamType::TRenderbufferIDPointer:
 
630
            return "GLuint *";
 
631
        case ParamType::TSamplerID:
 
632
            return "GLuint";
 
633
        case ParamType::TSamplerIDConstPointer:
 
634
            return "const GLuint *";
 
635
        case ParamType::TSamplerIDPointer:
 
636
            return "GLuint *";
 
637
        case ParamType::TSemaphoreID:
 
638
            return "GLuint";
 
639
        case ParamType::TSemaphoreIDConstPointer:
 
640
            return "const GLuint *";
 
641
        case ParamType::TSemaphoreIDPointer:
 
642
            return "GLuint *";
 
643
        case ParamType::TShaderProgramID:
 
644
            return "GLuint";
 
645
        case ParamType::TShaderProgramIDConstPointer:
 
646
            return "const GLuint *";
 
647
        case ParamType::TShaderProgramIDPointer:
 
648
            return "GLuint *";
 
649
        case ParamType::TShaderType:
 
650
            return "GLenum";
 
651
        case ParamType::TShadingModel:
 
652
            return "GLenum";
 
653
        case ParamType::TTextureEnvParameter:
 
654
            return "GLenum";
 
655
        case ParamType::TTextureEnvTarget:
 
656
            return "GLenum";
 
657
        case ParamType::TTextureID:
 
658
            return "GLuint";
 
659
        case ParamType::TTextureIDConstPointer:
 
660
            return "const GLuint *";
 
661
        case ParamType::TTextureIDPointer:
 
662
            return "GLuint *";
 
663
        case ParamType::TTextureTarget:
 
664
            return "GLenum";
 
665
        case ParamType::TTextureType:
 
666
            return "GLenum";
 
667
        case ParamType::TTransformFeedbackID:
 
668
            return "GLuint";
 
669
        case ParamType::TTransformFeedbackIDConstPointer:
 
670
            return "const GLuint *";
 
671
        case ParamType::TTransformFeedbackIDPointer:
 
672
            return "GLuint *";
 
673
        case ParamType::TVertexArrayID:
 
674
            return "GLuint";
 
675
        case ParamType::TVertexArrayIDConstPointer:
 
676
            return "const GLuint *";
 
677
        case ParamType::TVertexArrayIDPointer:
 
678
            return "GLuint *";
 
679
        case ParamType::TVertexAttribType:
 
680
            return "GLenum";
 
681
        case ParamType::TvoidConstPointer:
 
682
            return "const void *";
 
683
        case ParamType::TvoidConstPointerPointer:
 
684
            return "const void * const *";
 
685
        case ParamType::TvoidPointer:
 
686
            return "void *";
 
687
        case ParamType::TvoidPointerPointer:
 
688
            return "void **";
 
689
        default:
 
690
            UNREACHABLE();
 
691
            return "unknown";
 
692
    }
 
693
}
 
694
 
 
695
ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType)
 
696
{
 
697
    switch (paramType)
 
698
    {
 
699
        case ParamType::TBufferID:
 
700
            return ResourceIDType::Buffer;
 
701
        case ParamType::TBufferIDConstPointer:
 
702
            return ResourceIDType::Buffer;
 
703
        case ParamType::TBufferIDPointer:
 
704
            return ResourceIDType::Buffer;
 
705
        case ParamType::TFenceNVID:
 
706
            return ResourceIDType::FenceNV;
 
707
        case ParamType::TFenceNVIDConstPointer:
 
708
            return ResourceIDType::FenceNV;
 
709
        case ParamType::TFenceNVIDPointer:
 
710
            return ResourceIDType::FenceNV;
 
711
        case ParamType::TFramebufferID:
 
712
            return ResourceIDType::Framebuffer;
 
713
        case ParamType::TFramebufferIDConstPointer:
 
714
            return ResourceIDType::Framebuffer;
 
715
        case ParamType::TFramebufferIDPointer:
 
716
            return ResourceIDType::Framebuffer;
 
717
        case ParamType::TMemoryObjectID:
 
718
            return ResourceIDType::MemoryObject;
 
719
        case ParamType::TMemoryObjectIDConstPointer:
 
720
            return ResourceIDType::MemoryObject;
 
721
        case ParamType::TMemoryObjectIDPointer:
 
722
            return ResourceIDType::MemoryObject;
 
723
        case ParamType::TPathID:
 
724
            return ResourceIDType::Path;
 
725
        case ParamType::TProgramPipelineID:
 
726
            return ResourceIDType::ProgramPipeline;
 
727
        case ParamType::TProgramPipelineIDConstPointer:
 
728
            return ResourceIDType::ProgramPipeline;
 
729
        case ParamType::TProgramPipelineIDPointer:
 
730
            return ResourceIDType::ProgramPipeline;
 
731
        case ParamType::TQueryID:
 
732
            return ResourceIDType::Query;
 
733
        case ParamType::TQueryIDConstPointer:
 
734
            return ResourceIDType::Query;
 
735
        case ParamType::TQueryIDPointer:
 
736
            return ResourceIDType::Query;
 
737
        case ParamType::TRenderbufferID:
 
738
            return ResourceIDType::Renderbuffer;
 
739
        case ParamType::TRenderbufferIDConstPointer:
 
740
            return ResourceIDType::Renderbuffer;
 
741
        case ParamType::TRenderbufferIDPointer:
 
742
            return ResourceIDType::Renderbuffer;
 
743
        case ParamType::TSamplerID:
 
744
            return ResourceIDType::Sampler;
 
745
        case ParamType::TSamplerIDConstPointer:
 
746
            return ResourceIDType::Sampler;
 
747
        case ParamType::TSamplerIDPointer:
 
748
            return ResourceIDType::Sampler;
 
749
        case ParamType::TSemaphoreID:
 
750
            return ResourceIDType::Semaphore;
 
751
        case ParamType::TSemaphoreIDConstPointer:
 
752
            return ResourceIDType::Semaphore;
 
753
        case ParamType::TSemaphoreIDPointer:
 
754
            return ResourceIDType::Semaphore;
 
755
        case ParamType::TShaderProgramID:
 
756
            return ResourceIDType::ShaderProgram;
 
757
        case ParamType::TShaderProgramIDConstPointer:
 
758
            return ResourceIDType::ShaderProgram;
 
759
        case ParamType::TShaderProgramIDPointer:
 
760
            return ResourceIDType::ShaderProgram;
 
761
        case ParamType::TTextureID:
 
762
            return ResourceIDType::Texture;
 
763
        case ParamType::TTextureIDConstPointer:
 
764
            return ResourceIDType::Texture;
 
765
        case ParamType::TTextureIDPointer:
 
766
            return ResourceIDType::Texture;
 
767
        case ParamType::TTransformFeedbackID:
 
768
            return ResourceIDType::TransformFeedback;
 
769
        case ParamType::TTransformFeedbackIDConstPointer:
 
770
            return ResourceIDType::TransformFeedback;
 
771
        case ParamType::TTransformFeedbackIDPointer:
 
772
            return ResourceIDType::TransformFeedback;
 
773
        case ParamType::TVertexArrayID:
 
774
            return ResourceIDType::VertexArray;
 
775
        case ParamType::TVertexArrayIDConstPointer:
 
776
            return ResourceIDType::VertexArray;
 
777
        case ParamType::TVertexArrayIDPointer:
 
778
            return ResourceIDType::VertexArray;
 
779
        default:
 
780
            return ResourceIDType::InvalidEnum;
 
781
    }
 
782
}
 
783
 
 
784
const char *GetResourceIDTypeName(ResourceIDType resourceIDType)
 
785
{
 
786
    switch (resourceIDType)
 
787
    {
 
788
        case ResourceIDType::Buffer:
 
789
            return "Buffer";
 
790
        case ResourceIDType::FenceNV:
 
791
            return "FenceNV";
 
792
        case ResourceIDType::Framebuffer:
 
793
            return "Framebuffer";
 
794
        case ResourceIDType::MemoryObject:
 
795
            return "MemoryObject";
 
796
        case ResourceIDType::Path:
 
797
            return "Path";
 
798
        case ResourceIDType::ProgramPipeline:
 
799
            return "ProgramPipeline";
 
800
        case ResourceIDType::Query:
 
801
            return "Query";
 
802
        case ResourceIDType::Renderbuffer:
 
803
            return "Renderbuffer";
 
804
        case ResourceIDType::Sampler:
 
805
            return "Sampler";
 
806
        case ResourceIDType::Semaphore:
 
807
            return "Semaphore";
 
808
        case ResourceIDType::ShaderProgram:
 
809
            return "ShaderProgram";
 
810
        case ResourceIDType::Texture:
 
811
            return "Texture";
 
812
        case ResourceIDType::TransformFeedback:
 
813
            return "TransformFeedback";
 
814
        case ResourceIDType::VertexArray:
 
815
            return "VertexArray";
 
816
        default:
 
817
            UNREACHABLE();
 
818
            return "GetResourceIDTypeName error";
 
819
    }
 
820
}
 
821
}  // namespace angle