chromium/third_party/angle/src/libANGLE/capture/capture_gl_1_autogen.cpp

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// capture_gl_1_autogen.cpp:
//   Capture functions for the OpenGL ES Desktop GL 1.x entry points.

#include "libANGLE/capture/capture_gl_1_autogen.h"

#include "common/gl_enum_utils.h"
#include "libANGLE/Context.h"
#include "libANGLE/capture/FrameCapture.h"
#include "libANGLE/validationGL1_autogen.h"

usingnamespaceangle;

namespace gl
{

// GL 1.0
CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value)
{ … }

CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode)
{ … }

CallCapture CaptureBitmap(const State &glState,
                          bool isCallValid,
                          GLsizei width,
                          GLsizei height,
                          GLfloat xorig,
                          GLfloat yorig,
                          GLfloat xmove,
                          GLfloat ymove,
                          const GLubyte *bitmap)
{ … }

CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list)
{ … }

CallCapture CaptureCallLists(const State &glState,
                             bool isCallValid,
                             GLsizei n,
                             GLenum type,
                             const void *lists)
{ … }

CallCapture CaptureClearAccum(const State &glState,
                              bool isCallValid,
                              GLfloat red,
                              GLfloat green,
                              GLfloat blue,
                              GLfloat alpha)
{ … }

CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth)
{ … }

CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c)
{ … }

CallCapture CaptureClipPlane(const State &glState,
                             bool isCallValid,
                             GLenum plane,
                             const GLdouble *equation)
{ … }

CallCapture CaptureColor3b(const State &glState,
                           bool isCallValid,
                           GLbyte red,
                           GLbyte green,
                           GLbyte blue)
{ … }

CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v)
{ … }

CallCapture CaptureColor3d(const State &glState,
                           bool isCallValid,
                           GLdouble red,
                           GLdouble green,
                           GLdouble blue)
{ … }

CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureColor3f(const State &glState,
                           bool isCallValid,
                           GLfloat red,
                           GLfloat green,
                           GLfloat blue)
{ … }

CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureColor3i(const State &glState,
                           bool isCallValid,
                           GLint red,
                           GLint green,
                           GLint blue)
{ … }

CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureColor3s(const State &glState,
                           bool isCallValid,
                           GLshort red,
                           GLshort green,
                           GLshort blue)
{ … }

CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureColor3ub(const State &glState,
                            bool isCallValid,
                            GLubyte red,
                            GLubyte green,
                            GLubyte blue)
{ … }

CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v)
{ … }

CallCapture CaptureColor3ui(const State &glState,
                            bool isCallValid,
                            GLuint red,
                            GLuint green,
                            GLuint blue)
{ … }

CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v)
{ … }

CallCapture CaptureColor3us(const State &glState,
                            bool isCallValid,
                            GLushort red,
                            GLushort green,
                            GLushort blue)
{ … }

CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v)
{ … }

CallCapture CaptureColor4b(const State &glState,
                           bool isCallValid,
                           GLbyte red,
                           GLbyte green,
                           GLbyte blue,
                           GLbyte alpha)
{ … }

CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v)
{ … }

CallCapture CaptureColor4d(const State &glState,
                           bool isCallValid,
                           GLdouble red,
                           GLdouble green,
                           GLdouble blue,
                           GLdouble alpha)
{ … }

CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureColor4i(const State &glState,
                           bool isCallValid,
                           GLint red,
                           GLint green,
                           GLint blue,
                           GLint alpha)
{ … }

CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureColor4s(const State &glState,
                           bool isCallValid,
                           GLshort red,
                           GLshort green,
                           GLshort blue,
                           GLshort alpha)
{ … }

CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v)
{ … }

CallCapture CaptureColor4ui(const State &glState,
                            bool isCallValid,
                            GLuint red,
                            GLuint green,
                            GLuint blue,
                            GLuint alpha)
{ … }

CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v)
{ … }

CallCapture CaptureColor4us(const State &glState,
                            bool isCallValid,
                            GLushort red,
                            GLushort green,
                            GLushort blue,
                            GLushort alpha)
{ … }

CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v)
{ … }

CallCapture CaptureColorMaterial(const State &glState, bool isCallValid, GLenum face, GLenum mode)
{ … }

CallCapture CaptureCopyPixels(const State &glState,
                              bool isCallValid,
                              GLint x,
                              GLint y,
                              GLsizei width,
                              GLsizei height,
                              GLenum type)
{ … }

CallCapture CaptureDeleteLists(const State &glState, bool isCallValid, GLuint list, GLsizei range)
{ … }

CallCapture CaptureDepthRange(const State &glState, bool isCallValid, GLdouble n, GLdouble f)
{ … }

CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf)
{ … }

CallCapture CaptureDrawPixels(const State &glState,
                              bool isCallValid,
                              GLsizei width,
                              GLsizei height,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
{ … }

CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag)
{ … }

CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag)
{ … }

CallCapture CaptureEnd(const State &glState, bool isCallValid)
{ … }

CallCapture CaptureEndList(const State &glState, bool isCallValid)
{ … }

CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u)
{ … }

CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u)
{ … }

CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u)
{ … }

CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u)
{ … }

CallCapture CaptureEvalCoord2d(const State &glState, bool isCallValid, GLdouble u, GLdouble v)
{ … }

CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u)
{ … }

CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v)
{ … }

CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u)
{ … }

CallCapture CaptureEvalMesh1(const State &glState,
                             bool isCallValid,
                             GLenum mode,
                             GLint i1,
                             GLint i2)
{ … }

CallCapture CaptureEvalMesh2(const State &glState,
                             bool isCallValid,
                             GLenum mode,
                             GLint i1,
                             GLint i2,
                             GLint j1,
                             GLint j2)
{ … }

CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i)
{ … }

CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j)
{ … }

CallCapture CaptureFeedbackBuffer(const State &glState,
                                  bool isCallValid,
                                  GLsizei size,
                                  GLenum type,
                                  GLfloat *buffer)
{ … }

CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param)
{ … }

CallCapture CaptureFogiv(const State &glState, bool isCallValid, GLenum pname, const GLint *params)
{ … }

CallCapture CaptureFrustum(const State &glState,
                           bool isCallValid,
                           GLdouble left,
                           GLdouble right,
                           GLdouble bottom,
                           GLdouble top,
                           GLdouble zNear,
                           GLdouble zFar)
{ … }

CallCapture CaptureGenLists(const State &glState,
                            bool isCallValid,
                            GLsizei range,
                            GLuint returnValue)
{ … }

CallCapture CaptureGetClipPlane(const State &glState,
                                bool isCallValid,
                                GLenum plane,
                                GLdouble *equation)
{ … }

CallCapture CaptureGetDoublev(const State &glState, bool isCallValid, GLenum pname, GLdouble *data)
{ … }

CallCapture CaptureGetLightiv(const State &glState,
                              bool isCallValid,
                              GLenum light,
                              GLenum pname,
                              GLint *params)
{ … }

CallCapture CaptureGetMapdv(const State &glState,
                            bool isCallValid,
                            GLenum target,
                            GLenum query,
                            GLdouble *v)
{ … }

CallCapture CaptureGetMapfv(const State &glState,
                            bool isCallValid,
                            GLenum target,
                            GLenum query,
                            GLfloat *v)
{ … }

CallCapture CaptureGetMapiv(const State &glState,
                            bool isCallValid,
                            GLenum target,
                            GLenum query,
                            GLint *v)
{ … }

CallCapture CaptureGetMaterialiv(const State &glState,
                                 bool isCallValid,
                                 GLenum face,
                                 GLenum pname,
                                 GLint *params)
{ … }

CallCapture CaptureGetPixelMapfv(const State &glState,
                                 bool isCallValid,
                                 GLenum map,
                                 GLfloat *values)
{ … }

CallCapture CaptureGetPixelMapuiv(const State &glState,
                                  bool isCallValid,
                                  GLenum map,
                                  GLuint *values)
{ … }

CallCapture CaptureGetPixelMapusv(const State &glState,
                                  bool isCallValid,
                                  GLenum map,
                                  GLushort *values)
{ … }

CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask)
{ … }

CallCapture CaptureGetTexGendv(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLdouble *params)
{ … }

CallCapture CaptureGetTexGenfv(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLfloat *params)
{ … }

CallCapture CaptureGetTexGeniv(const State &glState,
                               bool isCallValid,
                               GLenum coord,
                               GLenum pname,
                               GLint *params)
{ … }

CallCapture CaptureGetTexImage(const State &glState,
                               bool isCallValid,
                               TextureTarget targetPacked,
                               GLint level,
                               GLenum format,
                               GLenum type,
                               void *pixels)
{ … }

CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask)
{ … }

CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c)
{ … }

CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c)
{ … }

CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c)
{ … }

CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c)
{ … }

CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c)
{ … }

CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c)
{ … }

CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c)
{ … }

CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c)
{ … }

CallCapture CaptureInitNames(const State &glState, bool isCallValid)
{ … }

CallCapture CaptureIsList(const State &glState,
                          bool isCallValid,
                          GLuint list,
                          GLboolean returnValue)
{ … }

CallCapture CaptureLightModeli(const State &glState, bool isCallValid, GLenum pname, GLint param)
{ … }

CallCapture CaptureLightModeliv(const State &glState,
                                bool isCallValid,
                                GLenum pname,
                                const GLint *params)
{ … }

CallCapture CaptureLighti(const State &glState,
                          bool isCallValid,
                          GLenum light,
                          GLenum pname,
                          GLint param)
{ … }

CallCapture CaptureLightiv(const State &glState,
                           bool isCallValid,
                           GLenum light,
                           GLenum pname,
                           const GLint *params)
{ … }

CallCapture CaptureLineStipple(const State &glState,
                               bool isCallValid,
                               GLint factor,
                               GLushort pattern)
{ … }

CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base)
{ … }

CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m)
{ … }

CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name)
{ … }

CallCapture CaptureMap1d(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLdouble u1,
                         GLdouble u2,
                         GLint stride,
                         GLint order,
                         const GLdouble *points)
{ … }

CallCapture CaptureMap1f(const State &glState,
                         bool isCallValid,
                         GLenum target,
                         GLfloat u1,
                         GLfloat u2,
                         GLint stride,
                         GLint order,
                         const GLfloat *points)
{ … }

CallCapture CaptureMap2d(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)
{ … }

CallCapture CaptureMap2f(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)
{ … }

CallCapture CaptureMapGrid1d(const State &glState,
                             bool isCallValid,
                             GLint un,
                             GLdouble u1,
                             GLdouble u2)
{ … }

CallCapture CaptureMapGrid1f(const State &glState,
                             bool isCallValid,
                             GLint un,
                             GLfloat u1,
                             GLfloat u2)
{ … }

CallCapture CaptureMapGrid2d(const State &glState,
                             bool isCallValid,
                             GLint un,
                             GLdouble u1,
                             GLdouble u2,
                             GLint vn,
                             GLdouble v1,
                             GLdouble v2)
{ … }

CallCapture CaptureMapGrid2f(const State &glState,
                             bool isCallValid,
                             GLint un,
                             GLfloat u1,
                             GLfloat u2,
                             GLint vn,
                             GLfloat v1,
                             GLfloat v2)
{ … }

CallCapture CaptureMateriali(const State &glState,
                             bool isCallValid,
                             GLenum face,
                             GLenum pname,
                             GLint param)
{ … }

CallCapture CaptureMaterialiv(const State &glState,
                              bool isCallValid,
                              GLenum face,
                              GLenum pname,
                              const GLint *params)
{ … }

CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m)
{ … }

CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode)
{ … }

CallCapture CaptureNormal3b(const State &glState, bool isCallValid, GLbyte nx, GLbyte ny, GLbyte nz)
{ … }

CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v)
{ … }

CallCapture CaptureNormal3d(const State &glState,
                            bool isCallValid,
                            GLdouble nx,
                            GLdouble ny,
                            GLdouble nz)
{ … }

CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureNormal3i(const State &glState, bool isCallValid, GLint nx, GLint ny, GLint nz)
{ … }

CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureNormal3s(const State &glState,
                            bool isCallValid,
                            GLshort nx,
                            GLshort ny,
                            GLshort nz)
{ … }

CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureOrtho(const State &glState,
                         bool isCallValid,
                         GLdouble left,
                         GLdouble right,
                         GLdouble bottom,
                         GLdouble top,
                         GLdouble zNear,
                         GLdouble zFar)
{ … }

CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token)
{ … }

CallCapture CapturePixelMapfv(const State &glState,
                              bool isCallValid,
                              GLenum map,
                              GLsizei mapsize,
                              const GLfloat *values)
{ … }

CallCapture CapturePixelMapuiv(const State &glState,
                               bool isCallValid,
                               GLenum map,
                               GLsizei mapsize,
                               const GLuint *values)
{ … }

CallCapture CapturePixelMapusv(const State &glState,
                               bool isCallValid,
                               GLenum map,
                               GLsizei mapsize,
                               const GLushort *values)
{ … }

CallCapture CapturePixelStoref(const State &glState, bool isCallValid, GLenum pname, GLfloat param)
{ … }

CallCapture CapturePixelTransferf(const State &glState,
                                  bool isCallValid,
                                  GLenum pname,
                                  GLfloat param)
{ … }

CallCapture CapturePixelTransferi(const State &glState, bool isCallValid, GLenum pname, GLint param)
{ … }

CallCapture CapturePixelZoom(const State &glState,
                             bool isCallValid,
                             GLfloat xfactor,
                             GLfloat yfactor)
{ … }

CallCapture CapturePolygonMode(const State &glState,
                               bool isCallValid,
                               GLenum face,
                               PolygonMode modePacked)
{ … }

CallCapture CapturePolygonStipple(const State &glState, bool isCallValid, const GLubyte *mask)
{ … }

CallCapture CapturePopAttrib(const State &glState, bool isCallValid)
{ … }

CallCapture CapturePopName(const State &glState, bool isCallValid)
{ … }

CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask)
{ … }

CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name)
{ … }

CallCapture CaptureRasterPos2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y)
{ … }

CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y)
{ … }

CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y)
{ … }

CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y)
{ … }

CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureRasterPos3d(const State &glState,
                               bool isCallValid,
                               GLdouble x,
                               GLdouble y,
                               GLdouble z)
{ … }

CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureRasterPos3f(const State &glState,
                               bool isCallValid,
                               GLfloat x,
                               GLfloat y,
                               GLfloat z)
{ … }

CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureRasterPos3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z)
{ … }

CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureRasterPos3s(const State &glState,
                               bool isCallValid,
                               GLshort x,
                               GLshort y,
                               GLshort z)
{ … }

CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureRasterPos4d(const State &glState,
                               bool isCallValid,
                               GLdouble x,
                               GLdouble y,
                               GLdouble z,
                               GLdouble w)
{ … }

CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureRasterPos4f(const State &glState,
                               bool isCallValid,
                               GLfloat x,
                               GLfloat y,
                               GLfloat z,
                               GLfloat w)
{ … }

CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureRasterPos4i(const State &glState,
                               bool isCallValid,
                               GLint x,
                               GLint y,
                               GLint z,
                               GLint w)
{ … }

CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureRasterPos4s(const State &glState,
                               bool isCallValid,
                               GLshort x,
                               GLshort y,
                               GLshort z,
                               GLshort w)
{ … }

CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureRectd(const State &glState,
                         bool isCallValid,
                         GLdouble x1,
                         GLdouble y1,
                         GLdouble x2,
                         GLdouble y2)
{ … }

CallCapture CaptureRectdv(const State &glState,
                          bool isCallValid,
                          const GLdouble *v1,
                          const GLdouble *v2)
{ … }

CallCapture CaptureRectf(const State &glState,
                         bool isCallValid,
                         GLfloat x1,
                         GLfloat y1,
                         GLfloat x2,
                         GLfloat y2)
{ … }

