| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. |
| // |
| // Copyright 2020 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // capture_gl_1_autogen.cpp: |
| // Capture functions for the OpenGL ES Desktop GL 1.x entry points. |
| |
| #include "libANGLE/capture/capture_gl_1_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/capture/FrameCapture.h" |
| #include "libANGLE/capture/gl_enum_utils.h" |
| #include "libANGLE/validationGL1_autogen.h" |
| |
| using namespace angle; |
| |
| namespace gl |
| { |
| |
| // GL 1.0 |
| CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfloat value) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("op", BigGLEnum::AccumOp, ParamType::TGLenum, op); |
| paramBuffer.addValueParam("value", ParamType::TGLfloat, value); |
| |
| return CallCapture(angle::EntryPoint::GLAccum, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); |
| |
| return CallCapture(angle::EntryPoint::GLBegin, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureBitmap(const State &glState, |
| bool isCallValid, |
| GLsizei width, |
| GLsizei height, |
| GLfloat xorig, |
| GLfloat yorig, |
| GLfloat xmove, |
| GLfloat ymove, |
| const GLubyte *bitmap) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addValueParam("xorig", ParamType::TGLfloat, xorig); |
| paramBuffer.addValueParam("yorig", ParamType::TGLfloat, yorig); |
| paramBuffer.addValueParam("xmove", ParamType::TGLfloat, xmove); |
| paramBuffer.addValueParam("ymove", ParamType::TGLfloat, ymove); |
| |
| if (isCallValid) |
| { |
| ParamCapture bitmapParam("bitmap", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, bitmap, &bitmapParam.value); |
| CaptureBitmap_bitmap(glState, isCallValid, width, height, xorig, yorig, xmove, ymove, |
| bitmap, &bitmapParam); |
| paramBuffer.addParam(std::move(bitmapParam)); |
| } |
| else |
| { |
| ParamCapture bitmapParam("bitmap", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr), |
| &bitmapParam.value); |
| paramBuffer.addParam(std::move(bitmapParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLBitmap, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCallList(const State &glState, bool isCallValid, GLuint list) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("list", ParamType::TGLuint, list); |
| |
| return CallCapture(angle::EntryPoint::GLCallList, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCallLists(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| GLenum type, |
| const void *lists) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| paramBuffer.addEnumParam("type", BigGLEnum::ListNameType, ParamType::TGLenum, type); |
| |
| if (isCallValid) |
| { |
| ParamCapture listsParam("lists", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, lists, &listsParam.value); |
| CaptureCallLists_lists(glState, isCallValid, n, type, lists, &listsParam); |
| paramBuffer.addParam(std::move(listsParam)); |
| } |
| else |
| { |
| ParamCapture listsParam("lists", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr), |
| &listsParam.value); |
| paramBuffer.addParam(std::move(listsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLCallLists, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearAccum(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(angle::EntryPoint::GLClearAccum, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearDepth(const State &glState, bool isCallValid, GLdouble depth) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("depth", ParamType::TGLdouble, depth); |
| |
| return CallCapture(angle::EntryPoint::GLClearDepth, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearIndex(const State &glState, bool isCallValid, GLfloat c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLfloat, c); |
| |
| return CallCapture(angle::EntryPoint::GLClearIndex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClipPlane(const State &glState, |
| bool isCallValid, |
| GLenum plane, |
| const GLdouble *equation) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("plane", BigGLEnum::ClipPlaneName, ParamType::TGLenum, plane); |
| |
| if (isCallValid) |
| { |
| ParamCapture equationParam("equation", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, equation, &equationParam.value); |
| CaptureClipPlane_equation(glState, isCallValid, plane, equation, &equationParam); |
| paramBuffer.addParam(std::move(equationParam)); |
| } |
| else |
| { |
| ParamCapture equationParam("equation", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &equationParam.value); |
| paramBuffer.addParam(std::move(equationParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLClipPlane, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3b(const State &glState, |
| bool isCallValid, |
| GLbyte red, |
| GLbyte green, |
| GLbyte blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLbyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLbyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLbyte, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3b, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3bv(const State &glState, bool isCallValid, const GLbyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLbyteConstPointer); |
| InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value); |
| CaptureColor3bv_v(glState, isCallValid, 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::GLColor3bv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3d(const State &glState, |
| bool isCallValid, |
| GLdouble red, |
| GLdouble green, |
| GLdouble blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLdouble, red); |
| paramBuffer.addValueParam("green", ParamType::TGLdouble, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLdouble, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureColor3dv_v(glState, isCallValid, 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::GLColor3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3f(const State &glState, |
| bool isCallValid, |
| GLfloat red, |
| GLfloat green, |
| GLfloat blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLfloat, red); |
| paramBuffer.addValueParam("green", ParamType::TGLfloat, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureColor3fv_v(glState, isCallValid, 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::GLColor3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3i(const State &glState, |
| bool isCallValid, |
| GLint red, |
| GLint green, |
| GLint blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLint, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureColor3iv_v(glState, isCallValid, 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::GLColor3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3s(const State &glState, |
| bool isCallValid, |
| GLshort red, |
| GLshort green, |
| GLshort blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLshort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLshort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLshort, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureColor3sv_v(glState, isCallValid, 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::GLColor3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3ub(const State &glState, |
| bool isCallValid, |
| GLubyte red, |
| GLubyte green, |
| GLubyte blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLubyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLubyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3ub, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3ubv(const State &glState, bool isCallValid, const GLubyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value); |
| CaptureColor3ubv_v(glState, isCallValid, 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::GLColor3ubv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3ui(const State &glState, |
| bool isCallValid, |
| GLuint red, |
| GLuint green, |
| GLuint blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLuint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLuint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLuint, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3uiv(const State &glState, bool isCallValid, const GLuint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value); |
| CaptureColor3uiv_v(glState, isCallValid, 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::GLColor3uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3us(const State &glState, |
| bool isCallValid, |
| GLushort red, |
| GLushort green, |
| GLushort blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLushort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLushort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLushort, blue); |
| |
| return CallCapture(angle::EntryPoint::GLColor3us, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor3usv(const State &glState, bool isCallValid, const GLushort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLushortConstPointer); |
| InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value); |
| CaptureColor3usv_v(glState, isCallValid, 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::GLColor3usv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4b(const State &glState, |
| bool isCallValid, |
| GLbyte red, |
| GLbyte green, |
| GLbyte blue, |
| GLbyte alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLbyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLbyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLbyte, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLbyte, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4b, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4bv(const State &glState, bool isCallValid, const GLbyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLbyteConstPointer); |
| InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value); |
| CaptureColor4bv_v(glState, isCallValid, 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::GLColor4bv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4d(const State &glState, |
| bool isCallValid, |
| GLdouble red, |
| GLdouble green, |
| GLdouble blue, |
| GLdouble alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLdouble, red); |
| paramBuffer.addValueParam("green", ParamType::TGLdouble, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLdouble, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLdouble, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureColor4dv_v(glState, isCallValid, 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::GLColor4dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureColor4fv_v(glState, isCallValid, 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::GLColor4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4i(const State &glState, |
| bool isCallValid, |
| GLint red, |
| GLint green, |
| GLint blue, |
| GLint alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLint, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLint, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureColor4iv_v(glState, isCallValid, 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::GLColor4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4s(const State &glState, |
| bool isCallValid, |
| GLshort red, |
| GLshort green, |
| GLshort blue, |
| GLshort alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLshort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLshort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLshort, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLshort, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureColor4sv_v(glState, isCallValid, 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::GLColor4sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4ubv(const State &glState, bool isCallValid, const GLubyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value); |
| CaptureColor4ubv_v(glState, isCallValid, 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::GLColor4ubv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4ui(const State &glState, |
| bool isCallValid, |
| GLuint red, |
| GLuint green, |
| GLuint blue, |
| GLuint alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLuint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLuint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLuint, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLuint, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4uiv(const State &glState, bool isCallValid, const GLuint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value); |
| CaptureColor4uiv_v(glState, isCallValid, 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::GLColor4uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4us(const State &glState, |
| bool isCallValid, |
| GLushort red, |
| GLushort green, |
| GLushort blue, |
| GLushort alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLushort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLushort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLushort, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLushort, alpha); |
| |
| return CallCapture(angle::EntryPoint::GLColor4us, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4usv(const State &glState, bool isCallValid, const GLushort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLushortConstPointer); |
| InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value); |
| CaptureColor4usv_v(glState, isCallValid, 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::GLColor4usv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColorMaterial(const State &glState, bool isCallValid, GLenum face, GLenum mode) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", BigGLEnum::TriangleFace, ParamType::TGLenum, face); |
| paramBuffer.addEnumParam("mode", BigGLEnum::ColorMaterialParameter, ParamType::TGLenum, mode); |
| |
| return CallCapture(angle::EntryPoint::GLColorMaterial, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCopyPixels(const State &glState, |
| bool isCallValid, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height, |
| GLenum type) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("height", ParamType::TGLsizei, height); |
| paramBuffer.addEnumParam("type", BigGLEnum::PixelCopyType, ParamType::TGLenum, type); |
| |
| return CallCapture(angle::EntryPoint::GLCopyPixels, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDeleteLists(const State &glState, bool isCallValid, GLuint list, GLsizei range) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("list", ParamType::TGLuint, list); |
| paramBuffer.addValueParam("range", ParamType::TGLsizei, range); |
| |
| return CallCapture(angle::EntryPoint::GLDeleteLists, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDepthRange(const State &glState, bool isCallValid, GLdouble n, GLdouble f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLdouble, n); |
| paramBuffer.addValueParam("f", ParamType::TGLdouble, f); |
| |
| return CallCapture(angle::EntryPoint::GLDepthRange, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("buf", BigGLEnum::DrawBufferMode, ParamType::TGLenum, buf); |
| |
| return CallCapture(angle::EntryPoint::GLDrawBuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDrawPixels(const State &glState, |
| bool isCallValid, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLenum type, |
| const void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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); |
| CaptureDrawPixels_pixels(glState, isCallValid, 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::GLDrawPixels, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEdgeFlag(const State &glState, bool isCallValid, GLboolean flag) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("flag", ParamType::TGLboolean, flag); |
| |
| return CallCapture(angle::EntryPoint::GLEdgeFlag, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEdgeFlagv(const State &glState, bool isCallValid, const GLboolean *flag) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture flagParam("flag", ParamType::TGLbooleanConstPointer); |
| InitParamValue(ParamType::TGLbooleanConstPointer, flag, &flagParam.value); |
| CaptureEdgeFlagv_flag(glState, isCallValid, flag, &flagParam); |
| paramBuffer.addParam(std::move(flagParam)); |
| } |
| else |
| { |
| ParamCapture flagParam("flag", ParamType::TGLbooleanConstPointer); |
| InitParamValue(ParamType::TGLbooleanConstPointer, static_cast<const GLboolean *>(nullptr), |
| &flagParam.value); |
| paramBuffer.addParam(std::move(flagParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLEdgeFlagv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEnd(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLEnd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEndList(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLEndList, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord1d(const State &glState, bool isCallValid, GLdouble u) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("u", ParamType::TGLdouble, u); |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord1d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord1dv(const State &glState, bool isCallValid, const GLdouble *u) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture uParam("u", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, u, &uParam.value); |
| CaptureEvalCoord1dv_u(glState, isCallValid, u, &uParam); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| else |
| { |
| ParamCapture uParam("u", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &uParam.value); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord1dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord1f(const State &glState, bool isCallValid, GLfloat u) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("u", ParamType::TGLfloat, u); |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord1f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord1fv(const State &glState, bool isCallValid, const GLfloat *u) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture uParam("u", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, u, &uParam.value); |
| CaptureEvalCoord1fv_u(glState, isCallValid, u, &uParam); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| else |
| { |
| ParamCapture uParam("u", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &uParam.value); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord1fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord2d(const State &glState, bool isCallValid, GLdouble u, GLdouble v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("u", ParamType::TGLdouble, u); |
| paramBuffer.addValueParam("v", ParamType::TGLdouble, v); |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord2dv(const State &glState, bool isCallValid, const GLdouble *u) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture uParam("u", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, u, &uParam.value); |
| CaptureEvalCoord2dv_u(glState, isCallValid, u, &uParam); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| else |
| { |
| ParamCapture uParam("u", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &uParam.value); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord2f(const State &glState, bool isCallValid, GLfloat u, GLfloat v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("u", ParamType::TGLfloat, u); |
| paramBuffer.addValueParam("v", ParamType::TGLfloat, v); |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalCoord2fv(const State &glState, bool isCallValid, const GLfloat *u) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture uParam("u", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, u, &uParam.value); |
| CaptureEvalCoord2fv_u(glState, isCallValid, u, &uParam); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| else |
| { |
| ParamCapture uParam("u", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &uParam.value); |
| paramBuffer.addParam(std::move(uParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLEvalCoord2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalMesh1(const State &glState, |
| bool isCallValid, |
| GLenum mode, |
| GLint i1, |
| GLint i2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mode", BigGLEnum::MeshMode1, ParamType::TGLenum, mode); |
| paramBuffer.addValueParam("i1", ParamType::TGLint, i1); |
| paramBuffer.addValueParam("i2", ParamType::TGLint, i2); |
| |
| return CallCapture(angle::EntryPoint::GLEvalMesh1, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalMesh2(const State &glState, |
| bool isCallValid, |
| GLenum mode, |
| GLint i1, |
| GLint i2, |
| GLint j1, |
| GLint j2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mode", BigGLEnum::MeshMode2, ParamType::TGLenum, mode); |
| paramBuffer.addValueParam("i1", ParamType::TGLint, i1); |
| paramBuffer.addValueParam("i2", ParamType::TGLint, i2); |
| paramBuffer.addValueParam("j1", ParamType::TGLint, j1); |
| paramBuffer.addValueParam("j2", ParamType::TGLint, j2); |
| |
| return CallCapture(angle::EntryPoint::GLEvalMesh2, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalPoint1(const State &glState, bool isCallValid, GLint i) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("i", ParamType::TGLint, i); |
| |
| return CallCapture(angle::EntryPoint::GLEvalPoint1, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEvalPoint2(const State &glState, bool isCallValid, GLint i, GLint j) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("i", ParamType::TGLint, i); |
| paramBuffer.addValueParam("j", ParamType::TGLint, j); |
| |
| return CallCapture(angle::EntryPoint::GLEvalPoint2, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFeedbackBuffer(const State &glState, |
| bool isCallValid, |
| GLsizei size, |
| GLenum type, |
| GLfloat *buffer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLsizei, size); |
| paramBuffer.addEnumParam("type", BigGLEnum::FeedbackType, ParamType::TGLenum, type); |
| |
| if (isCallValid) |
| { |
| ParamCapture bufferParam("buffer", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, buffer, &bufferParam.value); |
| CaptureFeedbackBuffer_buffer(glState, isCallValid, size, type, buffer, &bufferParam); |
| paramBuffer.addParam(std::move(bufferParam)); |
| } |
| else |
| { |
| ParamCapture bufferParam("buffer", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr), |
| &bufferParam.value); |
| paramBuffer.addParam(std::move(bufferParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLFeedbackBuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::FogParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLFogi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogiv(const State &glState, bool isCallValid, GLenum pname, const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::FogParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureFogiv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLFogiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFrustum(const State &glState, |
| bool isCallValid, |
| GLdouble left, |
| GLdouble right, |
| GLdouble bottom, |
| GLdouble top, |
| GLdouble zNear, |
| GLdouble zFar) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("left", ParamType::TGLdouble, left); |
| paramBuffer.addValueParam("right", ParamType::TGLdouble, right); |
| paramBuffer.addValueParam("bottom", ParamType::TGLdouble, bottom); |
| paramBuffer.addValueParam("top", ParamType::TGLdouble, top); |
| paramBuffer.addValueParam("zNear", ParamType::TGLdouble, zNear); |
| paramBuffer.addValueParam("zFar", ParamType::TGLdouble, zFar); |
| |
| return CallCapture(angle::EntryPoint::GLFrustum, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGenLists(const State &glState, |
| bool isCallValid, |
| GLsizei range, |
| GLuint returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("range", ParamType::TGLsizei, range); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLuint); |
| InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(angle::EntryPoint::GLGenLists, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetClipPlane(const State &glState, |
| bool isCallValid, |
| GLenum plane, |
| GLdouble *equation) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("plane", BigGLEnum::ClipPlaneName, ParamType::TGLenum, plane); |
| |
| if (isCallValid) |
| { |
| ParamCapture equationParam("equation", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, equation, &equationParam.value); |
| CaptureGetClipPlane_equation(glState, isCallValid, plane, equation, &equationParam); |
| paramBuffer.addParam(std::move(equationParam)); |
| } |
| else |
| { |
| ParamCapture equationParam("equation", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr), |
| &equationParam.value); |
| paramBuffer.addParam(std::move(equationParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetClipPlane, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetDoublev(const State &glState, bool isCallValid, GLenum pname, GLdouble *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::GetPName, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture dataParam("data", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, data, &dataParam.value); |
| CaptureGetDoublev_data(glState, isCallValid, pname, 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::GLGetDoublev, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetLightiv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); |
| paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetLightiv_params(glState, isCallValid, light, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetLightiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMapdv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLenum query, |
| GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, v, &vParam.value); |
| CaptureGetMapdv_v(glState, isCallValid, target, query, 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::GLGetMapdv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMapfv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLenum query, |
| GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, v, &vParam.value); |
| CaptureGetMapfv_v(glState, isCallValid, target, query, 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::GLGetMapfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMapiv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLenum query, |
| GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, v, &vParam.value); |
| CaptureGetMapiv_v(glState, isCallValid, target, query, 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::GLGetMapiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMaterialiv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", BigGLEnum::TriangleFace, ParamType::TGLenum, face); |
| paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetMaterialiv_params(glState, isCallValid, face, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetMaterialiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetPixelMapfv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLfloat *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, values, &valuesParam.value); |
| CaptureGetPixelMapfv_values(glState, isCallValid, map, 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::GLGetPixelMapfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetPixelMapuiv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLuint *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, values, &valuesParam.value); |
| CaptureGetPixelMapuiv_values(glState, isCallValid, map, 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::GLGetPixelMapuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetPixelMapusv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLushort *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLushortPointer); |
| InitParamValue(ParamType::TGLushortPointer, values, &valuesParam.value); |
| CaptureGetPixelMapusv_values(glState, isCallValid, map, 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::GLGetPixelMapusv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetPolygonStipple(const State &glState, bool isCallValid, GLubyte *mask) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture maskParam("mask", ParamType::TGLubytePointer); |
| InitParamValue(ParamType::TGLubytePointer, mask, &maskParam.value); |
| CaptureGetPolygonStipple_mask(glState, isCallValid, mask, &maskParam); |
| paramBuffer.addParam(std::move(maskParam)); |
| } |
| else |
| { |
| ParamCapture maskParam("mask", ParamType::TGLubytePointer); |
| InitParamValue(ParamType::TGLubytePointer, static_cast<GLubyte *>(nullptr), |
| &maskParam.value); |
| paramBuffer.addParam(std::move(maskParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetPolygonStipple, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexGendv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLdouble *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, params, ¶msParam.value); |
| CaptureGetTexGendv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLdoublePointer); |
| InitParamValue(ParamType::TGLdoublePointer, static_cast<GLdouble *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetTexGendv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexGenfv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value); |
| CaptureGetTexGenfv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetTexGenfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexGeniv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetTexGeniv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetTexGeniv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexImage(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| GLenum format, |
| GLenum type, |
| void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| 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 pixelsParam("pixels", ParamType::TvoidPointer); |
| InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value); |
| CaptureGetTexImage_pixels(glState, isCallValid, targetPacked, level, format, type, 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::GLGetTexImage, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexMask(const State &glState, bool isCallValid, GLuint mask) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("mask", ParamType::TGLuint, mask); |
| |
| return CallCapture(angle::EntryPoint::GLIndexMask, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexd(const State &glState, bool isCallValid, GLdouble c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLdouble, c); |
| |
| return CallCapture(angle::EntryPoint::GLIndexd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexdv(const State &glState, bool isCallValid, const GLdouble *c) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture cParam("c", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, c, &cParam.value); |
| CaptureIndexdv_c(glState, isCallValid, c, &cParam); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| else |
| { |
| ParamCapture cParam("c", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &cParam.value); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLIndexdv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexf(const State &glState, bool isCallValid, GLfloat c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLfloat, c); |
| |
| return CallCapture(angle::EntryPoint::GLIndexf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexfv(const State &glState, bool isCallValid, const GLfloat *c) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture cParam("c", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, c, &cParam.value); |
| CaptureIndexfv_c(glState, isCallValid, c, &cParam); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| else |
| { |
| ParamCapture cParam("c", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &cParam.value); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLIndexfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexi(const State &glState, bool isCallValid, GLint c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLint, c); |
| |
| return CallCapture(angle::EntryPoint::GLIndexi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexiv(const State &glState, bool isCallValid, const GLint *c) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture cParam("c", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, c, &cParam.value); |
| CaptureIndexiv_c(glState, isCallValid, c, &cParam); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| else |
| { |
| ParamCapture cParam("c", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| &cParam.value); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLIndexiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexs(const State &glState, bool isCallValid, GLshort c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLshort, c); |
| |
| return CallCapture(angle::EntryPoint::GLIndexs, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexsv(const State &glState, bool isCallValid, const GLshort *c) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture cParam("c", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, c, &cParam.value); |
| CaptureIndexsv_c(glState, isCallValid, c, &cParam); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| else |
| { |
| ParamCapture cParam("c", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr), |
| &cParam.value); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLIndexsv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureInitNames(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLInitNames, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIsList(const State &glState, |
| bool isCallValid, |
| GLuint list, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("list", ParamType::TGLuint, list); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(angle::EntryPoint::GLIsList, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModeli(const State &glState, bool isCallValid, GLenum pname, GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::LightModelParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLLightModeli, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModeliv(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::LightModelParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureLightModeliv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLLightModeliv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLighti(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| GLenum pname, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); |
| paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLLighti, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightiv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| GLenum pname, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); |
| paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureLightiv_params(glState, isCallValid, light, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLLightiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLineStipple(const State &glState, |
| bool isCallValid, |
| GLint factor, |
| GLushort pattern) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("factor", ParamType::TGLint, factor); |
| paramBuffer.addValueParam("pattern", ParamType::TGLushort, pattern); |
| |
| return CallCapture(angle::EntryPoint::GLLineStipple, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureListBase(const State &glState, bool isCallValid, GLuint base) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("base", ParamType::TGLuint, base); |
| |
| return CallCapture(angle::EntryPoint::GLListBase, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadMatrixd(const State &glState, bool isCallValid, const GLdouble *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, m, &mParam.value); |
| CaptureLoadMatrixd_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLLoadMatrixd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadName(const State &glState, bool isCallValid, GLuint name) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("name", ParamType::TGLuint, name); |
| |
| return CallCapture(angle::EntryPoint::GLLoadName, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMap1d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble u1, |
| GLdouble u2, |
| GLint stride, |
| GLint order, |
| const GLdouble *points) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); |
| paramBuffer.addValueParam("stride", ParamType::TGLint, stride); |
| paramBuffer.addValueParam("order", ParamType::TGLint, order); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointsParam("points", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, points, &pointsParam.value); |
| CaptureMap1d_points(glState, isCallValid, target, u1, u2, stride, order, points, |
| &pointsParam); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| else |
| { |
| ParamCapture pointsParam("points", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &pointsParam.value); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMap1d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMap1f(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLfloat u1, |
| GLfloat u2, |
| GLint stride, |
| GLint order, |
| const GLfloat *points) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); |
| paramBuffer.addValueParam("stride", ParamType::TGLint, stride); |
| paramBuffer.addValueParam("order", ParamType::TGLint, order); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointsParam("points", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, points, &pointsParam.value); |
| CaptureMap1f_points(glState, isCallValid, target, u1, u2, stride, order, points, |
| &pointsParam); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| else |
| { |
| ParamCapture pointsParam("points", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &pointsParam.value); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMap1f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMap2d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble u1, |
| GLdouble u2, |
| GLint ustride, |
| GLint uorder, |
| GLdouble v1, |
| GLdouble v2, |
| GLint vstride, |
| GLint vorder, |
| const GLdouble *points) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); |
| paramBuffer.addValueParam("ustride", ParamType::TGLint, ustride); |
| paramBuffer.addValueParam("uorder", ParamType::TGLint, uorder); |
| paramBuffer.addValueParam("v1", ParamType::TGLdouble, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLdouble, v2); |
| paramBuffer.addValueParam("vstride", ParamType::TGLint, vstride); |
| paramBuffer.addValueParam("vorder", ParamType::TGLint, vorder); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointsParam("points", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, points, &pointsParam.value); |
| CaptureMap2d_points(glState, isCallValid, target, u1, u2, ustride, uorder, v1, v2, vstride, |
| vorder, points, &pointsParam); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| else |
| { |
| ParamCapture pointsParam("points", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &pointsParam.value); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMap2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMap2f(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLfloat u1, |
| GLfloat u2, |
| GLint ustride, |
| GLint uorder, |
| GLfloat v1, |
| GLfloat v2, |
| GLint vstride, |
| GLint vorder, |
| const GLfloat *points) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); |
| paramBuffer.addValueParam("ustride", ParamType::TGLint, ustride); |
| paramBuffer.addValueParam("uorder", ParamType::TGLint, uorder); |
| paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2); |
| paramBuffer.addValueParam("vstride", ParamType::TGLint, vstride); |
| paramBuffer.addValueParam("vorder", ParamType::TGLint, vorder); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointsParam("points", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, points, &pointsParam.value); |
| CaptureMap2f_points(glState, isCallValid, target, u1, u2, ustride, uorder, v1, v2, vstride, |
| vorder, points, &pointsParam); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| else |
| { |
| ParamCapture pointsParam("points", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &pointsParam.value); |
| paramBuffer.addParam(std::move(pointsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMap2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapGrid1d(const State &glState, |
| bool isCallValid, |
| GLint un, |
| GLdouble u1, |
| GLdouble u2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("un", ParamType::TGLint, un); |
| paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); |
| |
| return CallCapture(angle::EntryPoint::GLMapGrid1d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapGrid1f(const State &glState, |
| bool isCallValid, |
| GLint un, |
| GLfloat u1, |
| GLfloat u2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("un", ParamType::TGLint, un); |
| paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); |
| |
| return CallCapture(angle::EntryPoint::GLMapGrid1f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapGrid2d(const State &glState, |
| bool isCallValid, |
| GLint un, |
| GLdouble u1, |
| GLdouble u2, |
| GLint vn, |
| GLdouble v1, |
| GLdouble v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("un", ParamType::TGLint, un); |
| paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); |
| paramBuffer.addValueParam("vn", ParamType::TGLint, vn); |
| paramBuffer.addValueParam("v1", ParamType::TGLdouble, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLdouble, v2); |
| |
| return CallCapture(angle::EntryPoint::GLMapGrid2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapGrid2f(const State &glState, |
| bool isCallValid, |
| GLint un, |
| GLfloat u1, |
| GLfloat u2, |
| GLint vn, |
| GLfloat v1, |
| GLfloat v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("un", ParamType::TGLint, un); |
| paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); |
| paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); |
| paramBuffer.addValueParam("vn", ParamType::TGLint, vn); |
| paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1); |
| paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2); |
| |
| return CallCapture(angle::EntryPoint::GLMapGrid2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMateriali(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| GLenum pname, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", BigGLEnum::TriangleFace, ParamType::TGLenum, face); |
| paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLMateriali, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMaterialiv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| GLenum pname, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", BigGLEnum::TriangleFace, ParamType::TGLenum, face); |
| paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureMaterialiv_params(glState, isCallValid, face, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMaterialiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultMatrixd(const State &glState, bool isCallValid, const GLdouble *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, m, &mParam.value); |
| CaptureMultMatrixd_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMultMatrixd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, GLenum mode) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("list", ParamType::TGLuint, list); |
| paramBuffer.addEnumParam("mode", BigGLEnum::ListMode, ParamType::TGLenum, mode); |
| |
| return CallCapture(angle::EntryPoint::GLNewList, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3b(const State &glState, bool isCallValid, GLbyte nx, GLbyte ny, GLbyte nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLbyte, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLbyte, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLbyte, nz); |
| |
| return CallCapture(angle::EntryPoint::GLNormal3b, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3bv(const State &glState, bool isCallValid, const GLbyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLbyteConstPointer); |
| InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value); |
| CaptureNormal3bv_v(glState, isCallValid, 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::GLNormal3bv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3d(const State &glState, |
| bool isCallValid, |
| GLdouble nx, |
| GLdouble ny, |
| GLdouble nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLdouble, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLdouble, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLdouble, nz); |
| |
| return CallCapture(angle::EntryPoint::GLNormal3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureNormal3dv_v(glState, isCallValid, 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::GLNormal3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureNormal3fv_v(glState, isCallValid, 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::GLNormal3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3i(const State &glState, bool isCallValid, GLint nx, GLint ny, GLint nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLint, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLint, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLint, nz); |
| |
| return CallCapture(angle::EntryPoint::GLNormal3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureNormal3iv_v(glState, isCallValid, 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::GLNormal3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3s(const State &glState, |
| bool isCallValid, |
| GLshort nx, |
| GLshort ny, |
| GLshort nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLshort, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLshort, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLshort, nz); |
| |
| return CallCapture(angle::EntryPoint::GLNormal3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureNormal3sv_v(glState, isCallValid, 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::GLNormal3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureOrtho(const State &glState, |
| bool isCallValid, |
| GLdouble left, |
| GLdouble right, |
| GLdouble bottom, |
| GLdouble top, |
| GLdouble zNear, |
| GLdouble zFar) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("left", ParamType::TGLdouble, left); |
| paramBuffer.addValueParam("right", ParamType::TGLdouble, right); |
| paramBuffer.addValueParam("bottom", ParamType::TGLdouble, bottom); |
| paramBuffer.addValueParam("top", ParamType::TGLdouble, top); |
| paramBuffer.addValueParam("zNear", ParamType::TGLdouble, zNear); |
| paramBuffer.addValueParam("zFar", ParamType::TGLdouble, zFar); |
| |
| return CallCapture(angle::EntryPoint::GLOrtho, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePassThrough(const State &glState, bool isCallValid, GLfloat token) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("token", ParamType::TGLfloat, token); |
| |
| return CallCapture(angle::EntryPoint::GLPassThrough, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelMapfv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLsizei mapsize, |
| const GLfloat *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, values, &valuesParam.value); |
| CapturePixelMapfv_values(glState, isCallValid, map, mapsize, 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::GLPixelMapfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelMapuiv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLsizei mapsize, |
| const GLuint *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, values, &valuesParam.value); |
| CapturePixelMapuiv_values(glState, isCallValid, map, mapsize, values, &valuesParam); |
| paramBuffer.addParam(std::move(valuesParam)); |
| } |
| else |
| { |
| ParamCapture valuesParam("values", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr), |
| &valuesParam.value); |
| paramBuffer.addParam(std::move(valuesParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLPixelMapuiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelMapusv(const State &glState, |
| bool isCallValid, |
| GLenum map, |
| GLsizei mapsize, |
| const GLushort *values) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); |
| paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); |
| |
| if (isCallValid) |
| { |
| ParamCapture valuesParam("values", ParamType::TGLushortConstPointer); |
| InitParamValue(ParamType::TGLushortConstPointer, values, &valuesParam.value); |
| CapturePixelMapusv_values(glState, isCallValid, map, mapsize, values, &valuesParam); |
| paramBuffer.addParam(std::move(valuesParam)); |
| } |
| else |
| { |
| ParamCapture valuesParam("values", ParamType::TGLushortConstPointer); |
| InitParamValue(ParamType::TGLushortConstPointer, static_cast<const GLushort *>(nullptr), |
| &valuesParam.value); |
| paramBuffer.addParam(std::move(valuesParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLPixelMapusv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelStoref(const State &glState, bool isCallValid, GLenum pname, GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::PixelStoreParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(angle::EntryPoint::GLPixelStoref, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelTransferf(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::PixelTransferParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(angle::EntryPoint::GLPixelTransferf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelTransferi(const State &glState, bool isCallValid, GLenum pname, GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::PixelTransferParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLPixelTransferi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePixelZoom(const State &glState, |
| bool isCallValid, |
| GLfloat xfactor, |
| GLfloat yfactor) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("xfactor", ParamType::TGLfloat, xfactor); |
| paramBuffer.addValueParam("yfactor", ParamType::TGLfloat, yfactor); |
| |
| return CallCapture(angle::EntryPoint::GLPixelZoom, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePolygonMode(const State &glState, bool isCallValid, GLenum face, GLenum mode) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", BigGLEnum::TriangleFace, ParamType::TGLenum, face); |
| paramBuffer.addEnumParam("mode", BigGLEnum::PolygonMode, ParamType::TGLenum, mode); |
| |
| return CallCapture(angle::EntryPoint::GLPolygonMode, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePolygonStipple(const State &glState, bool isCallValid, const GLubyte *mask) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture maskParam("mask", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, mask, &maskParam.value); |
| CapturePolygonStipple_mask(glState, isCallValid, mask, &maskParam); |
| paramBuffer.addParam(std::move(maskParam)); |
| } |
| else |
| { |
| ParamCapture maskParam("mask", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr), |
| &maskParam.value); |
| paramBuffer.addParam(std::move(maskParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLPolygonStipple, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePopAttrib(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLPopAttrib, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePopName(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLPopName, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield mask) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mask", BigGLEnum::AttribMask, ParamType::TGLbitfield, mask); |
| |
| return CallCapture(angle::EntryPoint::GLPushAttrib, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePushName(const State &glState, bool isCallValid, GLuint name) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("name", ParamType::TGLuint, name); |
| |
| return CallCapture(angle::EntryPoint::GLPushName, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureRasterPos2dv_v(glState, isCallValid, 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::GLRasterPos2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureRasterPos2fv_v(glState, isCallValid, 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::GLRasterPos2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2i(const State &glState, bool isCallValid, GLint x, GLint y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos2i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureRasterPos2iv_v(glState, isCallValid, 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::GLRasterPos2iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos2s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos2sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureRasterPos2sv_v(glState, isCallValid, 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::GLRasterPos2sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3d(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureRasterPos3dv_v(glState, isCallValid, 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::GLRasterPos3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3f(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(angle::EntryPoint::GLRasterPos3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureRasterPos3fv_v(glState, isCallValid, 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::GLRasterPos3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureRasterPos3iv_v(glState, isCallValid, 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::GLRasterPos3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3s(const State &glState, |
| bool isCallValid, |
| GLshort x, |
| GLshort y, |
| GLshort z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| paramBuffer.addValueParam("z", ParamType::TGLshort, z); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureRasterPos3sv_v(glState, isCallValid, 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::GLRasterPos3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4d(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z, |
| GLdouble w) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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::GLRasterPos4d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureRasterPos4dv_v(glState, isCallValid, 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::GLRasterPos4dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4f(const State &glState, |
| bool isCallValid, |
| GLfloat x, |
| GLfloat y, |
| GLfloat z, |
| GLfloat w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfloat, z); |
| paramBuffer.addValueParam("w", ParamType::TGLfloat, w); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos4f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureRasterPos4fv_v(glState, isCallValid, 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::GLRasterPos4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4i(const State &glState, |
| bool isCallValid, |
| GLint x, |
| GLint y, |
| GLint z, |
| GLint w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| paramBuffer.addValueParam("w", ParamType::TGLint, w); |
| |
| return CallCapture(angle::EntryPoint::GLRasterPos4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureRasterPos4iv_v(glState, isCallValid, 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::GLRasterPos4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4s(const State &glState, |
| bool isCallValid, |
| GLshort x, |
| GLshort y, |
| GLshort z, |
| GLshort w) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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::GLRasterPos4s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRasterPos4sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureRasterPos4sv_v(glState, isCallValid, 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::GLRasterPos4sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectd(const State &glState, |
| bool isCallValid, |
| GLdouble x1, |
| GLdouble y1, |
| GLdouble x2, |
| GLdouble y2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x1", ParamType::TGLdouble, x1); |
| paramBuffer.addValueParam("y1", ParamType::TGLdouble, y1); |
| paramBuffer.addValueParam("x2", ParamType::TGLdouble, x2); |
| paramBuffer.addValueParam("y2", ParamType::TGLdouble, y2); |
| |
| return CallCapture(angle::EntryPoint::GLRectd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectdv(const State &glState, |
| bool isCallValid, |
| const GLdouble *v1, |
| const GLdouble *v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture v1Param("v1", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v1, &v1Param.value); |
| CaptureRectdv_v1(glState, isCallValid, v1, v2, &v1Param); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| else |
| { |
| ParamCapture v1Param("v1", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &v1Param.value); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture v2Param("v2", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v2, &v2Param.value); |
| CaptureRectdv_v2(glState, isCallValid, v1, v2, &v2Param); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| else |
| { |
| ParamCapture v2Param("v2", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &v2Param.value); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLRectdv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectf(const State &glState, |
| bool isCallValid, |
| GLfloat x1, |
| GLfloat y1, |
| GLfloat x2, |
| GLfloat y2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x1", ParamType::TGLfloat, x1); |
| paramBuffer.addValueParam("y1", ParamType::TGLfloat, y1); |
| paramBuffer.addValueParam("x2", ParamType::TGLfloat, x2); |
| paramBuffer.addValueParam("y2", ParamType::TGLfloat, y2); |
| |
| return CallCapture(angle::EntryPoint::GLRectf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectfv(const State &glState, |
| bool isCallValid, |
| const GLfloat *v1, |
| const GLfloat *v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture v1Param("v1", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v1, &v1Param.value); |
| CaptureRectfv_v1(glState, isCallValid, v1, v2, &v1Param); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| else |
| { |
| ParamCapture v1Param("v1", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &v1Param.value); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture v2Param("v2", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v2, &v2Param.value); |
| CaptureRectfv_v2(glState, isCallValid, v1, v2, &v2Param); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| else |
| { |
| ParamCapture v2Param("v2", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &v2Param.value); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLRectfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRecti(const State &glState, |
| bool isCallValid, |
| GLint x1, |
| GLint y1, |
| GLint x2, |
| GLint y2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x1", ParamType::TGLint, x1); |
| paramBuffer.addValueParam("y1", ParamType::TGLint, y1); |
| paramBuffer.addValueParam("x2", ParamType::TGLint, x2); |
| paramBuffer.addValueParam("y2", ParamType::TGLint, y2); |
| |
| return CallCapture(angle::EntryPoint::GLRecti, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectiv(const State &glState, bool isCallValid, const GLint *v1, const GLint *v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture v1Param("v1", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v1, &v1Param.value); |
| CaptureRectiv_v1(glState, isCallValid, v1, v2, &v1Param); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| else |
| { |
| ParamCapture v1Param("v1", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| &v1Param.value); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture v2Param("v2", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v2, &v2Param.value); |
| CaptureRectiv_v2(glState, isCallValid, v1, v2, &v2Param); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| else |
| { |
| ParamCapture v2Param("v2", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| &v2Param.value); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLRectiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRects(const State &glState, |
| bool isCallValid, |
| GLshort x1, |
| GLshort y1, |
| GLshort x2, |
| GLshort y2) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x1", ParamType::TGLshort, x1); |
| paramBuffer.addValueParam("y1", ParamType::TGLshort, y1); |
| paramBuffer.addValueParam("x2", ParamType::TGLshort, x2); |
| paramBuffer.addValueParam("y2", ParamType::TGLshort, y2); |
| |
| return CallCapture(angle::EntryPoint::GLRects, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRectsv(const State &glState, |
| bool isCallValid, |
| const GLshort *v1, |
| const GLshort *v2) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture v1Param("v1", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v1, &v1Param.value); |
| CaptureRectsv_v1(glState, isCallValid, v1, v2, &v1Param); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| else |
| { |
| ParamCapture v1Param("v1", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr), |
| &v1Param.value); |
| paramBuffer.addParam(std::move(v1Param)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture v2Param("v2", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v2, &v2Param.value); |
| CaptureRectsv_v2(glState, isCallValid, v1, v2, &v2Param); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| else |
| { |
| ParamCapture v2Param("v2", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, static_cast<const GLshort *>(nullptr), |
| &v2Param.value); |
| paramBuffer.addParam(std::move(v2Param)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLRectsv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRenderMode(const State &glState, |
| bool isCallValid, |
| GLenum mode, |
| GLint returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mode", BigGLEnum::RenderingMode, ParamType::TGLenum, mode); |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLint); |
| InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(angle::EntryPoint::GLRenderMode, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRotated(const State &glState, |
| bool isCallValid, |
| GLdouble angle, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("angle", ParamType::TGLdouble, angle); |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLRotated, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureScaled(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLScaled, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSelectBuffer(const State &glState, |
| bool isCallValid, |
| GLsizei size, |
| GLuint *buffer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLsizei, size); |
| |
| if (isCallValid) |
| { |
| ParamCapture bufferParam("buffer", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, buffer, &bufferParam.value); |
| CaptureSelectBuffer_buffer(glState, isCallValid, size, buffer, &bufferParam); |
| paramBuffer.addParam(std::move(bufferParam)); |
| } |
| else |
| { |
| ParamCapture bufferParam("buffer", ParamType::TGLuintPointer); |
| InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), |
| &bufferParam.value); |
| paramBuffer.addParam(std::move(bufferParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLSelectBuffer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1d(const State &glState, bool isCallValid, GLdouble s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord1d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureTexCoord1dv_v(glState, isCallValid, 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::GLTexCoord1dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1f(const State &glState, bool isCallValid, GLfloat s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord1f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureTexCoord1fv_v(glState, isCallValid, 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::GLTexCoord1fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1i(const State &glState, bool isCallValid, GLint s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord1i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureTexCoord1iv_v(glState, isCallValid, 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::GLTexCoord1iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1s(const State &glState, bool isCallValid, GLshort s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord1s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord1sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureTexCoord1sv_v(glState, isCallValid, 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::GLTexCoord1sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2d(const State &glState, bool isCallValid, GLdouble s, GLdouble t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureTexCoord2dv_v(glState, isCallValid, 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::GLTexCoord2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2f(const State &glState, bool isCallValid, GLfloat s, GLfloat t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureTexCoord2fv_v(glState, isCallValid, 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::GLTexCoord2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2i(const State &glState, bool isCallValid, GLint s, GLint t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord2i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureTexCoord2iv_v(glState, isCallValid, 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::GLTexCoord2iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2s(const State &glState, bool isCallValid, GLshort s, GLshort t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord2s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord2sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureTexCoord2sv_v(glState, isCallValid, 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::GLTexCoord2sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3d(const State &glState, |
| bool isCallValid, |
| GLdouble s, |
| GLdouble t, |
| GLdouble r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| paramBuffer.addValueParam("r", ParamType::TGLdouble, r); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureTexCoord3dv_v(glState, isCallValid, 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::GLTexCoord3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3f(const State &glState, |
| bool isCallValid, |
| GLfloat s, |
| GLfloat t, |
| GLfloat r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| paramBuffer.addValueParam("r", ParamType::TGLfloat, r); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureTexCoord3fv_v(glState, isCallValid, 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::GLTexCoord3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3i(const State &glState, bool isCallValid, GLint s, GLint t, GLint r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| paramBuffer.addValueParam("r", ParamType::TGLint, r); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureTexCoord3iv_v(glState, isCallValid, 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::GLTexCoord3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3s(const State &glState, |
| bool isCallValid, |
| GLshort s, |
| GLshort t, |
| GLshort r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| paramBuffer.addValueParam("r", ParamType::TGLshort, r); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureTexCoord3sv_v(glState, isCallValid, 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::GLTexCoord3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4d(const State &glState, |
| bool isCallValid, |
| GLdouble s, |
| GLdouble t, |
| GLdouble r, |
| GLdouble q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| paramBuffer.addValueParam("r", ParamType::TGLdouble, r); |
| paramBuffer.addValueParam("q", ParamType::TGLdouble, q); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord4d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureTexCoord4dv_v(glState, isCallValid, 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::GLTexCoord4dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4f(const State &glState, |
| bool isCallValid, |
| GLfloat s, |
| GLfloat t, |
| GLfloat r, |
| GLfloat q) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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(angle::EntryPoint::GLTexCoord4f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureTexCoord4fv_v(glState, isCallValid, 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::GLTexCoord4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4i(const State &glState, |
| bool isCallValid, |
| GLint s, |
| GLint t, |
| GLint r, |
| GLint q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| paramBuffer.addValueParam("r", ParamType::TGLint, r); |
| paramBuffer.addValueParam("q", ParamType::TGLint, q); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureTexCoord4iv_v(glState, isCallValid, 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::GLTexCoord4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4s(const State &glState, |
| bool isCallValid, |
| GLshort s, |
| GLshort t, |
| GLshort r, |
| GLshort q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| paramBuffer.addValueParam("r", ParamType::TGLshort, r); |
| paramBuffer.addValueParam("q", ParamType::TGLshort, q); |
| |
| return CallCapture(angle::EntryPoint::GLTexCoord4s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoord4sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureTexCoord4sv_v(glState, isCallValid, 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::GLTexCoord4sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGend(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLdouble param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLdouble, param); |
| |
| return CallCapture(angle::EntryPoint::GLTexGend, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGendv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| const GLdouble *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, params, ¶msParam.value); |
| CaptureTexGendv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLTexGendv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGenf(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(angle::EntryPoint::GLTexGenf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGenfv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureTexGenfv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLTexGenfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGeni(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLTexGeni, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexGeniv(const State &glState, |
| bool isCallValid, |
| GLenum coord, |
| GLenum pname, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); |
| paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureTexGeniv_params(glState, isCallValid, coord, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLTexGeniv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLint internalformat, |
| GLsizei width, |
| GLint border, |
| GLenum format, |
| GLenum type, |
| const void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("border", ParamType::TGLint, border); |
| 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); |
| CaptureTexImage1D_pixels(glState, isCallValid, target, level, internalformat, width, border, |
| 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::GLTexImage1D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTranslated(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLTranslated, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| |
| return CallCapture(angle::EntryPoint::GLVertex2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureVertex2dv_v(glState, isCallValid, 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::GLVertex2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| |
| return CallCapture(angle::EntryPoint::GLVertex2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureVertex2fv_v(glState, isCallValid, 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::GLVertex2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2i(const State &glState, bool isCallValid, GLint x, GLint y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| |
| return CallCapture(angle::EntryPoint::GLVertex2i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureVertex2iv_v(glState, isCallValid, 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::GLVertex2iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2s(const State &glState, bool isCallValid, GLshort x, GLshort y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| |
| return CallCapture(angle::EntryPoint::GLVertex2s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex2sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureVertex2sv_v(glState, isCallValid, 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::GLVertex2sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3d(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLVertex3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureVertex3dv_v(glState, isCallValid, 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::GLVertex3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3f(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(angle::EntryPoint::GLVertex3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureVertex3fv_v(glState, isCallValid, 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::GLVertex3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| |
| return CallCapture(angle::EntryPoint::GLVertex3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureVertex3iv_v(glState, isCallValid, 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::GLVertex3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3s(const State &glState, bool isCallValid, GLshort x, GLshort y, GLshort z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| paramBuffer.addValueParam("z", ParamType::TGLshort, z); |
| |
| return CallCapture(angle::EntryPoint::GLVertex3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureVertex3sv_v(glState, isCallValid, 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::GLVertex3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4d(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z, |
| GLdouble w) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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::GLVertex4d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureVertex4dv_v(glState, isCallValid, 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::GLVertex4dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4f(const State &glState, |
| bool isCallValid, |
| GLfloat x, |
| GLfloat y, |
| GLfloat z, |
| GLfloat w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfloat, z); |
| paramBuffer.addValueParam("w", ParamType::TGLfloat, w); |
| |
| return CallCapture(angle::EntryPoint::GLVertex4f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureVertex4fv_v(glState, isCallValid, 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::GLVertex4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4i(const State &glState, |
| bool isCallValid, |
| GLint x, |
| GLint y, |
| GLint z, |
| GLint w) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| paramBuffer.addValueParam("w", ParamType::TGLint, w); |
| |
| return CallCapture(angle::EntryPoint::GLVertex4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureVertex4iv_v(glState, isCallValid, 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::GLVertex4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4s(const State &glState, |
| bool isCallValid, |
| GLshort x, |
| GLshort y, |
| GLshort z, |
| GLshort w) |
| { |
| ParamBuffer paramBuffer; |
| |
| 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::GLVertex4s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertex4sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureVertex4sv_v(glState, isCallValid, 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::GLVertex4sv, std::move(paramBuffer)); |
| } |
| |
| // GL 1.1 |
| CallCapture CaptureAreTexturesResident(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const GLuint *textures, |
| GLboolean *residences, |
| GLboolean returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| if (isCallValid) |
| { |
| ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, textures, &texturesParam.value); |
| CaptureAreTexturesResident_textures(glState, isCallValid, n, textures, residences, |
| &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)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture residencesParam("residences", ParamType::TGLbooleanPointer); |
| InitParamValue(ParamType::TGLbooleanPointer, residences, &residencesParam.value); |
| CaptureAreTexturesResident_residences(glState, isCallValid, n, textures, residences, |
| &residencesParam); |
| paramBuffer.addParam(std::move(residencesParam)); |
| } |
| else |
| { |
| ParamCapture residencesParam("residences", ParamType::TGLbooleanPointer); |
| InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr), |
| &residencesParam.value); |
| paramBuffer.addParam(std::move(residencesParam)); |
| } |
| |
| ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); |
| InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); |
| paramBuffer.addReturnValue(std::move(returnValueCapture)); |
| |
| return CallCapture(angle::EntryPoint::GLAreTexturesResident, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureArrayElement(const State &glState, bool isCallValid, GLint i) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("i", ParamType::TGLint, i); |
| |
| return CallCapture(angle::EntryPoint::GLArrayElement, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCopyTexImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLint border) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("border", ParamType::TGLint, border); |
| |
| return CallCapture(angle::EntryPoint::GLCopyTexImage1D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCopyTexSubImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint x, |
| GLint y, |
| GLsizei width) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| 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::GLCopyTexSubImage1D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEdgeFlagPointer(const State &glState, |
| bool isCallValid, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureEdgeFlagPointer_pointer(glState, isCallValid, 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::GLEdgeFlagPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexPointer(const State &glState, |
| bool isCallValid, |
| GLenum type, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("type", BigGLEnum::IndexPointerType, ParamType::TGLenum, type); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureIndexPointer_pointer(glState, isCallValid, 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::GLIndexPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexub(const State &glState, bool isCallValid, GLubyte c) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("c", ParamType::TGLubyte, c); |
| |
| return CallCapture(angle::EntryPoint::GLIndexub, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureIndexubv(const State &glState, bool isCallValid, const GLubyte *c) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture cParam("c", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, c, &cParam.value); |
| CaptureIndexubv_c(glState, isCallValid, c, &cParam); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| else |
| { |
| ParamCapture cParam("c", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, static_cast<const GLubyte *>(nullptr), |
| &cParam.value); |
| paramBuffer.addParam(std::move(cParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLIndexubv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureInterleavedArrays(const State &glState, |
| bool isCallValid, |
| GLenum format, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("format", BigGLEnum::InterleavedArrayFormat, ParamType::TGLenum, |
| format); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureInterleavedArrays_pointer(glState, isCallValid, format, 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::GLInterleavedArrays, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePopClientAttrib(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(angle::EntryPoint::GLPopClientAttrib, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePrioritizeTextures(const State &glState, |
| bool isCallValid, |
| GLsizei n, |
| const GLuint *textures, |
| const GLfloat *priorities) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLsizei, n); |
| |
| if (isCallValid) |
| { |
| ParamCapture texturesParam("textures", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, textures, &texturesParam.value); |
| CapturePrioritizeTextures_textures(glState, isCallValid, n, textures, priorities, |
| &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)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture prioritiesParam("priorities", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, priorities, &prioritiesParam.value); |
| CapturePrioritizeTextures_priorities(glState, isCallValid, n, textures, priorities, |
| &prioritiesParam); |
| paramBuffer.addParam(std::move(prioritiesParam)); |
| } |
| else |
| { |
| ParamCapture prioritiesParam("priorities", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &prioritiesParam.value); |
| paramBuffer.addParam(std::move(prioritiesParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLPrioritizeTextures, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbitfield mask) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("mask", BigGLEnum::ClientAttribMask, ParamType::TGLbitfield, mask); |
| |
| return CallCapture(angle::EntryPoint::GLPushClientAttrib, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexSubImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLsizei width, |
| GLenum format, |
| GLenum type, |
| const void *pixels) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| 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); |
| CaptureTexSubImage1D_pixels(glState, isCallValid, target, 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::GLTexSubImage1D, std::move(paramBuffer)); |
| } |
| |
| // GL 1.2 |
| |
| // GL 1.3 |
| CallCapture CaptureCompressedTexImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLint border, |
| GLsizei imageSize, |
| const void *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, |
| internalformat); |
| paramBuffer.addValueParam("width", ParamType::TGLsizei, width); |
| paramBuffer.addValueParam("border", ParamType::TGLint, border); |
| paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); |
| |
| if (isCallValid) |
| { |
| ParamCapture dataParam("data", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value); |
| CaptureCompressedTexImage1D_data(glState, isCallValid, target, level, internalformat, width, |
| border, 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::GLCompressedTexImage1D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureCompressedTexSubImage1D(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLsizei width, |
| GLenum format, |
| GLsizei imageSize, |
| const void *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); |
| 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); |
| CaptureCompressedTexSubImage1D_data(glState, isCallValid, target, 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::GLCompressedTexSubImage1D, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetCompressedTexImage(const State &glState, |
| bool isCallValid, |
| TextureTarget targetPacked, |
| GLint level, |
| void *img) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); |
| paramBuffer.addValueParam("level", ParamType::TGLint, level); |
| |
| if (isCallValid) |
| { |
| ParamCapture imgParam("img", ParamType::TvoidPointer); |
| InitParamValue(ParamType::TvoidPointer, img, &imgParam.value); |
| CaptureGetCompressedTexImage_img(glState, isCallValid, targetPacked, level, img, &imgParam); |
| paramBuffer.addParam(std::move(imgParam)); |
| } |
| else |
| { |
| ParamCapture imgParam("img", ParamType::TvoidPointer); |
| InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &imgParam.value); |
| paramBuffer.addParam(std::move(imgParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetCompressedTexImage, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadTransposeMatrixd(const State &glState, bool isCallValid, const GLdouble *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, m, &mParam.value); |
| CaptureLoadTransposeMatrixd_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLLoadTransposeMatrixd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadTransposeMatrixf(const State &glState, bool isCallValid, const GLfloat *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value); |
| CaptureLoadTransposeMatrixf_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLLoadTransposeMatrixf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultTransposeMatrixd(const State &glState, bool isCallValid, const GLdouble *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, m, &mParam.value); |
| CaptureMultTransposeMatrixd_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMultTransposeMatrixd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultTransposeMatrixf(const State &glState, bool isCallValid, const GLfloat *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value); |
| CaptureMultTransposeMatrixf_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| else |
| { |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &mParam.value); |
| paramBuffer.addParam(std::move(mParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLMultTransposeMatrixf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord1d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1dv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord1dv_v(glState, isCallValid, target, 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::GLMultiTexCoord1dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1f(const State &glState, bool isCallValid, GLenum target, GLfloat s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord1f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1fv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord1fv_v(glState, isCallValid, target, 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::GLMultiTexCoord1fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1i(const State &glState, bool isCallValid, GLenum target, GLint s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord1i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1iv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord1iv_v(glState, isCallValid, target, 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::GLMultiTexCoord1iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1s(const State &glState, bool isCallValid, GLenum target, GLshort s) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord1s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord1sv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord1sv_v(glState, isCallValid, target, 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::GLMultiTexCoord1sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble s, |
| GLdouble t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2dv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord2dv_v(glState, isCallValid, target, 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::GLMultiTexCoord2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2f(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLfloat s, |
| GLfloat t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2fv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord2fv_v(glState, isCallValid, target, 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::GLMultiTexCoord2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2i(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint s, |
| GLint t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord2i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2iv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord2iv_v(glState, isCallValid, target, 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::GLMultiTexCoord2iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2s(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLshort s, |
| GLshort t) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord2s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord2sv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord2sv_v(glState, isCallValid, target, 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::GLMultiTexCoord2sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble s, |
| GLdouble t, |
| GLdouble r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| paramBuffer.addValueParam("r", ParamType::TGLdouble, r); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3dv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord3dv_v(glState, isCallValid, target, 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::GLMultiTexCoord3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3f(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLfloat s, |
| GLfloat t, |
| GLfloat r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| paramBuffer.addValueParam("r", ParamType::TGLfloat, r); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3fv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord3fv_v(glState, isCallValid, target, 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::GLMultiTexCoord3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3i(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint s, |
| GLint t, |
| GLint r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| paramBuffer.addValueParam("r", ParamType::TGLint, r); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3iv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord3iv_v(glState, isCallValid, target, 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::GLMultiTexCoord3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3s(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLshort s, |
| GLshort t, |
| GLshort r) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| paramBuffer.addValueParam("r", ParamType::TGLshort, r); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord3sv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord3sv_v(glState, isCallValid, target, 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::GLMultiTexCoord3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4d(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLdouble s, |
| GLdouble t, |
| GLdouble r, |
| GLdouble q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLdouble, s); |
| paramBuffer.addValueParam("t", ParamType::TGLdouble, t); |
| paramBuffer.addValueParam("r", ParamType::TGLdouble, r); |
| paramBuffer.addValueParam("q", ParamType::TGLdouble, q); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord4d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4dv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord4dv_v(glState, isCallValid, target, 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::GLMultiTexCoord4dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4fv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord4fv_v(glState, isCallValid, target, 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::GLMultiTexCoord4fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4i(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLint s, |
| GLint t, |
| GLint r, |
| GLint q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLint, s); |
| paramBuffer.addValueParam("t", ParamType::TGLint, t); |
| paramBuffer.addValueParam("r", ParamType::TGLint, r); |
| paramBuffer.addValueParam("q", ParamType::TGLint, q); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord4i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4iv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord4iv_v(glState, isCallValid, target, 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::GLMultiTexCoord4iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4s(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLshort s, |
| GLshort t, |
| GLshort r, |
| GLshort q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLshort, s); |
| paramBuffer.addValueParam("t", ParamType::TGLshort, t); |
| paramBuffer.addValueParam("r", ParamType::TGLshort, r); |
| paramBuffer.addValueParam("q", ParamType::TGLshort, q); |
| |
| return CallCapture(angle::EntryPoint::GLMultiTexCoord4s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4sv(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureMultiTexCoord4sv_v(glState, isCallValid, target, 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::GLMultiTexCoord4sv, std::move(paramBuffer)); |
| } |
| |
| // GL 1.4 |
| CallCapture CaptureFogCoordPointer(const State &glState, |
| bool isCallValid, |
| GLenum type, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("type", BigGLEnum::FogPointerTypeEXT, ParamType::TGLenum, type); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureFogCoordPointer_pointer(glState, isCallValid, 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::GLFogCoordPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogCoordd(const State &glState, bool isCallValid, GLdouble coord) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("coord", ParamType::TGLdouble, coord); |
| |
| return CallCapture(angle::EntryPoint::GLFogCoordd, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogCoorddv(const State &glState, bool isCallValid, const GLdouble *coord) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture coordParam("coord", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, coord, &coordParam.value); |
| CaptureFogCoorddv_coord(glState, isCallValid, coord, &coordParam); |
| paramBuffer.addParam(std::move(coordParam)); |
| } |
| else |
| { |
| ParamCapture coordParam("coord", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, static_cast<const GLdouble *>(nullptr), |
| &coordParam.value); |
| paramBuffer.addParam(std::move(coordParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLFogCoorddv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogCoordf(const State &glState, bool isCallValid, GLfloat coord) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("coord", ParamType::TGLfloat, coord); |
| |
| return CallCapture(angle::EntryPoint::GLFogCoordf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogCoordfv(const State &glState, bool isCallValid, const GLfloat *coord) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture coordParam("coord", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, coord, &coordParam.value); |
| CaptureFogCoordfv_coord(glState, isCallValid, coord, &coordParam); |
| paramBuffer.addParam(std::move(coordParam)); |
| } |
| else |
| { |
| ParamCapture coordParam("coord", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr), |
| &coordParam.value); |
| paramBuffer.addParam(std::move(coordParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLFogCoordfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiDrawArrays(const State &glState, |
| bool isCallValid, |
| PrimitiveMode modePacked, |
| const GLint *first, |
| const GLsizei *count, |
| GLsizei drawcount) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked); |
| |
| if (isCallValid) |
| { |
| ParamCapture firstParam("first", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, first, &firstParam.value); |
| CaptureMultiDrawArrays_first(glState, isCallValid, modePacked, first, count, drawcount, |
| &firstParam); |
| paramBuffer.addParam(std::move(firstParam)); |
| } |
| else |
| { |
| ParamCapture firstParam("first", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| &firstParam.value); |
| paramBuffer.addParam(std::move(firstParam)); |
| } |
| |
| if (isCallValid) |
| { |
| ParamCapture countParam("count", ParamType::TGLsizeiConstPointer); |
| InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value); |
| CaptureMultiDrawArrays_count(glState, isCallValid, modePacked, first, count, drawcount, |
| &countParam); |
| paramBuffer.addParam(std::move(countParam)); |
| } |
| else |
| { |
| ParamCapture countParam("count", ParamType::TGLsizeiConstPointer); |
| InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr), |
| &countParam.value); |
| paramBuffer.addParam(std::move(countParam)); |
| } |
| |
| paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount); |
| |
| return CallCapture(angle::EntryPoint::GLMultiDrawArrays, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiDrawElements(const State &glState, |
| bool isCallValid, |
| PrimitiveMode modePacked, |
| const GLsizei *count, |
| DrawElementsType typePacked, |
| const void *const *indices, |
| GLsizei drawcount) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked); |
| |
| if (isCallValid) |
| { |
| ParamCapture countParam("count", ParamType::TGLsizeiConstPointer); |
| InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value); |
| CaptureMultiDrawElements_count(glState, isCallValid, modePacked, count, typePacked, indices, |
| drawcount, &countParam); |
| paramBuffer.addParam(std::move(countParam)); |
| } |
| else |
| { |
| ParamCapture countParam("count", ParamType::TGLsizeiConstPointer); |
| InitParamValue(ParamType::TGLsizeiConstPointer, static_cast<const GLsizei *>(nullptr), |
| &countParam.value); |
| paramBuffer.addParam(std::move(countParam)); |
| } |
| |
| paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked); |
| |
| if (isCallValid) |
| { |
| ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer); |
| InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value); |
| CaptureMultiDrawElements_indices(glState, isCallValid, modePacked, count, typePacked, |
| indices, drawcount, &indicesParam); |
| paramBuffer.addParam(std::move(indicesParam)); |
| } |
| else |
| { |
| ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer); |
| InitParamValue(ParamType::TvoidConstPointerPointer, |
| static_cast<const void *const *>(nullptr), &indicesParam.value); |
| paramBuffer.addParam(std::move(indicesParam)); |
| } |
| |
| paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount); |
| |
| return CallCapture(angle::EntryPoint::GLMultiDrawElements, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameteri(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(angle::EntryPoint::GLPointParameteri, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameteriv(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CapturePointParameteriv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr), |
| ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLPointParameteriv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3b(const State &glState, |
| bool isCallValid, |
| GLbyte red, |
| GLbyte green, |
| GLbyte blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLbyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLbyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLbyte, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3b, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3bv(const State &glState, bool isCallValid, const GLbyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLbyteConstPointer); |
| InitParamValue(ParamType::TGLbyteConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3bv_v(glState, isCallValid, 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::GLSecondaryColor3bv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3d(const State &glState, |
| bool isCallValid, |
| GLdouble red, |
| GLdouble green, |
| GLdouble blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLdouble, red); |
| paramBuffer.addValueParam("green", ParamType::TGLdouble, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLdouble, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3dv_v(glState, isCallValid, 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::GLSecondaryColor3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3f(const State &glState, |
| bool isCallValid, |
| GLfloat red, |
| GLfloat green, |
| GLfloat blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLfloat, red); |
| paramBuffer.addValueParam("green", ParamType::TGLfloat, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3fv_v(glState, isCallValid, 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::GLSecondaryColor3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3i(const State &glState, |
| bool isCallValid, |
| GLint red, |
| GLint green, |
| GLint blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLint, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3iv_v(glState, isCallValid, 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::GLSecondaryColor3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3s(const State &glState, |
| bool isCallValid, |
| GLshort red, |
| GLshort green, |
| GLshort blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLshort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLshort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLshort, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3sv_v(glState, isCallValid, 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::GLSecondaryColor3sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3ub(const State &glState, |
| bool isCallValid, |
| GLubyte red, |
| GLubyte green, |
| GLubyte blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLubyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLubyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3ub, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3ubv(const State &glState, bool isCallValid, const GLubyte *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLubyteConstPointer); |
| InitParamValue(ParamType::TGLubyteConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3ubv_v(glState, isCallValid, 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::GLSecondaryColor3ubv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3ui(const State &glState, |
| bool isCallValid, |
| GLuint red, |
| GLuint green, |
| GLuint blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLuint, red); |
| paramBuffer.addValueParam("green", ParamType::TGLuint, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLuint, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3ui, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3uiv(const State &glState, bool isCallValid, const GLuint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLuintConstPointer); |
| InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3uiv_v(glState, isCallValid, 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::GLSecondaryColor3uiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3us(const State &glState, |
| bool isCallValid, |
| GLushort red, |
| GLushort green, |
| GLushort blue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLushort, red); |
| paramBuffer.addValueParam("green", ParamType::TGLushort, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLushort, blue); |
| |
| return CallCapture(angle::EntryPoint::GLSecondaryColor3us, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColor3usv(const State &glState, bool isCallValid, const GLushort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLushortConstPointer); |
| InitParamValue(ParamType::TGLushortConstPointer, v, &vParam.value); |
| CaptureSecondaryColor3usv_v(glState, isCallValid, 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::GLSecondaryColor3usv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSecondaryColorPointer(const State &glState, |
| bool isCallValid, |
| GLint size, |
| GLenum type, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLint, size); |
| paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| if (isCallValid) |
| { |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureSecondaryColorPointer_pointer(glState, isCallValid, 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::GLSecondaryColorPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2d(const State &glState, bool isCallValid, GLdouble x, GLdouble y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos2d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureWindowPos2dv_v(glState, isCallValid, 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::GLWindowPos2dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2f(const State &glState, bool isCallValid, GLfloat x, GLfloat y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos2f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureWindowPos2fv_v(glState, isCallValid, 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::GLWindowPos2fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2i(const State &glState, bool isCallValid, GLint x, GLint y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos2i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureWindowPos2iv_v(glState, isCallValid, 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::GLWindowPos2iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2s(const State &glState, bool isCallValid, GLshort x, GLshort y) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos2s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos2sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureWindowPos2sv_v(glState, isCallValid, 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::GLWindowPos2sv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3d(const State &glState, |
| bool isCallValid, |
| GLdouble x, |
| GLdouble y, |
| GLdouble z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLdouble, x); |
| paramBuffer.addValueParam("y", ParamType::TGLdouble, y); |
| paramBuffer.addValueParam("z", ParamType::TGLdouble, z); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos3d, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3dv(const State &glState, bool isCallValid, const GLdouble *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLdoubleConstPointer); |
| InitParamValue(ParamType::TGLdoubleConstPointer, v, &vParam.value); |
| CaptureWindowPos3dv_v(glState, isCallValid, 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::GLWindowPos3dv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3f(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(angle::EntryPoint::GLWindowPos3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3fv(const State &glState, bool isCallValid, const GLfloat *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value); |
| CaptureWindowPos3fv_v(glState, isCallValid, 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::GLWindowPos3fv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3i(const State &glState, bool isCallValid, GLint x, GLint y, GLint z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLint, x); |
| paramBuffer.addValueParam("y", ParamType::TGLint, y); |
| paramBuffer.addValueParam("z", ParamType::TGLint, z); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos3i, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3iv(const State &glState, bool isCallValid, const GLint *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value); |
| CaptureWindowPos3iv_v(glState, isCallValid, 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::GLWindowPos3iv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3s(const State &glState, |
| bool isCallValid, |
| GLshort x, |
| GLshort y, |
| GLshort z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLshort, x); |
| paramBuffer.addValueParam("y", ParamType::TGLshort, y); |
| paramBuffer.addValueParam("z", ParamType::TGLshort, z); |
| |
| return CallCapture(angle::EntryPoint::GLWindowPos3s, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureWindowPos3sv(const State &glState, bool isCallValid, const GLshort *v) |
| { |
| ParamBuffer paramBuffer; |
| |
| if (isCallValid) |
| { |
| ParamCapture vParam("v", ParamType::TGLshortConstPointer); |
| InitParamValue(ParamType::TGLshortConstPointer, v, &vParam.value); |
| CaptureWindowPos3sv_v(glState, isCallValid, 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::GLWindowPos3sv, std::move(paramBuffer)); |
| } |
| |
| // GL 1.5 |
| CallCapture CaptureGetBufferSubData(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLintptr offset, |
| GLsizeiptr size, |
| void *data) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target); |
| 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); |
| CaptureGetBufferSubData_data(glState, isCallValid, target, 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::GLGetBufferSubData, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetQueryObjectiv(const State &glState, |
| bool isCallValid, |
| QueryID idPacked, |
| GLenum pname, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); |
| paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, |
| pname); |
| |
| if (isCallValid) |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetQueryObjectiv_params(glState, isCallValid, idPacked, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| else |
| { |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), ¶msParam.value); |
| paramBuffer.addParam(std::move(paramsParam)); |
| } |
| |
| return CallCapture(angle::EntryPoint::GLGetQueryObjectiv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMapBuffer(const State &glState, |
| bool isCallValid, |
| BufferBinding targetPacked, |
| GLenum access, |
| void *returnValue) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); |
| 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::GLMapBuffer, std::move(paramBuffer)); |
| } |
| |
| } // namespace gl |