chromium/third_party/angle/src/libANGLE/capture/capture_gl_4_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_4_autogen.cpp:
//   Capture functions for the OpenGL ES Desktop GL 4.x entry points.

#include "libANGLE/capture/capture_gl_4_autogen.h"

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

usingnamespaceangle;

namespace gl
{

// GL 4.0
CallCapture CaptureBeginQueryIndexed(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index,
                                     QueryID idPacked)
{ … }

CallCapture CaptureDrawTransformFeedback(const State &glState,
                                         bool isCallValid,
                                         GLenum mode,
                                         TransformFeedbackID idPacked)
{ … }

CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
                                               bool isCallValid,
                                               GLenum mode,
                                               TransformFeedbackID idPacked,
                                               GLuint stream)
{ … }

CallCapture CaptureEndQueryIndexed(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLuint index)
{ … }

CallCapture CaptureGetActiveSubroutineName(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           GLenum shadertype,
                                           GLuint index,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLchar *name)
{ … }

CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLsizei bufSize,
                                                  GLsizei *length,
                                                  GLchar *name)
{ … }

CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                GLenum shadertype,
                                                GLuint index,
                                                GLenum pname,
                                                GLint *values)
{ … }

CallCapture CaptureGetProgramStageiv(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     GLenum shadertype,
                                     GLenum pname,
                                     GLint *values)
{ … }

CallCapture CaptureGetQueryIndexediv(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index,
                                     GLenum pname,
                                     GLint *params)
{ … }

CallCapture CaptureGetSubroutineIndex(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      GLenum shadertype,
                                      const GLchar *name,
                                      GLuint returnValue)
{ … }

CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
                                                bool isCallValid,
                                                ShaderProgramID programPacked,
                                                GLenum shadertype,
                                                const GLchar *name,
                                                GLint returnValue)
{ … }

CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
                                           bool isCallValid,
                                           GLenum shadertype,
                                           GLint location,
                                           GLuint *params)
{ … }

CallCapture CaptureGetUniformdv(const State &glState,
                                bool isCallValid,
                                ShaderProgramID programPacked,
                                UniformLocation locationPacked,
                                GLdouble *params)
{ … }

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

CallCapture CaptureUniform1d(const State &glState,
                             bool isCallValid,
                             UniformLocation locationPacked,
                             GLdouble x)
{ … }

CallCapture CaptureUniform1dv(const State &glState,
                              bool isCallValid,
                              UniformLocation locationPacked,
                              GLsizei count,
                              const GLdouble *value)
{ … }

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

CallCapture CaptureUniform2dv(const State &glState,
                              bool isCallValid,
                              UniformLocation locationPacked,
                              GLsizei count,
                              const GLdouble *value)
{ … }

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

CallCapture CaptureUniform3dv(const State &glState,
                              bool isCallValid,
                              UniformLocation locationPacked,
                              GLsizei count,
                              const GLdouble *value)
{ … }

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

