← 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_1_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_1_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_gles31_params.cpp:
 
7
//   Pointer parameter capture functions for the OpenGL ES 3.1 entry points.
 
8
 
 
9
#include "libANGLE/capture_gles_3_1_autogen.h"
 
10
 
 
11
using namespace angle;
 
12
 
 
13
namespace gl
 
14
{
 
15
 
 
16
void CaptureCreateShaderProgramv_strings(const State &glState,
 
17
                                         bool isCallValid,
 
18
                                         ShaderType typePacked,
 
19
                                         GLsizei count,
 
20
                                         const GLchar *const *strings,
 
21
                                         ParamCapture *paramCapture)
 
22
{
 
23
    UNIMPLEMENTED();
 
24
}
 
25
 
 
26
void CaptureDeleteProgramPipelines_pipelinesPacked(const State &glState,
 
27
                                                   bool isCallValid,
 
28
                                                   GLsizei n,
 
29
                                                   const ProgramPipelineID *pipelines,
 
30
                                                   ParamCapture *paramCapture)
 
31
{
 
32
    CaptureMemory(pipelines, sizeof(ProgramPipelineID) * n, paramCapture);
 
33
}
 
34
 
 
35
void CaptureDrawArraysIndirect_indirect(const State &glState,
 
36
                                        bool isCallValid,
 
37
                                        PrimitiveMode modePacked,
 
38
                                        const void *indirect,
 
39
                                        ParamCapture *paramCapture)
 
40
{
 
41
    UNIMPLEMENTED();
 
42
}
 
43
 
 
44
void CaptureDrawElementsIndirect_indirect(const State &glState,
 
45
                                          bool isCallValid,
 
46
                                          PrimitiveMode modePacked,
 
47
                                          DrawElementsType typePacked,
 
48
                                          const void *indirect,
 
49
                                          ParamCapture *paramCapture)
 
50
{
 
51
    UNIMPLEMENTED();
 
52
}
 
53
 
 
54
void CaptureGenProgramPipelines_pipelinesPacked(const State &glState,
 
55
                                                bool isCallValid,
 
56
                                                GLsizei n,
 
57
                                                ProgramPipelineID *pipelines,
 
58
                                                ParamCapture *paramCapture)
 
59
{
 
60
    CaptureGenHandles(n, pipelines, paramCapture);
 
61
}
 
62
 
 
63
void CaptureGetBooleani_v_data(const State &glState,
 
64
                               bool isCallValid,
 
65
                               GLenum target,
 
66
                               GLuint index,
 
67
                               GLboolean *data,
 
68
                               ParamCapture *paramCapture)
 
69
{
 
70
    UNIMPLEMENTED();
 
71
}
 
72
 
 
73
void CaptureGetFramebufferParameteriv_params(const State &glState,
 
74
                                             bool isCallValid,
 
75
                                             GLenum target,
 
76
                                             GLenum pname,
 
77
                                             GLint *params,
 
78
                                             ParamCapture *paramCapture)
 
79
{
 
80
    UNIMPLEMENTED();
 
81
}
 
82
 
 
83
void CaptureGetMultisamplefv_val(const State &glState,
 
84
                                 bool isCallValid,
 
85
                                 GLenum pname,
 
86
                                 GLuint index,
 
87
                                 GLfloat *val,
 
88
                                 ParamCapture *paramCapture)
 
89
{
 
90
    UNIMPLEMENTED();
 
91
}
 
92
 
 
93
void CaptureGetProgramInterfaceiv_params(const State &glState,
 
94
                                         bool isCallValid,
 
95
                                         ShaderProgramID program,
 
96
                                         GLenum programInterface,
 
97
                                         GLenum pname,
 
98
                                         GLint *params,
 
99
                                         ParamCapture *paramCapture)
 
100
{
 
101
    UNIMPLEMENTED();
 
102
}
 
103
 
 
104
void CaptureGetProgramPipelineInfoLog_length(const State &glState,
 
105
                                             bool isCallValid,
 
106
                                             ProgramPipelineID pipeline,
 
107
                                             GLsizei bufSize,
 
108
                                             GLsizei *length,
 
109
                                             GLchar *infoLog,
 
110
                                             ParamCapture *paramCapture)
 
111
{
 
112
    UNIMPLEMENTED();
 
113
}
 
114
 
 
115
void CaptureGetProgramPipelineInfoLog_infoLog(const State &glState,
 
116
                                              bool isCallValid,
 
117
                                              ProgramPipelineID pipeline,
 
118
                                              GLsizei bufSize,
 
119
                                              GLsizei *length,
 
120
                                              GLchar *infoLog,
 
121
                                              ParamCapture *paramCapture)
 
122
{
 
123
    UNIMPLEMENTED();
 
124
}
 
125
 
 
126
void CaptureGetProgramPipelineiv_params(const State &glState,
 
127
                                        bool isCallValid,
 
128
                                        ProgramPipelineID pipeline,
 
129
                                        GLenum pname,
 
130
                                        GLint *params,
 
131
                                        ParamCapture *paramCapture)
 
132
{
 
133
    UNIMPLEMENTED();
 
134
}
 
135
 
 
136
void CaptureGetProgramResourceIndex_name(const State &glState,
 
137
                                         bool isCallValid,
 
138
                                         ShaderProgramID program,
 
139
                                         GLenum programInterface,
 
140
                                         const GLchar *name,
 
141
                                         ParamCapture *paramCapture)
 
142
{
 
143
    UNIMPLEMENTED();
 
144
}
 
145
 
 
146
void CaptureGetProgramResourceLocation_name(const State &glState,
 
147
                                            bool isCallValid,
 
148
                                            ShaderProgramID program,
 
149
                                            GLenum programInterface,
 
150
                                            const GLchar *name,
 
151
                                            ParamCapture *paramCapture)
 
152
{
 
153
    UNIMPLEMENTED();
 
154
}
 
155
 
 
156
void CaptureGetProgramResourceName_length(const State &glState,
 
157
                                          bool isCallValid,
 
158
                                          ShaderProgramID program,
 
159
                                          GLenum programInterface,
 
160
                                          GLuint index,
 
161
                                          GLsizei bufSize,
 
162
                                          GLsizei *length,
 
163
                                          GLchar *name,
 
164
                                          ParamCapture *paramCapture)
 
165
{
 
166
    UNIMPLEMENTED();
 
167
}
 
168
 
 
169
void CaptureGetProgramResourceName_name(const State &glState,
 
170
                                        bool isCallValid,
 
171
                                        ShaderProgramID program,
 
172
                                        GLenum programInterface,
 
173
                                        GLuint index,
 
174
                                        GLsizei bufSize,
 
175
                                        GLsizei *length,
 
176
                                        GLchar *name,
 
177
                                        ParamCapture *paramCapture)
 
178
{
 
179
    UNIMPLEMENTED();
 
180
}
 
181
 
 
182
void CaptureGetProgramResourceiv_props(const State &glState,
 
183
                                       bool isCallValid,
 
184
                                       ShaderProgramID program,
 
185
                                       GLenum programInterface,
 
186
                                       GLuint index,
 
187
                                       GLsizei propCount,
 
188
                                       const GLenum *props,
 
189
                                       GLsizei bufSize,
 
190
                                       GLsizei *length,
 
191
                                       GLint *params,
 
192
                                       ParamCapture *paramCapture)
 
193
{
 
194
    UNIMPLEMENTED();
 
195
}
 
196
 
 
197
void CaptureGetProgramResourceiv_length(const State &glState,
 
198
                                        bool isCallValid,
 
199
                                        ShaderProgramID program,
 
200
                                        GLenum programInterface,
 
201
                                        GLuint index,
 
202
                                        GLsizei propCount,
 
203
                                        const GLenum *props,
 
204
                                        GLsizei bufSize,
 
205
                                        GLsizei *length,
 
206
                                        GLint *params,
 
207
                                        ParamCapture *paramCapture)
 
208
{
 
209
    UNIMPLEMENTED();
 
210
}
 
211
 
 
212
void CaptureGetProgramResourceiv_params(const State &glState,
 
213
                                        bool isCallValid,
 
214
                                        ShaderProgramID program,
 
215
                                        GLenum programInterface,
 
216
                                        GLuint index,
 
217
                                        GLsizei propCount,
 
218
                                        const GLenum *props,
 
219
                                        GLsizei bufSize,
 
220
                                        GLsizei *length,
 
221
                                        GLint *params,
 
222
                                        ParamCapture *paramCapture)
 
223
{
 
224
    UNIMPLEMENTED();
 
225
}
 
226
 
 
227
void CaptureGetTexLevelParameterfv_params(const State &glState,
 
228
                                          bool isCallValid,
 
229
                                          TextureTarget targetPacked,
 
230
                                          GLint level,
 
231
                                          GLenum pname,
 
232
                                          GLfloat *params,
 
233
                                          ParamCapture *paramCapture)
 
234
{
 
235
    UNIMPLEMENTED();
 
236
}
 
237
 
 
238
void CaptureGetTexLevelParameteriv_params(const State &glState,
 
239
                                          bool isCallValid,
 
240
                                          TextureTarget targetPacked,
 
241
                                          GLint level,
 
242
                                          GLenum pname,
 
243
                                          GLint *params,
 
244
                                          ParamCapture *paramCapture)
 
245
{
 
246
    UNIMPLEMENTED();
 
247
}
 
248
 
 
249
void CaptureProgramUniform1fv_value(const State &glState,
 
250
                                    bool isCallValid,
 
251
                                    ShaderProgramID program,
 
252
                                    GLint location,
 
253
                                    GLsizei count,
 
254
                                    const GLfloat *value,
 
255
                                    ParamCapture *paramCapture)
 
256
{
 
257
    UNIMPLEMENTED();
 
258
}
 
259
 
 
260
void CaptureProgramUniform1iv_value(const State &glState,
 
261
                                    bool isCallValid,
 
262
                                    ShaderProgramID program,
 
263
                                    GLint location,
 
264
                                    GLsizei count,
 
265
                                    const GLint *value,
 
266
                                    ParamCapture *paramCapture)
 
267
{
 
268
    UNIMPLEMENTED();
 
269
}
 
270
 
 
271
void CaptureProgramUniform1uiv_value(const State &glState,
 
272
                                     bool isCallValid,
 
273
                                     ShaderProgramID program,
 
274
                                     GLint location,
 
275
                                     GLsizei count,
 
276
                                     const GLuint *value,
 
277
                                     ParamCapture *paramCapture)
 
278
{
 
279
    UNIMPLEMENTED();
 
280
}
 
281
 
 
282
void CaptureProgramUniform2fv_value(const State &glState,
 
283
                                    bool isCallValid,
 
284
                                    ShaderProgramID program,
 
285
                                    GLint location,
 
286
                                    GLsizei count,
 
287
                                    const GLfloat *value,
 
288
                                    ParamCapture *paramCapture)
 
289
{
 
290
    UNIMPLEMENTED();
 
291
}
 
292
 
 
293
void CaptureProgramUniform2iv_value(const State &glState,
 
294
                                    bool isCallValid,
 
295
                                    ShaderProgramID program,
 
296
                                    GLint location,
 
297
                                    GLsizei count,
 
298
                                    const GLint *value,
 
299
                                    ParamCapture *paramCapture)
 
300
{
 
301
    UNIMPLEMENTED();
 
302
}
 
303
 
 
304
void CaptureProgramUniform2uiv_value(const State &glState,
 
305
                                     bool isCallValid,
 
306
                                     ShaderProgramID program,
 
307
                                     GLint location,
 
308
                                     GLsizei count,
 
309
                                     const GLuint *value,
 
310
                                     ParamCapture *paramCapture)
 
311
{
 
312
    UNIMPLEMENTED();
 
313
}
 
314
 
 
315
void CaptureProgramUniform3fv_value(const State &glState,
 
316
                                    bool isCallValid,
 
317
                                    ShaderProgramID program,
 
318
                                    GLint location,
 
319
                                    GLsizei count,
 
320
                                    const GLfloat *value,
 
321
                                    ParamCapture *paramCapture)
 
322
{
 
323
    UNIMPLEMENTED();
 
324
}
 
325
 
 
326
void CaptureProgramUniform3iv_value(const State &glState,
 
327
                                    bool isCallValid,
 
328
                                    ShaderProgramID program,
 
329
                                    GLint location,
 
330
                                    GLsizei count,
 
331
                                    const GLint *value,
 
332
                                    ParamCapture *paramCapture)
 
333
{
 
334
    UNIMPLEMENTED();
 
335
}
 
336
 
 
337
void CaptureProgramUniform3uiv_value(const State &glState,
 
338
                                     bool isCallValid,
 
339
                                     ShaderProgramID program,
 
340
                                     GLint location,
 
341
                                     GLsizei count,
 
342
                                     const GLuint *value,
 
343
                                     ParamCapture *paramCapture)
 
344
{
 
345
    UNIMPLEMENTED();
 
346
}
 
347
 
 
348
void CaptureProgramUniform4fv_value(const State &glState,
 
349
                                    bool isCallValid,
 
350
                                    ShaderProgramID program,
 
351
                                    GLint location,
 
352
                                    GLsizei count,
 
353
                                    const GLfloat *value,
 
354
                                    ParamCapture *paramCapture)
 
355
{
 
356
    UNIMPLEMENTED();
 
357
}
 
358
 
 
359
void CaptureProgramUniform4iv_value(const State &glState,
 
360
                                    bool isCallValid,
 
361
                                    ShaderProgramID program,
 
362
                                    GLint location,
 
363
                                    GLsizei count,
 
364
                                    const GLint *value,
 
365
                                    ParamCapture *paramCapture)
 
366
{
 
367
    UNIMPLEMENTED();
 
368
}
 
369
 
 
370
void CaptureProgramUniform4uiv_value(const State &glState,
 
371
                                     bool isCallValid,
 
372
                                     ShaderProgramID program,
 
373
                                     GLint location,
 
374
                                     GLsizei count,
 
375
                                     const GLuint *value,
 
376
                                     ParamCapture *paramCapture)
 
377
{
 
378
    UNIMPLEMENTED();
 
379
}
 
380
 
 
381
void CaptureProgramUniformMatrix2fv_value(const State &glState,
 
382
                                          bool isCallValid,
 
383
                                          ShaderProgramID program,
 
384
                                          GLint location,
 
385
                                          GLsizei count,
 
386
                                          GLboolean transpose,
 
387
                                          const GLfloat *value,
 
388
                                          ParamCapture *paramCapture)
 
389
{
 
390
    UNIMPLEMENTED();
 
391
}
 
392
 
 
393
void CaptureProgramUniformMatrix2x3fv_value(const State &glState,
 
394
                                            bool isCallValid,
 
395
                                            ShaderProgramID program,
 
396
                                            GLint location,
 
397
                                            GLsizei count,
 
398
                                            GLboolean transpose,
 
399
                                            const GLfloat *value,
 
400
                                            ParamCapture *paramCapture)
 
401
{
 
402
    UNIMPLEMENTED();
 
403
}
 
404
 
 
405
void CaptureProgramUniformMatrix2x4fv_value(const State &glState,
 
406
                                            bool isCallValid,
 
407
                                            ShaderProgramID program,
 
408
                                            GLint location,
 
409
                                            GLsizei count,
 
410
                                            GLboolean transpose,
 
411
                                            const GLfloat *value,
 
412
                                            ParamCapture *paramCapture)
 
413
{
 
414
    UNIMPLEMENTED();
 
415
}
 
416
 
 
417
void CaptureProgramUniformMatrix3fv_value(const State &glState,
 
418
                                          bool isCallValid,
 
419
                                          ShaderProgramID program,
 
420
                                          GLint location,
 
421
                                          GLsizei count,
 
422
                                          GLboolean transpose,
 
423
                                          const GLfloat *value,
 
424
                                          ParamCapture *paramCapture)
 
425
{
 
426
    UNIMPLEMENTED();
 
427
}
 
428
 
 
429
void CaptureProgramUniformMatrix3x2fv_value(const State &glState,
 
430
                                            bool isCallValid,
 
431
                                            ShaderProgramID program,
 
432
                                            GLint location,
 
433
                                            GLsizei count,
 
434
                                            GLboolean transpose,
 
435
                                            const GLfloat *value,
 
436
                                            ParamCapture *paramCapture)
 
437
{
 
438
    UNIMPLEMENTED();
 
439
}
 
440
 
 
441
void CaptureProgramUniformMatrix3x4fv_value(const State &glState,
 
442
                                            bool isCallValid,
 
443
                                            ShaderProgramID program,
 
444
                                            GLint location,
 
445
                                            GLsizei count,
 
446
                                            GLboolean transpose,
 
447
                                            const GLfloat *value,
 
448
                                            ParamCapture *paramCapture)
 
449
{
 
450
    UNIMPLEMENTED();
 
451
}
 
452
 
 
453
void CaptureProgramUniformMatrix4fv_value(const State &glState,
 
454
                                          bool isCallValid,
 
455
                                          ShaderProgramID program,
 
456
                                          GLint location,
 
457
                                          GLsizei count,
 
458
                                          GLboolean transpose,
 
459
                                          const GLfloat *value,
 
460
                                          ParamCapture *paramCapture)
 
461
{
 
462
    UNIMPLEMENTED();
 
463
}
 
464
 
 
465
void CaptureProgramUniformMatrix4x2fv_value(const State &glState,
 
466
                                            bool isCallValid,
 
467
                                            ShaderProgramID program,
 
468
                                            GLint location,
 
469
                                            GLsizei count,
 
470
                                            GLboolean transpose,
 
471
                                            const GLfloat *value,
 
472
                                            ParamCapture *paramCapture)
 
473
{
 
474
    UNIMPLEMENTED();
 
475
}
 
476
 
 
477
void CaptureProgramUniformMatrix4x3fv_value(const State &glState,
 
478
                                            bool isCallValid,
 
479
                                            ShaderProgramID program,
 
480
                                            GLint location,
 
481
                                            GLsizei count,
 
482
                                            GLboolean transpose,
 
483
                                            const GLfloat *value,
 
484
                                            ParamCapture *paramCapture)
 
485
{
 
486
    UNIMPLEMENTED();
 
487
}
 
488
 
 
489
}  // namespace gl