CallCapture CaptureRectfv(const State &glState,
                          bool isCallValid,
                          const GLfloat *v1,
                          const GLfloat *v2)
{ … }

CallCapture CaptureRecti(const State &glState,
                         bool isCallValid,
                         GLint x1,
                         GLint y1,
                         GLint x2,
                         GLint y2)
{ … }

CallCapture CaptureRectiv(const State &glState, bool isCallValid, const GLint *v1, const GLint *v2)
{ … }

CallCapture CaptureRects(const State &glState,
                         bool isCallValid,
                         GLshort x1,
                         GLshort y1,
                         GLshort x2,
                         GLshort y2)
{ … }

CallCapture CaptureRectsv(const State &glState,
                          bool isCallValid,
                          const GLshort *v1,
                          const GLshort *v2)
{ … }

CallCapture CaptureRenderMode(const State &glState,
                              bool isCallValid,
                              GLenum mode,
                              GLint returnValue)
{ … }

CallCapture CaptureRotated(const State &glState,
                           bool isCallValid,
                           GLdouble angle,
                           GLdouble x,
                           GLdouble y,
                           GLdouble z)
{ … }

CallCapture CaptureScaled(const State &glState,
                          bool isCallValid,
                          GLdouble x,
                          GLdouble y,
                          GLdouble z)
{ … }

CallCapture CaptureSelectBuffer(const State &glState,
                                bool isCallValid,
                                GLsizei size,
                                GLuint *buffer)
{ … }

CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s)
{ … }

CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s)
{ … }

CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s)
{ … }

CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s)
{ … }

CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureTexCoord2d(const State &glState, bool isCallValid, GLdouble s, GLdouble t)
{ … }

CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t)
{ … }

CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t)
{ … }

CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t)
{ … }

CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureTexCoord3d(const State &glState,
                              bool isCallValid,
                              GLdouble s,
                              GLdouble t,
                              GLdouble r)
{ … }

CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureTexCoord3f(const State &glState,
                              bool isCallValid,
                              GLfloat s,
                              GLfloat t,
                              GLfloat r)
{ … }

CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureTexCoord3i(const State &glState, bool isCallValid, GLint s, GLint t, GLint r)
{ … }

CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureTexCoord3s(const State &glState,
                              bool isCallValid,
                              GLshort s,
                              GLshort t,
                              GLshort r)
{ … }

CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureTexCoord4d(const State &glState,
                              bool isCallValid,
                              GLdouble s,
                              GLdouble t,
                              GLdouble r,
                              GLdouble q)
{ … }

CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureTexCoord4f(const State &glState,
                              bool isCallValid,
                              GLfloat s,
                              GLfloat t,
                              GLfloat r,
                              GLfloat q)
{ … }

CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureTexCoord4i(const State &glState,
                              bool isCallValid,
                              GLint s,
                              GLint t,
                              GLint r,
                              GLint q)
{ … }

CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureTexCoord4s(const State &glState,
                              bool isCallValid,
                              GLshort s,
                              GLshort t,
                              GLshort r,
                              GLshort q)
{ … }

CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureTexGend(const State &glState,
                           bool isCallValid,
                           GLenum coord,
                           GLenum pname,
                           GLdouble param)
{ … }

CallCapture CaptureTexGendv(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLdouble *params)
{ … }

CallCapture CaptureTexGenf(const State &glState,
                           bool isCallValid,
                           GLenum coord,
                           GLenum pname,
                           GLfloat param)
{ … }

CallCapture CaptureTexGenfv(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLfloat *params)
{ … }

CallCapture CaptureTexGeni(const State &glState,
                           bool isCallValid,
                           GLenum coord,
                           GLenum pname,
                           GLint param)
{ … }

CallCapture CaptureTexGeniv(const State &glState,
                            bool isCallValid,
                            GLenum coord,
                            GLenum pname,
                            const GLint *params)
{ … }

CallCapture CaptureTexImage1D(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLint level,
                              GLint internalformat,
                              GLsizei width,
                              GLint border,
                              GLenum format,
                              GLenum type,
                              const void *pixels)
{ … }