CallCapture CaptureUniform4dv(const State &glState,
                              bool isCallValid,
                              UniformLocation locationPacked,
                              GLsizei count,
                              const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix2dv(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix2x3dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix2x4dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix3dv(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix3x2dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix3x4dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix4dv(const State &glState,
                                    bool isCallValid,
                                    UniformLocation locationPacked,
                                    GLsizei count,
                                    GLboolean transpose,
                                    const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix4x2dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformMatrix4x3dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
{ … }

CallCapture CaptureUniformSubroutinesuiv(const State &glState,
                                         bool isCallValid,
                                         GLenum shadertype,
                                         GLsizei count,
                                         const GLuint *indices)
{ … }

// GL 4.1
CallCapture CaptureDepthRangeArrayv(const State &glState,
                                    bool isCallValid,
                                    GLuint first,
                                    GLsizei count,
                                    const GLdouble *v)
{ … }

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

CallCapture CaptureGetDoublei_v(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLuint index,
                                GLdouble *data)
{ … }

CallCapture CaptureGetFloati_v(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLuint index,
                               GLfloat *data)
{ … }

CallCapture CaptureGetVertexAttribLdv(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      GLenum pname,
                                      GLdouble *params)
{ … }

CallCapture CaptureProgramUniform1d(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLdouble v0)
{ … }

CallCapture CaptureProgramUniform1dv(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value)
{ … }

CallCapture CaptureProgramUniform2d(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLdouble v0,
                                    GLdouble v1)
{ … }

CallCapture CaptureProgramUniform2dv(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value)
{ … }

CallCapture CaptureProgramUniform3d(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLdouble v0,
                                    GLdouble v1,
                                    GLdouble v2)
{ … }

CallCapture CaptureProgramUniform3dv(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value)
{ … }

CallCapture CaptureProgramUniform4d(const State &glState,
                                    bool isCallValid,
                                    ShaderProgramID programPacked,
                                    UniformLocation locationPacked,
                                    GLdouble v0,
                                    GLdouble v1,
                                    GLdouble v2,
                                    GLdouble v3)
{ … }

CallCapture CaptureProgramUniform4dv(const State &glState,
                                     bool isCallValid,
                                     ShaderProgramID programPacked,
                                     UniformLocation locationPacked,
                                     GLsizei count,
                                     const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
                                           bool isCallValid,
                                           ShaderProgramID programPacked,
                                           UniformLocation locationPacked,
                                           GLsizei count,
                                           GLboolean transpose,
                                           const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
{ … }

CallCapture CaptureScissorArrayv(const State &glState,
                                 bool isCallValid,
                                 GLuint first,
                                 GLsizei count,
                                 const GLint *v)
{ … }

CallCapture CaptureScissorIndexed(const State &glState,
                                  bool isCallValid,
                                  GLuint index,
                                  GLint left,
                                  GLint bottom,
                                  GLsizei width,
                                  GLsizei height)
{ … }

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

CallCapture CaptureVertexAttribL1d(const State &glState, bool isCallValid, GLuint index, GLdouble x)
{ … }

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

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

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

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

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

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

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

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

CallCapture CaptureViewportArrayv(const State &glState,
                                  bool isCallValid,
                                  GLuint first,
                                  GLsizei count,
                                  const GLfloat *v)
{ … }

CallCapture CaptureViewportIndexedf(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    GLfloat x,
                                    GLfloat y,
                                    GLfloat w,
                                    GLfloat h)
{ … }

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

// GL 4.2
CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
                                                   bool isCallValid,
                                                   PrimitiveMode modePacked,
                                                   GLint first,
                                                   GLsizei count,
                                                   GLsizei instancecount,
                                                   GLuint baseinstance)
{ … }

CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
                                                     bool isCallValid,
                                                     PrimitiveMode modePacked,
                                                     GLsizei count,
                                                     DrawElementsType typePacked,
                                                     const void *indices,
                                                     GLsizei instancecount,
                                                     GLuint baseinstance)
{ … }

CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
                                                               bool isCallValid,
                                                               PrimitiveMode modePacked,
                                                               GLsizei count,
                                                               DrawElementsType typePacked,
                                                               const void *indices,
                                                               GLsizei instancecount,
                                                               GLint basevertex,
                                                               GLuint baseinstance)
{ … }

CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
                                                  bool isCallValid,
                                                  GLenum mode,
                                                  TransformFeedbackID idPacked,
                                                  GLsizei instancecount)
{ … }

CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
                                                        bool isCallValid,
                                                        GLenum mode,
                                                        TransformFeedbackID idPacked,
                                                        GLuint stream,
                                                        GLsizei instancecount)
{ … }

CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLuint bufferIndex,
                                                  GLenum pname,
                                                  GLint *params)
{ … }

CallCapture CaptureTexStorage1D(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLsizei levels,
                                GLenum internalformat,
                                GLsizei width)
{ … }

// GL 4.3
CallCapture CaptureClearBufferData(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLenum internalformat,
                                   GLenum format,
                                   GLenum type,
                                   const void *data)
{ … }

CallCapture CaptureClearBufferSubData(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLenum internalformat,
                                      GLintptr offset,
                                      GLsizeiptr size,
                                      GLenum format,
                                      GLenum type,
                                      const void *data)
{ … }

CallCapture CaptureGetInternalformati64v(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLenum internalformat,
                                         GLenum pname,
                                         GLsizei count,
                                         GLint64 *params)
{ … }

CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
                                                   bool isCallValid,
                                                   ShaderProgramID programPacked,
                                                   GLenum programInterface,
                                                   const GLchar *name,
                                                   GLint returnValue)
{ … }

CallCapture CaptureInvalidateBufferData(const State &glState,
                                        bool isCallValid,
                                        BufferID bufferPacked)
{ … }

