// 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_2_autogen.cpp:
//   Capture functions for the OpenGL ES Desktop GL 2.x entry points.

#include "libANGLE/capture/capture_gl_2_autogen.h"

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

using namespace angle;

namespace gl
{

// GL 2.0
CallCapture CaptureGetVertexAttribdv(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     GLenum pname,
                                     GLdouble *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname);

    if (isCallValid)
    {
        ParamCapture paramsParam("params", ParamType::TGLdoublePointer);
        InitParamValue(ParamType::TGLdoublePointer, params, &paramsParam.value);
        CaptureGetVertexAttribdv_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::GLGetVertexAttribdv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib1d(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::GLVertexAttrib1d, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib1dv(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);
        CaptureVertexAttrib1dv_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::GLVertexAttrib1dv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib1s(const State &glState, bool isCallValid, GLuint index, GLshort x)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addValueParam("x", ParamType::TGLshort, x);

    return CallCapture(angle::EntryPoint::GLVertexAttrib1s, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib1sv(const State &glState,
                                   bool isCallValid,
                                   GLuint index,
                                   const GLshort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
        CaptureVertexAttrib1sv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib1sv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib2d(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::GLVertexAttrib2d, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib2dv(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);
        CaptureVertexAttrib2dv_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::GLVertexAttrib2dv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib2s(const State &glState,
                                  bool isCallValid,
                                  GLuint index,
                                  GLshort x,
                                  GLshort y)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addValueParam("x", ParamType::TGLshort, x);
    paramBuffer.addValueParam("y", ParamType::TGLshort, y);

    return CallCapture(angle::EntryPoint::GLVertexAttrib2s, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib2sv(const State &glState,
                                   bool isCallValid,
                                   GLuint index,
                                   const GLshort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
        CaptureVertexAttrib2sv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib2sv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib3d(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::GLVertexAttrib3d, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib3dv(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);
        CaptureVertexAttrib3dv_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::GLVertexAttrib3dv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib3s(const State &glState,
                                  bool isCallValid,
                                  GLuint index,
                                  GLshort x,
                                  GLshort y,
                                  GLshort z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addValueParam("x", ParamType::TGLshort, x);
    paramBuffer.addValueParam("y", ParamType::TGLshort, y);
    paramBuffer.addValueParam("z", ParamType::TGLshort, z);

    return CallCapture(angle::EntryPoint::GLVertexAttrib3s, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib3sv(const State &glState,
                                   bool isCallValid,
                                   GLuint index,
                                   const GLshort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
        CaptureVertexAttrib3sv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib3sv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nbv(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    const GLbyte *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
        InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value);
        CaptureVertexAttrib4Nbv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
        InitParamValue(ParamType::TGLbyteConstPointer, static_cast<const GLbyte *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nbv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Niv(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);
        CaptureVertexAttrib4Niv_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::GLVertexAttrib4Niv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nsv(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    const GLshort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
        CaptureVertexAttrib4Nsv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nsv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nub(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    GLubyte x,
                                    GLubyte y,
                                    GLubyte z,
                                    GLubyte w)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addValueParam("x", ParamType::TGLubyte, x);
    paramBuffer.addValueParam("y", ParamType::TGLubyte, y);
    paramBuffer.addValueParam("z", ParamType::TGLubyte, z);
    paramBuffer.addValueParam("w", ParamType::TGLubyte, w);

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nub, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nubv(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     const GLubyte *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
        InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value);
        CaptureVertexAttrib4Nubv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
        InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nubv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nuiv(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     const GLuint *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLuintConstPointer);
        InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
        CaptureVertexAttrib4Nuiv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLuintConstPointer);
        InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nuiv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4Nusv(const State &glState,
                                     bool isCallValid,
                                     GLuint index,
                                     const GLushort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLushortConstPointer);
        InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value);
        CaptureVertexAttrib4Nusv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLushortConstPointer);
        InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4Nusv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4bv(const State &glState,
                                   bool isCallValid,
                                   GLuint index,
                                   const GLbyte *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
        InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value);
        CaptureVertexAttrib4bv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLbyteConstPointer);
        InitParamValue(ParamType::TGLbyteConstPointer, static_cast<const GLbyte *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4bv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4d(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::GLVertexAttrib4d, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4dv(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);
        CaptureVertexAttrib4dv_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::GLVertexAttrib4dv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4iv(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);
        CaptureVertexAttrib4iv_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::GLVertexAttrib4iv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4s(const State &glState,
                                  bool isCallValid,
                                  GLuint index,
                                  GLshort x,
                                  GLshort y,
                                  GLshort z,
                                  GLshort w)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);
    paramBuffer.addValueParam("x", ParamType::TGLshort, x);
    paramBuffer.addValueParam("y", ParamType::TGLshort, y);
    paramBuffer.addValueParam("z", ParamType::TGLshort, z);
    paramBuffer.addValueParam("w", ParamType::TGLshort, w);

    return CallCapture(angle::EntryPoint::GLVertexAttrib4s, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4sv(const State &glState,
                                   bool isCallValid,
                                   GLuint index,
                                   const GLshort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value);
        CaptureVertexAttrib4sv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLshortConstPointer);
        InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4sv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4ubv(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    const GLubyte *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
        InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value);
        CaptureVertexAttrib4ubv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLubyteConstPointer);
        InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4ubv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4uiv(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    const GLuint *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLuintConstPointer);
        InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
        CaptureVertexAttrib4uiv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLuintConstPointer);
        InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4uiv, std::move(paramBuffer));
}

CallCapture CaptureVertexAttrib4usv(const State &glState,
                                    bool isCallValid,
                                    GLuint index,
                                    const GLushort *v)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("index", ParamType::TGLuint, index);

    if (isCallValid)
    {
        ParamCapture vParam("v", ParamType::TGLushortConstPointer);
        InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value);
        CaptureVertexAttrib4usv_v(glState, isCallValid, index, v, &vParam);
        paramBuffer.addParam(std::move(vParam));
    }
    else
    {
        ParamCapture vParam("v", ParamType::TGLushortConstPointer);
        InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr),
                       &vParam.value);
        paramBuffer.addParam(std::move(vParam));
    }

    return CallCapture(angle::EntryPoint::GLVertexAttrib4usv, std::move(paramBuffer));
}

// GL 2.1
}  // namespace gl