CallCapture CaptureTranslated(const State &glState,
                              bool isCallValid,
                              GLdouble x,
                              GLdouble y,
                              GLdouble z)
{ … }

CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y)
{ … }

CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y)
{ … }

CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y)
{ … }

CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y)
{ … }

CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureVertex3d(const State &glState,
                            bool isCallValid,
                            GLdouble x,
                            GLdouble y,
                            GLdouble z)
{ … }

CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureVertex3f(const State &glState, bool isCallValid, GLfloat x, GLfloat y, GLfloat z)
{ … }

CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureVertex3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z)
{ … }

CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureVertex3s(const State &glState, bool isCallValid, GLshort x, GLshort y, GLshort z)
{ … }

CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureVertex4d(const State &glState,
                            bool isCallValid,
                            GLdouble x,
                            GLdouble y,
                            GLdouble z,
                            GLdouble w)
{ … }

CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureVertex4f(const State &glState,
                            bool isCallValid,
                            GLfloat x,
                            GLfloat y,
                            GLfloat z,
                            GLfloat w)
{ … }

CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureVertex4i(const State &glState,
                            bool isCallValid,
                            GLint x,
                            GLint y,
                            GLint z,
                            GLint w)
{ … }

CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureVertex4s(const State &glState,
                            bool isCallValid,
                            GLshort x,
                            GLshort y,
                            GLshort z,
                            GLshort w)
{ … }

CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

// GL 1.1
CallCapture CaptureAreTexturesResident(const State &glState,
                                       bool isCallValid,
                                       GLsizei n,
                                       const GLuint *textures,
                                       GLboolean *residences,
                                       GLboolean returnValue)
{ … }

CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i)
{ … }

CallCapture CaptureCopyTexImage1D(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLint level,
                                  GLenum internalformat,
                                  GLint x,
                                  GLint y,
                                  GLsizei width,
                                  GLint border)
{ … }

CallCapture CaptureCopyTexSubImage1D(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLint level,
                                     GLint xoffset,
                                     GLint x,
                                     GLint y,
                                     GLsizei width)
{ … }

CallCapture CaptureEdgeFlagPointer(const State &glState,
                                   bool isCallValid,
                                   GLsizei stride,
                                   const void *pointer)
{ … }

CallCapture CaptureIndexPointer(const State &glState,
                                bool isCallValid,
                                GLenum type,
                                GLsizei stride,
                                const void *pointer)
{ … }

CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c)
{ … }

CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c)
{ … }

CallCapture CaptureInterleavedArrays(const State &glState,
                                     bool isCallValid,
                                     GLenum format,
                                     GLsizei stride,
                                     const void *pointer)
{ … }

CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid)
{ … }

CallCapture CapturePrioritizeTextures(const State &glState,
                                      bool isCallValid,
                                      GLsizei n,
                                      const GLuint *textures,
                                      const GLfloat *priorities)
{ … }

CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask)
{ … }

CallCapture CaptureTexSubImage1D(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLint level,
                                 GLint xoffset,
                                 GLsizei width,
                                 GLenum format,
                                 GLenum type,
                                 const void *pixels)
{ … }

// GL 1.2

// GL 1.3
CallCapture CaptureCompressedTexImage1D(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLint level,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLint border,
                                        GLsizei imageSize,
                                        const void *data)
{ … }

CallCapture CaptureCompressedTexSubImage1D(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLint level,
                                           GLint xoffset,
                                           GLsizei width,
                                           GLenum format,
                                           GLsizei imageSize,
                                           const void *data)
{ … }

CallCapture CaptureGetCompressedTexImage(const State &glState,
                                         bool isCallValid,
                                         TextureTarget targetPacked,
                                         GLint level,
                                         void *img)
{ … }

CallCapture CaptureLoadTransposeMatrixd(const State &glState, bool isCallValid, const GLdouble *m)
{ … }

CallCapture CaptureLoadTransposeMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
{ … }

CallCapture CaptureMultTransposeMatrixd(const State &glState, bool isCallValid, const GLdouble *m)
{ … }

CallCapture CaptureMultTransposeMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
{ … }

