src/third_party/angle/src/libANGLE/capture_gles_1_0_autogen.cpp

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2019 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_gles_1_0_autogen.cpp:
//   Capture functions for the OpenGL ES 1.0 entry points.

#include "libANGLE/capture_gles_1_0_autogen.h"

#include "libANGLE/Context.h"
#include "libANGLE/FrameCapture.h"
#include "libANGLE/gl_enum_utils.h"
#include "libANGLE/validationES1.h"

using namespace angle;

namespace gl
{

CallCapture CaptureAlphaFunc(const State &glState,
                             bool isCallValid,
                             AlphaTestFunc funcPacked,
                             GLfloat ref)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
    paramBuffer.addValueParam("ref", ParamType::TGLfloat, ref);

    return CallCapture(gl::EntryPoint::AlphaFunc, std::move(paramBuffer));
}

CallCapture CaptureAlphaFuncx(const State &glState,
                              bool isCallValid,
                              AlphaTestFunc funcPacked,
                              GLfixed ref)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
    paramBuffer.addValueParam("ref", ParamType::TGLfixed, ref);

    return CallCapture(gl::EntryPoint::AlphaFuncx, std::move(paramBuffer));
}

CallCapture CaptureClearColorx(const State &glState,
                               bool isCallValid,
                               GLfixed red,
                               GLfixed green,
                               GLfixed blue,
                               GLfixed alpha)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("red", ParamType::TGLfixed, red);
    paramBuffer.addValueParam("green", ParamType::TGLfixed, green);
    paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
    paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);

    return CallCapture(gl::EntryPoint::ClearColorx, std::move(paramBuffer));
}

CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("depth", ParamType::TGLfixed, depth);

    return CallCapture(gl::EntryPoint::ClearDepthx, std::move(paramBuffer));
}

CallCapture CaptureClientActiveTexture(const State &glState, bool isCallValid, GLenum texture)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture);

    return CallCapture(gl::EntryPoint::ClientActiveTexture, std::move(paramBuffer));
}

CallCapture CaptureClipPlanef(const State &glState, bool isCallValid, GLenum p, const GLfloat *eqn)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("p", GLenumGroup::ClipPlaneName, ParamType::TGLenum, p);

    ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, eqn, &eqnParam.value);
    CaptureClipPlanef_eqn(glState, isCallValid, p, eqn, &eqnParam);
    paramBuffer.addParam(std::move(eqnParam));

    return CallCapture(gl::EntryPoint::ClipPlanef, std::move(paramBuffer));
}

CallCapture CaptureClipPlanex(const State &glState,
                              bool isCallValid,
                              GLenum plane,
                              const GLfixed *equation)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);

    ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, equation, &equationParam.value);
    CaptureClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
    paramBuffer.addParam(std::move(equationParam));

    return CallCapture(gl::EntryPoint::ClipPlanex, std::move(paramBuffer));
}

CallCapture CaptureColor4f(const State &glState,
                           bool isCallValid,
                           GLfloat red,
                           GLfloat green,
                           GLfloat blue,
                           GLfloat alpha)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("red", ParamType::TGLfloat, red);
    paramBuffer.addValueParam("green", ParamType::TGLfloat, green);
    paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue);
    paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha);

    return CallCapture(gl::EntryPoint::Color4f, std::move(paramBuffer));
}

CallCapture CaptureColor4ub(const State &glState,
                            bool isCallValid,
                            GLubyte red,
                            GLubyte green,
                            GLubyte blue,
                            GLubyte alpha)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("red", ParamType::TGLubyte, red);
    paramBuffer.addValueParam("green", ParamType::TGLubyte, green);
    paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue);
    paramBuffer.addValueParam("alpha", ParamType::TGLubyte, alpha);

    return CallCapture(gl::EntryPoint::Color4ub, std::move(paramBuffer));
}

