kc3-lang/angle/src/libANGLE/capture/capture_gl_4_autogen.cpp

• Show log

  Commit

• Hash : 4bfb749f
  Author :
  Date : 2022-10-10T20:59:48
  

  Capture/Replay: Move shared trace code into src/common.
  
  This will let them be accessible to the test harnesses. The
  trace tests interpreter will need direct access to the classes
  that we move in this CL.
  
  This CL also moves the GLenum utils into the common folder,
  where they were already used by some other tests.
  
  Bug: angleproject:7752
  Change-Id: I97ad607938ef29bc316f6d40098478e002ea8128
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3963362
  Reviewed-by: Yuxin Hu <yuxinhu@google.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• 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"
  
  using namespace angle;
  
  namespace gl
  {
  
  // GL 4.0
  CallCapture CaptureBeginQueryIndexed(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLuint index,
                                       QueryID idPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked);
  
      return CallCapture(angle::EntryPoint::GLBeginQueryIndexed, std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawTransformFeedback(const State &glState,
                                           bool isCallValid,
                                           GLenum mode,
                                           TransformFeedbackID idPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
      paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked);
  
      return CallCapture(angle::EntryPoint::GLDrawTransformFeedback, std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawTransformFeedbackStream(const State &glState,
                                                 bool isCallValid,
                                                 GLenum mode,
                                                 TransformFeedbackID idPacked,
                                                 GLuint stream)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
      paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked);
      paramBuffer.addValueParam("stream", ParamType::TGLuint, stream);
  
      return CallCapture(angle::EntryPoint::GLDrawTransformFeedbackStream, std::move(paramBuffer));
  }
  
  CallCapture CaptureEndQueryIndexed(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint index)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      return CallCapture(angle::EntryPoint::GLEndQueryIndexed, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetActiveSubroutineName(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             GLenum shadertype,
                                             GLuint index,
                                             GLsizei bufSize,
                                             GLsizei *length,
                                             GLchar *name)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
          InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
          CaptureGetActiveSubroutineName_length(glState, isCallValid, programPacked, shadertype,
                                                index, bufSize, length, name, &lengthParam);
          paramBuffer.addParam(std::move(lengthParam));
      }
      else
      {
          ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
          InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
                         &lengthParam.value);
          paramBuffer.addParam(std::move(lengthParam));
      }
  
      if (isCallValid)
      {
          ParamCapture nameParam("name", ParamType::TGLcharPointer);
          InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
          CaptureGetActiveSubroutineName_name(glState, isCallValid, programPacked, shadertype, index,
                                              bufSize, length, name, &nameParam);
          paramBuffer.addParam(std::move(nameParam));
      }
      else
      {
          ParamCapture nameParam("name", ParamType::TGLcharPointer);
          InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
          paramBuffer.addParam(std::move(nameParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetActiveSubroutineName, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetActiveSubroutineUniformName(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLenum shadertype,
                                                    GLuint index,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLchar *name)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
          InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
          CaptureGetActiveSubroutineUniformName_length(glState, isCallValid, programPacked,
                                                       shadertype, index, bufSize, length, name,
                                                       &lengthParam);
          paramBuffer.addParam(std::move(lengthParam));
      }
      else
      {
          ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
          InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
                         &lengthParam.value);
          paramBuffer.addParam(std::move(lengthParam));
      }
  
      if (isCallValid)
      {
          ParamCapture nameParam("name", ParamType::TGLcharPointer);
          InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
          CaptureGetActiveSubroutineUniformName_name(glState, isCallValid, programPacked, shadertype,
                                                     index, bufSize, length, name, &nameParam);
          paramBuffer.addParam(std::move(nameParam));
      }
      else
      {
          ParamCapture nameParam("name", ParamType::TGLcharPointer);
          InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
          paramBuffer.addParam(std::move(nameParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetActiveSubroutineUniformName, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum shadertype,
                                                  GLuint index,
                                                  GLenum pname,
                                                  GLint *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addEnumParam("pname", BigGLEnum::SubroutineParameterName, ParamType::TGLenum,
                               pname);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value);
          CaptureGetActiveSubroutineUniformiv_values(glState, isCallValid, programPacked, shadertype,
                                                     index, pname, values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetActiveSubroutineUniformiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetProgramStageiv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       GLenum shadertype,
                                       GLenum pname,
                                       GLint *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addEnumParam("pname", BigGLEnum::ProgramStagePName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value);
          CaptureGetProgramStageiv_values(glState, isCallValid, programPacked, shadertype, pname,
                                          values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetProgramStageiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetQueryIndexediv(const State &glState,
                                       bool isCallValid,
                                       GLenum target,
                                       GLuint index,
                                       GLenum pname,
                                       GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addEnumParam("pname", BigGLEnum::QueryParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetQueryIndexediv_params(glState, isCallValid, target, index, pname, params,
                                          &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetQueryIndexediv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetSubroutineIndex(const State &glState,
                                        bool isCallValid,
                                        ShaderProgramID programPacked,
                                        GLenum shadertype,
                                        const GLchar *name,
                                        GLuint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
  
      if (isCallValid)
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
          CaptureGetSubroutineIndex_name(glState, isCallValid, programPacked, shadertype, name,
                                         &nameParam);
          paramBuffer.addParam(std::move(nameParam));
      }
      else
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
                         &nameParam.value);
          paramBuffer.addParam(std::move(nameParam));
      }
  
      ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
      InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLGetSubroutineIndex, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetSubroutineUniformLocation(const State &glState,
                                                  bool isCallValid,
                                                  ShaderProgramID programPacked,
                                                  GLenum shadertype,
                                                  const GLchar *name,
                                                  GLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
  
      if (isCallValid)
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
          CaptureGetSubroutineUniformLocation_name(glState, isCallValid, programPacked, shadertype,
                                                   name, &nameParam);
          paramBuffer.addParam(std::move(nameParam));
      }
      else
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
                         &nameParam.value);
          paramBuffer.addParam(std::move(nameParam));
      }
  
      ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
      InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLGetSubroutineUniformLocation, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetUniformSubroutineuiv(const State &glState,
                                             bool isCallValid,
                                             GLenum shadertype,
                                             GLint location,
                                             GLuint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addValueParam("location", ParamType::TGLint, location);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
          CaptureGetUniformSubroutineuiv_params(glState, isCallValid, shadertype, location, params,
                                                &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetUniformSubroutineuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetUniformdv(const State &glState,
                                  bool isCallValid,
                                  ShaderProgramID programPacked,
                                  UniformLocation locationPacked,
                                  GLdouble *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, params, &paramsParam.value);
          CaptureGetUniformdv_params(glState, isCallValid, programPacked, locationPacked, params,
                                     &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetUniformdv, std::move(paramBuffer));
  }
  
  CallCapture CapturePatchParameterfv(const State &glState,
                                      bool isCallValid,
                                      GLenum pname,
                                      const GLfloat *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("pname", BigGLEnum::PatchParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, values, &valuesParam.value);
          CapturePatchParameterfv_values(glState, isCallValid, pname, values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
                         &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLPatchParameterfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform1d(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLdouble x)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
  
      return CallCapture(angle::EntryPoint::GLUniform1d, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform1dv(const State &glState,
                                bool isCallValid,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniform1dv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniform1dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform2d(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLdouble x,
                               GLdouble y)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
  
      return CallCapture(angle::EntryPoint::GLUniform2d, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform2dv(const State &glState,
                                bool isCallValid,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniform2dv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniform2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform3d(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLdouble x,
                               GLdouble y,
                               GLdouble z)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
      paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
  
      return CallCapture(angle::EntryPoint::GLUniform3d, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform3dv(const State &glState,
                                bool isCallValid,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniform3dv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniform3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform4d(const State &glState,
                               bool isCallValid,
                               UniformLocation locationPacked,
                               GLdouble x,
                               GLdouble y,
                               GLdouble z,
                               GLdouble w)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
      paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
      paramBuffer.addValueParam("w", ParamType::TGLdouble, w);
  
      return CallCapture(angle::EntryPoint::GLUniform4d, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniform4dv(const State &glState,
                                bool isCallValid,
                                UniformLocation locationPacked,
                                GLsizei count,
                                const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniform4dv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniform4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix2dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix2dv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                        &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix2x3dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix2x3dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix2x3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix2x4dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix2x4dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix2x4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix3dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix3dv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                        &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix3x2dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix3x2dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix3x2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix3x4dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix3x4dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix3x4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix4dv(const State &glState,
                                      bool isCallValid,
                                      UniformLocation locationPacked,
                                      GLsizei count,
                                      GLboolean transpose,
                                      const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix4dv_value(glState, isCallValid, locationPacked, count, transpose, value,
                                        &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix4x2dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix4x2dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix4x2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformMatrix4x3dv(const State &glState,
                                        bool isCallValid,
                                        UniformLocation locationPacked,
                                        GLsizei count,
                                        GLboolean transpose,
                                        const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureUniformMatrix4x3dv_value(glState, isCallValid, locationPacked, count, transpose,
                                          value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformMatrix4x3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureUniformSubroutinesuiv(const State &glState,
                                           bool isCallValid,
                                           GLenum shadertype,
                                           GLsizei count,
                                           const GLuint *indices)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture indicesParam("indices", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, indices, &indicesParam.value);
          CaptureUniformSubroutinesuiv_indices(glState, isCallValid, shadertype, count, indices,
                                               &indicesParam);
          paramBuffer.addParam(std::move(indicesParam));
      }
      else
      {
          ParamCapture indicesParam("indices", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &indicesParam.value);
          paramBuffer.addParam(std::move(indicesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLUniformSubroutinesuiv, std::move(paramBuffer));
  }
  
  // GL 4.1
  CallCapture CaptureDepthRangeArrayv(const State &glState,
                                      bool isCallValid,
                                      GLuint first,
                                      GLsizei count,
                                      const GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
          CaptureDepthRangeArrayv_v(glState, isCallValid, first, count, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLDepthRangeArrayv, std::move(paramBuffer));
  }
  
  CallCapture CaptureDepthRangeIndexed(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       GLdouble n,
                                       GLdouble f)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("n", ParamType::TGLdouble, n);
      paramBuffer.addValueParam("f", ParamType::TGLdouble, f);
  
      return CallCapture(angle::EntryPoint::GLDepthRangeIndexed, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetDoublei_v(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLuint index,
                                  GLdouble *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::GetPName, ParamType::TGLenum, target);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, data, &dataParam.value);
          CaptureGetDoublei_v_data(glState, isCallValid, target, index, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetDoublei_v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetFloati_v(const State &glState,
                                 bool isCallValid,
                                 GLenum target,
                                 GLuint index,
                                 GLfloat *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::GetPName, ParamType::TGLenum, target);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, data, &dataParam.value);
          CaptureGetFloati_v_data(glState, isCallValid, target, index, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetFloati_v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetVertexAttribLdv(const State &glState,
                                        bool isCallValid,
                                        GLuint index,
                                        GLenum pname,
                                        GLdouble *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addEnumParam("pname", BigGLEnum::VertexAttribEnum, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, params, &paramsParam.value);
          CaptureGetVertexAttribLdv_params(glState, isCallValid, index, pname, params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetVertexAttribLdv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform1d(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      UniformLocation locationPacked,
                                      GLdouble v0)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("v0", ParamType::TGLdouble, v0);
  
      return CallCapture(angle::EntryPoint::GLProgramUniform1d, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform1dv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniform1dv_value(glState, isCallValid, programPacked, locationPacked, count,
                                         value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniform1dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform2d(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      UniformLocation locationPacked,
                                      GLdouble v0,
                                      GLdouble v1)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("v0", ParamType::TGLdouble, v0);
      paramBuffer.addValueParam("v1", ParamType::TGLdouble, v1);
  
      return CallCapture(angle::EntryPoint::GLProgramUniform2d, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform2dv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniform2dv_value(glState, isCallValid, programPacked, locationPacked, count,
                                         value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniform2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform3d(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      UniformLocation locationPacked,
                                      GLdouble v0,
                                      GLdouble v1,
                                      GLdouble v2)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("v0", ParamType::TGLdouble, v0);
      paramBuffer.addValueParam("v1", ParamType::TGLdouble, v1);
      paramBuffer.addValueParam("v2", ParamType::TGLdouble, v2);
  
      return CallCapture(angle::EntryPoint::GLProgramUniform3d, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform3dv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniform3dv_value(glState, isCallValid, programPacked, locationPacked, count,
                                         value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniform3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform4d(const State &glState,
                                      bool isCallValid,
                                      ShaderProgramID programPacked,
                                      UniformLocation locationPacked,
                                      GLdouble v0,
                                      GLdouble v1,
                                      GLdouble v2,
                                      GLdouble v3)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("v0", ParamType::TGLdouble, v0);
      paramBuffer.addValueParam("v1", ParamType::TGLdouble, v1);
      paramBuffer.addValueParam("v2", ParamType::TGLdouble, v2);
      paramBuffer.addValueParam("v3", ParamType::TGLdouble, v3);
  
      return CallCapture(angle::EntryPoint::GLProgramUniform4d, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniform4dv(const State &glState,
                                       bool isCallValid,
                                       ShaderProgramID programPacked,
                                       UniformLocation locationPacked,
                                       GLsizei count,
                                       const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniform4dv_value(glState, isCallValid, programPacked, locationPacked, count,
                                         value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniform4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix2dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix2dv_value(glState, isCallValid, programPacked, locationPacked,
                                               count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix2x3dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix2x3dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2x3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix2x4dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix2x4dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix2x4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix3dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix3dv_value(glState, isCallValid, programPacked, locationPacked,
                                               count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix3x2dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix3x2dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix3x4dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix3x4dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix3x4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix4dv(const State &glState,
                                             bool isCallValid,
                                             ShaderProgramID programPacked,
                                             UniformLocation locationPacked,
                                             GLsizei count,
                                             GLboolean transpose,
                                             const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix4dv_value(glState, isCallValid, programPacked, locationPacked,
                                               count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix4x2dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix4x2dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureProgramUniformMatrix4x3dv(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               UniformLocation locationPacked,
                                               GLsizei count,
                                               GLboolean transpose,
                                               const GLdouble *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, value, &valueParam.value);
          CaptureProgramUniformMatrix4x3dv_value(glState, isCallValid, programPacked, locationPacked,
                                                 count, transpose, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLProgramUniformMatrix4x3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureScissorArrayv(const State &glState,
                                   bool isCallValid,
                                   GLuint first,
                                   GLsizei count,
                                   const GLint *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
          CaptureScissorArrayv_v(glState, isCallValid, first, count, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLScissorArrayv, std::move(paramBuffer));
  }
  
  CallCapture CaptureScissorIndexed(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    GLint left,
                                    GLint bottom,
                                    GLsizei width,
                                    GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("left", ParamType::TGLint, left);
      paramBuffer.addValueParam("bottom", ParamType::TGLint, bottom);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLScissorIndexed, std::move(paramBuffer));
  }
  
  CallCapture CaptureScissorIndexedv(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     const GLint *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
          CaptureScissorIndexedv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLScissorIndexedv, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL1d(const State &glState, bool isCallValid, GLuint index, GLdouble x)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL1d, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL1dv(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      const GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
          CaptureVertexAttribL1dv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL1dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL2d(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL2d, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL2dv(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      const GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
          CaptureVertexAttribL2dv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL2dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL3d(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y,
                                     GLdouble z)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
      paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL3d, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL3dv(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      const GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
          CaptureVertexAttribL3dv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL3dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL4d(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     GLdouble x,
                                     GLdouble y,
                                     GLdouble z,
                                     GLdouble w)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("x", ParamType::TGLdouble, x);
      paramBuffer.addValueParam("y", ParamType::TGLdouble, y);
      paramBuffer.addValueParam("z", ParamType::TGLdouble, z);
      paramBuffer.addValueParam("w", ParamType::TGLdouble, w);
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL4d, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribL4dv(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      const GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value);
          CaptureVertexAttribL4dv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoubleConstPointer);
          InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexAttribL4dv, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribLPointer(const State &glState,
                                          bool isCallValid,
                                          GLuint index,
                                          GLint size,
                                          GLenum type,
                                          GLsizei stride,
                                          const void *pointer)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("size", ParamType::TGLint, size);
      paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      if (isCallValid)
      {
          ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
          CaptureVertexAttribLPointer_pointer(glState, isCallValid, index, size, type, stride,
                                              pointer, &pointerParam);
          paramBuffer.addParam(std::move(pointerParam));
      }
      else
      {
          ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &pointerParam.value);
          paramBuffer.addParam(std::move(pointerParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexAttribLPointer, std::move(paramBuffer));
  }
  
  CallCapture CaptureViewportArrayv(const State &glState,
                                    bool isCallValid,
                                    GLuint first,
                                    GLsizei count,
                                    const GLfloat *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
          CaptureViewportArrayv_v(glState, isCallValid, first, count, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLViewportArrayv, std::move(paramBuffer));
  }
  
  CallCapture CaptureViewportIndexedf(const State &glState,
                                      bool isCallValid,
                                      GLuint index,
                                      GLfloat x,
                                      GLfloat y,
                                      GLfloat w,
                                      GLfloat h)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
      paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
      paramBuffer.addValueParam("w", ParamType::TGLfloat, w);
      paramBuffer.addValueParam("h", ParamType::TGLfloat, h);
  
      return CallCapture(angle::EntryPoint::GLViewportIndexedf, std::move(paramBuffer));
  }
  
  CallCapture CaptureViewportIndexedfv(const State &glState,
                                       bool isCallValid,
                                       GLuint index,
                                       const GLfloat *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
          CaptureViewportIndexedfv_v(glState, isCallValid, index, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLViewportIndexedfv, std::move(paramBuffer));
  }
  
  // GL 4.2
  CallCapture CaptureDrawArraysInstancedBaseInstance(const State &glState,
                                                     bool isCallValid,
                                                     PrimitiveMode modePacked,
                                                     GLint first,
                                                     GLsizei count,
                                                     GLsizei instancecount,
                                                     GLuint baseinstance)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
      paramBuffer.addValueParam("first", ParamType::TGLint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
      paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
  
      return CallCapture(angle::EntryPoint::GLDrawArraysInstancedBaseInstance,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawElementsInstancedBaseInstance(const State &glState,
                                                       bool isCallValid,
                                                       PrimitiveMode modePacked,
                                                       GLsizei count,
                                                       DrawElementsType typePacked,
                                                       const void *indices,
                                                       GLsizei instancecount,
                                                       GLuint baseinstance)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
  
      if (isCallValid)
      {
          ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
          CaptureDrawElementsInstancedBaseInstance_indices(glState, isCallValid, modePacked, count,
                                                           typePacked, indices, instancecount,
                                                           baseinstance, &indicesParam);
          paramBuffer.addParam(std::move(indicesParam));
      }
      else
      {
          ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indicesParam.value);
          paramBuffer.addParam(std::move(indicesParam));
      }
  
      paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
      paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
  
      return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseInstance,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawElementsInstancedBaseVertexBaseInstance(const State &glState,
                                                                 bool isCallValid,
                                                                 PrimitiveMode modePacked,
                                                                 GLsizei count,
                                                                 DrawElementsType typePacked,
                                                                 const void *indices,
                                                                 GLsizei instancecount,
                                                                 GLint basevertex,
                                                                 GLuint baseinstance)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
      paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
  
      if (isCallValid)
      {
          ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
          CaptureDrawElementsInstancedBaseVertexBaseInstance_indices(
              glState, isCallValid, modePacked, count, typePacked, indices, instancecount, basevertex,
              baseinstance, &indicesParam);
          paramBuffer.addParam(std::move(indicesParam));
      }
      else
      {
          ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indicesParam.value);
          paramBuffer.addParam(std::move(indicesParam));
      }
  
      paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
      paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
      paramBuffer.addValueParam("baseinstance", ParamType::TGLuint, baseinstance);
  
      return CallCapture(angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstance,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState,
                                                    bool isCallValid,
                                                    GLenum mode,
                                                    TransformFeedbackID idPacked,
                                                    GLsizei instancecount)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
      paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked);
      paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
  
      return CallCapture(angle::EntryPoint::GLDrawTransformFeedbackInstanced, std::move(paramBuffer));
  }
  
  CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState,
                                                          bool isCallValid,
                                                          GLenum mode,
                                                          TransformFeedbackID idPacked,
                                                          GLuint stream,
                                                          GLsizei instancecount)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
      paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked);
      paramBuffer.addValueParam("stream", ParamType::TGLuint, stream);
      paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
  
      return CallCapture(angle::EntryPoint::GLDrawTransformFeedbackStreamInstanced,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState,
                                                    bool isCallValid,
                                                    ShaderProgramID programPacked,
                                                    GLuint bufferIndex,
                                                    GLenum pname,
                                                    GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("bufferIndex", ParamType::TGLuint, bufferIndex);
      paramBuffer.addEnumParam("pname", BigGLEnum::AtomicCounterBufferPName, ParamType::TGLenum,
                               pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetActiveAtomicCounterBufferiv_params(glState, isCallValid, programPacked,
                                                       bufferIndex, pname, params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetActiveAtomicCounterBufferiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureTexStorage1D(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLsizei levels,
                                  GLenum internalformat,
                                  GLsizei width)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
  
      return CallCapture(angle::EntryPoint::GLTexStorage1D, std::move(paramBuffer));
  }
  
  // GL 4.3
  CallCapture CaptureClearBufferData(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLenum internalformat,
                                     GLenum format,
                                     GLenum type,
                                     const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::BufferStorageTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearBufferData_data(glState, isCallValid, target, internalformat, format, type,
                                      data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearBufferData, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearBufferSubData(const State &glState,
                                        bool isCallValid,
                                        GLenum target,
                                        GLenum internalformat,
                                        GLintptr offset,
                                        GLsizeiptr size,
                                        GLenum format,
                                        GLenum type,
                                        const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearBufferSubData_data(glState, isCallValid, target, internalformat, offset, size,
                                         format, type, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetInternalformati64v(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLenum internalformat,
                                           GLenum pname,
                                           GLsizei count,
                                           GLint64 *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addEnumParam("pname", BigGLEnum::InternalFormatPName, ParamType::TGLenum, pname);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, params, &paramsParam.value);
          CaptureGetInternalformati64v_params(glState, isCallValid, target, internalformat, pname,
                                              count, params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetInternalformati64v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetProgramResourceLocationIndex(const State &glState,
                                                     bool isCallValid,
                                                     ShaderProgramID programPacked,
                                                     GLenum programInterface,
                                                     const GLchar *name,
                                                     GLint returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addEnumParam("programInterface", BigGLEnum::ProgramInterface, ParamType::TGLenum,
                               programInterface);
  
      if (isCallValid)
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
          CaptureGetProgramResourceLocationIndex_name(glState, isCallValid, programPacked,
                                                      programInterface, name, &nameParam);
          paramBuffer.addParam(std::move(nameParam));
      }
      else
      {
          ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
                         &nameParam.value);
          paramBuffer.addParam(std::move(nameParam));
      }
  
      ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
      InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLGetProgramResourceLocationIndex,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateBufferData(const State &glState,
                                          bool isCallValid,
                                          BufferID bufferPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
  
      return CallCapture(angle::EntryPoint::GLInvalidateBufferData, std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateBufferSubData(const State &glState,
                                             bool isCallValid,
                                             BufferID bufferPacked,
                                             GLintptr offset,
                                             GLsizeiptr length)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
  
      return CallCapture(angle::EntryPoint::GLInvalidateBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateTexImage(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLint level)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
  
      return CallCapture(angle::EntryPoint::GLInvalidateTexImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateTexSubImage(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLint zoffset,
                                           GLsizei width,
                                           GLsizei height,
                                           GLsizei depth)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
  
      return CallCapture(angle::EntryPoint::GLInvalidateTexSubImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureMultiDrawArraysIndirect(const State &glState,
                                             bool isCallValid,
                                             PrimitiveMode modePacked,
                                             const void *indirect,
                                             GLsizei drawcount,
                                             GLsizei stride)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
  
      if (isCallValid)
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
          CaptureMultiDrawArraysIndirect_indirect(glState, isCallValid, modePacked, indirect,
                                                  drawcount, stride, &indirectParam);
          paramBuffer.addParam(std::move(indirectParam));
      }
      else
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indirectParam.value);
          paramBuffer.addParam(std::move(indirectParam));
      }
  
      paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      return CallCapture(angle::EntryPoint::GLMultiDrawArraysIndirect, std::move(paramBuffer));
  }
  
  CallCapture CaptureMultiDrawElementsIndirect(const State &glState,
                                               bool isCallValid,
                                               PrimitiveMode modePacked,
                                               DrawElementsType typePacked,
                                               const void *indirect,
                                               GLsizei drawcount,
                                               GLsizei stride)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
      paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
  
      if (isCallValid)
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
          CaptureMultiDrawElementsIndirect_indirect(glState, isCallValid, modePacked, typePacked,
                                                    indirect, drawcount, stride, &indirectParam);
          paramBuffer.addParam(std::move(indirectParam));
      }
      else
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indirectParam.value);
          paramBuffer.addParam(std::move(indirectParam));
      }
  
      paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      return CallCapture(angle::EntryPoint::GLMultiDrawElementsIndirect, std::move(paramBuffer));
  }
  
  CallCapture CaptureShaderStorageBlockBinding(const State &glState,
                                               bool isCallValid,
                                               ShaderProgramID programPacked,
                                               GLuint storageBlockIndex,
                                               GLuint storageBlockBinding)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("storageBlockIndex", ParamType::TGLuint, storageBlockIndex);
      paramBuffer.addValueParam("storageBlockBinding", ParamType::TGLuint, storageBlockBinding);
  
      return CallCapture(angle::EntryPoint::GLShaderStorageBlockBinding, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureView(const State &glState,
                                 bool isCallValid,
                                 TextureID texturePacked,
                                 GLenum target,
                                 GLuint origtexture,
                                 GLenum internalformat,
                                 GLuint minlevel,
                                 GLuint numlevels,
                                 GLuint minlayer,
                                 GLuint numlayers)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("origtexture", ParamType::TGLuint, origtexture);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("minlevel", ParamType::TGLuint, minlevel);
      paramBuffer.addValueParam("numlevels", ParamType::TGLuint, numlevels);
      paramBuffer.addValueParam("minlayer", ParamType::TGLuint, minlayer);
      paramBuffer.addValueParam("numlayers", ParamType::TGLuint, numlayers);
  
      return CallCapture(angle::EntryPoint::GLTextureView, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexAttribLFormat(const State &glState,
                                         bool isCallValid,
                                         GLuint attribindex,
                                         GLint size,
                                         GLenum type,
                                         GLuint relativeoffset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
      paramBuffer.addValueParam("size", ParamType::TGLint, size);
      paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
  
      return CallCapture(angle::EntryPoint::GLVertexAttribLFormat, std::move(paramBuffer));
  }
  
  // GL 4.4
  CallCapture CaptureBindBuffersBase(const State &glState,
                                     bool isCallValid,
                                     GLenum target,
                                     GLuint first,
                                     GLsizei count,
                                     const BufferID *buffersPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target);
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
          CaptureBindBuffersBase_buffersPacked(glState, isCallValid, target, first, count,
                                               buffersPacked, &buffersPackedParam);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
      else
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
                         &buffersPackedParam.value);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindBuffersBase, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindBuffersRange(const State &glState,
                                      bool isCallValid,
                                      GLenum target,
                                      GLuint first,
                                      GLsizei count,
                                      const BufferID *buffersPacked,
                                      const GLintptr *offsets,
                                      const GLsizeiptr *sizes)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target);
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
          CaptureBindBuffersRange_buffersPacked(glState, isCallValid, target, first, count,
                                                buffersPacked, offsets, sizes, &buffersPackedParam);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
      else
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
                         &buffersPackedParam.value);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
  
      if (isCallValid)
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, offsets, &offsetsParam.value);
          CaptureBindBuffersRange_offsets(glState, isCallValid, target, first, count, buffersPacked,
                                          offsets, sizes, &offsetsParam);
          paramBuffer.addParam(std::move(offsetsParam));
      }
      else
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, static_cast<const GLintptr *>(nullptr),
                         &offsetsParam.value);
          paramBuffer.addParam(std::move(offsetsParam));
      }
  
      if (isCallValid)
      {
          ParamCapture sizesParam("sizes", ParamType::TGLsizeiptrConstPointer);
          InitParamValue(ParamType::TGLsizeiptrConstPointer, sizes, &sizesParam.value);
          CaptureBindBuffersRange_sizes(glState, isCallValid, target, first, count, buffersPacked,
                                        offsets, sizes, &sizesParam);
          paramBuffer.addParam(std::move(sizesParam));
      }
      else
      {
          ParamCapture sizesParam("sizes", ParamType::TGLsizeiptrConstPointer);
          InitParamValue(ParamType::TGLsizeiptrConstPointer, static_cast<const GLsizeiptr *>(nullptr),
                         &sizesParam.value);
          paramBuffer.addParam(std::move(sizesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindBuffersRange, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindImageTextures(const State &glState,
                                       bool isCallValid,
                                       GLuint first,
                                       GLsizei count,
                                       const GLuint *textures)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, textures, &texturesParam.value);
          CaptureBindImageTextures_textures(glState, isCallValid, first, count, textures,
                                            &texturesParam);
          paramBuffer.addParam(std::move(texturesParam));
      }
      else
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &texturesParam.value);
          paramBuffer.addParam(std::move(texturesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindImageTextures, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindSamplers(const State &glState,
                                  bool isCallValid,
                                  GLuint first,
                                  GLsizei count,
                                  const GLuint *samplers)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture samplersParam("samplers", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, samplers, &samplersParam.value);
          CaptureBindSamplers_samplers(glState, isCallValid, first, count, samplers, &samplersParam);
          paramBuffer.addParam(std::move(samplersParam));
      }
      else
      {
          ParamCapture samplersParam("samplers", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &samplersParam.value);
          paramBuffer.addParam(std::move(samplersParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindSamplers, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindTextures(const State &glState,
                                  bool isCallValid,
                                  GLuint first,
                                  GLsizei count,
                                  const GLuint *textures)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, textures, &texturesParam.value);
          CaptureBindTextures_textures(glState, isCallValid, first, count, textures, &texturesParam);
          paramBuffer.addParam(std::move(texturesParam));
      }
      else
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &texturesParam.value);
          paramBuffer.addParam(std::move(texturesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindTextures, std::move(paramBuffer));
  }
  
  CallCapture CaptureBindVertexBuffers(const State &glState,
                                       bool isCallValid,
                                       GLuint first,
                                       GLsizei count,
                                       const BufferID *buffersPacked,
                                       const GLintptr *offsets,
                                       const GLsizei *strides)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
          CaptureBindVertexBuffers_buffersPacked(glState, isCallValid, first, count, buffersPacked,
                                                 offsets, strides, &buffersPackedParam);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
      else
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
                         &buffersPackedParam.value);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
  
      if (isCallValid)
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, offsets, &offsetsParam.value);
          CaptureBindVertexBuffers_offsets(glState, isCallValid, first, count, buffersPacked, offsets,
                                           strides, &offsetsParam);
          paramBuffer.addParam(std::move(offsetsParam));
      }
      else
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, static_cast<const GLintptr *>(nullptr),
                         &offsetsParam.value);
          paramBuffer.addParam(std::move(offsetsParam));
      }
  
      if (isCallValid)
      {
          ParamCapture stridesParam("strides", ParamType::TGLsizeiConstPointer);
          InitParamValue(ParamType::TGLsizeiConstPointer, strides, &stridesParam.value);
          CaptureBindVertexBuffers_strides(glState, isCallValid, first, count, buffersPacked, offsets,
                                           strides, &stridesParam);
          paramBuffer.addParam(std::move(stridesParam));
      }
      else
      {
          ParamCapture stridesParam("strides", ParamType::TGLsizeiConstPointer);
          InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
                         &stridesParam.value);
          paramBuffer.addParam(std::move(stridesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLBindVertexBuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureBufferStorage(const State &glState,
                                   bool isCallValid,
                                   BufferBinding targetPacked,
                                   GLsizeiptr size,
                                   const void *data,
                                   GLbitfield flags)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureBufferStorage_data(glState, isCallValid, targetPacked, size, data, flags,
                                    &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      paramBuffer.addEnumParam("flags", BigGLEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
  
      return CallCapture(angle::EntryPoint::GLBufferStorage, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearTexImage(const State &glState,
                                   bool isCallValid,
                                   TextureID texturePacked,
                                   GLint level,
                                   GLenum format,
                                   GLenum type,
                                   const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearTexImage_data(glState, isCallValid, texturePacked, level, format, type, data,
                                    &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearTexImage, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearTexSubImage_data(glState, isCallValid, texturePacked, level, xoffset, yoffset,
                                       zoffset, width, height, depth, format, type, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearTexSubImage, std::move(paramBuffer));
  }
  
  // GL 4.5
  CallCapture CaptureBindTextureUnit(const State &glState,
                                     bool isCallValid,
                                     GLuint unit,
                                     TextureID texturePacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("unit", ParamType::TGLuint, unit);
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
  
      return CallCapture(angle::EntryPoint::GLBindTextureUnit, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("readFramebuffer", ParamType::TGLuint, readFramebuffer);
      paramBuffer.addValueParam("drawFramebuffer", ParamType::TGLuint, drawFramebuffer);
      paramBuffer.addValueParam("srcX0", ParamType::TGLint, srcX0);
      paramBuffer.addValueParam("srcY0", ParamType::TGLint, srcY0);
      paramBuffer.addValueParam("srcX1", ParamType::TGLint, srcX1);
      paramBuffer.addValueParam("srcY1", ParamType::TGLint, srcY1);
      paramBuffer.addValueParam("dstX0", ParamType::TGLint, dstX0);
      paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0);
      paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1);
      paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1);
      paramBuffer.addEnumParam("mask", BigGLEnum::ClearBufferMask, ParamType::TGLbitfield, mask);
      paramBuffer.addEnumParam("filter", BigGLEnum::BlitFramebufferFilter, ParamType::TGLenum,
                               filter);
  
      return CallCapture(angle::EntryPoint::GLBlitNamedFramebuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureCheckNamedFramebufferStatus(const State &glState,
                                                 bool isCallValid,
                                                 FramebufferID framebufferPacked,
                                                 GLenum target,
                                                 GLenum returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TGLenum);
      InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLCheckNamedFramebufferStatus, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedBufferData(const State &glState,
                                          bool isCallValid,
                                          BufferID bufferPacked,
                                          GLenum internalformat,
                                          GLenum format,
                                          GLenum type,
                                          const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearNamedBufferData_data(glState, isCallValid, bufferPacked, internalformat, format,
                                           type, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearNamedBufferData, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedBufferSubData(const State &glState,
                                             bool isCallValid,
                                             BufferID bufferPacked,
                                             GLenum internalformat,
                                             GLintptr offset,
                                             GLsizeiptr size,
                                             GLenum format,
                                             GLenum type,
                                             const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureClearNamedBufferSubData_data(glState, isCallValid, bufferPacked, internalformat,
                                              offset, size, format, type, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearNamedBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedFramebufferfi(const State &glState,
                                             bool isCallValid,
                                             FramebufferID framebufferPacked,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             GLfloat depth,
                                             GLint stencil)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer);
      paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
      paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth);
      paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil);
  
      return CallCapture(angle::EntryPoint::GLClearNamedFramebufferfi, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedFramebufferfv(const State &glState,
                                             bool isCallValid,
                                             FramebufferID framebufferPacked,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             const GLfloat *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer);
      paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
          CaptureClearNamedFramebufferfv_value(glState, isCallValid, framebufferPacked, buffer,
                                               drawbuffer, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearNamedFramebufferfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedFramebufferiv(const State &glState,
                                             bool isCallValid,
                                             FramebufferID framebufferPacked,
                                             GLenum buffer,
                                             GLint drawbuffer,
                                             const GLint *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer);
      paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
          CaptureClearNamedFramebufferiv_value(glState, isCallValid, framebufferPacked, buffer,
                                               drawbuffer, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearNamedFramebufferiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureClearNamedFramebufferuiv(const State &glState,
                                              bool isCallValid,
                                              FramebufferID framebufferPacked,
                                              GLenum buffer,
                                              GLint drawbuffer,
                                              const GLuint *value)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer);
      paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
  
      if (isCallValid)
      {
          ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
          CaptureClearNamedFramebufferuiv_value(glState, isCallValid, framebufferPacked, buffer,
                                                drawbuffer, value, &valueParam);
          paramBuffer.addParam(std::move(valueParam));
      }
      else
      {
          ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &valueParam.value);
          paramBuffer.addParam(std::move(valueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLClearNamedFramebufferuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureClipControl(const State &glState, bool isCallValid, GLenum origin, GLenum depth)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("origin", BigGLEnum::ClipControlOrigin, ParamType::TGLenum, origin);
      paramBuffer.addEnumParam("depth", BigGLEnum::ClipControlDepth, ParamType::TGLenum, depth);
  
      return CallCapture(angle::EntryPoint::GLClipControl, std::move(paramBuffer));
  }
  
  CallCapture CaptureCompressedTextureSubImage1D(const State &glState,
                                                 bool isCallValid,
                                                 TextureID texturePacked,
                                                 GLint level,
                                                 GLint xoffset,
                                                 GLsizei width,
                                                 GLenum format,
                                                 GLsizei imageSize,
                                                 const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format);
      paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureCompressedTextureSubImage1D_data(glState, isCallValid, texturePacked, level, xoffset,
                                                  width, format, imageSize, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCompressedTextureSubImage1D, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format);
      paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureCompressedTextureSubImage2D_data(glState, isCallValid, texturePacked, level, xoffset,
                                                  yoffset, width, height, format, imageSize, data,
                                                  &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCompressedTextureSubImage2D, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format);
      paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureCompressedTextureSubImage3D_data(glState, isCallValid, texturePacked, level, xoffset,
                                                  yoffset, zoffset, width, height, depth, format,
                                                  imageSize, data, &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCompressedTextureSubImage3D, std::move(paramBuffer));
  }
  
  CallCapture CaptureCopyNamedBufferSubData(const State &glState,
                                            bool isCallValid,
                                            GLuint readBuffer,
                                            GLuint writeBuffer,
                                            GLintptr readOffset,
                                            GLintptr writeOffset,
                                            GLsizeiptr size)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("readBuffer", ParamType::TGLuint, readBuffer);
      paramBuffer.addValueParam("writeBuffer", ParamType::TGLuint, writeBuffer);
      paramBuffer.addValueParam("readOffset", ParamType::TGLintptr, readOffset);
      paramBuffer.addValueParam("writeOffset", ParamType::TGLintptr, writeOffset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      return CallCapture(angle::EntryPoint::GLCopyNamedBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureCopyTextureSubImage1D(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLint level,
                                           GLint xoffset,
                                           GLint x,
                                           GLint y,
                                           GLsizei width)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("x", ParamType::TGLint, x);
      paramBuffer.addValueParam("y", ParamType::TGLint, y);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
  
      return CallCapture(angle::EntryPoint::GLCopyTextureSubImage1D, std::move(paramBuffer));
  }
  
  CallCapture CaptureCopyTextureSubImage2D(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLint level,
                                           GLint xoffset,
                                           GLint yoffset,
                                           GLint x,
                                           GLint y,
                                           GLsizei width,
                                           GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("x", ParamType::TGLint, x);
      paramBuffer.addValueParam("y", ParamType::TGLint, y);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLCopyTextureSubImage2D, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("x", ParamType::TGLint, x);
      paramBuffer.addValueParam("y", ParamType::TGLint, y);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLCopyTextureSubImage3D, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateBuffers(const State &glState,
                                   bool isCallValid,
                                   GLsizei n,
                                   BufferID *buffersPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDPointer);
          InitParamValue(ParamType::TBufferIDPointer, buffersPacked, &buffersPackedParam.value);
          CaptureCreateBuffers_buffersPacked(glState, isCallValid, n, buffersPacked,
                                             &buffersPackedParam);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
      else
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDPointer);
          InitParamValue(ParamType::TBufferIDPointer, static_cast<BufferID *>(nullptr),
                         &buffersPackedParam.value);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateBuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateFramebuffers(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        GLuint *framebuffers)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture framebuffersParam("framebuffers", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, framebuffers, &framebuffersParam.value);
          CaptureCreateFramebuffers_framebuffers(glState, isCallValid, n, framebuffers,
                                                 &framebuffersParam);
          paramBuffer.addParam(std::move(framebuffersParam));
      }
      else
      {
          ParamCapture framebuffersParam("framebuffers", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &framebuffersParam.value);
          paramBuffer.addParam(std::move(framebuffersParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateFramebuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateProgramPipelines(const State &glState,
                                            bool isCallValid,
                                            GLsizei n,
                                            GLuint *pipelines)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture pipelinesParam("pipelines", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, pipelines, &pipelinesParam.value);
          CaptureCreateProgramPipelines_pipelines(glState, isCallValid, n, pipelines,
                                                  &pipelinesParam);
          paramBuffer.addParam(std::move(pipelinesParam));
      }
      else
      {
          ParamCapture pipelinesParam("pipelines", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &pipelinesParam.value);
          paramBuffer.addParam(std::move(pipelinesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateProgramPipelines, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateQueries(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLsizei n,
                                   GLuint *ids)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture idsParam("ids", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
          CaptureCreateQueries_ids(glState, isCallValid, target, n, ids, &idsParam);
          paramBuffer.addParam(std::move(idsParam));
      }
      else
      {
          ParamCapture idsParam("ids", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
          paramBuffer.addParam(std::move(idsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateQueries, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateRenderbuffers(const State &glState,
                                         bool isCallValid,
                                         GLsizei n,
                                         RenderbufferID *renderbuffersPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture renderbuffersPackedParam("renderbuffersPacked",
                                                ParamType::TRenderbufferIDPointer);
          InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
                         &renderbuffersPackedParam.value);
          CaptureCreateRenderbuffers_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
                                                         &renderbuffersPackedParam);
          paramBuffer.addParam(std::move(renderbuffersPackedParam));
      }
      else
      {
          ParamCapture renderbuffersPackedParam("renderbuffersPacked",
                                                ParamType::TRenderbufferIDPointer);
          InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
                         &renderbuffersPackedParam.value);
          paramBuffer.addParam(std::move(renderbuffersPackedParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateRenderbuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateSamplers(const State &glState,
                                    bool isCallValid,
                                    GLsizei n,
                                    GLuint *samplers)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture samplersParam("samplers", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, samplers, &samplersParam.value);
          CaptureCreateSamplers_samplers(glState, isCallValid, n, samplers, &samplersParam);
          paramBuffer.addParam(std::move(samplersParam));
      }
      else
      {
          ParamCapture samplersParam("samplers", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &samplersParam.value);
          paramBuffer.addParam(std::move(samplersParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateSamplers, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateTextures(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLsizei n,
                                    GLuint *textures)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, textures, &texturesParam.value);
          CaptureCreateTextures_textures(glState, isCallValid, target, n, textures, &texturesParam);
          paramBuffer.addParam(std::move(texturesParam));
      }
      else
      {
          ParamCapture texturesParam("textures", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &texturesParam.value);
          paramBuffer.addParam(std::move(texturesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateTextures, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateTransformFeedbacks(const State &glState,
                                              bool isCallValid,
                                              GLsizei n,
                                              GLuint *ids)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture idsParam("ids", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
          CaptureCreateTransformFeedbacks_ids(glState, isCallValid, n, ids, &idsParam);
          paramBuffer.addParam(std::move(idsParam));
      }
      else
      {
          ParamCapture idsParam("ids", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
          paramBuffer.addParam(std::move(idsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateTransformFeedbacks, std::move(paramBuffer));
  }
  
  CallCapture CaptureCreateVertexArrays(const State &glState,
                                        bool isCallValid,
                                        GLsizei n,
                                        VertexArrayID *arraysPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
          InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
          CaptureCreateVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked,
                                                 &arraysPackedParam);
          paramBuffer.addParam(std::move(arraysPackedParam));
      }
      else
      {
          ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
          InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
                         &arraysPackedParam.value);
          paramBuffer.addParam(std::move(arraysPackedParam));
      }
  
      return CallCapture(angle::EntryPoint::GLCreateVertexArrays, std::move(paramBuffer));
  }
  
  CallCapture CaptureDisableVertexArrayAttrib(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              GLuint index)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      return CallCapture(angle::EntryPoint::GLDisableVertexArrayAttrib, std::move(paramBuffer));
  }
  
  CallCapture CaptureEnableVertexArrayAttrib(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint index)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      return CallCapture(angle::EntryPoint::GLEnableVertexArrayAttrib, std::move(paramBuffer));
  }
  
  CallCapture CaptureFlushMappedNamedBufferRange(const State &glState,
                                                 bool isCallValid,
                                                 BufferID bufferPacked,
                                                 GLintptr offset,
                                                 GLsizeiptr length)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
  
      return CallCapture(angle::EntryPoint::GLFlushMappedNamedBufferRange, std::move(paramBuffer));
  }
  
  CallCapture CaptureGenerateTextureMipmap(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
  
      return CallCapture(angle::EntryPoint::GLGenerateTextureMipmap, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetCompressedTextureImage(const State &glState,
                                               bool isCallValid,
                                               TextureID texturePacked,
                                               GLint level,
                                               GLsizei bufSize,
                                               void *pixels)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetCompressedTextureImage_pixels(glState, isCallValid, texturePacked, level, bufSize,
                                                  pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetCompressedTextureImage, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetCompressedTextureSubImage_pixels(glState, isCallValid, texturePacked, level,
                                                     xoffset, yoffset, zoffset, width, height, depth,
                                                     bufSize, pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetCompressedTextureSubImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedBufferParameteri64v(const State &glState,
                                                 bool isCallValid,
                                                 BufferID bufferPacked,
                                                 GLenum pname,
                                                 GLint64 *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, params, &paramsParam.value);
          CaptureGetNamedBufferParameteri64v_params(glState, isCallValid, bufferPacked, pname, params,
                                                    &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedBufferParameteri64v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedBufferParameteriv(const State &glState,
                                               bool isCallValid,
                                               BufferID bufferPacked,
                                               GLenum pname,
                                               GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetNamedBufferParameteriv_params(glState, isCallValid, bufferPacked, pname, params,
                                                  &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedBufferParameteriv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedBufferPointerv(const State &glState,
                                            bool isCallValid,
                                            BufferID bufferPacked,
                                            GLenum pname,
                                            void **params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
          InitParamValue(ParamType::TvoidPointerPointer, params, &paramsParam.value);
          CaptureGetNamedBufferPointerv_params(glState, isCallValid, bufferPacked, pname, params,
                                               &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
          InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedBufferPointerv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedBufferSubData(const State &glState,
                                           bool isCallValid,
                                           BufferID bufferPacked,
                                           GLintptr offset,
                                           GLsizeiptr size,
                                           void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
          CaptureGetNamedBufferSubData_data(glState, isCallValid, bufferPacked, offset, size, data,
                                            &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState,
                                                              bool isCallValid,
                                                              FramebufferID framebufferPacked,
                                                              GLenum attachment,
                                                              GLenum pname,
                                                              GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
                               attachment);
      paramBuffer.addEnumParam("pname", BigGLEnum::FramebufferAttachmentParameterName,
                               ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetNamedFramebufferAttachmentParameteriv_params(
              glState, isCallValid, framebufferPacked, attachment, pname, params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedFramebufferAttachmentParameteriv,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState,
                                                    bool isCallValid,
                                                    FramebufferID framebufferPacked,
                                                    GLenum pname,
                                                    GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetFramebufferParameter, ParamType::TGLenum,
                               pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, param, &paramParam.value);
          CaptureGetNamedFramebufferParameteriv_param(glState, isCallValid, framebufferPacked, pname,
                                                      param, &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedFramebufferParameteriv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState,
                                                     bool isCallValid,
                                                     RenderbufferID renderbufferPacked,
                                                     GLenum pname,
                                                     GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::RenderbufferParameterName, ParamType::TGLenum,
                               pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetNamedRenderbufferParameteriv_params(glState, isCallValid, renderbufferPacked,
                                                        pname, params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetNamedRenderbufferParameteriv,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureGetQueryBufferObjecti64v(const State &glState,
                                              bool isCallValid,
                                              GLuint id,
                                              BufferID bufferPacked,
                                              GLenum pname,
                                              GLintptr offset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("id", ParamType::TGLuint, id);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
                               pname);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
  
      return CallCapture(angle::EntryPoint::GLGetQueryBufferObjecti64v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetQueryBufferObjectiv(const State &glState,
                                            bool isCallValid,
                                            GLuint id,
                                            BufferID bufferPacked,
                                            GLenum pname,
                                            GLintptr offset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("id", ParamType::TGLuint, id);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
                               pname);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
  
      return CallCapture(angle::EntryPoint::GLGetQueryBufferObjectiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetQueryBufferObjectui64v(const State &glState,
                                               bool isCallValid,
                                               GLuint id,
                                               BufferID bufferPacked,
                                               GLenum pname,
                                               GLintptr offset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("id", ParamType::TGLuint, id);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
                               pname);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
  
      return CallCapture(angle::EntryPoint::GLGetQueryBufferObjectui64v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetQueryBufferObjectuiv(const State &glState,
                                             bool isCallValid,
                                             GLuint id,
                                             BufferID bufferPacked,
                                             GLenum pname,
                                             GLintptr offset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("id", ParamType::TGLuint, id);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum,
                               pname);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
  
      return CallCapture(angle::EntryPoint::GLGetQueryBufferObjectuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureImage(const State &glState,
                                     bool isCallValid,
                                     TextureID texturePacked,
                                     GLint level,
                                     GLenum format,
                                     GLenum type,
                                     GLsizei bufSize,
                                     void *pixels)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetTextureImage_pixels(glState, isCallValid, texturePacked, level, format, type,
                                        bufSize, pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureLevelParameterfv(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLenum pname,
                                                GLfloat *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
          CaptureGetTextureLevelParameterfv_params(glState, isCallValid, texturePacked, level, pname,
                                                   params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureLevelParameterfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureLevelParameteriv(const State &glState,
                                                bool isCallValid,
                                                TextureID texturePacked,
                                                GLint level,
                                                GLenum pname,
                                                GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetTextureLevelParameteriv_params(glState, isCallValid, texturePacked, level, pname,
                                                   params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureLevelParameteriv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureParameterIiv(const State &glState,
                                            bool isCallValid,
                                            TextureID texturePacked,
                                            GLenum pname,
                                            GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetTextureParameterIiv_params(glState, isCallValid, texturePacked, pname, params,
                                               &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureParameterIiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureParameterIuiv(const State &glState,
                                             bool isCallValid,
                                             TextureID texturePacked,
                                             GLenum pname,
                                             GLuint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
          CaptureGetTextureParameterIuiv_params(glState, isCallValid, texturePacked, pname, params,
                                                &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureParameterIuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureParameterfv(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLenum pname,
                                           GLfloat *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
          CaptureGetTextureParameterfv_params(glState, isCallValid, texturePacked, pname, params,
                                              &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureParameterfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTextureParameteriv(const State &glState,
                                           bool isCallValid,
                                           TextureID texturePacked,
                                           GLenum pname,
                                           GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
          CaptureGetTextureParameteriv_params(glState, isCallValid, texturePacked, pname, params,
                                              &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureParameteriv, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetTextureSubImage_pixels(glState, isCallValid, texturePacked, level, xoffset,
                                           yoffset, zoffset, width, height, depth, format, type,
                                           bufSize, pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTextureSubImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTransformFeedbacki64_v(const State &glState,
                                               bool isCallValid,
                                               GLuint xfb,
                                               GLenum pname,
                                               GLuint index,
                                               GLint64 *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb);
      paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, param, &paramParam.value);
          CaptureGetTransformFeedbacki64_v_param(glState, isCallValid, xfb, pname, index, param,
                                                 &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
                         &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTransformFeedbacki64_v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTransformFeedbacki_v(const State &glState,
                                             bool isCallValid,
                                             GLuint xfb,
                                             GLenum pname,
                                             GLuint index,
                                             GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb);
      paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, param, &paramParam.value);
          CaptureGetTransformFeedbacki_v_param(glState, isCallValid, xfb, pname, index, param,
                                               &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTransformFeedbacki_v, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetTransformFeedbackiv(const State &glState,
                                            bool isCallValid,
                                            GLuint xfb,
                                            GLenum pname,
                                            GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb);
      paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, param, &paramParam.value);
          CaptureGetTransformFeedbackiv_param(glState, isCallValid, xfb, pname, param, &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetTransformFeedbackiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState,
                                               bool isCallValid,
                                               VertexArrayID vaobjPacked,
                                               GLuint index,
                                               GLenum pname,
                                               GLint64 *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, param, &paramParam.value);
          CaptureGetVertexArrayIndexed64iv_param(glState, isCallValid, vaobjPacked, index, pname,
                                                 param, &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLint64Pointer);
          InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
                         &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetVertexArrayIndexed64iv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetVertexArrayIndexediv(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint index,
                                             GLenum pname,
                                             GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, param, &paramParam.value);
          CaptureGetVertexArrayIndexediv_param(glState, isCallValid, vaobjPacked, index, pname, param,
                                               &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetVertexArrayIndexediv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetVertexArrayiv(const State &glState,
                                      bool isCallValid,
                                      VertexArrayID vaobjPacked,
                                      GLenum pname,
                                      GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, param, &paramParam.value);
          CaptureGetVertexArrayiv_param(glState, isCallValid, vaobjPacked, pname, param, &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetVertexArrayiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnColorTable(const State &glState,
                                    bool isCallValid,
                                    GLenum target,
                                    GLenum format,
                                    GLenum type,
                                    GLsizei bufSize,
                                    void *table)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::ColorTableTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture tableParam("table", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, table, &tableParam.value);
          CaptureGetnColorTable_table(glState, isCallValid, target, format, type, bufSize, table,
                                      &tableParam);
          paramBuffer.addParam(std::move(tableParam));
      }
      else
      {
          ParamCapture tableParam("table", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &tableParam.value);
          paramBuffer.addParam(std::move(tableParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnColorTable, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnCompressedTexImage(const State &glState,
                                            bool isCallValid,
                                            GLenum target,
                                            GLint lod,
                                            GLsizei bufSize,
                                            void *pixels)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("lod", ParamType::TGLint, lod);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetnCompressedTexImage_pixels(glState, isCallValid, target, lod, bufSize, pixels,
                                               &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnCompressedTexImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnConvolutionFilter(const State &glState,
                                           bool isCallValid,
                                           GLenum target,
                                           GLenum format,
                                           GLenum type,
                                           GLsizei bufSize,
                                           void *image)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::ConvolutionTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture imageParam("image", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, image, &imageParam.value);
          CaptureGetnConvolutionFilter_image(glState, isCallValid, target, format, type, bufSize,
                                             image, &imageParam);
          paramBuffer.addParam(std::move(imageParam));
      }
      else
      {
          ParamCapture imageParam("image", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &imageParam.value);
          paramBuffer.addParam(std::move(imageParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnConvolutionFilter, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnHistogram(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLboolean reset,
                                   GLenum format,
                                   GLenum type,
                                   GLsizei bufSize,
                                   void *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::HistogramTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("reset", ParamType::TGLboolean, reset);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, values, &valuesParam.value);
          CaptureGetnHistogram_values(glState, isCallValid, target, reset, format, type, bufSize,
                                      values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnHistogram, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnMapdv(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLenum query,
                               GLsizei bufSize,
                               GLdouble *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, v, &vParam.value);
          CaptureGetnMapdv_v(glState, isCallValid, target, query, bufSize, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
                         &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnMapdv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnMapfv(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLenum query,
                               GLsizei bufSize,
                               GLfloat *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, v, &vParam.value);
          CaptureGetnMapfv_v(glState, isCallValid, target, query, bufSize, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr), &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnMapfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnMapiv(const State &glState,
                               bool isCallValid,
                               GLenum target,
                               GLenum query,
                               GLsizei bufSize,
                               GLint *v)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture vParam("v", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, v, &vParam.value);
          CaptureGetnMapiv_v(glState, isCallValid, target, query, bufSize, v, &vParam);
          paramBuffer.addParam(std::move(vParam));
      }
      else
      {
          ParamCapture vParam("v", ParamType::TGLintPointer);
          InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &vParam.value);
          paramBuffer.addParam(std::move(vParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnMapiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnMinmax(const State &glState,
                                bool isCallValid,
                                GLenum target,
                                GLboolean reset,
                                GLenum format,
                                GLenum type,
                                GLsizei bufSize,
                                void *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::MinmaxTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("reset", ParamType::TGLboolean, reset);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, values, &valuesParam.value);
          CaptureGetnMinmax_values(glState, isCallValid, target, reset, format, type, bufSize, values,
                                   &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnMinmax, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnPixelMapfv(const State &glState,
                                    bool isCallValid,
                                    GLenum map,
                                    GLsizei bufSize,
                                    GLfloat *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, values, &valuesParam.value);
          CaptureGetnPixelMapfv_values(glState, isCallValid, map, bufSize, values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLfloatPointer);
          InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
                         &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnPixelMapfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnPixelMapuiv(const State &glState,
                                     bool isCallValid,
                                     GLenum map,
                                     GLsizei bufSize,
                                     GLuint *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, values, &valuesParam.value);
          CaptureGetnPixelMapuiv_values(glState, isCallValid, map, bufSize, values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLuintPointer);
          InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
                         &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnPixelMapuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnPixelMapusv(const State &glState,
                                     bool isCallValid,
                                     GLenum map,
                                     GLsizei bufSize,
                                     GLushort *values)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture valuesParam("values", ParamType::TGLushortPointer);
          InitParamValue(ParamType::TGLushortPointer, values, &valuesParam.value);
          CaptureGetnPixelMapusv_values(glState, isCallValid, map, bufSize, values, &valuesParam);
          paramBuffer.addParam(std::move(valuesParam));
      }
      else
      {
          ParamCapture valuesParam("values", ParamType::TGLushortPointer);
          InitParamValue(ParamType::TGLushortPointer, static_cast<GLushort *>(nullptr),
                         &valuesParam.value);
          paramBuffer.addParam(std::move(valuesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnPixelMapusv, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnPolygonStipple(const State &glState,
                                        bool isCallValid,
                                        GLsizei bufSize,
                                        GLubyte *pattern)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture patternParam("pattern", ParamType::TGLubytePointer);
          InitParamValue(ParamType::TGLubytePointer, pattern, &patternParam.value);
          CaptureGetnPolygonStipple_pattern(glState, isCallValid, bufSize, pattern, &patternParam);
          paramBuffer.addParam(std::move(patternParam));
      }
      else
      {
          ParamCapture patternParam("pattern", ParamType::TGLubytePointer);
          InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr),
                         &patternParam.value);
          paramBuffer.addParam(std::move(patternParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnPolygonStipple, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnSeparableFilter(const State &glState,
                                         bool isCallValid,
                                         GLenum target,
                                         GLenum format,
                                         GLenum type,
                                         GLsizei rowBufSize,
                                         void *row,
                                         GLsizei columnBufSize,
                                         void *column,
                                         void *span)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::SeparableTarget, ParamType::TGLenum, target);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("rowBufSize", ParamType::TGLsizei, rowBufSize);
  
      if (isCallValid)
      {
          ParamCapture rowParam("row", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, row, &rowParam.value);
          CaptureGetnSeparableFilter_row(glState, isCallValid, target, format, type, rowBufSize, row,
                                         columnBufSize, column, span, &rowParam);
          paramBuffer.addParam(std::move(rowParam));
      }
      else
      {
          ParamCapture rowParam("row", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &rowParam.value);
          paramBuffer.addParam(std::move(rowParam));
      }
  
      paramBuffer.addValueParam("columnBufSize", ParamType::TGLsizei, columnBufSize);
  
      if (isCallValid)
      {
          ParamCapture columnParam("column", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, column, &columnParam.value);
          CaptureGetnSeparableFilter_column(glState, isCallValid, target, format, type, rowBufSize,
                                            row, columnBufSize, column, span, &columnParam);
          paramBuffer.addParam(std::move(columnParam));
      }
      else
      {
          ParamCapture columnParam("column", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &columnParam.value);
          paramBuffer.addParam(std::move(columnParam));
      }
  
      if (isCallValid)
      {
          ParamCapture spanParam("span", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, span, &spanParam.value);
          CaptureGetnSeparableFilter_span(glState, isCallValid, target, format, type, rowBufSize, row,
                                          columnBufSize, column, span, &spanParam);
          paramBuffer.addParam(std::move(spanParam));
      }
      else
      {
          ParamCapture spanParam("span", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &spanParam.value);
          paramBuffer.addParam(std::move(spanParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnSeparableFilter, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnTexImage(const State &glState,
                                  bool isCallValid,
                                  GLenum target,
                                  GLint level,
                                  GLenum format,
                                  GLenum type,
                                  GLsizei bufSize,
                                  void *pixels)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
          CaptureGetnTexImage_pixels(glState, isCallValid, target, level, format, type, bufSize,
                                     pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
          InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnTexImage, std::move(paramBuffer));
  }
  
  CallCapture CaptureGetnUniformdv(const State &glState,
                                   bool isCallValid,
                                   ShaderProgramID programPacked,
                                   UniformLocation locationPacked,
                                   GLsizei bufSize,
                                   GLdouble *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
      paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
      paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, params, &paramsParam.value);
          CaptureGetnUniformdv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
                                      params, &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
          InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLGetnUniformdv, std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateNamedFramebufferData(const State &glState,
                                                    bool isCallValid,
                                                    FramebufferID framebufferPacked,
                                                    GLsizei numAttachments,
                                                    const GLenum *attachments)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
  
      if (isCallValid)
      {
          ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
          CaptureInvalidateNamedFramebufferData_attachments(glState, isCallValid, framebufferPacked,
                                                            numAttachments, attachments,
                                                            &attachmentsParam);
          paramBuffer.addParam(std::move(attachmentsParam));
      }
      else
      {
          ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
                         &attachmentsParam.value);
          paramBuffer.addParam(std::move(attachmentsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLInvalidateNamedFramebufferData, std::move(paramBuffer));
  }
  
  CallCapture CaptureInvalidateNamedFramebufferSubData(const State &glState,
                                                       bool isCallValid,
                                                       FramebufferID framebufferPacked,
                                                       GLsizei numAttachments,
                                                       const GLenum *attachments,
                                                       GLint x,
                                                       GLint y,
                                                       GLsizei width,
                                                       GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
  
      if (isCallValid)
      {
          ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
          CaptureInvalidateNamedFramebufferSubData_attachments(
              glState, isCallValid, framebufferPacked, numAttachments, attachments, x, y, width,
              height, &attachmentsParam);
          paramBuffer.addParam(std::move(attachmentsParam));
      }
      else
      {
          ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
                         &attachmentsParam.value);
          paramBuffer.addParam(std::move(attachmentsParam));
      }
  
      paramBuffer.addValueParam("x", ParamType::TGLint, x);
      paramBuffer.addValueParam("y", ParamType::TGLint, y);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLInvalidateNamedFramebufferSubData,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureMapNamedBuffer(const State &glState,
                                    bool isCallValid,
                                    BufferID bufferPacked,
                                    GLenum access,
                                    void *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addEnumParam("access", BigGLEnum::BufferAccessARB, ParamType::TGLenum, access);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
      InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLMapNamedBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureMapNamedBufferRange(const State &glState,
                                         bool isCallValid,
                                         BufferID bufferPacked,
                                         GLintptr offset,
                                         GLsizeiptr length,
                                         GLbitfield access,
                                         void *returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
      paramBuffer.addEnumParam("access", BigGLEnum::MapBufferAccessMask, ParamType::TGLbitfield,
                               access);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer);
      InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLMapNamedBufferRange, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedBufferData(const State &glState,
                                     bool isCallValid,
                                     BufferID bufferPacked,
                                     GLsizeiptr size,
                                     const void *data,
                                     GLenum usage)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureNamedBufferData_data(glState, isCallValid, bufferPacked, size, data, usage,
                                      &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      paramBuffer.addEnumParam("usage", BigGLEnum::VertexBufferObjectUsage, ParamType::TGLenum,
                               usage);
  
      return CallCapture(angle::EntryPoint::GLNamedBufferData, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedBufferStorage(const State &glState,
                                        bool isCallValid,
                                        BufferID bufferPacked,
                                        GLsizeiptr size,
                                        const void *data,
                                        GLbitfield flags)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureNamedBufferStorage_data(glState, isCallValid, bufferPacked, size, data, flags,
                                         &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      paramBuffer.addEnumParam("flags", BigGLEnum::BufferStorageMask, ParamType::TGLbitfield, flags);
  
      return CallCapture(angle::EntryPoint::GLNamedBufferStorage, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedBufferSubData(const State &glState,
                                        bool isCallValid,
                                        BufferID bufferPacked,
                                        GLintptr offset,
                                        GLsizeiptr size,
                                        const void *data)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      if (isCallValid)
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
          CaptureNamedBufferSubData_data(glState, isCallValid, bufferPacked, offset, size, data,
                                         &dataParam);
          paramBuffer.addParam(std::move(dataParam));
      }
      else
      {
          ParamCapture dataParam("data", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &dataParam.value);
          paramBuffer.addParam(std::move(dataParam));
      }
  
      return CallCapture(angle::EntryPoint::GLNamedBufferSubData, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState,
                                                bool isCallValid,
                                                FramebufferID framebufferPacked,
                                                GLenum buf)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("buf", BigGLEnum::ColorBuffer, ParamType::TGLenum, buf);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferDrawBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferDrawBuffers(const State &glState,
                                                 bool isCallValid,
                                                 FramebufferID framebufferPacked,
                                                 GLsizei n,
                                                 const GLenum *bufs)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
  
      if (isCallValid)
      {
          ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
          CaptureNamedFramebufferDrawBuffers_bufs(glState, isCallValid, framebufferPacked, n, bufs,
                                                  &bufsParam);
          paramBuffer.addParam(std::move(bufsParam));
      }
      else
      {
          ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
          InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
                         &bufsParam.value);
          paramBuffer.addParam(std::move(bufsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferDrawBuffers, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferParameteri(const State &glState,
                                                bool isCallValid,
                                                FramebufferID framebufferPacked,
                                                GLenum pname,
                                                GLint param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::FramebufferParameterName, ParamType::TGLenum,
                               pname);
      paramBuffer.addValueParam("param", ParamType::TGLint, param);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferParameteri, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferReadBuffer(const State &glState,
                                                bool isCallValid,
                                                FramebufferID framebufferPacked,
                                                GLenum src)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("src", BigGLEnum::ColorBuffer, ParamType::TGLenum, src);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferReadBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum attachment,
                                                  GLenum renderbuffertarget,
                                                  RenderbufferID renderbufferPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
                               attachment);
      paramBuffer.addEnumParam("renderbuffertarget", BigGLEnum::RenderbufferTarget,
                               ParamType::TGLenum, renderbuffertarget);
      paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferRenderbuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferTexture(const State &glState,
                                             bool isCallValid,
                                             FramebufferID framebufferPacked,
                                             GLenum attachment,
                                             TextureID texturePacked,
                                             GLint level)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
                               attachment);
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferTexture, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedFramebufferTextureLayer(const State &glState,
                                                  bool isCallValid,
                                                  FramebufferID framebufferPacked,
                                                  GLenum attachment,
                                                  TextureID texturePacked,
                                                  GLint level,
                                                  GLint layer)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked);
      paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum,
                               attachment);
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
  
      return CallCapture(angle::EntryPoint::GLNamedFramebufferTextureLayer, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedRenderbufferStorage(const State &glState,
                                              bool isCallValid,
                                              RenderbufferID renderbufferPacked,
                                              GLenum internalformat,
                                              GLsizei width,
                                              GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLNamedRenderbufferStorage, std::move(paramBuffer));
  }
  
  CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState,
                                                         bool isCallValid,
                                                         RenderbufferID renderbufferPacked,
                                                         GLsizei samples,
                                                         GLenum internalformat,
                                                         GLsizei width,
                                                         GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked);
      paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLNamedRenderbufferStorageMultisample,
                         std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureBarrier(const State &glState, bool isCallValid)
  {
      ParamBuffer paramBuffer;
  
      return CallCapture(angle::EntryPoint::GLTextureBarrier, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureBuffer(const State &glState,
                                   bool isCallValid,
                                   TextureID texturePacked,
                                   GLenum internalformat,
                                   BufferID bufferPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
  
      return CallCapture(angle::EntryPoint::GLTextureBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureBufferRange(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum internalformat,
                                        BufferID bufferPacked,
                                        GLintptr offset,
                                        GLsizeiptr size)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      return CallCapture(angle::EntryPoint::GLTextureBufferRange, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameterIiv(const State &glState,
                                         bool isCallValid,
                                         TextureID texturePacked,
                                         GLenum pname,
                                         const GLint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
          CaptureTextureParameterIiv_params(glState, isCallValid, texturePacked, pname, params,
                                            &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureParameterIiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameterIuiv(const State &glState,
                                          bool isCallValid,
                                          TextureID texturePacked,
                                          GLenum pname,
                                          const GLuint *params)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, params, &paramsParam.value);
          CaptureTextureParameterIuiv_params(glState, isCallValid, texturePacked, pname, params,
                                             &paramsParam);
          paramBuffer.addParam(std::move(paramsParam));
      }
      else
      {
          ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &paramsParam.value);
          paramBuffer.addParam(std::move(paramsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureParameterIuiv, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameterf(const State &glState,
                                       bool isCallValid,
                                       TextureID texturePacked,
                                       GLenum pname,
                                       GLfloat param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
      paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
  
      return CallCapture(angle::EntryPoint::GLTextureParameterf, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameterfv(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum pname,
                                        const GLfloat *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, param, &paramParam.value);
          CaptureTextureParameterfv_param(glState, isCallValid, texturePacked, pname, param,
                                          &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
          InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
                         &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureParameterfv, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameteri(const State &glState,
                                       bool isCallValid,
                                       TextureID texturePacked,
                                       GLenum pname,
                                       GLint param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
      paramBuffer.addValueParam("param", ParamType::TGLint, param);
  
      return CallCapture(angle::EntryPoint::GLTextureParameteri, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureParameteriv(const State &glState,
                                        bool isCallValid,
                                        TextureID texturePacked,
                                        GLenum pname,
                                        const GLint *param)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname);
  
      if (isCallValid)
      {
          ParamCapture paramParam("param", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, param, &paramParam.value);
          CaptureTextureParameteriv_param(glState, isCallValid, texturePacked, pname, param,
                                          &paramParam);
          paramBuffer.addParam(std::move(paramParam));
      }
      else
      {
          ParamCapture paramParam("param", ParamType::TGLintConstPointer);
          InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
                         &paramParam.value);
          paramBuffer.addParam(std::move(paramParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureParameteriv, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureStorage1D(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLsizei levels,
                                      GLenum internalformat,
                                      GLsizei width)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
  
      return CallCapture(angle::EntryPoint::GLTextureStorage1D, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureStorage2D(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLsizei levels,
                                      GLenum internalformat,
                                      GLsizei width,
                                      GLsizei height)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
  
      return CallCapture(angle::EntryPoint::GLTextureStorage2D, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureStorage2DMultisample(const State &glState,
                                                 bool isCallValid,
                                                 TextureID texturePacked,
                                                 GLsizei samples,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLboolean fixedsamplelocations)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
  
      return CallCapture(angle::EntryPoint::GLTextureStorage2DMultisample, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureStorage3D(const State &glState,
                                      bool isCallValid,
                                      TextureID texturePacked,
                                      GLsizei levels,
                                      GLenum internalformat,
                                      GLsizei width,
                                      GLsizei height,
                                      GLsizei depth)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
  
      return CallCapture(angle::EntryPoint::GLTextureStorage3D, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureStorage3DMultisample(const State &glState,
                                                 bool isCallValid,
                                                 TextureID texturePacked,
                                                 GLsizei samples,
                                                 GLenum internalformat,
                                                 GLsizei width,
                                                 GLsizei height,
                                                 GLsizei depth,
                                                 GLboolean fixedsamplelocations)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples);
      paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum,
                               internalformat);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
  
      return CallCapture(angle::EntryPoint::GLTextureStorage3DMultisample, std::move(paramBuffer));
  }
  
  CallCapture CaptureTextureSubImage1D(const State &glState,
                                       bool isCallValid,
                                       TextureID texturePacked,
                                       GLint level,
                                       GLint xoffset,
                                       GLsizei width,
                                       GLenum format,
                                       GLenum type,
                                       const void *pixels)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
          CaptureTextureSubImage1D_pixels(glState, isCallValid, texturePacked, level, xoffset, width,
                                          format, type, pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureSubImage1D, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
          CaptureTextureSubImage2D_pixels(glState, isCallValid, texturePacked, level, xoffset,
                                          yoffset, width, height, format, type, pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureSubImage2D, std::move(paramBuffer));
  }
  
  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)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked);
      paramBuffer.addValueParam("level", ParamType::TGLint, level);
      paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset);
      paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset);
      paramBuffer.addValueParam("zoffset", ParamType::TGLint, zoffset);
      paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
      paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
      paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
      paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format);
      paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
          CaptureTextureSubImage3D_pixels(glState, isCallValid, texturePacked, level, xoffset,
                                          yoffset, zoffset, width, height, depth, format, type,
                                          pixels, &pixelsParam);
          paramBuffer.addParam(std::move(pixelsParam));
      }
      else
      {
          ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &pixelsParam.value);
          paramBuffer.addParam(std::move(pixelsParam));
      }
  
      return CallCapture(angle::EntryPoint::GLTextureSubImage3D, std::move(paramBuffer));
  }
  
  CallCapture CaptureTransformFeedbackBufferBase(const State &glState,
                                                 bool isCallValid,
                                                 GLuint xfb,
                                                 GLuint index,
                                                 BufferID bufferPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
  
      return CallCapture(angle::EntryPoint::GLTransformFeedbackBufferBase, std::move(paramBuffer));
  }
  
  CallCapture CaptureTransformFeedbackBufferRange(const State &glState,
                                                  bool isCallValid,
                                                  GLuint xfb,
                                                  GLuint index,
                                                  BufferID bufferPacked,
                                                  GLintptr offset,
                                                  GLsizeiptr size)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb);
      paramBuffer.addValueParam("index", ParamType::TGLuint, index);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
  
      return CallCapture(angle::EntryPoint::GLTransformFeedbackBufferRange, std::move(paramBuffer));
  }
  
  CallCapture CaptureUnmapNamedBuffer(const State &glState,
                                      bool isCallValid,
                                      BufferID bufferPacked,
                                      GLboolean returnValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
  
      ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean);
      InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
      paramBuffer.addReturnValue(std::move(returnValueCapture));
  
      return CallCapture(angle::EntryPoint::GLUnmapNamedBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayAttribBinding(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              GLuint attribindex,
                                              GLuint bindingindex)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
      paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayAttribBinding, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayAttribFormat(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint attribindex,
                                             GLint size,
                                             GLenum type,
                                             GLboolean normalized,
                                             GLuint relativeoffset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
      paramBuffer.addValueParam("size", ParamType::TGLint, size);
      paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
      paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayAttribFormat, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayAttribIFormat(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              GLuint attribindex,
                                              GLint size,
                                              GLenum type,
                                              GLuint relativeoffset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
      paramBuffer.addValueParam("size", ParamType::TGLint, size);
      paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribIType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayAttribIFormat, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayAttribLFormat(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              GLuint attribindex,
                                              GLint size,
                                              GLenum type,
                                              GLuint relativeoffset)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
      paramBuffer.addValueParam("size", ParamType::TGLint, size);
      paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type);
      paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayAttribLFormat, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayBindingDivisor(const State &glState,
                                               bool isCallValid,
                                               VertexArrayID vaobjPacked,
                                               GLuint bindingindex,
                                               GLuint divisor)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
      paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayBindingDivisor, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayElementBuffer(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              BufferID bufferPacked)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayElementBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayVertexBuffer(const State &glState,
                                             bool isCallValid,
                                             VertexArrayID vaobjPacked,
                                             GLuint bindingindex,
                                             BufferID bufferPacked,
                                             GLintptr offset,
                                             GLsizei stride)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
      paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked);
      paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      return CallCapture(angle::EntryPoint::GLVertexArrayVertexBuffer, std::move(paramBuffer));
  }
  
  CallCapture CaptureVertexArrayVertexBuffers(const State &glState,
                                              bool isCallValid,
                                              VertexArrayID vaobjPacked,
                                              GLuint first,
                                              GLsizei count,
                                              const BufferID *buffersPacked,
                                              const GLintptr *offsets,
                                              const GLsizei *strides)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked);
      paramBuffer.addValueParam("first", ParamType::TGLuint, first);
      paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
  
      if (isCallValid)
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
          CaptureVertexArrayVertexBuffers_buffersPacked(glState, isCallValid, vaobjPacked, first,
                                                        count, buffersPacked, offsets, strides,
                                                        &buffersPackedParam);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
      else
      {
          ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
          InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
                         &buffersPackedParam.value);
          paramBuffer.addParam(std::move(buffersPackedParam));
      }
  
      if (isCallValid)
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, offsets, &offsetsParam.value);
          CaptureVertexArrayVertexBuffers_offsets(glState, isCallValid, vaobjPacked, first, count,
                                                  buffersPacked, offsets, strides, &offsetsParam);
          paramBuffer.addParam(std::move(offsetsParam));
      }
      else
      {
          ParamCapture offsetsParam("offsets", ParamType::TGLintptrConstPointer);
          InitParamValue(ParamType::TGLintptrConstPointer, static_cast<const GLintptr *>(nullptr),
                         &offsetsParam.value);
          paramBuffer.addParam(std::move(offsetsParam));
      }
  
      if (isCallValid)
      {
          ParamCapture stridesParam("strides", ParamType::TGLsizeiConstPointer);
          InitParamValue(ParamType::TGLsizeiConstPointer, strides, &stridesParam.value);
          CaptureVertexArrayVertexBuffers_strides(glState, isCallValid, vaobjPacked, first, count,
                                                  buffersPacked, offsets, strides, &stridesParam);
          paramBuffer.addParam(std::move(stridesParam));
      }
      else
      {
          ParamCapture stridesParam("strides", ParamType::TGLsizeiConstPointer);
          InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr),
                         &stridesParam.value);
          paramBuffer.addParam(std::move(stridesParam));
      }
  
      return CallCapture(angle::EntryPoint::GLVertexArrayVertexBuffers, std::move(paramBuffer));
  }
  
  // GL 4.6
  CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState,
                                                  bool isCallValid,
                                                  GLenum mode,
                                                  const void *indirect,
                                                  GLintptr drawcount,
                                                  GLsizei maxdrawcount,
                                                  GLsizei stride)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
  
      if (isCallValid)
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
          CaptureMultiDrawArraysIndirectCount_indirect(
              glState, isCallValid, mode, indirect, drawcount, maxdrawcount, stride, &indirectParam);
          paramBuffer.addParam(std::move(indirectParam));
      }
      else
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indirectParam.value);
          paramBuffer.addParam(std::move(indirectParam));
      }
  
      paramBuffer.addValueParam("drawcount", ParamType::TGLintptr, drawcount);
      paramBuffer.addValueParam("maxdrawcount", ParamType::TGLsizei, maxdrawcount);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      return CallCapture(angle::EntryPoint::GLMultiDrawArraysIndirectCount, std::move(paramBuffer));
  }
  
  CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState,
                                                    bool isCallValid,
                                                    GLenum mode,
                                                    GLenum type,
                                                    const void *indirect,
                                                    GLintptr drawcount,
                                                    GLsizei maxdrawcount,
                                                    GLsizei stride)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode);
      paramBuffer.addEnumParam("type", BigGLEnum::DrawElementsType, ParamType::TGLenum, type);
  
      if (isCallValid)
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
          CaptureMultiDrawElementsIndirectCount_indirect(glState, isCallValid, mode, type, indirect,
                                                         drawcount, maxdrawcount, stride,
                                                         &indirectParam);
          paramBuffer.addParam(std::move(indirectParam));
      }
      else
      {
          ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
          InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
                         &indirectParam.value);
          paramBuffer.addParam(std::move(indirectParam));
      }
  
      paramBuffer.addValueParam("drawcount", ParamType::TGLintptr, drawcount);
      paramBuffer.addValueParam("maxdrawcount", ParamType::TGLsizei, maxdrawcount);
      paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
  
      return CallCapture(angle::EntryPoint::GLMultiDrawElementsIndirectCount, std::move(paramBuffer));
  }
  
  CallCapture CapturePolygonOffsetClamp(const State &glState,
                                        bool isCallValid,
                                        GLfloat factor,
                                        GLfloat units,
                                        GLfloat clamp)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("factor", ParamType::TGLfloat, factor);
      paramBuffer.addValueParam("units", ParamType::TGLfloat, units);
      paramBuffer.addValueParam("clamp", ParamType::TGLfloat, clamp);
  
      return CallCapture(angle::EntryPoint::GLPolygonOffsetClamp, std::move(paramBuffer));
  }
  
  CallCapture CaptureSpecializeShader(const State &glState,
                                      bool isCallValid,
                                      GLuint shader,
                                      const GLchar *pEntryPoint,
                                      GLuint numSpecializationConstants,
                                      const GLuint *pConstantIndex,
                                      const GLuint *pConstantValue)
  {
      ParamBuffer paramBuffer;
  
      paramBuffer.addValueParam("shader", ParamType::TGLuint, shader);
  
      if (isCallValid)
      {
          ParamCapture pEntryPointParam("pEntryPoint", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, pEntryPoint, &pEntryPointParam.value);
          CaptureSpecializeShader_pEntryPoint(glState, isCallValid, shader, pEntryPoint,
                                              numSpecializationConstants, pConstantIndex,
                                              pConstantValue, &pEntryPointParam);
          paramBuffer.addParam(std::move(pEntryPointParam));
      }
      else
      {
          ParamCapture pEntryPointParam("pEntryPoint", ParamType::TGLcharConstPointer);
          InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
                         &pEntryPointParam.value);
          paramBuffer.addParam(std::move(pEntryPointParam));
      }
  
      paramBuffer.addValueParam("numSpecializationConstants", ParamType::TGLuint,
                                numSpecializationConstants);
  
      if (isCallValid)
      {
          ParamCapture pConstantIndexParam("pConstantIndex", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, pConstantIndex, &pConstantIndexParam.value);
          CaptureSpecializeShader_pConstantIndex(glState, isCallValid, shader, pEntryPoint,
                                                 numSpecializationConstants, pConstantIndex,
                                                 pConstantValue, &pConstantIndexParam);
          paramBuffer.addParam(std::move(pConstantIndexParam));
      }
      else
      {
          ParamCapture pConstantIndexParam("pConstantIndex", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &pConstantIndexParam.value);
          paramBuffer.addParam(std::move(pConstantIndexParam));
      }
  
      if (isCallValid)
      {
          ParamCapture pConstantValueParam("pConstantValue", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, pConstantValue, &pConstantValueParam.value);
          CaptureSpecializeShader_pConstantValue(glState, isCallValid, shader, pEntryPoint,
                                                 numSpecializationConstants, pConstantIndex,
                                                 pConstantValue, &pConstantValueParam);
          paramBuffer.addParam(std::move(pConstantValueParam));
      }
      else
      {
          ParamCapture pConstantValueParam("pConstantValue", ParamType::TGLuintConstPointer);
          InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                         &pConstantValueParam.value);
          paramBuffer.addParam(std::move(pConstantValueParam));
      }
  
      return CallCapture(angle::EntryPoint::GLSpecializeShader, std::move(paramBuffer));
  }
  
  }  // namespace gl
  

Download