CallCapture CaptureInvalidateBufferSubData(const State &glState,
                                           bool isCallValid,
                                           BufferID bufferPacked,
                                           GLintptr offset,
                                           GLsizeiptr length)
{ … }

CallCapture CaptureInvalidateTexImage(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLint level)
{ … }

CallCapture CaptureInvalidateTexSubImage(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLsizei width,
                                         GLsizei height,
                                         GLsizei depth)
{ … }

CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
                                           bool isCallValid,
                                           PrimitiveMode modePacked,
                                           const void *indirect,
                                           GLsizei drawcount,
                                           GLsizei stride)
{ … }

CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
                                             bool isCallValid,
                                             PrimitiveMode modePacked,
                                             DrawElementsType typePacked,
                                             const void *indirect,
                                             GLsizei drawcount,
                                             GLsizei stride)
{ … }

CallCapture CaptureShaderStorageBlockBinding(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLuint storageBlockIndex,
                                             GLuint storageBlockBinding)
{ … }

CallCapture CaptureTextureView(const State &glState,
                               bool isCallValid,
                               TextureID texturePacked,
                               GLenum target,
                               GLuint origtexture,
                               GLenum internalformat,
                               GLuint minlevel,
                               GLuint numlevels,
                               GLuint minlayer,
                               GLuint numlayers)
{ … }

CallCapture CaptureVertexAttribLFormat(const State &glState,
                                       bool isCallValid,
                                       GLuint attribindex,
                                       GLint size,
                                       GLenum type,
                                       GLuint relativeoffset)
{ … }

// GL 4.4
CallCapture CaptureBindBuffersBase(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLuint first,
                                   GLsizei count,
                                   const BufferID *buffersPacked)
{ … }

CallCapture CaptureBindBuffersRange(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLuint first,
                                    GLsizei count,
                                    const BufferID *buffersPacked,
                                    const GLintptr *offsets,
                                    const GLsizeiptr *sizes)
{ … }

CallCapture CaptureBindImageTextures(const State &glState,
                                     bool isCallValid,
                                     GLuint first,
                                     GLsizei count,
                                     const GLuint *textures)
{ … }

CallCapture CaptureBindSamplers(const State &glState,
                                bool isCallValid,
                                GLuint first,
                                GLsizei count,
                                const GLuint *samplers)
{ … }

CallCapture CaptureBindTextures(const State &glState,
                                bool isCallValid,
                                GLuint first,
                                GLsizei count,
                                const GLuint *textures)
{ … }

CallCapture CaptureBindVertexBuffers(const State &glState,
                                     bool isCallValid,
                                     GLuint first,
                                     GLsizei count,
                                     const BufferID *buffersPacked,
                                     const GLintptr *offsets,
                                     const GLsizei *strides)
{ … }

CallCapture CaptureBufferStorage(const State &glState,
                                 bool isCallValid,
                                 BufferBinding targetPacked,
                                 GLsizeiptr size,
                                 const void *data,
                                 GLbitfield flags)
{ … }

CallCapture CaptureClearTexImage(const State &glState,
                                 bool isCallValid,
                                 TextureID texturePacked,
                                 GLint level,
                                 GLenum format,
                                 GLenum type,
                                 const void *data)
{ … }

CallCapture CaptureClearTexSubImage(const State &glState,
                                    bool isCallValid,
                                    TextureID texturePacked,
                                    GLint level,
                                    GLint xoffset,
                                    GLint yoffset,
                                    GLint zoffset,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth,
                                    GLenum format,
                                    GLenum type,
                                    const void *data)
{ … }

// GL 4.5
CallCapture CaptureBindTextureUnit(const State &glState,
                                   bool isCallValid,
                                   GLuint unit,
                                   TextureID texturePacked)
{ … }

CallCapture CaptureBlitNamedFramebuffer(const State &glState,
                                        bool isCallValid,
                                        GLuint readFramebuffer,
                                        GLuint drawFramebuffer,
                                        GLint srcX0,
                                        GLint srcY0,
                                        GLint srcX1,
                                        GLint srcY1,
                                        GLint dstX0,
                                        GLint dstY0,
                                        GLint dstX1,
                                        GLint dstY1,
                                        GLbitfield mask,
                                        GLenum filter)
{ … }

CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
                                               bool isCallValid,
                                               FramebufferID framebufferPacked,
                                               GLenum target,
                                               GLenum returnValue)
{ … }