CallCapture CaptureColor4x(const State &glState,
                           bool isCallValid,
                           GLfixed red,
                           GLfixed green,
                           GLfixed blue,
                           GLfixed alpha)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("red", ParamType::TGLfixed, red);
    paramBuffer.addValueParam("green", ParamType::TGLfixed, green);
    paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
    paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);

    return CallCapture(gl::EntryPoint::Color4x, std::move(paramBuffer));
}

CallCapture CaptureColorPointer(const State &glState,
                                bool isCallValid,
                                GLint size,
                                VertexAttribType typePacked,
                                GLsizei stride,
                                const void *pointer)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("size", ParamType::TGLint, size);
    paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
    paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);

    ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
    InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
    CaptureColorPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
                                &pointerParam);
    paramBuffer.addParam(std::move(pointerParam));

    return CallCapture(gl::EntryPoint::ColorPointer, std::move(paramBuffer));
}

CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
    paramBuffer.addValueParam("f", ParamType::TGLfixed, f);

    return CallCapture(gl::EntryPoint::DepthRangex, std::move(paramBuffer));
}

CallCapture CaptureDisableClientState(const State &glState,
                                      bool isCallValid,
                                      ClientVertexArrayType arrayPacked)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);

    return CallCapture(gl::EntryPoint::DisableClientState, std::move(paramBuffer));
}

CallCapture CaptureEnableClientState(const State &glState,
                                     bool isCallValid,
                                     ClientVertexArrayType arrayPacked)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);

    return CallCapture(gl::EntryPoint::EnableClientState, std::move(paramBuffer));
}

CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::Fogf, std::move(paramBuffer));
}

CallCapture CaptureFogfv(const State &glState,
                         bool isCallValid,
                         GLenum pname,
                         const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CaptureFogfv_params(glState, isCallValid, pname, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::Fogfv, std::move(paramBuffer));
}

CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::Fogx, std::move(paramBuffer));
}

CallCapture CaptureFogxv(const State &glState, bool isCallValid, GLenum pname, const GLfixed *param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname);

    ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
    CaptureFogxv_param(glState, isCallValid, pname, param, &paramParam);
    paramBuffer.addParam(std::move(paramParam));

    return CallCapture(gl::EntryPoint::Fogxv, std::move(paramBuffer));
}

CallCapture CaptureFrustumf(const State &glState,
                            bool isCallValid,
                            GLfloat l,
                            GLfloat r,
                            GLfloat b,
                            GLfloat t,
                            GLfloat n,
                            GLfloat f)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("l", ParamType::TGLfloat, l);
    paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
    paramBuffer.addValueParam("b", ParamType::TGLfloat, b);
    paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
    paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
    paramBuffer.addValueParam("f", ParamType::TGLfloat, f);

    return CallCapture(gl::EntryPoint::Frustumf, std::move(paramBuffer));
}

CallCapture CaptureFrustumx(const State &glState,
                            bool isCallValid,
                            GLfixed l,
                            GLfixed r,
                            GLfixed b,
                            GLfixed t,
                            GLfixed n,
                            GLfixed f)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("l", ParamType::TGLfixed, l);
    paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
    paramBuffer.addValueParam("b", ParamType::TGLfixed, b);
    paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
    paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
    paramBuffer.addValueParam("f", ParamType::TGLfixed, f);

    return CallCapture(gl::EntryPoint::Frustumx, std::move(paramBuffer));
}

CallCapture CaptureGetClipPlanef(const State &glState,
                                 bool isCallValid,
                                 GLenum plane,
                                 GLfloat *equation)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);

    ParamCapture equationParam("equation", ParamType::TGLfloatPointer);
    InitParamValue(ParamType::TGLfloatPointer, equation, &equationParam.value);
    CaptureGetClipPlanef_equation(glState, isCallValid, plane, equation, &equationParam);
    paramBuffer.addParam(std::move(equationParam));

    return CallCapture(gl::EntryPoint::GetClipPlanef, std::move(paramBuffer));
}