CallCapture CaptureMultiTexCoord1d(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLdouble s)
{ … }

CallCapture CaptureMultiTexCoord1dv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLdouble *v)
{ … }

CallCapture CaptureMultiTexCoord1f(const State &glState, bool isCallValid, GLenum target, GLfloat s)
{ … }

CallCapture CaptureMultiTexCoord1fv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLfloat *v)
{ … }

CallCapture CaptureMultiTexCoord1i(const State &glState, bool isCallValid, GLenum target, GLint s)
{ … }

CallCapture CaptureMultiTexCoord1iv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLint *v)
{ … }

CallCapture CaptureMultiTexCoord1s(const State &glState, bool isCallValid, GLenum target, GLshort s)
{ … }

CallCapture CaptureMultiTexCoord1sv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLshort *v)
{ … }

CallCapture CaptureMultiTexCoord2d(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLdouble s,
                                   GLdouble t)
{ … }

CallCapture CaptureMultiTexCoord2dv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLdouble *v)
{ … }

CallCapture CaptureMultiTexCoord2f(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLfloat s,
                                   GLfloat t)
{ … }

CallCapture CaptureMultiTexCoord2fv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLfloat *v)
{ … }

CallCapture CaptureMultiTexCoord2i(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLint s,
                                   GLint t)
{ … }

CallCapture CaptureMultiTexCoord2iv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLint *v)
{ … }

CallCapture CaptureMultiTexCoord2s(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLshort s,
                                   GLshort t)
{ … }

CallCapture CaptureMultiTexCoord2sv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLshort *v)
{ … }

CallCapture CaptureMultiTexCoord3d(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLdouble s,
                                   GLdouble t,
                                   GLdouble r)
{ … }

CallCapture CaptureMultiTexCoord3dv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLdouble *v)
{ … }

CallCapture CaptureMultiTexCoord3f(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLfloat s,
                                   GLfloat t,
                                   GLfloat r)
{ … }

CallCapture CaptureMultiTexCoord3fv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLfloat *v)
{ … }

CallCapture CaptureMultiTexCoord3i(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLint s,
                                   GLint t,
                                   GLint r)
{ … }

CallCapture CaptureMultiTexCoord3iv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLint *v)
{ … }

CallCapture CaptureMultiTexCoord3s(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLshort s,
                                   GLshort t,
                                   GLshort r)
{ … }

CallCapture CaptureMultiTexCoord3sv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLshort *v)
{ … }

CallCapture CaptureMultiTexCoord4d(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLdouble s,
                                   GLdouble t,
                                   GLdouble r,
                                   GLdouble q)
{ … }

CallCapture CaptureMultiTexCoord4dv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLdouble *v)
{ … }

CallCapture CaptureMultiTexCoord4fv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLfloat *v)
{ … }

CallCapture CaptureMultiTexCoord4i(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLint s,
                                   GLint t,
                                   GLint r,
                                   GLint q)
{ … }

CallCapture CaptureMultiTexCoord4iv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLint *v)
{ … }

CallCapture CaptureMultiTexCoord4s(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLshort s,
                                   GLshort t,
                                   GLshort r,
                                   GLshort q)
{ … }

CallCapture CaptureMultiTexCoord4sv(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    const GLshort *v)
{ … }

// GL 1.4
CallCapture CaptureFogCoordPointer(const State &glState,
                                   bool isCallValid,
                                   GLenum type,
                                   GLsizei stride,
                                   const void *pointer)
{ … }

CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord)
{ … }

CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord)
{ … }

CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord)
{ … }

CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord)
{ … }

CallCapture CaptureMultiDrawArrays(const State &glState,
                                   bool isCallValid,
                                   PrimitiveMode modePacked,
                                   const GLint *first,
                                   const GLsizei *count,
                                   GLsizei drawcount)
{ … }

CallCapture CaptureMultiDrawElements(const State &glState,
                                     bool isCallValid,
                                     PrimitiveMode modePacked,
                                     const GLsizei *count,
                                     DrawElementsType typePacked,
                                     const void *const *indices,
                                     GLsizei drawcount)
{ … }