CallCapture CaptureClearNamedBufferData(const State &glState,
                                        bool isCallValid,
                                        BufferID bufferPacked,
                                        GLenum internalformat,
                                        GLenum format,
                                        GLenum type,
                                        const void *data)
{ … }

CallCapture CaptureClearNamedBufferSubData(const State &glState,
                                           bool isCallValid,
                                           BufferID bufferPacked,
                                           GLenum internalformat,
                                           GLintptr offset,
                                           GLsizeiptr size,
                                           GLenum format,
                                           GLenum type,
                                           const void *data)
{ … }

CallCapture CaptureClearNamedFramebufferfi(const State &glState,
                                           bool isCallValid,
                                           FramebufferID framebufferPacked,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           GLfloat depth,
                                           GLint stencil)
{ … }

CallCapture CaptureClearNamedFramebufferfv(const State &glState,
                                           bool isCallValid,
                                           FramebufferID framebufferPacked,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLfloat *value)
{ … }

CallCapture CaptureClearNamedFramebufferiv(const State &glState,
                                           bool isCallValid,
                                           FramebufferID framebufferPacked,
                                           GLenum buffer,
                                           GLint drawbuffer,
                                           const GLint *value)
{ … }

CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
                                            bool isCallValid,
                                            FramebufferID framebufferPacked,
                                            GLenum buffer,
                                            GLint drawbuffer,
                                            const GLuint *value)
{ … }

CallCapture CaptureClipControl(const State &glState,
                               bool isCallValid,
                               ClipOrigin originPacked,
                               ClipDepthMode depthPacked)
{ … }

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

CallCapture CaptureCompressedTextureSubImage2D(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLenum format,
                                               GLsizei imageSize,
                                               const void *data)
{ … }

CallCapture CaptureCompressedTextureSubImage3D(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLint zoffset,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLenum format,
                                               GLsizei imageSize,
                                               const void *data)
{ … }

CallCapture CaptureCopyNamedBufferSubData(const State &glState,
                                          bool isCallValid,
                                          GLuint readBuffer,
                                          GLuint writeBuffer,
                                          GLintptr readOffset,
                                          GLintptr writeOffset,
                                          GLsizeiptr size)
{ … }

CallCapture CaptureCopyTextureSubImage1D(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint x,
                                         GLint y,
                                         GLsizei width)
{ … }

CallCapture CaptureCopyTextureSubImage2D(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height)
{ … }

CallCapture CaptureCopyTextureSubImage3D(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLint level,
                                         GLint xoffset,
                                         GLint yoffset,
                                         GLint zoffset,
                                         GLint x,
                                         GLint y,
                                         GLsizei width,
                                         GLsizei height)
{ … }

CallCapture CaptureCreateBuffers(const State &glState,
                                 bool isCallValid,
                                 GLsizei n,
                                 BufferID *buffersPacked)
{ … }

CallCapture CaptureCreateFramebuffers(const State &glState,
                                      bool isCallValid,
                                      GLsizei n,
                                      GLuint *framebuffers)
{ … }

CallCapture CaptureCreateProgramPipelines(const State &glState,
                                          bool isCallValid,
                                          GLsizei n,
                                          GLuint *pipelines)
{ … }

CallCapture CaptureCreateQueries(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLsizei n,
                                 GLuint *ids)
{ … }

CallCapture CaptureCreateRenderbuffers(const State &glState,
                                       bool isCallValid,
                                       GLsizei n,
                                       RenderbufferID *renderbuffersPacked)
{ … }

CallCapture CaptureCreateSamplers(const State &glState,
                                  bool isCallValid,
                                  GLsizei n,
                                  GLuint *samplers)
{ … }

CallCapture CaptureCreateTextures(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLsizei n,
                                  GLuint *textures)
{ … }

CallCapture CaptureCreateTransformFeedbacks(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            GLuint *ids)
{ … }

CallCapture CaptureCreateVertexArrays(const State &glState,
                                      bool isCallValid,
                                      GLsizei n,
                                      VertexArrayID *arraysPacked)
{ … }

CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint index)
{ … }

CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID vaobjPacked,
                                           GLuint index)
{ … }

CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked,
                                               GLintptr offset,
                                               GLsizeiptr length)
{ … }

CallCapture CaptureGenerateTextureMipmap(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked)
{ … }