CallCapture CaptureGetClipPlanex(const State &glState,
                                 bool isCallValid,
                                 GLenum plane,
                                 GLfixed *equation)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);

    ParamCapture equationParam("equation", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, equation, &equationParam.value);
    CaptureGetClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
    paramBuffer.addParam(std::move(equationParam));

    return CallCapture(gl::EntryPoint::GetClipPlanex, std::move(paramBuffer));
}

CallCapture CaptureGetFixedv(const State &glState, bool isCallValid, GLenum pname, GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);

    ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
    CaptureGetFixedv_params(glState, isCallValid, pname, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetFixedv, std::move(paramBuffer));
}

CallCapture CaptureGetLightfv(const State &glState,
                              bool isCallValid,
                              GLenum light,
                              LightParameter pnamePacked,
                              GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
    InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
    CaptureGetLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetLightfv, std::move(paramBuffer));
}

CallCapture CaptureGetLightxv(const State &glState,
                              bool isCallValid,
                              GLenum light,
                              LightParameter pnamePacked,
                              GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
    CaptureGetLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetLightxv, std::move(paramBuffer));
}

CallCapture CaptureGetMaterialfv(const State &glState,
                                 bool isCallValid,
                                 GLenum face,
                                 MaterialParameter pnamePacked,
                                 GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
    InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
    CaptureGetMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetMaterialfv, std::move(paramBuffer));
}

CallCapture CaptureGetMaterialxv(const State &glState,
                                 bool isCallValid,
                                 GLenum face,
                                 MaterialParameter pnamePacked,
                                 GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
    CaptureGetMaterialxv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetMaterialxv, std::move(paramBuffer));
}

CallCapture CaptureGetTexEnvfv(const State &glState,
                               bool isCallValid,
                               TextureEnvTarget targetPacked,
                               TextureEnvParameter pnamePacked,
                               GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
    InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
    CaptureGetTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params,
                              &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetTexEnvfv, std::move(paramBuffer));
}

CallCapture CaptureGetTexEnviv(const State &glState,
                               bool isCallValid,
                               TextureEnvTarget targetPacked,
                               TextureEnvParameter pnamePacked,
                               GLint *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLintPointer);
    InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
    CaptureGetTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params,
                              &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetTexEnviv, std::move(paramBuffer));
}

CallCapture CaptureGetTexEnvxv(const State &glState,
                               bool isCallValid,
                               TextureEnvTarget targetPacked,
                               TextureEnvParameter pnamePacked,
                               GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
    CaptureGetTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params,
                              &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetTexEnvxv, std::move(paramBuffer));
}

CallCapture CaptureGetTexParameterxv(const State &glState,
                                     bool isCallValid,
                                     TextureType targetPacked,
                                     GLenum pname,
                                     GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
    paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);

    ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
    InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
    CaptureGetTexParameterxv_params(glState, isCallValid, targetPacked, pname, params,
                                    &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::GetTexParameterxv, std::move(paramBuffer));
}

CallCapture CaptureLightModelf(const State &glState, bool isCallValid, GLenum pname, GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::LightModelf, std::move(paramBuffer));
}

CallCapture CaptureLightModelfv(const State &glState,
                                bool isCallValid,
                                GLenum pname,
                                const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CaptureLightModelfv_params(glState, isCallValid, pname, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::LightModelfv, std::move(paramBuffer));
}

CallCapture CaptureLightModelx(const State &glState, bool isCallValid, GLenum pname, GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::LightModelx, std::move(paramBuffer));
}

CallCapture CaptureLightModelxv(const State &glState,
                                bool isCallValid,
                                GLenum pname,
                                const GLfixed *param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);

    ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
    CaptureLightModelxv_param(glState, isCallValid, pname, param, &paramParam);
    paramBuffer.addParam(std::move(paramParam));

    return CallCapture(gl::EntryPoint::LightModelxv, std::move(paramBuffer));
}

CallCapture CaptureLightf(const State &glState,
                          bool isCallValid,
                          GLenum light,
                          LightParameter pnamePacked,
                          GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::Lightf, std::move(paramBuffer));
}

