1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // capture_gles_1_0_autogen.h:
9 //   Capture functions for the OpenGL ES 1.0 entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
13 
14 #include "common/PackedEnums.h"
15 #include "libANGLE/capture/FrameCapture.h"
16 
17 namespace gl
18 {
19 
20 // Method Captures
21 
22 angle::CallCapture CaptureAlphaFunc(const State &glState,
23                                     bool isCallValid,
24                                     AlphaTestFunc funcPacked,
25                                     GLfloat ref);
26 angle::CallCapture CaptureAlphaFuncx(const State &glState,
27                                      bool isCallValid,
28                                      AlphaTestFunc funcPacked,
29                                      GLfixed ref);
30 angle::CallCapture CaptureClearColorx(const State &glState,
31                                       bool isCallValid,
32                                       GLfixed red,
33                                       GLfixed green,
34                                       GLfixed blue,
35                                       GLfixed alpha);
36 angle::CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth);
37 angle::CallCapture CaptureClientActiveTexture(const State &glState,
38                                               bool isCallValid,
39                                               GLenum texture);
40 angle::CallCapture CaptureClipPlanef(const State &glState,
41                                      bool isCallValid,
42                                      GLenum p,
43                                      const GLfloat *eqn);
44 angle::CallCapture CaptureClipPlanex(const State &glState,
45                                      bool isCallValid,
46                                      GLenum plane,
47                                      const GLfixed *equation);
48 angle::CallCapture CaptureColor4f(const State &glState,
49                                   bool isCallValid,
50                                   GLfloat red,
51                                   GLfloat green,
52                                   GLfloat blue,
53                                   GLfloat alpha);
54 angle::CallCapture CaptureColor4ub(const State &glState,
55                                    bool isCallValid,
56                                    GLubyte red,
57                                    GLubyte green,
58                                    GLubyte blue,
59                                    GLubyte alpha);
60 angle::CallCapture CaptureColor4x(const State &glState,
61                                   bool isCallValid,
62                                   GLfixed red,
63                                   GLfixed green,
64                                   GLfixed blue,
65                                   GLfixed alpha);
66 angle::CallCapture CaptureColorPointer(const State &glState,
67                                        bool isCallValid,
68                                        GLint size,
69                                        VertexAttribType typePacked,
70                                        GLsizei stride,
71                                        const void *pointer);
72 angle::CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f);
73 angle::CallCapture CaptureDisableClientState(const State &glState,
74                                              bool isCallValid,
75                                              ClientVertexArrayType arrayPacked);
76 angle::CallCapture CaptureEnableClientState(const State &glState,
77                                             bool isCallValid,
78                                             ClientVertexArrayType arrayPacked);
79 angle::CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param);
80 angle::CallCapture CaptureFogfv(const State &glState,
81                                 bool isCallValid,
82                                 GLenum pname,
83                                 const GLfloat *params);
84 angle::CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param);
85 angle::CallCapture CaptureFogxv(const State &glState,
86                                 bool isCallValid,
87                                 GLenum pname,
88                                 const GLfixed *param);
89 angle::CallCapture CaptureFrustumf(const State &glState,
90                                    bool isCallValid,
91                                    GLfloat l,
92                                    GLfloat r,
93                                    GLfloat b,
94                                    GLfloat t,
95                                    GLfloat n,
96                                    GLfloat f);
97 angle::CallCapture CaptureFrustumx(const State &glState,
98                                    bool isCallValid,
99                                    GLfixed l,
100                                    GLfixed r,
101                                    GLfixed b,
102                                    GLfixed t,
103                                    GLfixed n,
104                                    GLfixed f);
105 angle::CallCapture CaptureGetClipPlanef(const State &glState,
106                                         bool isCallValid,
107                                         GLenum plane,
108                                         GLfloat *equation);
109 angle::CallCapture CaptureGetClipPlanex(const State &glState,
110                                         bool isCallValid,
111                                         GLenum plane,
112                                         GLfixed *equation);
113 angle::CallCapture CaptureGetFixedv(const State &glState,
114                                     bool isCallValid,
115                                     GLenum pname,
116                                     GLfixed *params);
117 angle::CallCapture CaptureGetLightfv(const State &glState,
118                                      bool isCallValid,
119                                      GLenum light,
120                                      LightParameter pnamePacked,
121                                      GLfloat *params);
122 angle::CallCapture CaptureGetLightxv(const State &glState,
123                                      bool isCallValid,
124                                      GLenum light,
125                                      LightParameter pnamePacked,
126                                      GLfixed *params);
127 angle::CallCapture CaptureGetMaterialfv(const State &glState,
128                                         bool isCallValid,
129                                         GLenum face,
130                                         MaterialParameter pnamePacked,
131                                         GLfloat *params);
132 angle::CallCapture CaptureGetMaterialxv(const State &glState,
133                                         bool isCallValid,
134                                         GLenum face,
135                                         MaterialParameter pnamePacked,
136                                         GLfixed *params);
137 angle::CallCapture CaptureGetTexEnvfv(const State &glState,
138                                       bool isCallValid,
139                                       TextureEnvTarget targetPacked,
140                                       TextureEnvParameter pnamePacked,
141                                       GLfloat *params);
142 angle::CallCapture CaptureGetTexEnviv(const State &glState,
143                                       bool isCallValid,
144                                       TextureEnvTarget targetPacked,
145                                       TextureEnvParameter pnamePacked,
146                                       GLint *params);
147 angle::CallCapture CaptureGetTexEnvxv(const State &glState,
148                                       bool isCallValid,
149                                       TextureEnvTarget targetPacked,
150                                       TextureEnvParameter pnamePacked,
151                                       GLfixed *params);
152 angle::CallCapture CaptureGetTexParameterxv(const State &glState,
153                                             bool isCallValid,
154                                             TextureType targetPacked,
155                                             GLenum pname,
156                                             GLfixed *params);
157 angle::CallCapture CaptureLightModelf(const State &glState,
158                                       bool isCallValid,
159                                       GLenum pname,
160                                       GLfloat param);
161 angle::CallCapture CaptureLightModelfv(const State &glState,
162                                        bool isCallValid,
163                                        GLenum pname,
164                                        const GLfloat *params);
165 angle::CallCapture CaptureLightModelx(const State &glState,
166                                       bool isCallValid,
167                                       GLenum pname,
168                                       GLfixed param);
169 angle::CallCapture CaptureLightModelxv(const State &glState,
170                                        bool isCallValid,
171                                        GLenum pname,
172                                        const GLfixed *param);
173 angle::CallCapture CaptureLightf(const State &glState,
174                                  bool isCallValid,
175                                  GLenum light,
176                                  LightParameter pnamePacked,
177                                  GLfloat param);
178 angle::CallCapture CaptureLightfv(const State &glState,
179                                   bool isCallValid,
180                                   GLenum light,
181                                   LightParameter pnamePacked,
182                                   const GLfloat *params);
183 angle::CallCapture CaptureLightx(const State &glState,
184                                  bool isCallValid,
185                                  GLenum light,
186                                  LightParameter pnamePacked,
187                                  GLfixed param);
188 angle::CallCapture CaptureLightxv(const State &glState,
189                                   bool isCallValid,
190                                   GLenum light,
191                                   LightParameter pnamePacked,
192                                   const GLfixed *params);
193 angle::CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width);
194 angle::CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid);
195 angle::CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
196 angle::CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
197 angle::CallCapture CaptureLogicOp(const State &glState,
198                                   bool isCallValid,
199                                   LogicalOperation opcodePacked);
200 angle::CallCapture CaptureMaterialf(const State &glState,
201                                     bool isCallValid,
202                                     GLenum face,
203                                     MaterialParameter pnamePacked,
204                                     GLfloat param);
205 angle::CallCapture CaptureMaterialfv(const State &glState,
206                                      bool isCallValid,
207                                      GLenum face,
208                                      MaterialParameter pnamePacked,
209                                      const GLfloat *params);
210 angle::CallCapture CaptureMaterialx(const State &glState,
211                                     bool isCallValid,
212                                     GLenum face,
213                                     MaterialParameter pnamePacked,
214                                     GLfixed param);
215 angle::CallCapture CaptureMaterialxv(const State &glState,
216                                      bool isCallValid,
217                                      GLenum face,
218                                      MaterialParameter pnamePacked,
219                                      const GLfixed *param);
220 angle::CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked);
221 angle::CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m);
222 angle::CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m);
223 angle::CallCapture CaptureMultiTexCoord4f(const State &glState,
224                                           bool isCallValid,
225                                           GLenum target,
226                                           GLfloat s,
227                                           GLfloat t,
228                                           GLfloat r,
229                                           GLfloat q);
230 angle::CallCapture CaptureMultiTexCoord4x(const State &glState,
231                                           bool isCallValid,
232                                           GLenum texture,
233                                           GLfixed s,
234                                           GLfixed t,
235                                           GLfixed r,
236                                           GLfixed q);
237 angle::CallCapture CaptureNormal3f(const State &glState,
238                                    bool isCallValid,
239                                    GLfloat nx,
240                                    GLfloat ny,
241                                    GLfloat nz);
242 angle::CallCapture CaptureNormal3x(const State &glState,
243                                    bool isCallValid,
244                                    GLfixed nx,
245                                    GLfixed ny,
246                                    GLfixed nz);
247 angle::CallCapture CaptureNormalPointer(const State &glState,
248                                         bool isCallValid,
249                                         VertexAttribType typePacked,
250                                         GLsizei stride,
251                                         const void *pointer);
252 angle::CallCapture CaptureOrthof(const State &glState,
253                                  bool isCallValid,
254                                  GLfloat l,
255                                  GLfloat r,
256                                  GLfloat b,
257                                  GLfloat t,
258                                  GLfloat n,
259                                  GLfloat f);
260 angle::CallCapture CaptureOrthox(const State &glState,
261                                  bool isCallValid,
262                                  GLfixed l,
263                                  GLfixed r,
264                                  GLfixed b,
265                                  GLfixed t,
266                                  GLfixed n,
267                                  GLfixed f);
268 angle::CallCapture CapturePointParameterf(const State &glState,
269                                           bool isCallValid,
270                                           PointParameter pnamePacked,
271                                           GLfloat param);
272 angle::CallCapture CapturePointParameterfv(const State &glState,
273                                            bool isCallValid,
274                                            PointParameter pnamePacked,
275                                            const GLfloat *params);
276 angle::CallCapture CapturePointParameterx(const State &glState,
277                                           bool isCallValid,
278                                           PointParameter pnamePacked,
279                                           GLfixed param);
280 angle::CallCapture CapturePointParameterxv(const State &glState,
281                                            bool isCallValid,
282                                            PointParameter pnamePacked,
283                                            const GLfixed *params);
284 angle::CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size);
285 angle::CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size);
286 angle::CallCapture CapturePolygonOffsetx(const State &glState,
287                                          bool isCallValid,
288                                          GLfixed factor,
289                                          GLfixed units);
290 angle::CallCapture CapturePopMatrix(const State &glState, bool isCallValid);
291 angle::CallCapture CapturePushMatrix(const State &glState, bool isCallValid);
292 angle::CallCapture CaptureRotatef(const State &glState,
293                                   bool isCallValid,
294                                   GLfloat angle,
295                                   GLfloat x,
296                                   GLfloat y,
297                                   GLfloat z);
298 angle::CallCapture CaptureRotatex(const State &glState,
299                                   bool isCallValid,
300                                   GLfixed angle,
301                                   GLfixed x,
302                                   GLfixed y,
303                                   GLfixed z);
304 angle::CallCapture CaptureSampleCoveragex(const State &glState,
305                                           bool isCallValid,
306                                           GLclampx value,
307                                           GLboolean invert);
308 angle::CallCapture CaptureScalef(const State &glState,
309                                  bool isCallValid,
310                                  GLfloat x,
311                                  GLfloat y,
312                                  GLfloat z);
313 angle::CallCapture CaptureScalex(const State &glState,
314                                  bool isCallValid,
315                                  GLfixed x,
316                                  GLfixed y,
317                                  GLfixed z);
318 angle::CallCapture CaptureShadeModel(const State &glState,
319                                      bool isCallValid,
320                                      ShadingModel modePacked);
321 angle::CallCapture CaptureTexCoordPointer(const State &glState,
322                                           bool isCallValid,
323                                           GLint size,
324                                           VertexAttribType typePacked,
325                                           GLsizei stride,
326                                           const void *pointer);
327 angle::CallCapture CaptureTexEnvf(const State &glState,
328                                   bool isCallValid,
329                                   TextureEnvTarget targetPacked,
330                                   TextureEnvParameter pnamePacked,
331                                   GLfloat param);
332 angle::CallCapture CaptureTexEnvfv(const State &glState,
333                                    bool isCallValid,
334                                    TextureEnvTarget targetPacked,
335                                    TextureEnvParameter pnamePacked,
336                                    const GLfloat *params);
337 angle::CallCapture CaptureTexEnvi(const State &glState,
338                                   bool isCallValid,
339                                   TextureEnvTarget targetPacked,
340                                   TextureEnvParameter pnamePacked,
341                                   GLint param);
342 angle::CallCapture CaptureTexEnviv(const State &glState,
343                                    bool isCallValid,
344                                    TextureEnvTarget targetPacked,
345                                    TextureEnvParameter pnamePacked,
346                                    const GLint *params);
347 angle::CallCapture CaptureTexEnvx(const State &glState,
348                                   bool isCallValid,
349                                   TextureEnvTarget targetPacked,
350                                   TextureEnvParameter pnamePacked,
351                                   GLfixed param);
352 angle::CallCapture CaptureTexEnvxv(const State &glState,
353                                    bool isCallValid,
354                                    TextureEnvTarget targetPacked,
355                                    TextureEnvParameter pnamePacked,
356                                    const GLfixed *params);
357 angle::CallCapture CaptureTexParameterx(const State &glState,
358                                         bool isCallValid,
359                                         TextureType targetPacked,
360                                         GLenum pname,
361                                         GLfixed param);
362 angle::CallCapture CaptureTexParameterxv(const State &glState,
363                                          bool isCallValid,
364                                          TextureType targetPacked,
365                                          GLenum pname,
366                                          const GLfixed *params);
367 angle::CallCapture CaptureTranslatef(const State &glState,
368                                      bool isCallValid,
369                                      GLfloat x,
370                                      GLfloat y,
371                                      GLfloat z);
372 angle::CallCapture CaptureTranslatex(const State &glState,
373                                      bool isCallValid,
374                                      GLfixed x,
375                                      GLfixed y,
376                                      GLfixed z);
377 angle::CallCapture CaptureVertexPointer(const State &glState,
378                                         bool isCallValid,
379                                         GLint size,
380                                         VertexAttribType typePacked,
381                                         GLsizei stride,
382                                         const void *pointer);
383 
384 // Parameter Captures
385 
386 void CaptureClipPlanef_eqn(const State &glState,
387                            bool isCallValid,
388                            GLenum p,
389                            const GLfloat *eqn,
390                            angle::ParamCapture *paramCapture);
391 void CaptureClipPlanex_equation(const State &glState,
392                                 bool isCallValid,
393                                 GLenum plane,
394                                 const GLfixed *equation,
395                                 angle::ParamCapture *paramCapture);
396 void CaptureColorPointer_pointer(const State &glState,
397                                  bool isCallValid,
398                                  GLint size,
399                                  VertexAttribType typePacked,
400                                  GLsizei stride,
401                                  const void *pointer,
402                                  angle::ParamCapture *paramCapture);
403 void CaptureFogfv_params(const State &glState,
404                          bool isCallValid,
405                          GLenum pname,
406                          const GLfloat *params,
407                          angle::ParamCapture *paramCapture);
408 void CaptureFogxv_param(const State &glState,
409                         bool isCallValid,
410                         GLenum pname,
411                         const GLfixed *param,
412                         angle::ParamCapture *paramCapture);
413 void CaptureGetClipPlanef_equation(const State &glState,
414                                    bool isCallValid,
415                                    GLenum plane,
416                                    GLfloat *equation,
417                                    angle::ParamCapture *paramCapture);
418 void CaptureGetClipPlanex_equation(const State &glState,
419                                    bool isCallValid,
420                                    GLenum plane,
421                                    GLfixed *equation,
422                                    angle::ParamCapture *paramCapture);
423 void CaptureGetFixedv_params(const State &glState,
424                              bool isCallValid,
425                              GLenum pname,
426                              GLfixed *params,
427                              angle::ParamCapture *paramCapture);
428 void CaptureGetLightfv_params(const State &glState,
429                               bool isCallValid,
430                               GLenum light,
431                               LightParameter pnamePacked,
432                               GLfloat *params,
433                               angle::ParamCapture *paramCapture);
434 void CaptureGetLightxv_params(const State &glState,
435                               bool isCallValid,
436                               GLenum light,
437                               LightParameter pnamePacked,
438                               GLfixed *params,
439                               angle::ParamCapture *paramCapture);
440 void CaptureGetMaterialfv_params(const State &glState,
441                                  bool isCallValid,
442                                  GLenum face,
443                                  MaterialParameter pnamePacked,
444                                  GLfloat *params,
445                                  angle::ParamCapture *paramCapture);
446 void CaptureGetMaterialxv_params(const State &glState,
447                                  bool isCallValid,
448                                  GLenum face,
449                                  MaterialParameter pnamePacked,
450                                  GLfixed *params,
451                                  angle::ParamCapture *paramCapture);
452 void CaptureGetTexEnvfv_params(const State &glState,
453                                bool isCallValid,
454                                TextureEnvTarget targetPacked,
455                                TextureEnvParameter pnamePacked,
456                                GLfloat *params,
457                                angle::ParamCapture *paramCapture);
458 void CaptureGetTexEnviv_params(const State &glState,
459                                bool isCallValid,
460                                TextureEnvTarget targetPacked,
461                                TextureEnvParameter pnamePacked,
462                                GLint *params,
463                                angle::ParamCapture *paramCapture);
464 void CaptureGetTexEnvxv_params(const State &glState,
465                                bool isCallValid,
466                                TextureEnvTarget targetPacked,
467                                TextureEnvParameter pnamePacked,
468                                GLfixed *params,
469                                angle::ParamCapture *paramCapture);
470 void CaptureGetTexParameterxv_params(const State &glState,
471                                      bool isCallValid,
472                                      TextureType targetPacked,
473                                      GLenum pname,
474                                      GLfixed *params,
475                                      angle::ParamCapture *paramCapture);
476 void CaptureLightModelfv_params(const State &glState,
477                                 bool isCallValid,
478                                 GLenum pname,
479                                 const GLfloat *params,
480                                 angle::ParamCapture *paramCapture);
481 void CaptureLightModelxv_param(const State &glState,
482                                bool isCallValid,
483                                GLenum pname,
484                                const GLfixed *param,
485                                angle::ParamCapture *paramCapture);
486 void CaptureLightfv_params(const State &glState,
487                            bool isCallValid,
488                            GLenum light,
489                            LightParameter pnamePacked,
490                            const GLfloat *params,
491                            angle::ParamCapture *paramCapture);
492 void CaptureLightxv_params(const State &glState,
493                            bool isCallValid,
494                            GLenum light,
495                            LightParameter pnamePacked,
496                            const GLfixed *params,
497                            angle::ParamCapture *paramCapture);
498 void CaptureLoadMatrixf_m(const State &glState,
499                           bool isCallValid,
500                           const GLfloat *m,
501                           angle::ParamCapture *paramCapture);
502 void CaptureLoadMatrixx_m(const State &glState,
503                           bool isCallValid,
504                           const GLfixed *m,
505                           angle::ParamCapture *paramCapture);
506 void CaptureMaterialfv_params(const State &glState,
507                               bool isCallValid,
508                               GLenum face,
509                               MaterialParameter pnamePacked,
510                               const GLfloat *params,
511                               angle::ParamCapture *paramCapture);
512 void CaptureMaterialxv_param(const State &glState,
513                              bool isCallValid,
514                              GLenum face,
515                              MaterialParameter pnamePacked,
516                              const GLfixed *param,
517                              angle::ParamCapture *paramCapture);
518 void CaptureMultMatrixf_m(const State &glState,
519                           bool isCallValid,
520                           const GLfloat *m,
521                           angle::ParamCapture *paramCapture);
522 void CaptureMultMatrixx_m(const State &glState,
523                           bool isCallValid,
524                           const GLfixed *m,
525                           angle::ParamCapture *paramCapture);
526 void CaptureNormalPointer_pointer(const State &glState,
527                                   bool isCallValid,
528                                   VertexAttribType typePacked,
529                                   GLsizei stride,
530                                   const void *pointer,
531                                   angle::ParamCapture *paramCapture);
532 void CapturePointParameterfv_params(const State &glState,
533                                     bool isCallValid,
534                                     PointParameter pnamePacked,
535                                     const GLfloat *params,
536                                     angle::ParamCapture *paramCapture);
537 void CapturePointParameterxv_params(const State &glState,
538                                     bool isCallValid,
539                                     PointParameter pnamePacked,
540                                     const GLfixed *params,
541                                     angle::ParamCapture *paramCapture);
542 void CaptureTexCoordPointer_pointer(const State &glState,
543                                     bool isCallValid,
544                                     GLint size,
545                                     VertexAttribType typePacked,
546                                     GLsizei stride,
547                                     const void *pointer,
548                                     angle::ParamCapture *paramCapture);
549 void CaptureTexEnvfv_params(const State &glState,
550                             bool isCallValid,
551                             TextureEnvTarget targetPacked,
552                             TextureEnvParameter pnamePacked,
553                             const GLfloat *params,
554                             angle::ParamCapture *paramCapture);
555 void CaptureTexEnviv_params(const State &glState,
556                             bool isCallValid,
557                             TextureEnvTarget targetPacked,
558                             TextureEnvParameter pnamePacked,
559                             const GLint *params,
560                             angle::ParamCapture *paramCapture);
561 void CaptureTexEnvxv_params(const State &glState,
562                             bool isCallValid,
563                             TextureEnvTarget targetPacked,
564                             TextureEnvParameter pnamePacked,
565                             const GLfixed *params,
566                             angle::ParamCapture *paramCapture);
567 void CaptureTexParameterxv_params(const State &glState,
568                                   bool isCallValid,
569                                   TextureType targetPacked,
570                                   GLenum pname,
571                                   const GLfixed *params,
572                                   angle::ParamCapture *paramCapture);
573 void CaptureVertexPointer_pointer(const State &glState,
574                                   bool isCallValid,
575                                   GLint size,
576                                   VertexAttribType typePacked,
577                                   GLsizei stride,
578                                   const void *pointer,
579                                   angle::ParamCapture *paramCapture);
580 }  // namespace gl
581 
582 #endif  // LIBANGLE_CAPTURE_GLES_1_0_AUTOGEN_H_
583