CallCapture CaptureGetCompressedTextureImage(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLint level,
                                             GLsizei bufSize,
                                             void *pixels)
{ … }

CallCapture CaptureGetCompressedTextureSubImage(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint xoffset,
                                                GLint yoffset,
                                                GLint zoffset,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLsizei bufSize,
                                                void *pixels)
{ … }

CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked,
                                               GLenum pname,
                                               GLint64 *params)
{ … }

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

CallCapture CaptureGetNamedBufferPointerv(const State &glState,
                                          bool isCallValid,
                                          BufferID bufferPacked,
                                          GLenum pname,
                                          void **params)
{ … }

CallCapture CaptureGetNamedBufferSubData(const State &glState,
                                         bool isCallValid,
                                         BufferID bufferPacked,
                                         GLintptr offset,
                                         GLsizeiptr size,
                                         void *data)
{ … }

CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
                                                            bool isCallValid,
                                                            FramebufferID framebufferPacked,
                                                            GLenum attachment,
                                                            GLenum pname,
                                                            GLint *params)
{ … }

CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum pname,
                                                  GLint *param)
{ … }

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

CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
                                            bool isCallValid,
                                            GLuint id,
                                            BufferID bufferPacked,
                                            GLenum pname,
                                            GLintptr offset)
{ … }

CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
                                          bool isCallValid,
                                          GLuint id,
                                          BufferID bufferPacked,
                                          GLenum pname,
                                          GLintptr offset)
{ … }

CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
                                             bool isCallValid,
                                             GLuint id,
                                             BufferID bufferPacked,
                                             GLenum pname,
                                             GLintptr offset)
{ … }

CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
                                           bool isCallValid,
                                           GLuint id,
                                           BufferID bufferPacked,
                                           GLenum pname,
                                           GLintptr offset)
{ … }

CallCapture CaptureGetTextureImage(const State &glState,
                                   bool isCallValid,
                                   TextureID texturePacked,
                                   GLint level,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   void *pixels)
{ … }

CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLint level,
                                              GLenum pname,
                                              GLfloat *params)
{ … }

CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
                                              bool isCallValid,
                                              TextureID texturePacked,
                                              GLint level,
                                              GLenum pname,
                                              GLint *params)
{ … }

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

CallCapture CaptureGetTextureParameterIuiv(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLenum pname,
                                           GLuint *params)
{ … }

CallCapture CaptureGetTextureParameterfv(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLenum pname,
                                         GLfloat *params)
{ … }

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

CallCapture CaptureGetTextureSubImage(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLint level,
                                      GLint xoffset,
                                      GLint yoffset,
                                      GLint zoffset,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth,
                                      GLenum format,
                                      GLenum type,
                                      GLsizei bufSize,
                                      void *pixels)
{ … }

CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
                                             bool isCallValid,
                                             GLuint xfb,
                                             GLenum pname,
                                             GLuint index,
                                             GLint64 *param)
{ … }

CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
                                           bool isCallValid,
                                           GLuint xfb,
                                           GLenum pname,
                                           GLuint index,
                                           GLint *param)
{ … }

CallCapture CaptureGetTransformFeedbackiv(const State &glState,
                                          bool isCallValid,
                                          GLuint xfb,
                                          GLenum pname,
                                          GLint *param)
{ … }

CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint index,
                                             GLenum pname,
                                             GLint64 *param)
{ … }

CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID vaobjPacked,
                                           GLuint index,
                                           GLenum pname,
                                           GLint *param)
{ … }

CallCapture CaptureGetVertexArrayiv(const State &glState,
                                    bool isCallValid,
                                    VertexArrayID vaobjPacked,
                                    GLenum pname,
                                    GLint *param)
{ … }

CallCapture CaptureGetnColorTable(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  void *table)
{ … }

CallCapture CaptureGetnCompressedTexImage(const State &glState,
                                          bool isCallValid,
                                          GLenum target,
                                          GLint lod,
                                          GLsizei bufSize,
                                          void *pixels)
{ … }

CallCapture CaptureGetnConvolutionFilter(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei bufSize,
                                         void *image)
{ … }

CallCapture CaptureGetnHistogram(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLboolean reset,
                                 GLenum format,
                                 GLenum type,
                                 GLsizei bufSize,
                                 void *values)
{ … }

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

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

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