CallCapture CaptureLightfv(const State &glState,
                           bool isCallValid,
                           GLenum light,
                           LightParameter pnamePacked,
                           const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CaptureLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::Lightfv, std::move(paramBuffer));
}

CallCapture CaptureLightx(const State &glState,
                          bool isCallValid,
                          GLenum light,
                          LightParameter pnamePacked,
                          GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::Lightx, std::move(paramBuffer));
}

CallCapture CaptureLightxv(const State &glState,
                           bool isCallValid,
                           GLenum light,
                           LightParameter pnamePacked,
                           const GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
    paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
    CaptureLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::Lightxv, std::move(paramBuffer));
}

CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("width", ParamType::TGLfixed, width);

    return CallCapture(gl::EntryPoint::LineWidthx, std::move(paramBuffer));
}

CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid)
{
    ParamBuffer paramBuffer;

    return CallCapture(gl::EntryPoint::LoadIdentity, std::move(paramBuffer));
}

CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
{
    ParamBuffer paramBuffer;

    ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
    CaptureLoadMatrixf_m(glState, isCallValid, m, &mParam);
    paramBuffer.addParam(std::move(mParam));

    return CallCapture(gl::EntryPoint::LoadMatrixf, std::move(paramBuffer));
}

CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m)
{
    ParamBuffer paramBuffer;

    ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
    CaptureLoadMatrixx_m(glState, isCallValid, m, &mParam);
    paramBuffer.addParam(std::move(mParam));

    return CallCapture(gl::EntryPoint::LoadMatrixx, std::move(paramBuffer));
}

CallCapture CaptureLogicOp(const State &glState, bool isCallValid, LogicalOperation opcodePacked)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked);

    return CallCapture(gl::EntryPoint::LogicOp, std::move(paramBuffer));
}

CallCapture CaptureMaterialf(const State &glState,
                             bool isCallValid,
                             GLenum face,
                             MaterialParameter pnamePacked,
                             GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::Materialf, std::move(paramBuffer));
}

CallCapture CaptureMaterialfv(const State &glState,
                              bool isCallValid,
                              GLenum face,
                              MaterialParameter pnamePacked,
                              const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CaptureMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::Materialfv, std::move(paramBuffer));
}

CallCapture CaptureMaterialx(const State &glState,
                             bool isCallValid,
                             GLenum face,
                             MaterialParameter pnamePacked,
                             GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::Materialx, std::move(paramBuffer));
}

CallCapture CaptureMaterialxv(const State &glState,
                              bool isCallValid,
                              GLenum face,
                              MaterialParameter pnamePacked,
                              const GLfixed *param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
    paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);

    ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
    CaptureMaterialxv_param(glState, isCallValid, face, pnamePacked, param, &paramParam);
    paramBuffer.addParam(std::move(paramParam));

    return CallCapture(gl::EntryPoint::Materialxv, std::move(paramBuffer));
}

CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("modePacked", ParamType::TMatrixType, modePacked);

    return CallCapture(gl::EntryPoint::MatrixMode, std::move(paramBuffer));
}

CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m)
{
    ParamBuffer paramBuffer;

    ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
    CaptureMultMatrixf_m(glState, isCallValid, m, &mParam);
    paramBuffer.addParam(std::move(mParam));

    return CallCapture(gl::EntryPoint::MultMatrixf, std::move(paramBuffer));
}

CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m)
{
    ParamBuffer paramBuffer;

    ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
    CaptureMultMatrixx_m(glState, isCallValid, m, &mParam);
    paramBuffer.addParam(std::move(mParam));

    return CallCapture(gl::EntryPoint::MultMatrixx, std::move(paramBuffer));
}

CallCapture CaptureMultiTexCoord4f(const State &glState,
                                   bool isCallValid,
                                   GLenum target,
                                   GLfloat s,
                                   GLfloat t,
                                   GLfloat r,
                                   GLfloat q)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target);
    paramBuffer.addValueParam("s", ParamType::TGLfloat, s);
    paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
    paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
    paramBuffer.addValueParam("q", ParamType::TGLfloat, q);

    return CallCapture(gl::EntryPoint::MultiTexCoord4f, std::move(paramBuffer));
}

