← Back to branch summary

~mmach/netext73/webkit2gtk

« back to all changes in this revision

Viewing changes to Source/ThirdParty/ANGLE/src/libANGLE/capture_gles_3_0_params.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/capture_gles_3_0_params.cpp
 
1
//
 
2
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
 
3
// Use of this source code is governed by a BSD-style license that can be
 
4
// found in the LICENSE file.
 
5
//
 
6
// capture_gles3_params.cpp:
 
7
//   Pointer parameter capture functions for the OpenGL ES 3.0 entry points.
 
8
 
 
9
#include "libANGLE/capture_gles_2_0_autogen.h"
 
10
#include "libANGLE/capture_gles_3_0_autogen.h"
 
11
 
 
12
using namespace angle;
 
13
 
 
14
namespace gl
 
15
{
 
16
void CaptureClearBufferfv_value(const State &glState,
 
17
                                bool isCallValid,
 
18
                                GLenum buffer,
 
19
                                GLint drawbuffer,
 
20
                                const GLfloat *value,
 
21
                                ParamCapture *paramCapture)
 
22
{
 
23
    UNIMPLEMENTED();
 
24
}
 
25
 
 
26
void CaptureClearBufferiv_value(const State &glState,
 
27
                                bool isCallValid,
 
28
                                GLenum buffer,
 
29
                                GLint drawbuffer,
 
30
                                const GLint *value,
 
31
                                ParamCapture *paramCapture)
 
32
{
 
33
    UNIMPLEMENTED();
 
34
}
 
35
 
 
36
void CaptureClearBufferuiv_value(const State &glState,
 
37
                                 bool isCallValid,
 
38
                                 GLenum buffer,
 
39
                                 GLint drawbuffer,
 
40
                                 const GLuint *value,
 
41
                                 ParamCapture *paramCapture)
 
42
{
 
43
    UNIMPLEMENTED();
 
44
}
 
45
 
 
46
void CaptureCompressedTexImage3D_data(const State &glState,
 
47
                                      bool isCallValid,
 
48
                                      TextureTarget targetPacked,
 
49
                                      GLint level,
 
50
                                      GLenum internalformat,
 
51
                                      GLsizei width,
 
52
                                      GLsizei height,
 
53
                                      GLsizei depth,
 
54
                                      GLint border,
 
55
                                      GLsizei imageSize,
 
56
                                      const void *data,
 
57
                                      ParamCapture *paramCapture)
 
58
{
 
59
    if (glState.getTargetBuffer(gl::BufferBinding::PixelUnpack))
 
60
    {
 
61
        return;
 
62
    }
 
63
 
 
64
    if (!data)
 
65
    {
 
66
        return;
 
67
    }
 
68
 
 
69
    CaptureMemory(data, imageSize, paramCapture);
 
70
}
 
71
 
 
72
void CaptureCompressedTexSubImage3D_data(const State &glState,
 
73
                                         bool isCallValid,
 
74
                                         TextureTarget targetPacked,
 
75
                                         GLint level,
 
76
                                         GLint xoffset,
 
77
                                         GLint yoffset,
 
78
                                         GLint zoffset,
 
79
                                         GLsizei width,
 
80
                                         GLsizei height,
 
81
                                         GLsizei depth,
 
82
                                         GLenum format,
 
83
                                         GLsizei imageSize,
 
84
                                         const void *data,
 
85
                                         ParamCapture *paramCapture)
 
86
{
 
87
    CaptureCompressedTexImage3D_data(glState, isCallValid, targetPacked, level, 0, width, height,
 
88
                                     depth, 0, imageSize, data, paramCapture);
 
89
}
 
90
 
 
91
void CaptureDeleteQueries_idsPacked(const State &glState,
 
92
                                    bool isCallValid,
 
93
                                    GLsizei n,
 
94
                                    const QueryID *ids,
 
95
                                    ParamCapture *paramCapture)
 
96
{
 
97
    CaptureMemory(ids, sizeof(QueryID) * n, paramCapture);
 
98
}
 
99
 
 
100
void CaptureDeleteSamplers_samplersPacked(const State &glState,
 
101
                                          bool isCallValid,
 
102
                                          GLsizei count,
 
103
                                          const SamplerID *samplers,
 
104
                                          ParamCapture *paramCapture)
 
105
{
 
106
    CaptureMemory(samplers, sizeof(SamplerID) * count, paramCapture);
 
107
}
 
108
 
 
109
void CaptureDeleteTransformFeedbacks_idsPacked(const State &glState,
 
110
                                               bool isCallValid,
 
111
                                               GLsizei n,
 
112
                                               const TransformFeedbackID *ids,
 
113
                                               ParamCapture *paramCapture)
 
114
{
 
115
    CaptureMemory(ids, sizeof(TransformFeedbackID) * n, paramCapture);
 
116
}
 
117
 
 
118
void CaptureDeleteVertexArrays_arraysPacked(const State &glState,
 
119
                                            bool isCallValid,
 
120
                                            GLsizei n,
 
121
                                            const VertexArrayID *arrays,
 
122
                                            ParamCapture *paramCapture)
 
123
{
 
124
    CaptureMemory(arrays, sizeof(VertexArrayID) * n, paramCapture);
 
125
}
 
126
 
 
127
void CaptureDrawBuffers_bufs(const State &glState,
 
128
                             bool isCallValid,
 
129
                             GLsizei n,
 
130
                             const GLenum *bufs,
 
131
                             ParamCapture *paramCapture)
 
132
{
 
133
    CaptureMemory(bufs, sizeof(GLenum) * n, paramCapture);
 
134
}
 
135
 
 
136
void CaptureDrawElementsInstanced_indices(const State &glState,
 
137
                                          bool isCallValid,
 
138
                                          PrimitiveMode modePacked,
 
139
                                          GLsizei count,
 
140
                                          DrawElementsType typePacked,
 
141
                                          const void *indices,
 
142
                                          GLsizei instancecount,
 
143
                                          ParamCapture *paramCapture)
 
144
{
 
145
    CaptureDrawElements_indices(glState, isCallValid, modePacked, count, typePacked, indices,
 
146
                                paramCapture);
 
147
}
 
148
 
 
149
void CaptureDrawRangeElements_indices(const State &glState,
 
150
                                      bool isCallValid,
 
151
                                      PrimitiveMode modePacked,
 
152
                                      GLuint start,
 
153
                                      GLuint end,
 
154
                                      GLsizei count,
 
155
                                      DrawElementsType typePacked,
 
156
                                      const void *indices,
 
157
                                      ParamCapture *paramCapture)
 
158
{
 
159
    UNIMPLEMENTED();
 
160
}
 
161
 
 
162
void CaptureGenQueries_idsPacked(const State &glState,
 
163
                                 bool isCallValid,
 
164
                                 GLsizei n,
 
165
                                 QueryID *ids,
 
166
                                 ParamCapture *paramCapture)
 
167
{
 
168
    CaptureGenHandles(n, ids, paramCapture);
 
169
}
 
170
 
 
171
void CaptureGenSamplers_samplersPacked(const State &glState,
 
172
                                       bool isCallValid,
 
173
                                       GLsizei count,
 
174
                                       SamplerID *samplers,
 
175
                                       ParamCapture *paramCapture)
 
176
{
 
177
    CaptureGenHandles(count, samplers, paramCapture);
 
178
}
 
179
 
 
180
void CaptureGenTransformFeedbacks_idsPacked(const State &glState,
 
181
                                            bool isCallValid,
 
182
                                            GLsizei n,
 
183
                                            TransformFeedbackID *ids,
 
184
                                            ParamCapture *paramCapture)
 
185
{
 
186
    CaptureGenHandles(n, ids, paramCapture);
 
187
}
 
188
 
 
189
void CaptureGenVertexArrays_arraysPacked(const State &glState,
 
190
                                         bool isCallValid,
 
191
                                         GLsizei n,
 
192
                                         VertexArrayID *arrays,
 
193
                                         ParamCapture *paramCapture)
 
194
{
 
195
    CaptureGenHandles(n, arrays, paramCapture);
 
196
}
 
197
 
 
198
void CaptureGetActiveUniformBlockName_length(const State &glState,
 
199
                                             bool isCallValid,
 
200
                                             ShaderProgramID program,
 
201
                                             GLuint uniformBlockIndex,
 
202
                                             GLsizei bufSize,
 
203
                                             GLsizei *length,
 
204
                                             GLchar *uniformBlockName,
 
205
                                             ParamCapture *paramCapture)
 
206
{
 
207
    UNIMPLEMENTED();
 
208
}
 
209
 
 
210
void CaptureGetActiveUniformBlockName_uniformBlockName(const State &glState,
 
211
                                                       bool isCallValid,
 
212
                                                       ShaderProgramID program,
 
213
                                                       GLuint uniformBlockIndex,
 
214
                                                       GLsizei bufSize,
 
215
                                                       GLsizei *length,
 
216
                                                       GLchar *uniformBlockName,
 
217
                                                       ParamCapture *paramCapture)
 
218
{
 
219
    UNIMPLEMENTED();
 
220
}
 
221
 
 
222
void CaptureGetActiveUniformBlockiv_params(const State &glState,
 
223
                                           bool isCallValid,
 
224
                                           ShaderProgramID program,
 
225
                                           GLuint uniformBlockIndex,
 
226
                                           GLenum pname,
 
227
                                           GLint *params,
 
228
                                           ParamCapture *paramCapture)
 
229
{
 
230
    UNIMPLEMENTED();
 
231
}
 
232
 
 
233
void CaptureGetActiveUniformsiv_uniformIndices(const State &glState,
 
234
                                               bool isCallValid,
 
235
                                               ShaderProgramID program,
 
236
                                               GLsizei uniformCount,
 
237
                                               const GLuint *uniformIndices,
 
238
                                               GLenum pname,
 
239
                                               GLint *params,
 
240
                                               ParamCapture *paramCapture)
 
241
{
 
242
    UNIMPLEMENTED();
 
243
}
 
244
 
 
245
void CaptureGetActiveUniformsiv_params(const State &glState,
 
246
                                       bool isCallValid,
 
247
                                       ShaderProgramID program,
 
248
                                       GLsizei uniformCount,
 
249
                                       const GLuint *uniformIndices,
 
250
                                       GLenum pname,
 
251
                                       GLint *params,
 
252
                                       ParamCapture *paramCapture)
 
253
{
 
254
    UNIMPLEMENTED();
 
255
}
 
256
 
 
257
void CaptureGetBufferParameteri64v_params(const State &glState,
 
258
                                          bool isCallValid,
 
259
                                          BufferBinding targetPacked,
 
260
                                          GLenum pname,
 
261
                                          GLint64 *params,
 
262
                                          ParamCapture *paramCapture)
 
263
{
 
264
    UNIMPLEMENTED();
 
265
}
 
266
 
 
267
void CaptureGetBufferPointerv_params(const State &glState,
 
268
                                     bool isCallValid,
 
269
                                     BufferBinding targetPacked,
 
270
                                     GLenum pname,
 
271
                                     void **params,
 
272
                                     ParamCapture *paramCapture)
 
273
{
 
274
    UNIMPLEMENTED();
 
275
}
 
276
 
 
277
void CaptureGetFragDataLocation_name(const State &glState,
 
278
                                     bool isCallValid,
 
279
                                     ShaderProgramID program,
 
280
                                     const GLchar *name,
 
281
                                     ParamCapture *paramCapture)
 
282
{
 
283
    UNIMPLEMENTED();
 
284
}
 
285
 
 
286
void CaptureGetInteger64i_v_data(const State &glState,
 
287
                                 bool isCallValid,
 
288
                                 GLenum target,
 
289
                                 GLuint index,
 
290
                                 GLint64 *data,
 
291
                                 ParamCapture *paramCapture)
 
292
{
 
293
    UNIMPLEMENTED();
 
294
}
 
295
 
 
296
void CaptureGetInteger64v_data(const State &glState,
 
297
                               bool isCallValid,
 
298
                               GLenum pname,
 
299
                               GLint64 *data,
 
300
                               ParamCapture *paramCapture)
 
301
{
 
302
    UNIMPLEMENTED();
 
303
}
 
304
 
 
305
void CaptureGetIntegeri_v_data(const State &glState,
 
306
                               bool isCallValid,
 
307
                               GLenum target,
 
308
                               GLuint index,
 
309
                               GLint *data,
 
310
                               ParamCapture *paramCapture)
 
311
{
 
312
    UNIMPLEMENTED();
 
313
}
 
314
 
 
315
void CaptureGetInternalformativ_params(const State &glState,
 
316
                                       bool isCallValid,
 
317
                                       GLenum target,
 
318
                                       GLenum internalformat,
 
319
                                       GLenum pname,
 
320
                                       GLsizei bufSize,
 
321
                                       GLint *params,
 
322
                                       ParamCapture *paramCapture)
 
323
{
 
324
    UNIMPLEMENTED();
 
325
}
 
326
 
 
327
void CaptureGetProgramBinary_length(const State &glState,
 
328
                                    bool isCallValid,
 
329
                                    ShaderProgramID program,
 
330
                                    GLsizei bufSize,
 
331
                                    GLsizei *length,
 
332
                                    GLenum *binaryFormat,
 
333
                                    void *binary,
 
334
                                    ParamCapture *paramCapture)
 
335
{
 
336
    UNIMPLEMENTED();
 
337
}
 
338
 
 
339
void CaptureGetProgramBinary_binaryFormat(const State &glState,
 
340
                                          bool isCallValid,
 
341
                                          ShaderProgramID program,
 
342
                                          GLsizei bufSize,
 
343
                                          GLsizei *length,
 
344
                                          GLenum *binaryFormat,
 
345
                                          void *binary,
 
346
                                          ParamCapture *paramCapture)
 
347
{
 
348
    UNIMPLEMENTED();
 
349
}
 
350
 
 
351
void CaptureGetProgramBinary_binary(const State &glState,
 
352
                                    bool isCallValid,
 
353
                                    ShaderProgramID program,
 
354
                                    GLsizei bufSize,
 
355
                                    GLsizei *length,
 
356
                                    GLenum *binaryFormat,
 
357
                                    void *binary,
 
358
                                    ParamCapture *paramCapture)
 
359
{
 
360
    UNIMPLEMENTED();
 
361
}
 
362
 
 
363
void CaptureGetQueryObjectuiv_params(const State &glState,
 
364
                                     bool isCallValid,
 
365
                                     QueryID id,
 
366
                                     GLenum pname,
 
367
                                     GLuint *params,
 
368
                                     ParamCapture *paramCapture)
 
369
{
 
370
    // This only returns one value
 
371
    paramCapture->readBufferSizeBytes = sizeof(GLint);
 
372
}
 
373
 
 
374
void CaptureGetQueryiv_params(const State &glState,
 
375
                              bool isCallValid,
 
376
                              QueryType targetPacked,
 
377
                              GLenum pname,
 
378
                              GLint *params,
 
379
                              ParamCapture *paramCapture)
 
380
{
 
381
    UNIMPLEMENTED();
 
382
}
 
383
 
 
384
void CaptureGetSamplerParameterfv_params(const State &glState,
 
385
                                         bool isCallValid,
 
386
                                         SamplerID sampler,
 
387
                                         GLenum pname,
 
388
                                         GLfloat *params,
 
389
                                         ParamCapture *paramCapture)
 
390
{
 
391
    UNIMPLEMENTED();
 
392
}
 
393
 
 
394
void CaptureGetSamplerParameteriv_params(const State &glState,
 
395
                                         bool isCallValid,
 
396
                                         SamplerID sampler,
 
397
                                         GLenum pname,
 
398
                                         GLint *params,
 
399
                                         ParamCapture *paramCapture)
 
400
{
 
401
    UNIMPLEMENTED();
 
402
}
 
403
 
 
404
void CaptureGetSynciv_length(const State &glState,
 
405
                             bool isCallValid,
 
406
                             GLsync sync,
 
407
                             GLenum pname,
 
408
                             GLsizei bufSize,
 
409
                             GLsizei *length,
 
410
                             GLint *values,
 
411
                             ParamCapture *paramCapture)
 
412
{
 
413
    UNIMPLEMENTED();
 
414
}
 
415
 
 
416
void CaptureGetSynciv_values(const State &glState,
 
417
                             bool isCallValid,
 
418
                             GLsync sync,
 
419
                             GLenum pname,
 
420
                             GLsizei bufSize,
 
421
                             GLsizei *length,
 
422
                             GLint *values,
 
423
                             ParamCapture *paramCapture)
 
424
{
 
425
    UNIMPLEMENTED();
 
426
}
 
427
 
 
428
void CaptureGetTransformFeedbackVarying_length(const State &glState,
 
429
                                               bool isCallValid,
 
430
                                               ShaderProgramID program,
 
431
                                               GLuint index,
 
432
                                               GLsizei bufSize,
 
433
                                               GLsizei *length,
 
434
                                               GLsizei *size,
 
435
                                               GLenum *type,
 
436
                                               GLchar *name,
 
437
                                               ParamCapture *paramCapture)
 
438
{
 
439
    UNIMPLEMENTED();
 
440
}
 
441
 
 
442
void CaptureGetTransformFeedbackVarying_size(const State &glState,
 
443
                                             bool isCallValid,
 
444
                                             ShaderProgramID program,
 
445
                                             GLuint index,
 
446
                                             GLsizei bufSize,
 
447
                                             GLsizei *length,
 
448
                                             GLsizei *size,
 
449
                                             GLenum *type,
 
450
                                             GLchar *name,
 
451
                                             ParamCapture *paramCapture)
 
452
{
 
453
    UNIMPLEMENTED();
 
454
}
 
455
 
 
456
void CaptureGetTransformFeedbackVarying_type(const State &glState,
 
457
                                             bool isCallValid,
 
458
                                             ShaderProgramID program,
 
459
                                             GLuint index,
 
460
                                             GLsizei bufSize,
 
461
                                             GLsizei *length,
 
462
                                             GLsizei *size,
 
463
                                             GLenum *type,
 
464
                                             GLchar *name,
 
465
                                             ParamCapture *paramCapture)
 
466
{
 
467
    UNIMPLEMENTED();
 
468
}
 
469
 
 
470
void CaptureGetTransformFeedbackVarying_name(const State &glState,
 
471
                                             bool isCallValid,
 
472
                                             ShaderProgramID program,
 
473
                                             GLuint index,
 
474
                                             GLsizei bufSize,
 
475
                                             GLsizei *length,
 
476
                                             GLsizei *size,
 
477
                                             GLenum *type,
 
478
                                             GLchar *name,
 
479
                                             ParamCapture *paramCapture)
 
480
{
 
481
    UNIMPLEMENTED();
 
482
}
 
483
 
 
484
void CaptureGetUniformBlockIndex_uniformBlockName(const State &glState,
 
485
                                                  bool isCallValid,
 
486
                                                  ShaderProgramID program,
 
487
                                                  const GLchar *uniformBlockName,
 
488
                                                  ParamCapture *paramCapture)
 
489
{
 
490
    CaptureString(uniformBlockName, paramCapture);
 
491
}
 
492
 
 
493
void CaptureGetUniformIndices_uniformNames(const State &glState,
 
494
                                           bool isCallValid,
 
495
                                           ShaderProgramID program,
 
496
                                           GLsizei uniformCount,
 
497
                                           const GLchar *const *uniformNames,
 
498
                                           GLuint *uniformIndices,
 
499
                                           ParamCapture *paramCapture)
 
500
{
 
501
    UNIMPLEMENTED();
 
502
}
 
503
 
 
504
void CaptureGetUniformIndices_uniformIndices(const State &glState,
 
505
                                             bool isCallValid,
 
506
                                             ShaderProgramID program,
 
507
                                             GLsizei uniformCount,
 
508
                                             const GLchar *const *uniformNames,
 
509
                                             GLuint *uniformIndices,
 
510
                                             ParamCapture *paramCapture)
 
511
{
 
512
    UNIMPLEMENTED();
 
513
}
 
514
 
 
515
void CaptureGetUniformuiv_params(const State &glState,
 
516
                                 bool isCallValid,
 
517
                                 ShaderProgramID program,
 
518
                                 GLint location,
 
519
                                 GLuint *params,
 
520
                                 ParamCapture *paramCapture)
 
521
{
 
522
    UNIMPLEMENTED();
 
523
}
 
524
 
 
525
void CaptureGetVertexAttribIiv_params(const State &glState,
 
526
                                      bool isCallValid,
 
527
                                      GLuint index,
 
528
                                      GLenum pname,
 
529
                                      GLint *params,
 
530
                                      ParamCapture *paramCapture)
 
531
{
 
532
    UNIMPLEMENTED();
 
533
}
 
534
 
 
535
void CaptureGetVertexAttribIuiv_params(const State &glState,
 
536
                                       bool isCallValid,
 
537
                                       GLuint index,
 
538
                                       GLenum pname,
 
539
                                       GLuint *params,
 
540
                                       ParamCapture *paramCapture)
 
541
{
 
542
    UNIMPLEMENTED();
 
543
}
 
544
 
 
545
void CaptureInvalidateFramebuffer_attachments(const State &glState,
 
546
                                              bool isCallValid,
 
547
                                              GLenum target,
 
548
                                              GLsizei numAttachments,
 
549
                                              const GLenum *attachments,
 
550
                                              ParamCapture *paramCapture)
 
551
{
 
552
    UNIMPLEMENTED();
 
553
}
 
554
 
 
555
void CaptureInvalidateSubFramebuffer_attachments(const State &glState,
 
556
                                                 bool isCallValid,
 
557
                                                 GLenum target,
 
558
                                                 GLsizei numAttachments,
 
559
                                                 const GLenum *attachments,
 
560
                                                 GLint x,
 
561
                                                 GLint y,
 
562
                                                 GLsizei width,
 
563
                                                 GLsizei height,
 
564
                                                 ParamCapture *paramCapture)
 
565
{
 
566
    UNIMPLEMENTED();
 
567
}
 
568
 
 
569
void CaptureProgramBinary_binary(const State &glState,
 
570
                                 bool isCallValid,
 
571
                                 ShaderProgramID program,
 
572
                                 GLenum binaryFormat,
 
573
                                 const void *binary,
 
574
                                 GLsizei length,
 
575
                                 ParamCapture *paramCapture)
 
576
{
 
577
    UNIMPLEMENTED();
 
578
}
 
579
 
 
580
void CaptureSamplerParameterfv_param(const State &glState,
 
581
                                     bool isCallValid,
 
582
                                     SamplerID sampler,
 
583
                                     GLenum pname,
 
584
                                     const GLfloat *param,
 
585
                                     ParamCapture *paramCapture)
 
586
{
 
587
    UNIMPLEMENTED();
 
588
}
 
589
 
 
590
void CaptureSamplerParameteriv_param(const State &glState,
 
591
                                     bool isCallValid,
 
592
                                     SamplerID sampler,
 
593
                                     GLenum pname,
 
594
                                     const GLint *param,
 
595
                                     ParamCapture *paramCapture)
 
596
{
 
597
    UNIMPLEMENTED();
 
598
}
 
599
 
 
600
void CaptureTexImage3D_pixels(const State &glState,
 
601
                              bool isCallValid,
 
602
                              TextureTarget targetPacked,
 
603
                              GLint level,
 
604
                              GLint internalformat,
 
605
                              GLsizei width,
 
606
                              GLsizei height,
 
607
                              GLsizei depth,
 
608
                              GLint border,
 
609
                              GLenum format,
 
610
                              GLenum type,
 
611
                              const void *pixels,
 
612
                              ParamCapture *paramCapture)
 
613
{
 
614
    if (glState.getTargetBuffer(gl::BufferBinding::PixelUnpack))
 
615
    {
 
616
        return;
 
617
    }
 
618
 
 
619
    if (!pixels)
 
620
    {
 
621
        return;
 
622
    }
 
623
 
 
624
    const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(format, type);
 
625
    const gl::PixelUnpackState &unpack           = glState.getUnpackState();
 
626
 
 
627
    const Extents size(width, height, depth);
 
628
 
 
629
    GLuint endByte = 0;
 
630
    bool unpackSize =
 
631
        internalFormatInfo.computePackUnpackEndByte(type, size, unpack, true, &endByte);
 
632
    ASSERT(unpackSize);
 
633
 
 
634
    CaptureMemory(pixels, static_cast<size_t>(endByte), paramCapture);
 
635
}
 
636
 
 
637
void CaptureTexSubImage3D_pixels(const State &glState,
 
638
                                 bool isCallValid,
 
639
                                 TextureTarget targetPacked,
 
640
                                 GLint level,
 
641
                                 GLint xoffset,
 
642
                                 GLint yoffset,
 
643
                                 GLint zoffset,
 
644
                                 GLsizei width,
 
645
                                 GLsizei height,
 
646
                                 GLsizei depth,
 
647
                                 GLenum format,
 
648
                                 GLenum type,
 
649
                                 const void *pixels,
 
650
                                 ParamCapture *paramCapture)
 
651
{
 
652
    CaptureTexImage3D_pixels(glState, isCallValid, targetPacked, level, 0, width, height, depth, 0,
 
653
                             format, type, pixels, paramCapture);
 
654
}
 
655
 
 
656
void CaptureTransformFeedbackVaryings_varyings(const State &glState,
 
657
                                               bool isCallValid,
 
658
                                               ShaderProgramID program,
 
659
                                               GLsizei count,
 
660
                                               const GLchar *const *varyings,
 
661
                                               GLenum bufferMode,
 
662
                                               ParamCapture *paramCapture)
 
663
{
 
664
    for (GLsizei index = 0; index < count; ++index)
 
665
    {
 
666
        CaptureString(varyings[index], paramCapture);
 
667
    }
 
668
}
 
669
 
 
670
void CaptureUniform1uiv_value(const State &glState,
 
671
                              bool isCallValid,
 
672
                              GLint location,
 
673
                              GLsizei count,
 
674
                              const GLuint *value,
 
675
                              ParamCapture *paramCapture)
 
676
{
 
677
    UNIMPLEMENTED();
 
678
}
 
679
 
 
680
void CaptureUniform2uiv_value(const State &glState,
 
681
                              bool isCallValid,
 
682
                              GLint location,
 
683
                              GLsizei count,
 
684
                              const GLuint *value,
 
685
                              ParamCapture *paramCapture)
 
686
{
 
687
    UNIMPLEMENTED();
 
688
}
 
689
 
 
690
void CaptureUniform3uiv_value(const State &glState,
 
691
                              bool isCallValid,
 
692
                              GLint location,
 
693
                              GLsizei count,
 
694
                              const GLuint *value,
 
695
                              ParamCapture *paramCapture)
 
696
{
 
697
    UNIMPLEMENTED();
 
698
}
 
699
 
 
700
void CaptureUniform4uiv_value(const State &glState,
 
701
                              bool isCallValid,
 
702
                              GLint location,
 
703
                              GLsizei count,
 
704
                              const GLuint *value,
 
705
                              ParamCapture *paramCapture)
 
706
{
 
707
    UNIMPLEMENTED();
 
708
}
 
709
 
 
710
void CaptureUniformMatrix2x3fv_value(const State &glState,
 
711
                                     bool isCallValid,
 
712
                                     GLint location,
 
713
                                     GLsizei count,
 
714
                                     GLboolean transpose,
 
715
                                     const GLfloat *value,
 
716
                                     ParamCapture *paramCapture)
 
717
{
 
718
    UNIMPLEMENTED();
 
719
}
 
720
 
 
721
void CaptureUniformMatrix2x4fv_value(const State &glState,
 
722
                                     bool isCallValid,
 
723
                                     GLint location,
 
724
                                     GLsizei count,
 
725
                                     GLboolean transpose,
 
726
                                     const GLfloat *value,
 
727
                                     ParamCapture *paramCapture)
 
728
{
 
729
    UNIMPLEMENTED();
 
730
}
 
731
 
 
732
void CaptureUniformMatrix3x2fv_value(const State &glState,
 
733
                                     bool isCallValid,
 
734
                                     GLint location,
 
735
                                     GLsizei count,
 
736
                                     GLboolean transpose,
 
737
                                     const GLfloat *value,
 
738
                                     ParamCapture *paramCapture)
 
739
{
 
740
    UNIMPLEMENTED();
 
741
}
 
742
 
 
743
void CaptureUniformMatrix3x4fv_value(const State &glState,
 
744
                                     bool isCallValid,
 
745
                                     GLint location,
 
746
                                     GLsizei count,
 
747
                                     GLboolean transpose,
 
748
                                     const GLfloat *value,
 
749
                                     ParamCapture *paramCapture)
 
750
{
 
751
    UNIMPLEMENTED();
 
752
}
 
753
 
 
754
void CaptureUniformMatrix4x2fv_value(const State &glState,
 
755
                                     bool isCallValid,
 
756
                                     GLint location,
 
757
                                     GLsizei count,
 
758
                                     GLboolean transpose,
 
759
                                     const GLfloat *value,
 
760
                                     ParamCapture *paramCapture)
 
761
{
 
762
    UNIMPLEMENTED();
 
763
}
 
764
 
 
765
void CaptureUniformMatrix4x3fv_value(const State &glState,
 
766
                                     bool isCallValid,
 
767
                                     GLint location,
 
768
                                     GLsizei count,
 
769
                                     GLboolean transpose,
 
770
                                     const GLfloat *value,
 
771
                                     ParamCapture *paramCapture)
 
772
{
 
773
    UNIMPLEMENTED();
 
774
}
 
775
 
 
776
void CaptureVertexAttribI4iv_v(const State &glState,
 
777
                               bool isCallValid,
 
778
                               GLuint index,
 
779
                               const GLint *v,
 
780
                               ParamCapture *paramCapture)
 
781
{
 
782
    UNIMPLEMENTED();
 
783
}
 
784
 
 
785
void CaptureVertexAttribI4uiv_v(const State &glState,
 
786
                                bool isCallValid,
 
787
                                GLuint index,
 
788
                                const GLuint *v,
 
789
                                ParamCapture *paramCapture)
 
790
{
 
791
    UNIMPLEMENTED();
 
792
}
 
793
 
 
794
void CaptureVertexAttribIPointer_pointer(const State &glState,
 
795
                                         bool isCallValid,
 
796
                                         GLuint index,
 
797
                                         GLint size,
 
798
                                         VertexAttribType typePacked,
 
799
                                         GLsizei stride,
 
800
                                         const void *pointer,
 
801
                                         ParamCapture *paramCapture)
 
802
{
 
803
    UNIMPLEMENTED();
 
804
}
 
805
 
 
806
}  // namespace gl