CallCapture CaptureGetnMinmax(const State &glState,
                              bool isCallValid,
                              GLenum target,
                              GLboolean reset,
                              GLenum format,
                              GLenum type,
                              GLsizei bufSize,
                              void *values)
{ … }

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

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

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

CallCapture CaptureGetnPolygonStipple(const State &glState,
                                      bool isCallValid,
                                      GLsizei bufSize,
                                      GLubyte *pattern)
{ … }

CallCapture CaptureGetnSeparableFilter(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLenum format,
                                       GLenum type,
                                       GLsizei rowBufSize,
                                       void *row,
                                       GLsizei columnBufSize,
                                       void *column,
                                       void *span)
{ … }

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

CallCapture CaptureGetnUniformdv(const State &glState,
                                 bool isCallValid,
                                 ShaderProgramID programPacked,
                                 UniformLocation locationPacked,
                                 GLsizei bufSize,
                                 GLdouble *params)
{ … }

CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLsizei numAttachments,
                                                  const GLenum *attachments)
{ … }

CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
                                                     bool isCallValid,
                                                     FramebufferID framebufferPacked,
                                                     GLsizei numAttachments,
                                                     const GLenum *attachments,
                                                     GLint x,
                                                     GLint y,
                                                     GLsizei width,
                                                     GLsizei height)
{ … }

CallCapture CaptureMapNamedBuffer(const State &glState,
                                  bool isCallValid,
                                  BufferID bufferPacked,
                                  GLenum access,
                                  void *returnValue)
{ … }

CallCapture CaptureMapNamedBufferRange(const State &glState,
                                       bool isCallValid,
                                       BufferID bufferPacked,
                                       GLintptr offset,
                                       GLsizeiptr length,
                                       GLbitfield access,
                                       void *returnValue)
{ … }

CallCapture CaptureNamedBufferData(const State &glState,
                                   bool isCallValid,
                                   BufferID bufferPacked,
                                   GLsizeiptr size,
                                   const void *data,
                                   GLenum usage)
{ … }

CallCapture CaptureNamedBufferStorage(const State &glState,
                                      bool isCallValid,
                                      BufferID bufferPacked,
                                      GLsizeiptr size,
                                      const void *data,
                                      GLbitfield flags)
{ … }

CallCapture CaptureNamedBufferSubData(const State &glState,
                                      bool isCallValid,
                                      BufferID bufferPacked,
                                      GLintptr offset,
                                      GLsizeiptr size,
                                      const void *data)
{ … }

CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
                                              bool isCallValid,
                                              FramebufferID framebufferPacked,
                                              GLenum buf)
{ … }

CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
                                               bool isCallValid,
                                               FramebufferID framebufferPacked,
                                               GLsizei n,
                                               const GLenum *bufs)
{ … }

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

CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
                                              bool isCallValid,
                                              FramebufferID framebufferPacked,
                                              GLenum src)
{ … }

CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
                                                bool isCallValid,
                                                FramebufferID framebufferPacked,
                                                GLenum attachment,
                                                GLenum renderbuffertarget,
                                                RenderbufferID renderbufferPacked)
{ … }

CallCapture CaptureNamedFramebufferTexture(const State &glState,
                                           bool isCallValid,
                                           FramebufferID framebufferPacked,
                                           GLenum attachment,
                                           TextureID texturePacked,
                                           GLint level)
{ … }

CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
                                                bool isCallValid,
                                                FramebufferID framebufferPacked,
                                                GLenum attachment,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLint layer)
{ … }

CallCapture CaptureNamedRenderbufferStorage(const State &glState,
                                            bool isCallValid,
                                            RenderbufferID renderbufferPacked,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height)
{ … }

CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
                                                       bool isCallValid,
                                                       RenderbufferID renderbufferPacked,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height)
{ … }

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

CallCapture CaptureTextureBuffer(const State &glState,
                                 bool isCallValid,
                                 TextureID texturePacked,
                                 GLenum internalformat,
                                 BufferID bufferPacked)
{ … }

CallCapture CaptureTextureBufferRange(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLenum internalformat,
                                      BufferID bufferPacked,
                                      GLintptr offset,
                                      GLsizeiptr size)
{ … }

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

CallCapture CaptureTextureParameterIuiv(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum pname,
                                        const GLuint *params)
{ … }

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

CallCapture CaptureTextureParameterfv(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLenum pname,
                                      const GLfloat *param)
{ … }

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