CallCapture CaptureMultiTexCoord4x(const State &glState,
                                   bool isCallValid,
                                   GLenum texture,
                                   GLfixed s,
                                   GLfixed t,
                                   GLfixed r,
                                   GLfixed q)
{
    ParamBuffer paramBuffer;

    paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture);
    paramBuffer.addValueParam("s", ParamType::TGLfixed, s);
    paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
    paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
    paramBuffer.addValueParam("q", ParamType::TGLfixed, q);

    return CallCapture(gl::EntryPoint::MultiTexCoord4x, std::move(paramBuffer));
}

CallCapture CaptureNormal3f(const State &glState,
                            bool isCallValid,
                            GLfloat nx,
                            GLfloat ny,
                            GLfloat nz)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("nx", ParamType::TGLfloat, nx);
    paramBuffer.addValueParam("ny", ParamType::TGLfloat, ny);
    paramBuffer.addValueParam("nz", ParamType::TGLfloat, nz);

    return CallCapture(gl::EntryPoint::Normal3f, std::move(paramBuffer));
}

CallCapture CaptureNormal3x(const State &glState,
                            bool isCallValid,
                            GLfixed nx,
                            GLfixed ny,
                            GLfixed nz)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("nx", ParamType::TGLfixed, nx);
    paramBuffer.addValueParam("ny", ParamType::TGLfixed, ny);
    paramBuffer.addValueParam("nz", ParamType::TGLfixed, nz);

    return CallCapture(gl::EntryPoint::Normal3x, std::move(paramBuffer));
}

CallCapture CaptureNormalPointer(const State &glState,
                                 bool isCallValid,
                                 VertexAttribType typePacked,
                                 GLsizei stride,
                                 const void *pointer)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
    paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);

    ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
    InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
    CaptureNormalPointer_pointer(glState, isCallValid, typePacked, stride, pointer, &pointerParam);
    paramBuffer.addParam(std::move(pointerParam));

    return CallCapture(gl::EntryPoint::NormalPointer, std::move(paramBuffer));
}

CallCapture CaptureOrthof(const State &glState,
                          bool isCallValid,
                          GLfloat l,
                          GLfloat r,
                          GLfloat b,
                          GLfloat t,
                          GLfloat n,
                          GLfloat f)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("l", ParamType::TGLfloat, l);
    paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
    paramBuffer.addValueParam("b", ParamType::TGLfloat, b);
    paramBuffer.addValueParam("t", ParamType::TGLfloat, t);
    paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
    paramBuffer.addValueParam("f", ParamType::TGLfloat, f);

    return CallCapture(gl::EntryPoint::Orthof, std::move(paramBuffer));
}

CallCapture CaptureOrthox(const State &glState,
                          bool isCallValid,
                          GLfixed l,
                          GLfixed r,
                          GLfixed b,
                          GLfixed t,
                          GLfixed n,
                          GLfixed f)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("l", ParamType::TGLfixed, l);
    paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
    paramBuffer.addValueParam("b", ParamType::TGLfixed, b);
    paramBuffer.addValueParam("t", ParamType::TGLfixed, t);
    paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
    paramBuffer.addValueParam("f", ParamType::TGLfixed, f);

    return CallCapture(gl::EntryPoint::Orthox, std::move(paramBuffer));
}

CallCapture CapturePointParameterf(const State &glState,
                                   bool isCallValid,
                                   PointParameter pnamePacked,
                                   GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::PointParameterf, std::move(paramBuffer));
}

CallCapture CapturePointParameterfv(const State &glState,
                                    bool isCallValid,
                                    PointParameter pnamePacked,
                                    const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CapturePointParameterfv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::PointParameterfv, std::move(paramBuffer));
}

