• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_gl_3_autogen.h:
9 //   Capture functions for the OpenGL ES Desktop GL 3.x entry points.
10 
11 #ifndef LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
12 #define LIBANGLE_CAPTURE_GL_3_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 // GL 3.0
23 angle::CallCapture CaptureBeginConditionalRender(const State &glState,
24                                                  bool isCallValid,
25                                                  GLuint id,
26                                                  GLenum mode);
27 angle::CallCapture CaptureBindFragDataLocation(const State &glState,
28                                                bool isCallValid,
29                                                ShaderProgramID programPacked,
30                                                GLuint color,
31                                                const GLchar *name);
32 angle::CallCapture CaptureClampColor(const State &glState,
33                                      bool isCallValid,
34                                      GLenum target,
35                                      GLenum clamp);
36 angle::CallCapture CaptureEndConditionalRender(const State &glState, bool isCallValid);
37 angle::CallCapture CaptureFramebufferTexture1D(const State &glState,
38                                                bool isCallValid,
39                                                GLenum target,
40                                                GLenum attachment,
41                                                TextureTarget textargetPacked,
42                                                TextureID texturePacked,
43                                                GLint level);
44 angle::CallCapture CaptureFramebufferTexture3D(const State &glState,
45                                                bool isCallValid,
46                                                GLenum target,
47                                                GLenum attachment,
48                                                TextureTarget textargetPacked,
49                                                TextureID texturePacked,
50                                                GLint level,
51                                                GLint zoffset);
52 angle::CallCapture CaptureVertexAttribI1i(const State &glState,
53                                           bool isCallValid,
54                                           GLuint index,
55                                           GLint x);
56 angle::CallCapture CaptureVertexAttribI1iv(const State &glState,
57                                            bool isCallValid,
58                                            GLuint index,
59                                            const GLint *v);
60 angle::CallCapture CaptureVertexAttribI1ui(const State &glState,
61                                            bool isCallValid,
62                                            GLuint index,
63                                            GLuint x);
64 angle::CallCapture CaptureVertexAttribI1uiv(const State &glState,
65                                             bool isCallValid,
66                                             GLuint index,
67                                             const GLuint *v);
68 angle::CallCapture CaptureVertexAttribI2i(const State &glState,
69                                           bool isCallValid,
70                                           GLuint index,
71                                           GLint x,
72                                           GLint y);
73 angle::CallCapture CaptureVertexAttribI2iv(const State &glState,
74                                            bool isCallValid,
75                                            GLuint index,
76                                            const GLint *v);
77 angle::CallCapture CaptureVertexAttribI2ui(const State &glState,
78                                            bool isCallValid,
79                                            GLuint index,
80                                            GLuint x,
81                                            GLuint y);
82 angle::CallCapture CaptureVertexAttribI2uiv(const State &glState,
83                                             bool isCallValid,
84                                             GLuint index,
85                                             const GLuint *v);
86 angle::CallCapture CaptureVertexAttribI3i(const State &glState,
87                                           bool isCallValid,
88                                           GLuint index,
89                                           GLint x,
90                                           GLint y,
91                                           GLint z);
92 angle::CallCapture CaptureVertexAttribI3iv(const State &glState,
93                                            bool isCallValid,
94                                            GLuint index,
95                                            const GLint *v);
96 angle::CallCapture CaptureVertexAttribI3ui(const State &glState,
97                                            bool isCallValid,
98                                            GLuint index,
99                                            GLuint x,
100                                            GLuint y,
101                                            GLuint z);
102 angle::CallCapture CaptureVertexAttribI3uiv(const State &glState,
103                                             bool isCallValid,
104                                             GLuint index,
105                                             const GLuint *v);
106 angle::CallCapture CaptureVertexAttribI4bv(const State &glState,
107                                            bool isCallValid,
108                                            GLuint index,
109                                            const GLbyte *v);
110 angle::CallCapture CaptureVertexAttribI4sv(const State &glState,
111                                            bool isCallValid,
112                                            GLuint index,
113                                            const GLshort *v);
114 angle::CallCapture CaptureVertexAttribI4ubv(const State &glState,
115                                             bool isCallValid,
116                                             GLuint index,
117                                             const GLubyte *v);
118 angle::CallCapture CaptureVertexAttribI4usv(const State &glState,
119                                             bool isCallValid,
120                                             GLuint index,
121                                             const GLushort *v);
122 
123 // GL 3.1
124 angle::CallCapture CaptureGetActiveUniformName(const State &glState,
125                                                bool isCallValid,
126                                                ShaderProgramID programPacked,
127                                                GLuint uniformIndex,
128                                                GLsizei bufSize,
129                                                GLsizei *length,
130                                                GLchar *uniformName);
131 angle::CallCapture CapturePrimitiveRestartIndex(const State &glState,
132                                                 bool isCallValid,
133                                                 GLuint index);
134 
135 // GL 3.2
136 angle::CallCapture CaptureMultiDrawElementsBaseVertex(const State &glState,
137                                                       bool isCallValid,
138                                                       PrimitiveMode modePacked,
139                                                       const GLsizei *count,
140                                                       DrawElementsType typePacked,
141                                                       const void *const *indices,
142                                                       GLsizei drawcount,
143                                                       const GLint *basevertex);
144 angle::CallCapture CaptureProvokingVertex(const State &glState,
145                                           bool isCallValid,
146                                           ProvokingVertexConvention modePacked);
147 angle::CallCapture CaptureTexImage2DMultisample(const State &glState,
148                                                 bool isCallValid,
149                                                 GLenum target,
150                                                 GLsizei samples,
151                                                 GLenum internalformat,
152                                                 GLsizei width,
153                                                 GLsizei height,
154                                                 GLboolean fixedsamplelocations);
155 angle::CallCapture CaptureTexImage3DMultisample(const State &glState,
156                                                 bool isCallValid,
157                                                 GLenum target,
158                                                 GLsizei samples,
159                                                 GLenum internalformat,
160                                                 GLsizei width,
161                                                 GLsizei height,
162                                                 GLsizei depth,
163                                                 GLboolean fixedsamplelocations);
164 
165 // GL 3.3
166 angle::CallCapture CaptureBindFragDataLocationIndexed(const State &glState,
167                                                       bool isCallValid,
168                                                       ShaderProgramID programPacked,
169                                                       GLuint colorNumber,
170                                                       GLuint index,
171                                                       const GLchar *name);
172 angle::CallCapture CaptureColorP3ui(const State &glState,
173                                     bool isCallValid,
174                                     GLenum type,
175                                     GLuint color);
176 angle::CallCapture CaptureColorP3uiv(const State &glState,
177                                      bool isCallValid,
178                                      GLenum type,
179                                      const GLuint *color);
180 angle::CallCapture CaptureColorP4ui(const State &glState,
181                                     bool isCallValid,
182                                     GLenum type,
183                                     GLuint color);
184 angle::CallCapture CaptureColorP4uiv(const State &glState,
185                                      bool isCallValid,
186                                      GLenum type,
187                                      const GLuint *color);
188 angle::CallCapture CaptureGetFragDataIndex(const State &glState,
189                                            bool isCallValid,
190                                            ShaderProgramID programPacked,
191                                            const GLchar *name,
192                                            GLint returnValue);
193 angle::CallCapture CaptureGetQueryObjecti64v(const State &glState,
194                                              bool isCallValid,
195                                              QueryID idPacked,
196                                              GLenum pname,
197                                              GLint64 *params);
198 angle::CallCapture CaptureGetQueryObjectui64v(const State &glState,
199                                               bool isCallValid,
200                                               QueryID idPacked,
201                                               GLenum pname,
202                                               GLuint64 *params);
203 angle::CallCapture CaptureMultiTexCoordP1ui(const State &glState,
204                                             bool isCallValid,
205                                             GLenum texture,
206                                             GLenum type,
207                                             GLuint coords);
208 angle::CallCapture CaptureMultiTexCoordP1uiv(const State &glState,
209                                              bool isCallValid,
210                                              GLenum texture,
211                                              GLenum type,
212                                              const GLuint *coords);
213 angle::CallCapture CaptureMultiTexCoordP2ui(const State &glState,
214                                             bool isCallValid,
215                                             GLenum texture,
216                                             GLenum type,
217                                             GLuint coords);
218 angle::CallCapture CaptureMultiTexCoordP2uiv(const State &glState,
219                                              bool isCallValid,
220                                              GLenum texture,
221                                              GLenum type,
222                                              const GLuint *coords);
223 angle::CallCapture CaptureMultiTexCoordP3ui(const State &glState,
224                                             bool isCallValid,
225                                             GLenum texture,
226                                             GLenum type,
227                                             GLuint coords);
228 angle::CallCapture CaptureMultiTexCoordP3uiv(const State &glState,
229                                              bool isCallValid,
230                                              GLenum texture,
231                                              GLenum type,
232                                              const GLuint *coords);
233 angle::CallCapture CaptureMultiTexCoordP4ui(const State &glState,
234                                             bool isCallValid,
235                                             GLenum texture,
236                                             GLenum type,
237                                             GLuint coords);
238 angle::CallCapture CaptureMultiTexCoordP4uiv(const State &glState,
239                                              bool isCallValid,
240                                              GLenum texture,
241                                              GLenum type,
242                                              const GLuint *coords);
243 angle::CallCapture CaptureNormalP3ui(const State &glState,
244                                      bool isCallValid,
245                                      GLenum type,
246                                      GLuint coords);
247 angle::CallCapture CaptureNormalP3uiv(const State &glState,
248                                       bool isCallValid,
249                                       GLenum type,
250                                       const GLuint *coords);
251 angle::CallCapture CaptureQueryCounter(const State &glState,
252                                        bool isCallValid,
253                                        QueryID idPacked,
254                                        QueryType targetPacked);
255 angle::CallCapture CaptureSecondaryColorP3ui(const State &glState,
256                                              bool isCallValid,
257                                              GLenum type,
258                                              GLuint color);
259 angle::CallCapture CaptureSecondaryColorP3uiv(const State &glState,
260                                               bool isCallValid,
261                                               GLenum type,
262                                               const GLuint *color);
263 angle::CallCapture CaptureTexCoordP1ui(const State &glState,
264                                        bool isCallValid,
265                                        GLenum type,
266                                        GLuint coords);
267 angle::CallCapture CaptureTexCoordP1uiv(const State &glState,
268                                         bool isCallValid,
269                                         GLenum type,
270                                         const GLuint *coords);
271 angle::CallCapture CaptureTexCoordP2ui(const State &glState,
272                                        bool isCallValid,
273                                        GLenum type,
274                                        GLuint coords);
275 angle::CallCapture CaptureTexCoordP2uiv(const State &glState,
276                                         bool isCallValid,
277                                         GLenum type,
278                                         const GLuint *coords);
279 angle::CallCapture CaptureTexCoordP3ui(const State &glState,
280                                        bool isCallValid,
281                                        GLenum type,
282                                        GLuint coords);
283 angle::CallCapture CaptureTexCoordP3uiv(const State &glState,
284                                         bool isCallValid,
285                                         GLenum type,
286                                         const GLuint *coords);
287 angle::CallCapture CaptureTexCoordP4ui(const State &glState,
288                                        bool isCallValid,
289                                        GLenum type,
290                                        GLuint coords);
291 angle::CallCapture CaptureTexCoordP4uiv(const State &glState,
292                                         bool isCallValid,
293                                         GLenum type,
294                                         const GLuint *coords);
295 angle::CallCapture CaptureVertexAttribP1ui(const State &glState,
296                                            bool isCallValid,
297                                            GLuint index,
298                                            GLenum type,
299                                            GLboolean normalized,
300                                            GLuint value);
301 angle::CallCapture CaptureVertexAttribP1uiv(const State &glState,
302                                             bool isCallValid,
303                                             GLuint index,
304                                             GLenum type,
305                                             GLboolean normalized,
306                                             const GLuint *value);
307 angle::CallCapture CaptureVertexAttribP2ui(const State &glState,
308                                            bool isCallValid,
309                                            GLuint index,
310                                            GLenum type,
311                                            GLboolean normalized,
312                                            GLuint value);
313 angle::CallCapture CaptureVertexAttribP2uiv(const State &glState,
314                                             bool isCallValid,
315                                             GLuint index,
316                                             GLenum type,
317                                             GLboolean normalized,
318                                             const GLuint *value);
319 angle::CallCapture CaptureVertexAttribP3ui(const State &glState,
320                                            bool isCallValid,
321                                            GLuint index,
322                                            GLenum type,
323                                            GLboolean normalized,
324                                            GLuint value);
325 angle::CallCapture CaptureVertexAttribP3uiv(const State &glState,
326                                             bool isCallValid,
327                                             GLuint index,
328                                             GLenum type,
329                                             GLboolean normalized,
330                                             const GLuint *value);
331 angle::CallCapture CaptureVertexAttribP4ui(const State &glState,
332                                            bool isCallValid,
333                                            GLuint index,
334                                            GLenum type,
335                                            GLboolean normalized,
336                                            GLuint value);
337 angle::CallCapture CaptureVertexAttribP4uiv(const State &glState,
338                                             bool isCallValid,
339                                             GLuint index,
340                                             GLenum type,
341                                             GLboolean normalized,
342                                             const GLuint *value);
343 angle::CallCapture CaptureVertexP2ui(const State &glState,
344                                      bool isCallValid,
345                                      GLenum type,
346                                      GLuint value);
347 angle::CallCapture CaptureVertexP2uiv(const State &glState,
348                                       bool isCallValid,
349                                       GLenum type,
350                                       const GLuint *value);
351 angle::CallCapture CaptureVertexP3ui(const State &glState,
352                                      bool isCallValid,
353                                      GLenum type,
354                                      GLuint value);
355 angle::CallCapture CaptureVertexP3uiv(const State &glState,
356                                       bool isCallValid,
357                                       GLenum type,
358                                       const GLuint *value);
359 angle::CallCapture CaptureVertexP4ui(const State &glState,
360                                      bool isCallValid,
361                                      GLenum type,
362                                      GLuint value);
363 angle::CallCapture CaptureVertexP4uiv(const State &glState,
364                                       bool isCallValid,
365                                       GLenum type,
366                                       const GLuint *value);
367 
368 // Parameter Captures
369 
370 // GL 3.0
371 void CaptureBindFragDataLocation_name(const State &glState,
372                                       bool isCallValid,
373                                       ShaderProgramID programPacked,
374                                       GLuint color,
375                                       const GLchar *name,
376                                       angle::ParamCapture *paramCapture);
377 void CaptureVertexAttribI1iv_v(const State &glState,
378                                bool isCallValid,
379                                GLuint index,
380                                const GLint *v,
381                                angle::ParamCapture *paramCapture);
382 void CaptureVertexAttribI1uiv_v(const State &glState,
383                                 bool isCallValid,
384                                 GLuint index,
385                                 const GLuint *v,
386                                 angle::ParamCapture *paramCapture);
387 void CaptureVertexAttribI2iv_v(const State &glState,
388                                bool isCallValid,
389                                GLuint index,
390                                const GLint *v,
391                                angle::ParamCapture *paramCapture);
392 void CaptureVertexAttribI2uiv_v(const State &glState,
393                                 bool isCallValid,
394                                 GLuint index,
395                                 const GLuint *v,
396                                 angle::ParamCapture *paramCapture);
397 void CaptureVertexAttribI3iv_v(const State &glState,
398                                bool isCallValid,
399                                GLuint index,
400                                const GLint *v,
401                                angle::ParamCapture *paramCapture);
402 void CaptureVertexAttribI3uiv_v(const State &glState,
403                                 bool isCallValid,
404                                 GLuint index,
405                                 const GLuint *v,
406                                 angle::ParamCapture *paramCapture);
407 void CaptureVertexAttribI4bv_v(const State &glState,
408                                bool isCallValid,
409                                GLuint index,
410                                const GLbyte *v,
411                                angle::ParamCapture *paramCapture);
412 void CaptureVertexAttribI4sv_v(const State &glState,
413                                bool isCallValid,
414                                GLuint index,
415                                const GLshort *v,
416                                angle::ParamCapture *paramCapture);
417 void CaptureVertexAttribI4ubv_v(const State &glState,
418                                 bool isCallValid,
419                                 GLuint index,
420                                 const GLubyte *v,
421                                 angle::ParamCapture *paramCapture);
422 void CaptureVertexAttribI4usv_v(const State &glState,
423                                 bool isCallValid,
424                                 GLuint index,
425                                 const GLushort *v,
426                                 angle::ParamCapture *paramCapture);
427 
428 // GL 3.1
429 void CaptureGetActiveUniformName_length(const State &glState,
430                                         bool isCallValid,
431                                         ShaderProgramID programPacked,
432                                         GLuint uniformIndex,
433                                         GLsizei bufSize,
434                                         GLsizei *length,
435                                         GLchar *uniformName,
436                                         angle::ParamCapture *paramCapture);
437 void CaptureGetActiveUniformName_uniformName(const State &glState,
438                                              bool isCallValid,
439                                              ShaderProgramID programPacked,
440                                              GLuint uniformIndex,
441                                              GLsizei bufSize,
442                                              GLsizei *length,
443                                              GLchar *uniformName,
444                                              angle::ParamCapture *paramCapture);
445 
446 // GL 3.2
447 void CaptureMultiDrawElementsBaseVertex_count(const State &glState,
448                                               bool isCallValid,
449                                               PrimitiveMode modePacked,
450                                               const GLsizei *count,
451                                               DrawElementsType typePacked,
452                                               const void *const *indices,
453                                               GLsizei drawcount,
454                                               const GLint *basevertex,
455                                               angle::ParamCapture *paramCapture);
456 void CaptureMultiDrawElementsBaseVertex_indices(const State &glState,
457                                                 bool isCallValid,
458                                                 PrimitiveMode modePacked,
459                                                 const GLsizei *count,
460                                                 DrawElementsType typePacked,
461                                                 const void *const *indices,
462                                                 GLsizei drawcount,
463                                                 const GLint *basevertex,
464                                                 angle::ParamCapture *paramCapture);
465 void CaptureMultiDrawElementsBaseVertex_basevertex(const State &glState,
466                                                    bool isCallValid,
467                                                    PrimitiveMode modePacked,
468                                                    const GLsizei *count,
469                                                    DrawElementsType typePacked,
470                                                    const void *const *indices,
471                                                    GLsizei drawcount,
472                                                    const GLint *basevertex,
473                                                    angle::ParamCapture *paramCapture);
474 
475 // GL 3.3
476 void CaptureBindFragDataLocationIndexed_name(const State &glState,
477                                              bool isCallValid,
478                                              ShaderProgramID programPacked,
479                                              GLuint colorNumber,
480                                              GLuint index,
481                                              const GLchar *name,
482                                              angle::ParamCapture *paramCapture);
483 void CaptureColorP3uiv_color(const State &glState,
484                              bool isCallValid,
485                              GLenum type,
486                              const GLuint *color,
487                              angle::ParamCapture *paramCapture);
488 void CaptureColorP4uiv_color(const State &glState,
489                              bool isCallValid,
490                              GLenum type,
491                              const GLuint *color,
492                              angle::ParamCapture *paramCapture);
493 void CaptureGetFragDataIndex_name(const State &glState,
494                                   bool isCallValid,
495                                   ShaderProgramID programPacked,
496                                   const GLchar *name,
497                                   angle::ParamCapture *paramCapture);
498 void CaptureGetQueryObjecti64v_params(const State &glState,
499                                       bool isCallValid,
500                                       QueryID idPacked,
501                                       GLenum pname,
502                                       GLint64 *params,
503                                       angle::ParamCapture *paramCapture);
504 void CaptureGetQueryObjectui64v_params(const State &glState,
505                                        bool isCallValid,
506                                        QueryID idPacked,
507                                        GLenum pname,
508                                        GLuint64 *params,
509                                        angle::ParamCapture *paramCapture);
510 void CaptureMultiTexCoordP1uiv_coords(const State &glState,
511                                       bool isCallValid,
512                                       GLenum texture,
513                                       GLenum type,
514                                       const GLuint *coords,
515                                       angle::ParamCapture *paramCapture);
516 void CaptureMultiTexCoordP2uiv_coords(const State &glState,
517                                       bool isCallValid,
518                                       GLenum texture,
519                                       GLenum type,
520                                       const GLuint *coords,
521                                       angle::ParamCapture *paramCapture);
522 void CaptureMultiTexCoordP3uiv_coords(const State &glState,
523                                       bool isCallValid,
524                                       GLenum texture,
525                                       GLenum type,
526                                       const GLuint *coords,
527                                       angle::ParamCapture *paramCapture);
528 void CaptureMultiTexCoordP4uiv_coords(const State &glState,
529                                       bool isCallValid,
530                                       GLenum texture,
531                                       GLenum type,
532                                       const GLuint *coords,
533                                       angle::ParamCapture *paramCapture);
534 void CaptureNormalP3uiv_coords(const State &glState,
535                                bool isCallValid,
536                                GLenum type,
537                                const GLuint *coords,
538                                angle::ParamCapture *paramCapture);
539 void CaptureSecondaryColorP3uiv_color(const State &glState,
540                                       bool isCallValid,
541                                       GLenum type,
542                                       const GLuint *color,
543                                       angle::ParamCapture *paramCapture);
544 void CaptureTexCoordP1uiv_coords(const State &glState,
545                                  bool isCallValid,
546                                  GLenum type,
547                                  const GLuint *coords,
548                                  angle::ParamCapture *paramCapture);
549 void CaptureTexCoordP2uiv_coords(const State &glState,
550                                  bool isCallValid,
551                                  GLenum type,
552                                  const GLuint *coords,
553                                  angle::ParamCapture *paramCapture);
554 void CaptureTexCoordP3uiv_coords(const State &glState,
555                                  bool isCallValid,
556                                  GLenum type,
557                                  const GLuint *coords,
558                                  angle::ParamCapture *paramCapture);
559 void CaptureTexCoordP4uiv_coords(const State &glState,
560                                  bool isCallValid,
561                                  GLenum type,
562                                  const GLuint *coords,
563                                  angle::ParamCapture *paramCapture);
564 void CaptureVertexAttribP1uiv_value(const State &glState,
565                                     bool isCallValid,
566                                     GLuint index,
567                                     GLenum type,
568                                     GLboolean normalized,
569                                     const GLuint *value,
570                                     angle::ParamCapture *paramCapture);
571 void CaptureVertexAttribP2uiv_value(const State &glState,
572                                     bool isCallValid,
573                                     GLuint index,
574                                     GLenum type,
575                                     GLboolean normalized,
576                                     const GLuint *value,
577                                     angle::ParamCapture *paramCapture);
578 void CaptureVertexAttribP3uiv_value(const State &glState,
579                                     bool isCallValid,
580                                     GLuint index,
581                                     GLenum type,
582                                     GLboolean normalized,
583                                     const GLuint *value,
584                                     angle::ParamCapture *paramCapture);
585 void CaptureVertexAttribP4uiv_value(const State &glState,
586                                     bool isCallValid,
587                                     GLuint index,
588                                     GLenum type,
589                                     GLboolean normalized,
590                                     const GLuint *value,
591                                     angle::ParamCapture *paramCapture);
592 void CaptureVertexP2uiv_value(const State &glState,
593                               bool isCallValid,
594                               GLenum type,
595                               const GLuint *value,
596                               angle::ParamCapture *paramCapture);
597 void CaptureVertexP3uiv_value(const State &glState,
598                               bool isCallValid,
599                               GLenum type,
600                               const GLuint *value,
601                               angle::ParamCapture *paramCapture);
602 void CaptureVertexP4uiv_value(const State &glState,
603                               bool isCallValid,
604                               GLenum type,
605                               const GLuint *value,
606                               angle::ParamCapture *paramCapture);
607 }  // namespace gl
608 
609 #endif  // LIBANGLE_CAPTURE_GL_3_AUTOGEN_H_
610