CallCapture CaptureTextureParameteriv(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLenum pname,
                                      const GLint *param)
{ … }

CallCapture CaptureTextureStorage1D(const State &glState,
                                    bool isCallValid,
                                    TextureID texturePacked,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width)
{ … }

CallCapture CaptureTextureStorage2D(const State &glState,
                                    bool isCallValid,
                                    TextureID texturePacked,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLsizei height)
{ … }

CallCapture CaptureTextureStorage2DMultisample(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLsizei samples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLboolean fixedsamplelocations)
{ … }

CallCapture CaptureTextureStorage3D(const State &glState,
                                    bool isCallValid,
                                    TextureID texturePacked,
                                    GLsizei levels,
                                    GLenum internalformat,
                                    GLsizei width,
                                    GLsizei height,
                                    GLsizei depth)
{ … }

CallCapture CaptureTextureStorage3DMultisample(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLsizei samples,
                                               GLenum internalformat,
                                               GLsizei width,
                                               GLsizei height,
                                               GLsizei depth,
                                               GLboolean fixedsamplelocations)
{ … }

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

CallCapture CaptureTextureSubImage2D(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{ … }

CallCapture CaptureTextureSubImage3D(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLint xoffset,
                                     GLint yoffset,
                                     GLint zoffset,
                                     GLsizei width,
                                     GLsizei height,
                                     GLsizei depth,
                                     GLenum format,
                                     GLenum type,
                                     const void *pixels)
{ … }

CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
                                               bool isCallValid,
                                               GLuint xfb,
                                               GLuint index,
                                               BufferID bufferPacked)
{ … }

CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
                                                bool isCallValid,
                                                GLuint xfb,
                                                GLuint index,
                                                BufferID bufferPacked,
                                                GLintptr offset,
                                                GLsizeiptr size)
{ … }

CallCapture CaptureUnmapNamedBuffer(const State &glState,
                                    bool isCallValid,
                                    BufferID bufferPacked,
                                    GLboolean returnValue)
{ … }

CallCapture CaptureVertexArrayAttribBinding(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint attribindex,
                                            GLuint bindingindex)
{ … }

CallCapture CaptureVertexArrayAttribFormat(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID vaobjPacked,
                                           GLuint attribindex,
                                           GLint size,
                                           GLenum type,
                                           GLboolean normalized,
                                           GLuint relativeoffset)
{ … }

CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint attribindex,
                                            GLint size,
                                            GLenum type,
                                            GLuint relativeoffset)
{ … }

CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint attribindex,
                                            GLint size,
                                            GLenum type,
                                            GLuint relativeoffset)
{ … }

CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint bindingindex,
                                             GLuint divisor)
{ … }

CallCapture CaptureVertexArrayElementBuffer(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            BufferID bufferPacked)
{ … }

CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
                                           bool isCallValid,
                                           VertexArrayID vaobjPacked,
                                           GLuint bindingindex,
                                           BufferID bufferPacked,
                                           GLintptr offset,
                                           GLsizei stride)
{ … }

CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
                                            bool isCallValid,
                                            VertexArrayID vaobjPacked,
                                            GLuint first,
                                            GLsizei count,
                                            const BufferID *buffersPacked,
                                            const GLintptr *offsets,
                                            const GLsizei *strides)
{ … }

// GL 4.6
CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
                                                bool isCallValid,
                                                GLenum mode,
                                                const void *indirect,
                                                GLintptr drawcount,
                                                GLsizei maxdrawcount,
                                                GLsizei stride)
{ … }

CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
                                                  bool isCallValid,
                                                  GLenum mode,
                                                  GLenum type,
                                                  const void *indirect,
                                                  GLintptr drawcount,
                                                  GLsizei maxdrawcount,
                                                  GLsizei stride)
{ … }

CallCapture CapturePolygonOffsetClamp(const State &glState,
                                      bool isCallValid,
                                      GLfloat factor,
                                      GLfloat units,
                                      GLfloat clamp)
{ … }

CallCapture CaptureSpecializeShader(const State &glState,
                                    bool isCallValid,
                                    GLuint shader,
                                    const GLchar *pEntryPoint,
                                    GLuint numSpecializationConstants,
                                    const GLuint *pConstantIndex,
                                    const GLuint *pConstantValue)
{ … }

}  // namespace gl