CallCapture CapturePointParameterx(const State &glState,
                                   bool isCallValid,
                                   PointParameter pnamePacked,
                                   GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::PointParameterx, std::move(paramBuffer));
}

CallCapture CapturePointParameterxv(const State &glState,
                                    bool isCallValid,
                                    PointParameter pnamePacked,
                                    const GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
    CapturePointParameterxv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::PointParameterxv, std::move(paramBuffer));
}

CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("size", ParamType::TGLfloat, size);

    return CallCapture(gl::EntryPoint::PointSize, std::move(paramBuffer));
}

CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("size", ParamType::TGLfixed, size);

    return CallCapture(gl::EntryPoint::PointSizex, std::move(paramBuffer));
}

CallCapture CapturePolygonOffsetx(const State &glState,
                                  bool isCallValid,
                                  GLfixed factor,
                                  GLfixed units)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("factor", ParamType::TGLfixed, factor);
    paramBuffer.addValueParam("units", ParamType::TGLfixed, units);

    return CallCapture(gl::EntryPoint::PolygonOffsetx, std::move(paramBuffer));
}

CallCapture CapturePopMatrix(const State &glState, bool isCallValid)
{
    ParamBuffer paramBuffer;

    return CallCapture(gl::EntryPoint::PopMatrix, std::move(paramBuffer));
}

CallCapture CapturePushMatrix(const State &glState, bool isCallValid)
{
    ParamBuffer paramBuffer;

    return CallCapture(gl::EntryPoint::PushMatrix, std::move(paramBuffer));
}

CallCapture CaptureRotatef(const State &glState,
                           bool isCallValid,
                           GLfloat angle,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("angle", ParamType::TGLfloat, angle);
    paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
    paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
    paramBuffer.addValueParam("z", ParamType::TGLfloat, z);

    return CallCapture(gl::EntryPoint::Rotatef, std::move(paramBuffer));
}

CallCapture CaptureRotatex(const State &glState,
                           bool isCallValid,
                           GLfixed angle,
                           GLfixed x,
                           GLfixed y,
                           GLfixed z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("angle", ParamType::TGLfixed, angle);
    paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
    paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
    paramBuffer.addValueParam("z", ParamType::TGLfixed, z);

    return CallCapture(gl::EntryPoint::Rotatex, std::move(paramBuffer));
}

CallCapture CaptureSampleCoveragex(const State &glState,
                                   bool isCallValid,
                                   GLclampx value,
                                   GLboolean invert)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("value", ParamType::TGLclampx, value);
    paramBuffer.addValueParam("invert", ParamType::TGLboolean, invert);

    return CallCapture(gl::EntryPoint::SampleCoveragex, std::move(paramBuffer));
}

CallCapture CaptureScalef(const State &glState, bool isCallValid, GLfloat x, GLfloat y, GLfloat z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
    paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
    paramBuffer.addValueParam("z", ParamType::TGLfloat, z);

    return CallCapture(gl::EntryPoint::Scalef, std::move(paramBuffer));
}

CallCapture CaptureScalex(const State &glState, bool isCallValid, GLfixed x, GLfixed y, GLfixed z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
    paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
    paramBuffer.addValueParam("z", ParamType::TGLfixed, z);

    return CallCapture(gl::EntryPoint::Scalex, std::move(paramBuffer));
}

CallCapture CaptureShadeModel(const State &glState, bool isCallValid, ShadingModel modePacked)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("modePacked", ParamType::TShadingModel, modePacked);

    return CallCapture(gl::EntryPoint::ShadeModel, std::move(paramBuffer));
}

CallCapture CaptureTexCoordPointer(const State &glState,
                                   bool isCallValid,
                                   GLint size,
                                   VertexAttribType typePacked,
                                   GLsizei stride,
                                   const void *pointer)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("size", ParamType::TGLint, size);
    paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
    paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);

    ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
    InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
    CaptureTexCoordPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
                                   &pointerParam);
    paramBuffer.addParam(std::move(pointerParam));

    return CallCapture(gl::EntryPoint::TexCoordPointer, std::move(paramBuffer));
}