CallCapture CapturePointParameteri(const State &glState,
                                   bool isCallValid,
                                   GLenum pname,
                                   GLint param)
{ … }

CallCapture CapturePointParameteriv(const State &glState,
                                    bool isCallValid,
                                    GLenum pname,
                                    const GLint *params)
{ … }

CallCapture CaptureSecondaryColor3b(const State &glState,
                                    bool isCallValid,
                                    GLbyte red,
                                    GLbyte green,
                                    GLbyte blue)
{ … }

CallCapture CaptureSecondaryColor3bv(const State &glState, bool isCallValid, const GLbyte *v)
{ … }

CallCapture CaptureSecondaryColor3d(const State &glState,
                                    bool isCallValid,
                                    GLdouble red,
                                    GLdouble green,
                                    GLdouble blue)
{ … }

CallCapture CaptureSecondaryColor3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureSecondaryColor3f(const State &glState,
                                    bool isCallValid,
                                    GLfloat red,
                                    GLfloat green,
                                    GLfloat blue)
{ … }

CallCapture CaptureSecondaryColor3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureSecondaryColor3i(const State &glState,
                                    bool isCallValid,
                                    GLint red,
                                    GLint green,
                                    GLint blue)
{ … }

CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureSecondaryColor3s(const State &glState,
                                    bool isCallValid,
                                    GLshort red,
                                    GLshort green,
                                    GLshort blue)
{ … }

CallCapture CaptureSecondaryColor3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureSecondaryColor3ub(const State &glState,
                                     bool isCallValid,
                                     GLubyte red,
                                     GLubyte green,
                                     GLubyte blue)
{ … }

CallCapture CaptureSecondaryColor3ubv(const State &glState, bool isCallValid, const GLubyte *v)
{ … }

CallCapture CaptureSecondaryColor3ui(const State &glState,
                                     bool isCallValid,
                                     GLuint red,
                                     GLuint green,
                                     GLuint blue)
{ … }

CallCapture CaptureSecondaryColor3uiv(const State &glState, bool isCallValid, const GLuint *v)
{ … }

CallCapture CaptureSecondaryColor3us(const State &glState,
                                     bool isCallValid,
                                     GLushort red,
                                     GLushort green,
                                     GLushort blue)
{ … }

CallCapture CaptureSecondaryColor3usv(const State &glState, bool isCallValid, const GLushort *v)
{ … }

CallCapture CaptureSecondaryColorPointer(const State &glState,
                                         bool isCallValid,
                                         GLint size,
                                         GLenum type,
                                         GLsizei stride,
                                         const void *pointer)
{ … }

CallCapture CaptureWindowPos2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y)
{ … }

CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y)
{ … }

CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y)
{ … }

CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y)
{ … }

CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

CallCapture CaptureWindowPos3d(const State &glState,
                               bool isCallValid,
                               GLdouble x,
                               GLdouble y,
                               GLdouble z)
{ … }

CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v)
{ … }

CallCapture CaptureWindowPos3f(const State &glState,
                               bool isCallValid,
                               GLfloat x,
                               GLfloat y,
                               GLfloat z)
{ … }

CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v)
{ … }

CallCapture CaptureWindowPos3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z)
{ … }

CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v)
{ … }

CallCapture CaptureWindowPos3s(const State &glState,
                               bool isCallValid,
                               GLshort x,
                               GLshort y,
                               GLshort z)
{ … }

CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v)
{ … }

// GL 1.5
CallCapture CaptureGetBufferSubData(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLintptr offset,
                                    GLsizeiptr size,
                                    void *data)
{ … }

CallCapture CaptureGetQueryObjectiv(const State &glState,
                                    bool isCallValid,
                                    QueryID idPacked,
                                    GLenum pname,
                                    GLint *params)
{ … }

CallCapture CaptureMapBuffer(const State &glState,
                             bool isCallValid,
                             BufferBinding targetPacked,
                             GLenum access,
                             void *returnValue)
{ … }

}  // namespace gl