• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //
2 // Copyright 2022 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_gl_1_params.cpp:
7 //   Pointer parameter capture functions for the OpenGL 1.x entry points.
8 
9 #include "libANGLE/capture/capture_gl_1_autogen.h"
10 
11 namespace gl
12 {
13 // GL 1.0
CaptureBitmap_bitmap(const State & glState,bool isCallValid,GLsizei width,GLsizei height,GLfloat xorig,GLfloat yorig,GLfloat xmove,GLfloat ymove,const GLubyte * bitmap,angle::ParamCapture * paramCapture)14 void CaptureBitmap_bitmap(const State &glState,
15                           bool isCallValid,
16                           GLsizei width,
17                           GLsizei height,
18                           GLfloat xorig,
19                           GLfloat yorig,
20                           GLfloat xmove,
21                           GLfloat ymove,
22                           const GLubyte *bitmap,
23                           angle::ParamCapture *paramCapture)
24 {
25     UNIMPLEMENTED();
26 }
CaptureCallLists_lists(const State & glState,bool isCallValid,GLsizei n,GLenum type,const void * lists,angle::ParamCapture * paramCapture)27 void CaptureCallLists_lists(const State &glState,
28                             bool isCallValid,
29                             GLsizei n,
30                             GLenum type,
31                             const void *lists,
32                             angle::ParamCapture *paramCapture)
33 {
34     UNIMPLEMENTED();
35 }
CaptureClipPlane_equation(const State & glState,bool isCallValid,GLenum plane,const GLdouble * equation,angle::ParamCapture * paramCapture)36 void CaptureClipPlane_equation(const State &glState,
37                                bool isCallValid,
38                                GLenum plane,
39                                const GLdouble *equation,
40                                angle::ParamCapture *paramCapture)
41 {
42     UNIMPLEMENTED();
43 }
CaptureColor3bv_v(const State & glState,bool isCallValid,const GLbyte * v,angle::ParamCapture * paramCapture)44 void CaptureColor3bv_v(const State &glState,
45                        bool isCallValid,
46                        const GLbyte *v,
47                        angle::ParamCapture *paramCapture)
48 {
49     UNIMPLEMENTED();
50 }
CaptureColor3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)51 void CaptureColor3dv_v(const State &glState,
52                        bool isCallValid,
53                        const GLdouble *v,
54                        angle::ParamCapture *paramCapture)
55 {
56     UNIMPLEMENTED();
57 }
CaptureColor3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)58 void CaptureColor3fv_v(const State &glState,
59                        bool isCallValid,
60                        const GLfloat *v,
61                        angle::ParamCapture *paramCapture)
62 {
63     UNIMPLEMENTED();
64 }
CaptureColor3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)65 void CaptureColor3iv_v(const State &glState,
66                        bool isCallValid,
67                        const GLint *v,
68                        angle::ParamCapture *paramCapture)
69 {
70     UNIMPLEMENTED();
71 }
CaptureColor3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)72 void CaptureColor3sv_v(const State &glState,
73                        bool isCallValid,
74                        const GLshort *v,
75                        angle::ParamCapture *paramCapture)
76 {
77     UNIMPLEMENTED();
78 }
CaptureColor3ubv_v(const State & glState,bool isCallValid,const GLubyte * v,angle::ParamCapture * paramCapture)79 void CaptureColor3ubv_v(const State &glState,
80                         bool isCallValid,
81                         const GLubyte *v,
82                         angle::ParamCapture *paramCapture)
83 {
84     UNIMPLEMENTED();
85 }
CaptureColor3uiv_v(const State & glState,bool isCallValid,const GLuint * v,angle::ParamCapture * paramCapture)86 void CaptureColor3uiv_v(const State &glState,
87                         bool isCallValid,
88                         const GLuint *v,
89                         angle::ParamCapture *paramCapture)
90 {
91     UNIMPLEMENTED();
92 }
CaptureColor3usv_v(const State & glState,bool isCallValid,const GLushort * v,angle::ParamCapture * paramCapture)93 void CaptureColor3usv_v(const State &glState,
94                         bool isCallValid,
95                         const GLushort *v,
96                         angle::ParamCapture *paramCapture)
97 {
98     UNIMPLEMENTED();
99 }
CaptureColor4bv_v(const State & glState,bool isCallValid,const GLbyte * v,angle::ParamCapture * paramCapture)100 void CaptureColor4bv_v(const State &glState,
101                        bool isCallValid,
102                        const GLbyte *v,
103                        angle::ParamCapture *paramCapture)
104 {
105     UNIMPLEMENTED();
106 }
CaptureColor4dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)107 void CaptureColor4dv_v(const State &glState,
108                        bool isCallValid,
109                        const GLdouble *v,
110                        angle::ParamCapture *paramCapture)
111 {
112     UNIMPLEMENTED();
113 }
CaptureColor4fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)114 void CaptureColor4fv_v(const State &glState,
115                        bool isCallValid,
116                        const GLfloat *v,
117                        angle::ParamCapture *paramCapture)
118 {
119     UNIMPLEMENTED();
120 }
CaptureColor4iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)121 void CaptureColor4iv_v(const State &glState,
122                        bool isCallValid,
123                        const GLint *v,
124                        angle::ParamCapture *paramCapture)
125 {
126     UNIMPLEMENTED();
127 }
CaptureColor4sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)128 void CaptureColor4sv_v(const State &glState,
129                        bool isCallValid,
130                        const GLshort *v,
131                        angle::ParamCapture *paramCapture)
132 {
133     UNIMPLEMENTED();
134 }
CaptureColor4ubv_v(const State & glState,bool isCallValid,const GLubyte * v,angle::ParamCapture * paramCapture)135 void CaptureColor4ubv_v(const State &glState,
136                         bool isCallValid,
137                         const GLubyte *v,
138                         angle::ParamCapture *paramCapture)
139 {
140     UNIMPLEMENTED();
141 }
CaptureColor4uiv_v(const State & glState,bool isCallValid,const GLuint * v,angle::ParamCapture * paramCapture)142 void CaptureColor4uiv_v(const State &glState,
143                         bool isCallValid,
144                         const GLuint *v,
145                         angle::ParamCapture *paramCapture)
146 {
147     UNIMPLEMENTED();
148 }
CaptureColor4usv_v(const State & glState,bool isCallValid,const GLushort * v,angle::ParamCapture * paramCapture)149 void CaptureColor4usv_v(const State &glState,
150                         bool isCallValid,
151                         const GLushort *v,
152                         angle::ParamCapture *paramCapture)
153 {
154     UNIMPLEMENTED();
155 }
CaptureDrawPixels_pixels(const State & glState,bool isCallValid,GLsizei width,GLsizei height,GLenum format,GLenum type,const void * pixels,angle::ParamCapture * paramCapture)156 void CaptureDrawPixels_pixels(const State &glState,
157                               bool isCallValid,
158                               GLsizei width,
159                               GLsizei height,
160                               GLenum format,
161                               GLenum type,
162                               const void *pixels,
163                               angle::ParamCapture *paramCapture)
164 {
165     UNIMPLEMENTED();
166 }
CaptureEdgeFlagv_flag(const State & glState,bool isCallValid,const GLboolean * flag,angle::ParamCapture * paramCapture)167 void CaptureEdgeFlagv_flag(const State &glState,
168                            bool isCallValid,
169                            const GLboolean *flag,
170                            angle::ParamCapture *paramCapture)
171 {
172     UNIMPLEMENTED();
173 }
CaptureEvalCoord1dv_u(const State & glState,bool isCallValid,const GLdouble * u,angle::ParamCapture * paramCapture)174 void CaptureEvalCoord1dv_u(const State &glState,
175                            bool isCallValid,
176                            const GLdouble *u,
177                            angle::ParamCapture *paramCapture)
178 {
179     UNIMPLEMENTED();
180 }
CaptureEvalCoord1fv_u(const State & glState,bool isCallValid,const GLfloat * u,angle::ParamCapture * paramCapture)181 void CaptureEvalCoord1fv_u(const State &glState,
182                            bool isCallValid,
183                            const GLfloat *u,
184                            angle::ParamCapture *paramCapture)
185 {
186     UNIMPLEMENTED();
187 }
CaptureEvalCoord2dv_u(const State & glState,bool isCallValid,const GLdouble * u,angle::ParamCapture * paramCapture)188 void CaptureEvalCoord2dv_u(const State &glState,
189                            bool isCallValid,
190                            const GLdouble *u,
191                            angle::ParamCapture *paramCapture)
192 {
193     UNIMPLEMENTED();
194 }
CaptureEvalCoord2fv_u(const State & glState,bool isCallValid,const GLfloat * u,angle::ParamCapture * paramCapture)195 void CaptureEvalCoord2fv_u(const State &glState,
196                            bool isCallValid,
197                            const GLfloat *u,
198                            angle::ParamCapture *paramCapture)
199 {
200     UNIMPLEMENTED();
201 }
CaptureFeedbackBuffer_buffer(const State & glState,bool isCallValid,GLsizei size,GLenum type,GLfloat * buffer,angle::ParamCapture * paramCapture)202 void CaptureFeedbackBuffer_buffer(const State &glState,
203                                   bool isCallValid,
204                                   GLsizei size,
205                                   GLenum type,
206                                   GLfloat *buffer,
207                                   angle::ParamCapture *paramCapture)
208 {
209     UNIMPLEMENTED();
210 }
CaptureFogiv_params(const State & glState,bool isCallValid,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)211 void CaptureFogiv_params(const State &glState,
212                          bool isCallValid,
213                          GLenum pname,
214                          const GLint *params,
215                          angle::ParamCapture *paramCapture)
216 {
217     UNIMPLEMENTED();
218 }
CaptureGetClipPlane_equation(const State & glState,bool isCallValid,GLenum plane,GLdouble * equation,angle::ParamCapture * paramCapture)219 void CaptureGetClipPlane_equation(const State &glState,
220                                   bool isCallValid,
221                                   GLenum plane,
222                                   GLdouble *equation,
223                                   angle::ParamCapture *paramCapture)
224 {
225     UNIMPLEMENTED();
226 }
CaptureGetDoublev_data(const State & glState,bool isCallValid,GLenum pname,GLdouble * data,angle::ParamCapture * paramCapture)227 void CaptureGetDoublev_data(const State &glState,
228                             bool isCallValid,
229                             GLenum pname,
230                             GLdouble *data,
231                             angle::ParamCapture *paramCapture)
232 {
233     UNIMPLEMENTED();
234 }
CaptureGetLightiv_params(const State & glState,bool isCallValid,GLenum light,GLenum pname,GLint * params,angle::ParamCapture * paramCapture)235 void CaptureGetLightiv_params(const State &glState,
236                               bool isCallValid,
237                               GLenum light,
238                               GLenum pname,
239                               GLint *params,
240                               angle::ParamCapture *paramCapture)
241 {
242     UNIMPLEMENTED();
243 }
CaptureGetMapdv_v(const State & glState,bool isCallValid,GLenum target,GLenum query,GLdouble * v,angle::ParamCapture * paramCapture)244 void CaptureGetMapdv_v(const State &glState,
245                        bool isCallValid,
246                        GLenum target,
247                        GLenum query,
248                        GLdouble *v,
249                        angle::ParamCapture *paramCapture)
250 {
251     UNIMPLEMENTED();
252 }
CaptureGetMapfv_v(const State & glState,bool isCallValid,GLenum target,GLenum query,GLfloat * v,angle::ParamCapture * paramCapture)253 void CaptureGetMapfv_v(const State &glState,
254                        bool isCallValid,
255                        GLenum target,
256                        GLenum query,
257                        GLfloat *v,
258                        angle::ParamCapture *paramCapture)
259 {
260     UNIMPLEMENTED();
261 }
CaptureGetMapiv_v(const State & glState,bool isCallValid,GLenum target,GLenum query,GLint * v,angle::ParamCapture * paramCapture)262 void CaptureGetMapiv_v(const State &glState,
263                        bool isCallValid,
264                        GLenum target,
265                        GLenum query,
266                        GLint *v,
267                        angle::ParamCapture *paramCapture)
268 {
269     UNIMPLEMENTED();
270 }
CaptureGetMaterialiv_params(const State & glState,bool isCallValid,GLenum face,GLenum pname,GLint * params,angle::ParamCapture * paramCapture)271 void CaptureGetMaterialiv_params(const State &glState,
272                                  bool isCallValid,
273                                  GLenum face,
274                                  GLenum pname,
275                                  GLint *params,
276                                  angle::ParamCapture *paramCapture)
277 {
278     UNIMPLEMENTED();
279 }
CaptureGetPixelMapfv_values(const State & glState,bool isCallValid,GLenum map,GLfloat * values,angle::ParamCapture * paramCapture)280 void CaptureGetPixelMapfv_values(const State &glState,
281                                  bool isCallValid,
282                                  GLenum map,
283                                  GLfloat *values,
284                                  angle::ParamCapture *paramCapture)
285 {
286     UNIMPLEMENTED();
287 }
CaptureGetPixelMapuiv_values(const State & glState,bool isCallValid,GLenum map,GLuint * values,angle::ParamCapture * paramCapture)288 void CaptureGetPixelMapuiv_values(const State &glState,
289                                   bool isCallValid,
290                                   GLenum map,
291                                   GLuint *values,
292                                   angle::ParamCapture *paramCapture)
293 {
294     UNIMPLEMENTED();
295 }
CaptureGetPixelMapusv_values(const State & glState,bool isCallValid,GLenum map,GLushort * values,angle::ParamCapture * paramCapture)296 void CaptureGetPixelMapusv_values(const State &glState,
297                                   bool isCallValid,
298                                   GLenum map,
299                                   GLushort *values,
300                                   angle::ParamCapture *paramCapture)
301 {
302     UNIMPLEMENTED();
303 }
CaptureGetPolygonStipple_mask(const State & glState,bool isCallValid,GLubyte * mask,angle::ParamCapture * paramCapture)304 void CaptureGetPolygonStipple_mask(const State &glState,
305                                    bool isCallValid,
306                                    GLubyte *mask,
307                                    angle::ParamCapture *paramCapture)
308 {
309     UNIMPLEMENTED();
310 }
CaptureGetTexGendv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLdouble * params,angle::ParamCapture * paramCapture)311 void CaptureGetTexGendv_params(const State &glState,
312                                bool isCallValid,
313                                GLenum coord,
314                                GLenum pname,
315                                GLdouble *params,
316                                angle::ParamCapture *paramCapture)
317 {
318     UNIMPLEMENTED();
319 }
CaptureGetTexGenfv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLfloat * params,angle::ParamCapture * paramCapture)320 void CaptureGetTexGenfv_params(const State &glState,
321                                bool isCallValid,
322                                GLenum coord,
323                                GLenum pname,
324                                GLfloat *params,
325                                angle::ParamCapture *paramCapture)
326 {
327     UNIMPLEMENTED();
328 }
CaptureGetTexGeniv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,GLint * params,angle::ParamCapture * paramCapture)329 void CaptureGetTexGeniv_params(const State &glState,
330                                bool isCallValid,
331                                GLenum coord,
332                                GLenum pname,
333                                GLint *params,
334                                angle::ParamCapture *paramCapture)
335 {
336     UNIMPLEMENTED();
337 }
CaptureGetTexImage_pixels(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,GLenum format,GLenum type,void * pixels,angle::ParamCapture * paramCapture)338 void CaptureGetTexImage_pixels(const State &glState,
339                                bool isCallValid,
340                                TextureTarget targetPacked,
341                                GLint level,
342                                GLenum format,
343                                GLenum type,
344                                void *pixels,
345                                angle::ParamCapture *paramCapture)
346 {
347     UNIMPLEMENTED();
348 }
CaptureIndexdv_c(const State & glState,bool isCallValid,const GLdouble * c,angle::ParamCapture * paramCapture)349 void CaptureIndexdv_c(const State &glState,
350                       bool isCallValid,
351                       const GLdouble *c,
352                       angle::ParamCapture *paramCapture)
353 {
354     UNIMPLEMENTED();
355 }
CaptureIndexfv_c(const State & glState,bool isCallValid,const GLfloat * c,angle::ParamCapture * paramCapture)356 void CaptureIndexfv_c(const State &glState,
357                       bool isCallValid,
358                       const GLfloat *c,
359                       angle::ParamCapture *paramCapture)
360 {
361     UNIMPLEMENTED();
362 }
CaptureIndexiv_c(const State & glState,bool isCallValid,const GLint * c,angle::ParamCapture * paramCapture)363 void CaptureIndexiv_c(const State &glState,
364                       bool isCallValid,
365                       const GLint *c,
366                       angle::ParamCapture *paramCapture)
367 {
368     UNIMPLEMENTED();
369 }
CaptureIndexsv_c(const State & glState,bool isCallValid,const GLshort * c,angle::ParamCapture * paramCapture)370 void CaptureIndexsv_c(const State &glState,
371                       bool isCallValid,
372                       const GLshort *c,
373                       angle::ParamCapture *paramCapture)
374 {
375     UNIMPLEMENTED();
376 }
CaptureLightModeliv_params(const State & glState,bool isCallValid,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)377 void CaptureLightModeliv_params(const State &glState,
378                                 bool isCallValid,
379                                 GLenum pname,
380                                 const GLint *params,
381                                 angle::ParamCapture *paramCapture)
382 {
383     UNIMPLEMENTED();
384 }
CaptureLightiv_params(const State & glState,bool isCallValid,GLenum light,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)385 void CaptureLightiv_params(const State &glState,
386                            bool isCallValid,
387                            GLenum light,
388                            GLenum pname,
389                            const GLint *params,
390                            angle::ParamCapture *paramCapture)
391 {
392     UNIMPLEMENTED();
393 }
CaptureLoadMatrixd_m(const State & glState,bool isCallValid,const GLdouble * m,angle::ParamCapture * paramCapture)394 void CaptureLoadMatrixd_m(const State &glState,
395                           bool isCallValid,
396                           const GLdouble *m,
397                           angle::ParamCapture *paramCapture)
398 {
399     UNIMPLEMENTED();
400 }
CaptureMap1d_points(const State & glState,bool isCallValid,GLenum target,GLdouble u1,GLdouble u2,GLint stride,GLint order,const GLdouble * points,angle::ParamCapture * paramCapture)401 void CaptureMap1d_points(const State &glState,
402                          bool isCallValid,
403                          GLenum target,
404                          GLdouble u1,
405                          GLdouble u2,
406                          GLint stride,
407                          GLint order,
408                          const GLdouble *points,
409                          angle::ParamCapture *paramCapture)
410 {
411     UNIMPLEMENTED();
412 }
CaptureMap1f_points(const State & glState,bool isCallValid,GLenum target,GLfloat u1,GLfloat u2,GLint stride,GLint order,const GLfloat * points,angle::ParamCapture * paramCapture)413 void CaptureMap1f_points(const State &glState,
414                          bool isCallValid,
415                          GLenum target,
416                          GLfloat u1,
417                          GLfloat u2,
418                          GLint stride,
419                          GLint order,
420                          const GLfloat *points,
421                          angle::ParamCapture *paramCapture)
422 {
423     UNIMPLEMENTED();
424 }
CaptureMap2d_points(const State & glState,bool isCallValid,GLenum target,GLdouble u1,GLdouble u2,GLint ustride,GLint uorder,GLdouble v1,GLdouble v2,GLint vstride,GLint vorder,const GLdouble * points,angle::ParamCapture * paramCapture)425 void CaptureMap2d_points(const State &glState,
426                          bool isCallValid,
427                          GLenum target,
428                          GLdouble u1,
429                          GLdouble u2,
430                          GLint ustride,
431                          GLint uorder,
432                          GLdouble v1,
433                          GLdouble v2,
434                          GLint vstride,
435                          GLint vorder,
436                          const GLdouble *points,
437                          angle::ParamCapture *paramCapture)
438 {
439     UNIMPLEMENTED();
440 }
CaptureMap2f_points(const State & glState,bool isCallValid,GLenum target,GLfloat u1,GLfloat u2,GLint ustride,GLint uorder,GLfloat v1,GLfloat v2,GLint vstride,GLint vorder,const GLfloat * points,angle::ParamCapture * paramCapture)441 void CaptureMap2f_points(const State &glState,
442                          bool isCallValid,
443                          GLenum target,
444                          GLfloat u1,
445                          GLfloat u2,
446                          GLint ustride,
447                          GLint uorder,
448                          GLfloat v1,
449                          GLfloat v2,
450                          GLint vstride,
451                          GLint vorder,
452                          const GLfloat *points,
453                          angle::ParamCapture *paramCapture)
454 {
455     UNIMPLEMENTED();
456 }
CaptureMaterialiv_params(const State & glState,bool isCallValid,GLenum face,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)457 void CaptureMaterialiv_params(const State &glState,
458                               bool isCallValid,
459                               GLenum face,
460                               GLenum pname,
461                               const GLint *params,
462                               angle::ParamCapture *paramCapture)
463 {
464     UNIMPLEMENTED();
465 }
CaptureMultMatrixd_m(const State & glState,bool isCallValid,const GLdouble * m,angle::ParamCapture * paramCapture)466 void CaptureMultMatrixd_m(const State &glState,
467                           bool isCallValid,
468                           const GLdouble *m,
469                           angle::ParamCapture *paramCapture)
470 {
471     UNIMPLEMENTED();
472 }
CaptureNormal3bv_v(const State & glState,bool isCallValid,const GLbyte * v,angle::ParamCapture * paramCapture)473 void CaptureNormal3bv_v(const State &glState,
474                         bool isCallValid,
475                         const GLbyte *v,
476                         angle::ParamCapture *paramCapture)
477 {
478     UNIMPLEMENTED();
479 }
CaptureNormal3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)480 void CaptureNormal3dv_v(const State &glState,
481                         bool isCallValid,
482                         const GLdouble *v,
483                         angle::ParamCapture *paramCapture)
484 {
485     UNIMPLEMENTED();
486 }
CaptureNormal3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)487 void CaptureNormal3fv_v(const State &glState,
488                         bool isCallValid,
489                         const GLfloat *v,
490                         angle::ParamCapture *paramCapture)
491 {
492     UNIMPLEMENTED();
493 }
CaptureNormal3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)494 void CaptureNormal3iv_v(const State &glState,
495                         bool isCallValid,
496                         const GLint *v,
497                         angle::ParamCapture *paramCapture)
498 {
499     UNIMPLEMENTED();
500 }
CaptureNormal3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)501 void CaptureNormal3sv_v(const State &glState,
502                         bool isCallValid,
503                         const GLshort *v,
504                         angle::ParamCapture *paramCapture)
505 {
506     UNIMPLEMENTED();
507 }
CapturePixelMapfv_values(const State & glState,bool isCallValid,GLenum map,GLsizei mapsize,const GLfloat * values,angle::ParamCapture * paramCapture)508 void CapturePixelMapfv_values(const State &glState,
509                               bool isCallValid,
510                               GLenum map,
511                               GLsizei mapsize,
512                               const GLfloat *values,
513                               angle::ParamCapture *paramCapture)
514 {
515     UNIMPLEMENTED();
516 }
CapturePixelMapuiv_values(const State & glState,bool isCallValid,GLenum map,GLsizei mapsize,const GLuint * values,angle::ParamCapture * paramCapture)517 void CapturePixelMapuiv_values(const State &glState,
518                                bool isCallValid,
519                                GLenum map,
520                                GLsizei mapsize,
521                                const GLuint *values,
522                                angle::ParamCapture *paramCapture)
523 {
524     UNIMPLEMENTED();
525 }
CapturePixelMapusv_values(const State & glState,bool isCallValid,GLenum map,GLsizei mapsize,const GLushort * values,angle::ParamCapture * paramCapture)526 void CapturePixelMapusv_values(const State &glState,
527                                bool isCallValid,
528                                GLenum map,
529                                GLsizei mapsize,
530                                const GLushort *values,
531                                angle::ParamCapture *paramCapture)
532 {
533     UNIMPLEMENTED();
534 }
CapturePolygonStipple_mask(const State & glState,bool isCallValid,const GLubyte * mask,angle::ParamCapture * paramCapture)535 void CapturePolygonStipple_mask(const State &glState,
536                                 bool isCallValid,
537                                 const GLubyte *mask,
538                                 angle::ParamCapture *paramCapture)
539 {
540     UNIMPLEMENTED();
541 }
CaptureRasterPos2dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)542 void CaptureRasterPos2dv_v(const State &glState,
543                            bool isCallValid,
544                            const GLdouble *v,
545                            angle::ParamCapture *paramCapture)
546 {
547     UNIMPLEMENTED();
548 }
CaptureRasterPos2fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)549 void CaptureRasterPos2fv_v(const State &glState,
550                            bool isCallValid,
551                            const GLfloat *v,
552                            angle::ParamCapture *paramCapture)
553 {
554     UNIMPLEMENTED();
555 }
CaptureRasterPos2iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)556 void CaptureRasterPos2iv_v(const State &glState,
557                            bool isCallValid,
558                            const GLint *v,
559                            angle::ParamCapture *paramCapture)
560 {
561     UNIMPLEMENTED();
562 }
CaptureRasterPos2sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)563 void CaptureRasterPos2sv_v(const State &glState,
564                            bool isCallValid,
565                            const GLshort *v,
566                            angle::ParamCapture *paramCapture)
567 {
568     UNIMPLEMENTED();
569 }
CaptureRasterPos3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)570 void CaptureRasterPos3dv_v(const State &glState,
571                            bool isCallValid,
572                            const GLdouble *v,
573                            angle::ParamCapture *paramCapture)
574 {
575     UNIMPLEMENTED();
576 }
CaptureRasterPos3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)577 void CaptureRasterPos3fv_v(const State &glState,
578                            bool isCallValid,
579                            const GLfloat *v,
580                            angle::ParamCapture *paramCapture)
581 {
582     UNIMPLEMENTED();
583 }
CaptureRasterPos3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)584 void CaptureRasterPos3iv_v(const State &glState,
585                            bool isCallValid,
586                            const GLint *v,
587                            angle::ParamCapture *paramCapture)
588 {
589     UNIMPLEMENTED();
590 }
CaptureRasterPos3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)591 void CaptureRasterPos3sv_v(const State &glState,
592                            bool isCallValid,
593                            const GLshort *v,
594                            angle::ParamCapture *paramCapture)
595 {
596     UNIMPLEMENTED();
597 }
CaptureRasterPos4dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)598 void CaptureRasterPos4dv_v(const State &glState,
599                            bool isCallValid,
600                            const GLdouble *v,
601                            angle::ParamCapture *paramCapture)
602 {
603     UNIMPLEMENTED();
604 }
CaptureRasterPos4fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)605 void CaptureRasterPos4fv_v(const State &glState,
606                            bool isCallValid,
607                            const GLfloat *v,
608                            angle::ParamCapture *paramCapture)
609 {
610     UNIMPLEMENTED();
611 }
CaptureRasterPos4iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)612 void CaptureRasterPos4iv_v(const State &glState,
613                            bool isCallValid,
614                            const GLint *v,
615                            angle::ParamCapture *paramCapture)
616 {
617     UNIMPLEMENTED();
618 }
CaptureRasterPos4sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)619 void CaptureRasterPos4sv_v(const State &glState,
620                            bool isCallValid,
621                            const GLshort *v,
622                            angle::ParamCapture *paramCapture)
623 {
624     UNIMPLEMENTED();
625 }
CaptureRectdv_v1(const State & glState,bool isCallValid,const GLdouble * v1,const GLdouble * v2,angle::ParamCapture * paramCapture)626 void CaptureRectdv_v1(const State &glState,
627                       bool isCallValid,
628                       const GLdouble *v1,
629                       const GLdouble *v2,
630                       angle::ParamCapture *paramCapture)
631 {
632     UNIMPLEMENTED();
633 }
CaptureRectdv_v2(const State & glState,bool isCallValid,const GLdouble * v1,const GLdouble * v2,angle::ParamCapture * paramCapture)634 void CaptureRectdv_v2(const State &glState,
635                       bool isCallValid,
636                       const GLdouble *v1,
637                       const GLdouble *v2,
638                       angle::ParamCapture *paramCapture)
639 {
640     UNIMPLEMENTED();
641 }
CaptureRectfv_v1(const State & glState,bool isCallValid,const GLfloat * v1,const GLfloat * v2,angle::ParamCapture * paramCapture)642 void CaptureRectfv_v1(const State &glState,
643                       bool isCallValid,
644                       const GLfloat *v1,
645                       const GLfloat *v2,
646                       angle::ParamCapture *paramCapture)
647 {
648     UNIMPLEMENTED();
649 }
CaptureRectfv_v2(const State & glState,bool isCallValid,const GLfloat * v1,const GLfloat * v2,angle::ParamCapture * paramCapture)650 void CaptureRectfv_v2(const State &glState,
651                       bool isCallValid,
652                       const GLfloat *v1,
653                       const GLfloat *v2,
654                       angle::ParamCapture *paramCapture)
655 {
656     UNIMPLEMENTED();
657 }
CaptureRectiv_v1(const State & glState,bool isCallValid,const GLint * v1,const GLint * v2,angle::ParamCapture * paramCapture)658 void CaptureRectiv_v1(const State &glState,
659                       bool isCallValid,
660                       const GLint *v1,
661                       const GLint *v2,
662                       angle::ParamCapture *paramCapture)
663 {
664     UNIMPLEMENTED();
665 }
CaptureRectiv_v2(const State & glState,bool isCallValid,const GLint * v1,const GLint * v2,angle::ParamCapture * paramCapture)666 void CaptureRectiv_v2(const State &glState,
667                       bool isCallValid,
668                       const GLint *v1,
669                       const GLint *v2,
670                       angle::ParamCapture *paramCapture)
671 {
672     UNIMPLEMENTED();
673 }
CaptureRectsv_v1(const State & glState,bool isCallValid,const GLshort * v1,const GLshort * v2,angle::ParamCapture * paramCapture)674 void CaptureRectsv_v1(const State &glState,
675                       bool isCallValid,
676                       const GLshort *v1,
677                       const GLshort *v2,
678                       angle::ParamCapture *paramCapture)
679 {
680     UNIMPLEMENTED();
681 }
CaptureRectsv_v2(const State & glState,bool isCallValid,const GLshort * v1,const GLshort * v2,angle::ParamCapture * paramCapture)682 void CaptureRectsv_v2(const State &glState,
683                       bool isCallValid,
684                       const GLshort *v1,
685                       const GLshort *v2,
686                       angle::ParamCapture *paramCapture)
687 {
688     UNIMPLEMENTED();
689 }
CaptureSelectBuffer_buffer(const State & glState,bool isCallValid,GLsizei size,GLuint * buffer,angle::ParamCapture * paramCapture)690 void CaptureSelectBuffer_buffer(const State &glState,
691                                 bool isCallValid,
692                                 GLsizei size,
693                                 GLuint *buffer,
694                                 angle::ParamCapture *paramCapture)
695 {
696     UNIMPLEMENTED();
697 }
CaptureTexCoord1dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)698 void CaptureTexCoord1dv_v(const State &glState,
699                           bool isCallValid,
700                           const GLdouble *v,
701                           angle::ParamCapture *paramCapture)
702 {
703     UNIMPLEMENTED();
704 }
CaptureTexCoord1fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)705 void CaptureTexCoord1fv_v(const State &glState,
706                           bool isCallValid,
707                           const GLfloat *v,
708                           angle::ParamCapture *paramCapture)
709 {
710     UNIMPLEMENTED();
711 }
CaptureTexCoord1iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)712 void CaptureTexCoord1iv_v(const State &glState,
713                           bool isCallValid,
714                           const GLint *v,
715                           angle::ParamCapture *paramCapture)
716 {
717     UNIMPLEMENTED();
718 }
CaptureTexCoord1sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)719 void CaptureTexCoord1sv_v(const State &glState,
720                           bool isCallValid,
721                           const GLshort *v,
722                           angle::ParamCapture *paramCapture)
723 {
724     UNIMPLEMENTED();
725 }
CaptureTexCoord2dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)726 void CaptureTexCoord2dv_v(const State &glState,
727                           bool isCallValid,
728                           const GLdouble *v,
729                           angle::ParamCapture *paramCapture)
730 {
731     UNIMPLEMENTED();
732 }
CaptureTexCoord2fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)733 void CaptureTexCoord2fv_v(const State &glState,
734                           bool isCallValid,
735                           const GLfloat *v,
736                           angle::ParamCapture *paramCapture)
737 {
738     UNIMPLEMENTED();
739 }
CaptureTexCoord2iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)740 void CaptureTexCoord2iv_v(const State &glState,
741                           bool isCallValid,
742                           const GLint *v,
743                           angle::ParamCapture *paramCapture)
744 {
745     UNIMPLEMENTED();
746 }
CaptureTexCoord2sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)747 void CaptureTexCoord2sv_v(const State &glState,
748                           bool isCallValid,
749                           const GLshort *v,
750                           angle::ParamCapture *paramCapture)
751 {
752     UNIMPLEMENTED();
753 }
CaptureTexCoord3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)754 void CaptureTexCoord3dv_v(const State &glState,
755                           bool isCallValid,
756                           const GLdouble *v,
757                           angle::ParamCapture *paramCapture)
758 {
759     UNIMPLEMENTED();
760 }
CaptureTexCoord3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)761 void CaptureTexCoord3fv_v(const State &glState,
762                           bool isCallValid,
763                           const GLfloat *v,
764                           angle::ParamCapture *paramCapture)
765 {
766     UNIMPLEMENTED();
767 }
CaptureTexCoord3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)768 void CaptureTexCoord3iv_v(const State &glState,
769                           bool isCallValid,
770                           const GLint *v,
771                           angle::ParamCapture *paramCapture)
772 {
773     UNIMPLEMENTED();
774 }
CaptureTexCoord3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)775 void CaptureTexCoord3sv_v(const State &glState,
776                           bool isCallValid,
777                           const GLshort *v,
778                           angle::ParamCapture *paramCapture)
779 {
780     UNIMPLEMENTED();
781 }
CaptureTexCoord4dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)782 void CaptureTexCoord4dv_v(const State &glState,
783                           bool isCallValid,
784                           const GLdouble *v,
785                           angle::ParamCapture *paramCapture)
786 {
787     UNIMPLEMENTED();
788 }
CaptureTexCoord4fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)789 void CaptureTexCoord4fv_v(const State &glState,
790                           bool isCallValid,
791                           const GLfloat *v,
792                           angle::ParamCapture *paramCapture)
793 {
794     UNIMPLEMENTED();
795 }
CaptureTexCoord4iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)796 void CaptureTexCoord4iv_v(const State &glState,
797                           bool isCallValid,
798                           const GLint *v,
799                           angle::ParamCapture *paramCapture)
800 {
801     UNIMPLEMENTED();
802 }
CaptureTexCoord4sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)803 void CaptureTexCoord4sv_v(const State &glState,
804                           bool isCallValid,
805                           const GLshort *v,
806                           angle::ParamCapture *paramCapture)
807 {
808     UNIMPLEMENTED();
809 }
CaptureTexGendv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLdouble * params,angle::ParamCapture * paramCapture)810 void CaptureTexGendv_params(const State &glState,
811                             bool isCallValid,
812                             GLenum coord,
813                             GLenum pname,
814                             const GLdouble *params,
815                             angle::ParamCapture *paramCapture)
816 {
817     UNIMPLEMENTED();
818 }
CaptureTexGenfv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLfloat * params,angle::ParamCapture * paramCapture)819 void CaptureTexGenfv_params(const State &glState,
820                             bool isCallValid,
821                             GLenum coord,
822                             GLenum pname,
823                             const GLfloat *params,
824                             angle::ParamCapture *paramCapture)
825 {
826     UNIMPLEMENTED();
827 }
CaptureTexGeniv_params(const State & glState,bool isCallValid,GLenum coord,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)828 void CaptureTexGeniv_params(const State &glState,
829                             bool isCallValid,
830                             GLenum coord,
831                             GLenum pname,
832                             const GLint *params,
833                             angle::ParamCapture *paramCapture)
834 {
835     UNIMPLEMENTED();
836 }
CaptureTexImage1D_pixels(const State & glState,bool isCallValid,GLenum target,GLint level,GLint internalformat,GLsizei width,GLint border,GLenum format,GLenum type,const void * pixels,angle::ParamCapture * paramCapture)837 void CaptureTexImage1D_pixels(const State &glState,
838                               bool isCallValid,
839                               GLenum target,
840                               GLint level,
841                               GLint internalformat,
842                               GLsizei width,
843                               GLint border,
844                               GLenum format,
845                               GLenum type,
846                               const void *pixels,
847                               angle::ParamCapture *paramCapture)
848 {
849     UNIMPLEMENTED();
850 }
CaptureVertex2dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)851 void CaptureVertex2dv_v(const State &glState,
852                         bool isCallValid,
853                         const GLdouble *v,
854                         angle::ParamCapture *paramCapture)
855 {
856     UNIMPLEMENTED();
857 }
CaptureVertex2fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)858 void CaptureVertex2fv_v(const State &glState,
859                         bool isCallValid,
860                         const GLfloat *v,
861                         angle::ParamCapture *paramCapture)
862 {
863     UNIMPLEMENTED();
864 }
CaptureVertex2iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)865 void CaptureVertex2iv_v(const State &glState,
866                         bool isCallValid,
867                         const GLint *v,
868                         angle::ParamCapture *paramCapture)
869 {
870     UNIMPLEMENTED();
871 }
CaptureVertex2sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)872 void CaptureVertex2sv_v(const State &glState,
873                         bool isCallValid,
874                         const GLshort *v,
875                         angle::ParamCapture *paramCapture)
876 {
877     UNIMPLEMENTED();
878 }
CaptureVertex3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)879 void CaptureVertex3dv_v(const State &glState,
880                         bool isCallValid,
881                         const GLdouble *v,
882                         angle::ParamCapture *paramCapture)
883 {
884     UNIMPLEMENTED();
885 }
CaptureVertex3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)886 void CaptureVertex3fv_v(const State &glState,
887                         bool isCallValid,
888                         const GLfloat *v,
889                         angle::ParamCapture *paramCapture)
890 {
891     UNIMPLEMENTED();
892 }
CaptureVertex3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)893 void CaptureVertex3iv_v(const State &glState,
894                         bool isCallValid,
895                         const GLint *v,
896                         angle::ParamCapture *paramCapture)
897 {
898     UNIMPLEMENTED();
899 }
CaptureVertex3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)900 void CaptureVertex3sv_v(const State &glState,
901                         bool isCallValid,
902                         const GLshort *v,
903                         angle::ParamCapture *paramCapture)
904 {
905     UNIMPLEMENTED();
906 }
CaptureVertex4dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)907 void CaptureVertex4dv_v(const State &glState,
908                         bool isCallValid,
909                         const GLdouble *v,
910                         angle::ParamCapture *paramCapture)
911 {
912     UNIMPLEMENTED();
913 }
CaptureVertex4fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)914 void CaptureVertex4fv_v(const State &glState,
915                         bool isCallValid,
916                         const GLfloat *v,
917                         angle::ParamCapture *paramCapture)
918 {
919     UNIMPLEMENTED();
920 }
CaptureVertex4iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)921 void CaptureVertex4iv_v(const State &glState,
922                         bool isCallValid,
923                         const GLint *v,
924                         angle::ParamCapture *paramCapture)
925 {
926     UNIMPLEMENTED();
927 }
CaptureVertex4sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)928 void CaptureVertex4sv_v(const State &glState,
929                         bool isCallValid,
930                         const GLshort *v,
931                         angle::ParamCapture *paramCapture)
932 {
933     UNIMPLEMENTED();
934 }
935 
936 // GL 1.1
CaptureAreTexturesResident_textures(const State & glState,bool isCallValid,GLsizei n,const GLuint * textures,GLboolean * residences,angle::ParamCapture * paramCapture)937 void CaptureAreTexturesResident_textures(const State &glState,
938                                          bool isCallValid,
939                                          GLsizei n,
940                                          const GLuint *textures,
941                                          GLboolean *residences,
942                                          angle::ParamCapture *paramCapture)
943 {
944     UNIMPLEMENTED();
945 }
CaptureAreTexturesResident_residences(const State & glState,bool isCallValid,GLsizei n,const GLuint * textures,GLboolean * residences,angle::ParamCapture * paramCapture)946 void CaptureAreTexturesResident_residences(const State &glState,
947                                            bool isCallValid,
948                                            GLsizei n,
949                                            const GLuint *textures,
950                                            GLboolean *residences,
951                                            angle::ParamCapture *paramCapture)
952 {
953     UNIMPLEMENTED();
954 }
CaptureEdgeFlagPointer_pointer(const State & glState,bool isCallValid,GLsizei stride,const void * pointer,angle::ParamCapture * paramCapture)955 void CaptureEdgeFlagPointer_pointer(const State &glState,
956                                     bool isCallValid,
957                                     GLsizei stride,
958                                     const void *pointer,
959                                     angle::ParamCapture *paramCapture)
960 {
961     UNIMPLEMENTED();
962 }
CaptureIndexPointer_pointer(const State & glState,bool isCallValid,GLenum type,GLsizei stride,const void * pointer,angle::ParamCapture * paramCapture)963 void CaptureIndexPointer_pointer(const State &glState,
964                                  bool isCallValid,
965                                  GLenum type,
966                                  GLsizei stride,
967                                  const void *pointer,
968                                  angle::ParamCapture *paramCapture)
969 {
970     UNIMPLEMENTED();
971 }
CaptureIndexubv_c(const State & glState,bool isCallValid,const GLubyte * c,angle::ParamCapture * paramCapture)972 void CaptureIndexubv_c(const State &glState,
973                        bool isCallValid,
974                        const GLubyte *c,
975                        angle::ParamCapture *paramCapture)
976 {
977     UNIMPLEMENTED();
978 }
CaptureInterleavedArrays_pointer(const State & glState,bool isCallValid,GLenum format,GLsizei stride,const void * pointer,angle::ParamCapture * paramCapture)979 void CaptureInterleavedArrays_pointer(const State &glState,
980                                       bool isCallValid,
981                                       GLenum format,
982                                       GLsizei stride,
983                                       const void *pointer,
984                                       angle::ParamCapture *paramCapture)
985 {
986     UNIMPLEMENTED();
987 }
CapturePrioritizeTextures_textures(const State & glState,bool isCallValid,GLsizei n,const GLuint * textures,const GLfloat * priorities,angle::ParamCapture * paramCapture)988 void CapturePrioritizeTextures_textures(const State &glState,
989                                         bool isCallValid,
990                                         GLsizei n,
991                                         const GLuint *textures,
992                                         const GLfloat *priorities,
993                                         angle::ParamCapture *paramCapture)
994 {
995     UNIMPLEMENTED();
996 }
CapturePrioritizeTextures_priorities(const State & glState,bool isCallValid,GLsizei n,const GLuint * textures,const GLfloat * priorities,angle::ParamCapture * paramCapture)997 void CapturePrioritizeTextures_priorities(const State &glState,
998                                           bool isCallValid,
999                                           GLsizei n,
1000                                           const GLuint *textures,
1001                                           const GLfloat *priorities,
1002                                           angle::ParamCapture *paramCapture)
1003 {
1004     UNIMPLEMENTED();
1005 }
CaptureTexSubImage1D_pixels(const State & glState,bool isCallValid,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLenum type,const void * pixels,angle::ParamCapture * paramCapture)1006 void CaptureTexSubImage1D_pixels(const State &glState,
1007                                  bool isCallValid,
1008                                  GLenum target,
1009                                  GLint level,
1010                                  GLint xoffset,
1011                                  GLsizei width,
1012                                  GLenum format,
1013                                  GLenum type,
1014                                  const void *pixels,
1015                                  angle::ParamCapture *paramCapture)
1016 {
1017     UNIMPLEMENTED();
1018 }
1019 
1020 // GL 1.2
CaptureCompressedTexImage1D_data(const State & glState,bool isCallValid,GLenum target,GLint level,GLenum internalformat,GLsizei width,GLint border,GLsizei imageSize,const void * data,angle::ParamCapture * paramCapture)1021 void CaptureCompressedTexImage1D_data(const State &glState,
1022                                       bool isCallValid,
1023                                       GLenum target,
1024                                       GLint level,
1025                                       GLenum internalformat,
1026                                       GLsizei width,
1027                                       GLint border,
1028                                       GLsizei imageSize,
1029                                       const void *data,
1030                                       angle::ParamCapture *paramCapture)
1031 {
1032     UNIMPLEMENTED();
1033 }
CaptureCompressedTexSubImage1D_data(const State & glState,bool isCallValid,GLenum target,GLint level,GLint xoffset,GLsizei width,GLenum format,GLsizei imageSize,const void * data,angle::ParamCapture * paramCapture)1034 void CaptureCompressedTexSubImage1D_data(const State &glState,
1035                                          bool isCallValid,
1036                                          GLenum target,
1037                                          GLint level,
1038                                          GLint xoffset,
1039                                          GLsizei width,
1040                                          GLenum format,
1041                                          GLsizei imageSize,
1042                                          const void *data,
1043                                          angle::ParamCapture *paramCapture)
1044 {
1045     UNIMPLEMENTED();
1046 }
CaptureGetCompressedTexImage_img(const State & glState,bool isCallValid,TextureTarget targetPacked,GLint level,void * img,angle::ParamCapture * paramCapture)1047 void CaptureGetCompressedTexImage_img(const State &glState,
1048                                       bool isCallValid,
1049                                       TextureTarget targetPacked,
1050                                       GLint level,
1051                                       void *img,
1052                                       angle::ParamCapture *paramCapture)
1053 {
1054     UNIMPLEMENTED();
1055 }
CaptureLoadTransposeMatrixd_m(const State & glState,bool isCallValid,const GLdouble * m,angle::ParamCapture * paramCapture)1056 void CaptureLoadTransposeMatrixd_m(const State &glState,
1057                                    bool isCallValid,
1058                                    const GLdouble *m,
1059                                    angle::ParamCapture *paramCapture)
1060 {
1061     UNIMPLEMENTED();
1062 }
CaptureLoadTransposeMatrixf_m(const State & glState,bool isCallValid,const GLfloat * m,angle::ParamCapture * paramCapture)1063 void CaptureLoadTransposeMatrixf_m(const State &glState,
1064                                    bool isCallValid,
1065                                    const GLfloat *m,
1066                                    angle::ParamCapture *paramCapture)
1067 {
1068     UNIMPLEMENTED();
1069 }
CaptureMultTransposeMatrixd_m(const State & glState,bool isCallValid,const GLdouble * m,angle::ParamCapture * paramCapture)1070 void CaptureMultTransposeMatrixd_m(const State &glState,
1071                                    bool isCallValid,
1072                                    const GLdouble *m,
1073                                    angle::ParamCapture *paramCapture)
1074 {
1075     UNIMPLEMENTED();
1076 }
CaptureMultTransposeMatrixf_m(const State & glState,bool isCallValid,const GLfloat * m,angle::ParamCapture * paramCapture)1077 void CaptureMultTransposeMatrixf_m(const State &glState,
1078                                    bool isCallValid,
1079                                    const GLfloat *m,
1080                                    angle::ParamCapture *paramCapture)
1081 {
1082     UNIMPLEMENTED();
1083 }
CaptureMultiTexCoord1dv_v(const State & glState,bool isCallValid,GLenum target,const GLdouble * v,angle::ParamCapture * paramCapture)1084 void CaptureMultiTexCoord1dv_v(const State &glState,
1085                                bool isCallValid,
1086                                GLenum target,
1087                                const GLdouble *v,
1088                                angle::ParamCapture *paramCapture)
1089 {
1090     UNIMPLEMENTED();
1091 }
CaptureMultiTexCoord1fv_v(const State & glState,bool isCallValid,GLenum target,const GLfloat * v,angle::ParamCapture * paramCapture)1092 void CaptureMultiTexCoord1fv_v(const State &glState,
1093                                bool isCallValid,
1094                                GLenum target,
1095                                const GLfloat *v,
1096                                angle::ParamCapture *paramCapture)
1097 {
1098     UNIMPLEMENTED();
1099 }
CaptureMultiTexCoord1iv_v(const State & glState,bool isCallValid,GLenum target,const GLint * v,angle::ParamCapture * paramCapture)1100 void CaptureMultiTexCoord1iv_v(const State &glState,
1101                                bool isCallValid,
1102                                GLenum target,
1103                                const GLint *v,
1104                                angle::ParamCapture *paramCapture)
1105 {
1106     UNIMPLEMENTED();
1107 }
CaptureMultiTexCoord1sv_v(const State & glState,bool isCallValid,GLenum target,const GLshort * v,angle::ParamCapture * paramCapture)1108 void CaptureMultiTexCoord1sv_v(const State &glState,
1109                                bool isCallValid,
1110                                GLenum target,
1111                                const GLshort *v,
1112                                angle::ParamCapture *paramCapture)
1113 {
1114     UNIMPLEMENTED();
1115 }
CaptureMultiTexCoord2dv_v(const State & glState,bool isCallValid,GLenum target,const GLdouble * v,angle::ParamCapture * paramCapture)1116 void CaptureMultiTexCoord2dv_v(const State &glState,
1117                                bool isCallValid,
1118                                GLenum target,
1119                                const GLdouble *v,
1120                                angle::ParamCapture *paramCapture)
1121 {
1122     UNIMPLEMENTED();
1123 }
CaptureMultiTexCoord2fv_v(const State & glState,bool isCallValid,GLenum target,const GLfloat * v,angle::ParamCapture * paramCapture)1124 void CaptureMultiTexCoord2fv_v(const State &glState,
1125                                bool isCallValid,
1126                                GLenum target,
1127                                const GLfloat *v,
1128                                angle::ParamCapture *paramCapture)
1129 {
1130     UNIMPLEMENTED();
1131 }
CaptureMultiTexCoord2iv_v(const State & glState,bool isCallValid,GLenum target,const GLint * v,angle::ParamCapture * paramCapture)1132 void CaptureMultiTexCoord2iv_v(const State &glState,
1133                                bool isCallValid,
1134                                GLenum target,
1135                                const GLint *v,
1136                                angle::ParamCapture *paramCapture)
1137 {
1138     UNIMPLEMENTED();
1139 }
CaptureMultiTexCoord2sv_v(const State & glState,bool isCallValid,GLenum target,const GLshort * v,angle::ParamCapture * paramCapture)1140 void CaptureMultiTexCoord2sv_v(const State &glState,
1141                                bool isCallValid,
1142                                GLenum target,
1143                                const GLshort *v,
1144                                angle::ParamCapture *paramCapture)
1145 {
1146     UNIMPLEMENTED();
1147 }
CaptureMultiTexCoord3dv_v(const State & glState,bool isCallValid,GLenum target,const GLdouble * v,angle::ParamCapture * paramCapture)1148 void CaptureMultiTexCoord3dv_v(const State &glState,
1149                                bool isCallValid,
1150                                GLenum target,
1151                                const GLdouble *v,
1152                                angle::ParamCapture *paramCapture)
1153 {
1154     UNIMPLEMENTED();
1155 }
CaptureMultiTexCoord3fv_v(const State & glState,bool isCallValid,GLenum target,const GLfloat * v,angle::ParamCapture * paramCapture)1156 void CaptureMultiTexCoord3fv_v(const State &glState,
1157                                bool isCallValid,
1158                                GLenum target,
1159                                const GLfloat *v,
1160                                angle::ParamCapture *paramCapture)
1161 {
1162     UNIMPLEMENTED();
1163 }
CaptureMultiTexCoord3iv_v(const State & glState,bool isCallValid,GLenum target,const GLint * v,angle::ParamCapture * paramCapture)1164 void CaptureMultiTexCoord3iv_v(const State &glState,
1165                                bool isCallValid,
1166                                GLenum target,
1167                                const GLint *v,
1168                                angle::ParamCapture *paramCapture)
1169 {
1170     UNIMPLEMENTED();
1171 }
CaptureMultiTexCoord3sv_v(const State & glState,bool isCallValid,GLenum target,const GLshort * v,angle::ParamCapture * paramCapture)1172 void CaptureMultiTexCoord3sv_v(const State &glState,
1173                                bool isCallValid,
1174                                GLenum target,
1175                                const GLshort *v,
1176                                angle::ParamCapture *paramCapture)
1177 {
1178     UNIMPLEMENTED();
1179 }
CaptureMultiTexCoord4dv_v(const State & glState,bool isCallValid,GLenum target,const GLdouble * v,angle::ParamCapture * paramCapture)1180 void CaptureMultiTexCoord4dv_v(const State &glState,
1181                                bool isCallValid,
1182                                GLenum target,
1183                                const GLdouble *v,
1184                                angle::ParamCapture *paramCapture)
1185 {
1186     UNIMPLEMENTED();
1187 }
CaptureMultiTexCoord4fv_v(const State & glState,bool isCallValid,GLenum target,const GLfloat * v,angle::ParamCapture * paramCapture)1188 void CaptureMultiTexCoord4fv_v(const State &glState,
1189                                bool isCallValid,
1190                                GLenum target,
1191                                const GLfloat *v,
1192                                angle::ParamCapture *paramCapture)
1193 {
1194     UNIMPLEMENTED();
1195 }
CaptureMultiTexCoord4iv_v(const State & glState,bool isCallValid,GLenum target,const GLint * v,angle::ParamCapture * paramCapture)1196 void CaptureMultiTexCoord4iv_v(const State &glState,
1197                                bool isCallValid,
1198                                GLenum target,
1199                                const GLint *v,
1200                                angle::ParamCapture *paramCapture)
1201 {
1202     UNIMPLEMENTED();
1203 }
CaptureMultiTexCoord4sv_v(const State & glState,bool isCallValid,GLenum target,const GLshort * v,angle::ParamCapture * paramCapture)1204 void CaptureMultiTexCoord4sv_v(const State &glState,
1205                                bool isCallValid,
1206                                GLenum target,
1207                                const GLshort *v,
1208                                angle::ParamCapture *paramCapture)
1209 {
1210     UNIMPLEMENTED();
1211 }
1212 
1213 // GL 1.3
CaptureFogCoordPointer_pointer(const State & glState,bool isCallValid,GLenum type,GLsizei stride,const void * pointer,angle::ParamCapture * paramCapture)1214 void CaptureFogCoordPointer_pointer(const State &glState,
1215                                     bool isCallValid,
1216                                     GLenum type,
1217                                     GLsizei stride,
1218                                     const void *pointer,
1219                                     angle::ParamCapture *paramCapture)
1220 {
1221     UNIMPLEMENTED();
1222 }
CaptureFogCoorddv_coord(const State & glState,bool isCallValid,const GLdouble * coord,angle::ParamCapture * paramCapture)1223 void CaptureFogCoorddv_coord(const State &glState,
1224                              bool isCallValid,
1225                              const GLdouble *coord,
1226                              angle::ParamCapture *paramCapture)
1227 {
1228     UNIMPLEMENTED();
1229 }
CaptureFogCoordfv_coord(const State & glState,bool isCallValid,const GLfloat * coord,angle::ParamCapture * paramCapture)1230 void CaptureFogCoordfv_coord(const State &glState,
1231                              bool isCallValid,
1232                              const GLfloat *coord,
1233                              angle::ParamCapture *paramCapture)
1234 {
1235     UNIMPLEMENTED();
1236 }
CaptureMultiDrawArrays_first(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * first,const GLsizei * count,GLsizei drawcount,angle::ParamCapture * paramCapture)1237 void CaptureMultiDrawArrays_first(const State &glState,
1238                                   bool isCallValid,
1239                                   PrimitiveMode modePacked,
1240                                   const GLint *first,
1241                                   const GLsizei *count,
1242                                   GLsizei drawcount,
1243                                   angle::ParamCapture *paramCapture)
1244 {
1245     UNIMPLEMENTED();
1246 }
CaptureMultiDrawArrays_count(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLint * first,const GLsizei * count,GLsizei drawcount,angle::ParamCapture * paramCapture)1247 void CaptureMultiDrawArrays_count(const State &glState,
1248                                   bool isCallValid,
1249                                   PrimitiveMode modePacked,
1250                                   const GLint *first,
1251                                   const GLsizei *count,
1252                                   GLsizei drawcount,
1253                                   angle::ParamCapture *paramCapture)
1254 {
1255     UNIMPLEMENTED();
1256 }
CaptureMultiDrawElements_count(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount,angle::ParamCapture * paramCapture)1257 void CaptureMultiDrawElements_count(const State &glState,
1258                                     bool isCallValid,
1259                                     PrimitiveMode modePacked,
1260                                     const GLsizei *count,
1261                                     DrawElementsType typePacked,
1262                                     const void *const *indices,
1263                                     GLsizei drawcount,
1264                                     angle::ParamCapture *paramCapture)
1265 {
1266     UNIMPLEMENTED();
1267 }
CaptureMultiDrawElements_indices(const State & glState,bool isCallValid,PrimitiveMode modePacked,const GLsizei * count,DrawElementsType typePacked,const void * const * indices,GLsizei drawcount,angle::ParamCapture * paramCapture)1268 void CaptureMultiDrawElements_indices(const State &glState,
1269                                       bool isCallValid,
1270                                       PrimitiveMode modePacked,
1271                                       const GLsizei *count,
1272                                       DrawElementsType typePacked,
1273                                       const void *const *indices,
1274                                       GLsizei drawcount,
1275                                       angle::ParamCapture *paramCapture)
1276 {
1277     UNIMPLEMENTED();
1278 }
CapturePointParameteriv_params(const State & glState,bool isCallValid,GLenum pname,const GLint * params,angle::ParamCapture * paramCapture)1279 void CapturePointParameteriv_params(const State &glState,
1280                                     bool isCallValid,
1281                                     GLenum pname,
1282                                     const GLint *params,
1283                                     angle::ParamCapture *paramCapture)
1284 {
1285     UNIMPLEMENTED();
1286 }
CaptureSecondaryColor3bv_v(const State & glState,bool isCallValid,const GLbyte * v,angle::ParamCapture * paramCapture)1287 void CaptureSecondaryColor3bv_v(const State &glState,
1288                                 bool isCallValid,
1289                                 const GLbyte *v,
1290                                 angle::ParamCapture *paramCapture)
1291 {
1292     UNIMPLEMENTED();
1293 }
CaptureSecondaryColor3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)1294 void CaptureSecondaryColor3dv_v(const State &glState,
1295                                 bool isCallValid,
1296                                 const GLdouble *v,
1297                                 angle::ParamCapture *paramCapture)
1298 {
1299     UNIMPLEMENTED();
1300 }
CaptureSecondaryColor3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)1301 void CaptureSecondaryColor3fv_v(const State &glState,
1302                                 bool isCallValid,
1303                                 const GLfloat *v,
1304                                 angle::ParamCapture *paramCapture)
1305 {
1306     UNIMPLEMENTED();
1307 }
CaptureSecondaryColor3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)1308 void CaptureSecondaryColor3iv_v(const State &glState,
1309                                 bool isCallValid,
1310                                 const GLint *v,
1311                                 angle::ParamCapture *paramCapture)
1312 {
1313     UNIMPLEMENTED();
1314 }
CaptureSecondaryColor3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)1315 void CaptureSecondaryColor3sv_v(const State &glState,
1316                                 bool isCallValid,
1317                                 const GLshort *v,
1318                                 angle::ParamCapture *paramCapture)
1319 {
1320     UNIMPLEMENTED();
1321 }
CaptureSecondaryColor3ubv_v(const State & glState,bool isCallValid,const GLubyte * v,angle::ParamCapture * paramCapture)1322 void CaptureSecondaryColor3ubv_v(const State &glState,
1323                                  bool isCallValid,
1324                                  const GLubyte *v,
1325                                  angle::ParamCapture *paramCapture)
1326 {
1327     UNIMPLEMENTED();
1328 }
CaptureSecondaryColor3uiv_v(const State & glState,bool isCallValid,const GLuint * v,angle::ParamCapture * paramCapture)1329 void CaptureSecondaryColor3uiv_v(const State &glState,
1330                                  bool isCallValid,
1331                                  const GLuint *v,
1332                                  angle::ParamCapture *paramCapture)
1333 {
1334     UNIMPLEMENTED();
1335 }
CaptureSecondaryColor3usv_v(const State & glState,bool isCallValid,const GLushort * v,angle::ParamCapture * paramCapture)1336 void CaptureSecondaryColor3usv_v(const State &glState,
1337                                  bool isCallValid,
1338                                  const GLushort *v,
1339                                  angle::ParamCapture *paramCapture)
1340 {
1341     UNIMPLEMENTED();
1342 }
CaptureSecondaryColorPointer_pointer(const State & glState,bool isCallValid,GLint size,GLenum type,GLsizei stride,const void * pointer,angle::ParamCapture * paramCapture)1343 void CaptureSecondaryColorPointer_pointer(const State &glState,
1344                                           bool isCallValid,
1345                                           GLint size,
1346                                           GLenum type,
1347                                           GLsizei stride,
1348                                           const void *pointer,
1349                                           angle::ParamCapture *paramCapture)
1350 {
1351     UNIMPLEMENTED();
1352 }
CaptureWindowPos2dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)1353 void CaptureWindowPos2dv_v(const State &glState,
1354                            bool isCallValid,
1355                            const GLdouble *v,
1356                            angle::ParamCapture *paramCapture)
1357 {
1358     UNIMPLEMENTED();
1359 }
CaptureWindowPos2fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)1360 void CaptureWindowPos2fv_v(const State &glState,
1361                            bool isCallValid,
1362                            const GLfloat *v,
1363                            angle::ParamCapture *paramCapture)
1364 {
1365     UNIMPLEMENTED();
1366 }
CaptureWindowPos2iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)1367 void CaptureWindowPos2iv_v(const State &glState,
1368                            bool isCallValid,
1369                            const GLint *v,
1370                            angle::ParamCapture *paramCapture)
1371 {
1372     UNIMPLEMENTED();
1373 }
CaptureWindowPos2sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)1374 void CaptureWindowPos2sv_v(const State &glState,
1375                            bool isCallValid,
1376                            const GLshort *v,
1377                            angle::ParamCapture *paramCapture)
1378 {
1379     UNIMPLEMENTED();
1380 }
CaptureWindowPos3dv_v(const State & glState,bool isCallValid,const GLdouble * v,angle::ParamCapture * paramCapture)1381 void CaptureWindowPos3dv_v(const State &glState,
1382                            bool isCallValid,
1383                            const GLdouble *v,
1384                            angle::ParamCapture *paramCapture)
1385 {
1386     UNIMPLEMENTED();
1387 }
CaptureWindowPos3fv_v(const State & glState,bool isCallValid,const GLfloat * v,angle::ParamCapture * paramCapture)1388 void CaptureWindowPos3fv_v(const State &glState,
1389                            bool isCallValid,
1390                            const GLfloat *v,
1391                            angle::ParamCapture *paramCapture)
1392 {
1393     UNIMPLEMENTED();
1394 }
CaptureWindowPos3iv_v(const State & glState,bool isCallValid,const GLint * v,angle::ParamCapture * paramCapture)1395 void CaptureWindowPos3iv_v(const State &glState,
1396                            bool isCallValid,
1397                            const GLint *v,
1398                            angle::ParamCapture *paramCapture)
1399 {
1400     UNIMPLEMENTED();
1401 }
CaptureWindowPos3sv_v(const State & glState,bool isCallValid,const GLshort * v,angle::ParamCapture * paramCapture)1402 void CaptureWindowPos3sv_v(const State &glState,
1403                            bool isCallValid,
1404                            const GLshort *v,
1405                            angle::ParamCapture *paramCapture)
1406 {
1407     UNIMPLEMENTED();
1408 }
1409 
1410 // GL 1.4
CaptureGetBufferSubData_data(const State & glState,bool isCallValid,GLenum target,GLintptr offset,GLsizeiptr size,void * data,angle::ParamCapture * paramCapture)1411 void CaptureGetBufferSubData_data(const State &glState,
1412                                   bool isCallValid,
1413                                   GLenum target,
1414                                   GLintptr offset,
1415                                   GLsizeiptr size,
1416                                   void *data,
1417                                   angle::ParamCapture *paramCapture)
1418 {
1419     UNIMPLEMENTED();
1420 }
CaptureGetQueryObjectiv_params(const State & glState,bool isCallValid,QueryID idPacked,GLenum pname,GLint * params,angle::ParamCapture * paramCapture)1421 void CaptureGetQueryObjectiv_params(const State &glState,
1422                                     bool isCallValid,
1423                                     QueryID idPacked,
1424                                     GLenum pname,
1425                                     GLint *params,
1426                                     angle::ParamCapture *paramCapture)
1427 {
1428     UNIMPLEMENTED();
1429 }
1430 }  // namespace gl
1431