CallCapture CaptureTexEnvf(const State &glState,
                           bool isCallValid,
                           TextureEnvTarget targetPacked,
                           TextureEnvParameter pnamePacked,
                           GLfloat param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfloat, param);

    return CallCapture(gl::EntryPoint::TexEnvf, std::move(paramBuffer));
}

CallCapture CaptureTexEnvfv(const State &glState,
                            bool isCallValid,
                            TextureEnvTarget targetPacked,
                            TextureEnvParameter pnamePacked,
                            const GLfloat *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
    InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
    CaptureTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::TexEnvfv, std::move(paramBuffer));
}

CallCapture CaptureTexEnvi(const State &glState,
                           bool isCallValid,
                           TextureEnvTarget targetPacked,
                           TextureEnvParameter pnamePacked,
                           GLint param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLint, param);

    return CallCapture(gl::EntryPoint::TexEnvi, std::move(paramBuffer));
}

CallCapture CaptureTexEnviv(const State &glState,
                            bool isCallValid,
                            TextureEnvTarget targetPacked,
                            TextureEnvParameter pnamePacked,
                            const GLint *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
    InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
    CaptureTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::TexEnviv, std::move(paramBuffer));
}

CallCapture CaptureTexEnvx(const State &glState,
                           bool isCallValid,
                           TextureEnvTarget targetPacked,
                           TextureEnvParameter pnamePacked,
                           GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::TexEnvx, std::move(paramBuffer));
}

CallCapture CaptureTexEnvxv(const State &glState,
                            bool isCallValid,
                            TextureEnvTarget targetPacked,
                            TextureEnvParameter pnamePacked,
                            const GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
    paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);

    ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
    CaptureTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::TexEnvxv, std::move(paramBuffer));
}

CallCapture CaptureTexParameterx(const State &glState,
                                 bool isCallValid,
                                 TextureType targetPacked,
                                 GLenum pname,
                                 GLfixed param)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
    paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
    paramBuffer.addValueParam("param", ParamType::TGLfixed, param);

    return CallCapture(gl::EntryPoint::TexParameterx, std::move(paramBuffer));
}

CallCapture CaptureTexParameterxv(const State &glState,
                                  bool isCallValid,
                                  TextureType targetPacked,
                                  GLenum pname,
                                  const GLfixed *params)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
    paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);

    ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
    InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
    CaptureTexParameterxv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
    paramBuffer.addParam(std::move(paramsParam));

    return CallCapture(gl::EntryPoint::TexParameterxv, std::move(paramBuffer));
}

CallCapture CaptureTranslatef(const State &glState,
                              bool isCallValid,
                              GLfloat x,
                              GLfloat y,
                              GLfloat z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
    paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
    paramBuffer.addValueParam("z", ParamType::TGLfloat, z);

    return CallCapture(gl::EntryPoint::Translatef, std::move(paramBuffer));
}

CallCapture CaptureTranslatex(const State &glState,
                              bool isCallValid,
                              GLfixed x,
                              GLfixed y,
                              GLfixed z)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("x", ParamType::TGLfixed, x);
    paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
    paramBuffer.addValueParam("z", ParamType::TGLfixed, z);

    return CallCapture(gl::EntryPoint::Translatex, std::move(paramBuffer));
}

CallCapture CaptureVertexPointer(const State &glState,
                                 bool isCallValid,
                                 GLint size,
                                 VertexAttribType typePacked,
                                 GLsizei stride,
                                 const void *pointer)
{
    ParamBuffer paramBuffer;

    paramBuffer.addValueParam("size", ParamType::TGLint, size);
    paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
    paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);

    ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
    InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
    CaptureVertexPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer,
                                 &pointerParam);
    paramBuffer.addParam(std::move(pointerParam));

    return CallCapture(gl::EntryPoint::VertexPointer, std::move(paramBuffer));
}

}  // namespace gl