| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. |
| // |
| // Copyright 2019 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // capture_gles_1_0_autogen.cpp: |
| // Capture functions for the OpenGL ES 1.0 entry points. |
| |
| #include "libANGLE/capture_gles_1_0_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/FrameCapture.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationES1.h" |
| |
| using namespace angle; |
| |
| namespace gl |
| { |
| |
| CallCapture CaptureAlphaFunc(const State &glState, |
| bool isCallValid, |
| AlphaTestFunc funcPacked, |
| GLfloat ref) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked); |
| paramBuffer.addValueParam("ref", ParamType::TGLfloat, ref); |
| |
| return CallCapture(gl::EntryPoint::AlphaFunc, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureAlphaFuncx(const State &glState, |
| bool isCallValid, |
| AlphaTestFunc funcPacked, |
| GLfixed ref) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked); |
| paramBuffer.addValueParam("ref", ParamType::TGLfixed, ref); |
| |
| return CallCapture(gl::EntryPoint::AlphaFuncx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearColorx(const State &glState, |
| bool isCallValid, |
| GLfixed red, |
| GLfixed green, |
| GLfixed blue, |
| GLfixed alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLfixed, red); |
| paramBuffer.addValueParam("green", ParamType::TGLfixed, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha); |
| |
| return CallCapture(gl::EntryPoint::ClearColorx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClearDepthx(const State &glState, bool isCallValid, GLfixed depth) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("depth", ParamType::TGLfixed, depth); |
| |
| return CallCapture(gl::EntryPoint::ClearDepthx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClientActiveTexture(const State &glState, bool isCallValid, GLenum texture) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); |
| |
| return CallCapture(gl::EntryPoint::ClientActiveTexture, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClipPlanef(const State &glState, bool isCallValid, GLenum p, const GLfloat *eqn) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("p", GLenumGroup::ClipPlaneName, ParamType::TGLenum, p); |
| |
| ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, eqn, &eqnParam.value); |
| CaptureClipPlanef_eqn(glState, isCallValid, p, eqn, &eqnParam); |
| paramBuffer.addParam(std::move(eqnParam)); |
| |
| return CallCapture(gl::EntryPoint::ClipPlanef, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureClipPlanex(const State &glState, |
| bool isCallValid, |
| GLenum plane, |
| const GLfixed *equation) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); |
| |
| ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, equation, &equationParam.value); |
| CaptureClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam); |
| paramBuffer.addParam(std::move(equationParam)); |
| |
| return CallCapture(gl::EntryPoint::ClipPlanex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4f(const State &glState, |
| bool isCallValid, |
| GLfloat red, |
| GLfloat green, |
| GLfloat blue, |
| GLfloat alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLfloat, red); |
| paramBuffer.addValueParam("green", ParamType::TGLfloat, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha); |
| |
| return CallCapture(gl::EntryPoint::Color4f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4ub(const State &glState, |
| bool isCallValid, |
| GLubyte red, |
| GLubyte green, |
| GLubyte blue, |
| GLubyte alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLubyte, red); |
| paramBuffer.addValueParam("green", ParamType::TGLubyte, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLubyte, alpha); |
| |
| return CallCapture(gl::EntryPoint::Color4ub, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColor4x(const State &glState, |
| bool isCallValid, |
| GLfixed red, |
| GLfixed green, |
| GLfixed blue, |
| GLfixed alpha) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("red", ParamType::TGLfixed, red); |
| paramBuffer.addValueParam("green", ParamType::TGLfixed, green); |
| paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue); |
| paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha); |
| |
| return CallCapture(gl::EntryPoint::Color4x, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureColorPointer(const State &glState, |
| bool isCallValid, |
| GLint size, |
| VertexAttribType typePacked, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLint, size); |
| paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureColorPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer, |
| &pointerParam); |
| paramBuffer.addParam(std::move(pointerParam)); |
| |
| return CallCapture(gl::EntryPoint::ColorPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDepthRangex(const State &glState, bool isCallValid, GLfixed n, GLfixed f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("n", ParamType::TGLfixed, n); |
| paramBuffer.addValueParam("f", ParamType::TGLfixed, f); |
| |
| return CallCapture(gl::EntryPoint::DepthRangex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureDisableClientState(const State &glState, |
| bool isCallValid, |
| ClientVertexArrayType arrayPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked); |
| |
| return CallCapture(gl::EntryPoint::DisableClientState, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureEnableClientState(const State &glState, |
| bool isCallValid, |
| ClientVertexArrayType arrayPacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked); |
| |
| return CallCapture(gl::EntryPoint::EnableClientState, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::Fogf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogfv(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureFogfv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::Fogfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::Fogx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFogxv(const State &glState, bool isCallValid, GLenum pname, const GLfixed *param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramParam("param", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, param, ¶mParam.value); |
| CaptureFogxv_param(glState, isCallValid, pname, param, ¶mParam); |
| paramBuffer.addParam(std::move(paramParam)); |
| |
| return CallCapture(gl::EntryPoint::Fogxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFrustumf(const State &glState, |
| bool isCallValid, |
| GLfloat l, |
| GLfloat r, |
| GLfloat b, |
| GLfloat t, |
| GLfloat n, |
| GLfloat f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("l", ParamType::TGLfloat, l); |
| paramBuffer.addValueParam("r", ParamType::TGLfloat, r); |
| paramBuffer.addValueParam("b", ParamType::TGLfloat, b); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| paramBuffer.addValueParam("n", ParamType::TGLfloat, n); |
| paramBuffer.addValueParam("f", ParamType::TGLfloat, f); |
| |
| return CallCapture(gl::EntryPoint::Frustumf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureFrustumx(const State &glState, |
| bool isCallValid, |
| GLfixed l, |
| GLfixed r, |
| GLfixed b, |
| GLfixed t, |
| GLfixed n, |
| GLfixed f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("l", ParamType::TGLfixed, l); |
| paramBuffer.addValueParam("r", ParamType::TGLfixed, r); |
| paramBuffer.addValueParam("b", ParamType::TGLfixed, b); |
| paramBuffer.addValueParam("t", ParamType::TGLfixed, t); |
| paramBuffer.addValueParam("n", ParamType::TGLfixed, n); |
| paramBuffer.addValueParam("f", ParamType::TGLfixed, f); |
| |
| return CallCapture(gl::EntryPoint::Frustumx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetClipPlanef(const State &glState, |
| bool isCallValid, |
| GLenum plane, |
| GLfloat *equation) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); |
| |
| ParamCapture equationParam("equation", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, equation, &equationParam.value); |
| CaptureGetClipPlanef_equation(glState, isCallValid, plane, equation, &equationParam); |
| paramBuffer.addParam(std::move(equationParam)); |
| |
| return CallCapture(gl::EntryPoint::GetClipPlanef, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetClipPlanex(const State &glState, |
| bool isCallValid, |
| GLenum plane, |
| GLfixed *equation) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); |
| |
| ParamCapture equationParam("equation", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, equation, &equationParam.value); |
| CaptureGetClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam); |
| paramBuffer.addParam(std::move(equationParam)); |
| |
| return CallCapture(gl::EntryPoint::GetClipPlanex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetFixedv(const State &glState, bool isCallValid, GLenum pname, GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value); |
| CaptureGetFixedv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetFixedv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetLightfv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value); |
| CaptureGetLightfv_params(glState, isCallValid, light, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetLightfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetLightxv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value); |
| CaptureGetLightxv_params(glState, isCallValid, light, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetLightxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMaterialfv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value); |
| CaptureGetMaterialfv_params(glState, isCallValid, face, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetMaterialfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetMaterialxv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value); |
| CaptureGetMaterialxv_params(glState, isCallValid, face, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetMaterialxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexEnvfv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatPointer); |
| InitParamValue(ParamType::TGLfloatPointer, params, ¶msParam.value); |
| CaptureGetTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetTexEnvfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexEnviv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintPointer); |
| InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); |
| CaptureGetTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetTexEnviv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexEnvxv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value); |
| CaptureGetTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetTexEnvxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureGetTexParameterxv(const State &glState, |
| bool isCallValid, |
| TextureType targetPacked, |
| GLenum pname, |
| GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedPointer); |
| InitParamValue(ParamType::TGLfixedPointer, params, ¶msParam.value); |
| CaptureGetTexParameterxv_params(glState, isCallValid, targetPacked, pname, params, |
| ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::GetTexParameterxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModelf(const State &glState, bool isCallValid, GLenum pname, GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::LightModelf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModelfv(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureLightModelfv_params(glState, isCallValid, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::LightModelfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModelx(const State &glState, bool isCallValid, GLenum pname, GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::LightModelx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightModelxv(const State &glState, |
| bool isCallValid, |
| GLenum pname, |
| const GLfixed *param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); |
| |
| ParamCapture paramParam("param", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, param, ¶mParam.value); |
| CaptureLightModelxv_param(glState, isCallValid, pname, param, ¶mParam); |
| paramBuffer.addParam(std::move(paramParam)); |
| |
| return CallCapture(gl::EntryPoint::LightModelxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightf(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::Lightf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightfv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureLightfv_params(glState, isCallValid, light, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::Lightfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightx(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::Lightx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLightxv(const State &glState, |
| bool isCallValid, |
| GLenum light, |
| LightParameter pnamePacked, |
| const GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value); |
| CaptureLightxv_params(glState, isCallValid, light, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::Lightxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLineWidthx(const State &glState, bool isCallValid, GLfixed width) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("width", ParamType::TGLfixed, width); |
| |
| return CallCapture(gl::EntryPoint::LineWidthx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadIdentity(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::LoadIdentity, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLfloat *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value); |
| CaptureLoadMatrixf_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| |
| return CallCapture(gl::EntryPoint::LoadMatrixf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLfixed *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| ParamCapture mParam("m", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value); |
| CaptureLoadMatrixx_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| |
| return CallCapture(gl::EntryPoint::LoadMatrixx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureLogicOp(const State &glState, bool isCallValid, LogicalOperation opcodePacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked); |
| |
| return CallCapture(gl::EntryPoint::LogicOp, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMaterialf(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::Materialf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMaterialfv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureMaterialfv_params(glState, isCallValid, face, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::Materialfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMaterialx(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::Materialx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMaterialxv(const State &glState, |
| bool isCallValid, |
| GLenum face, |
| MaterialParameter pnamePacked, |
| const GLfixed *param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); |
| |
| ParamCapture paramParam("param", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, param, ¶mParam.value); |
| CaptureMaterialxv_param(glState, isCallValid, face, pnamePacked, param, ¶mParam); |
| paramBuffer.addParam(std::move(paramParam)); |
| |
| return CallCapture(gl::EntryPoint::Materialxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMatrixMode(const State &glState, bool isCallValid, MatrixType modePacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TMatrixType, modePacked); |
| |
| return CallCapture(gl::EntryPoint::MatrixMode, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLfloat *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| ParamCapture mParam("m", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value); |
| CaptureMultMatrixf_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| |
| return CallCapture(gl::EntryPoint::MultMatrixf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLfixed *m) |
| { |
| ParamBuffer paramBuffer; |
| |
| ParamCapture mParam("m", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value); |
| CaptureMultMatrixx_m(glState, isCallValid, m, &mParam); |
| paramBuffer.addParam(std::move(mParam)); |
| |
| return CallCapture(gl::EntryPoint::MultMatrixx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4f(const State &glState, |
| bool isCallValid, |
| GLenum target, |
| GLfloat s, |
| GLfloat t, |
| GLfloat r, |
| GLfloat q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); |
| paramBuffer.addValueParam("s", ParamType::TGLfloat, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| paramBuffer.addValueParam("r", ParamType::TGLfloat, r); |
| paramBuffer.addValueParam("q", ParamType::TGLfloat, q); |
| |
| return CallCapture(gl::EntryPoint::MultiTexCoord4f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureMultiTexCoord4x(const State &glState, |
| bool isCallValid, |
| GLenum texture, |
| GLfixed s, |
| GLfixed t, |
| GLfixed r, |
| GLfixed q) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); |
| paramBuffer.addValueParam("s", ParamType::TGLfixed, s); |
| paramBuffer.addValueParam("t", ParamType::TGLfixed, t); |
| paramBuffer.addValueParam("r", ParamType::TGLfixed, r); |
| paramBuffer.addValueParam("q", ParamType::TGLfixed, q); |
| |
| return CallCapture(gl::EntryPoint::MultiTexCoord4x, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3f(const State &glState, |
| bool isCallValid, |
| GLfloat nx, |
| GLfloat ny, |
| GLfloat nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLfloat, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLfloat, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLfloat, nz); |
| |
| return CallCapture(gl::EntryPoint::Normal3f, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormal3x(const State &glState, |
| bool isCallValid, |
| GLfixed nx, |
| GLfixed ny, |
| GLfixed nz) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("nx", ParamType::TGLfixed, nx); |
| paramBuffer.addValueParam("ny", ParamType::TGLfixed, ny); |
| paramBuffer.addValueParam("nz", ParamType::TGLfixed, nz); |
| |
| return CallCapture(gl::EntryPoint::Normal3x, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureNormalPointer(const State &glState, |
| bool isCallValid, |
| VertexAttribType typePacked, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureNormalPointer_pointer(glState, isCallValid, typePacked, stride, pointer, &pointerParam); |
| paramBuffer.addParam(std::move(pointerParam)); |
| |
| return CallCapture(gl::EntryPoint::NormalPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureOrthof(const State &glState, |
| bool isCallValid, |
| GLfloat l, |
| GLfloat r, |
| GLfloat b, |
| GLfloat t, |
| GLfloat n, |
| GLfloat f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("l", ParamType::TGLfloat, l); |
| paramBuffer.addValueParam("r", ParamType::TGLfloat, r); |
| paramBuffer.addValueParam("b", ParamType::TGLfloat, b); |
| paramBuffer.addValueParam("t", ParamType::TGLfloat, t); |
| paramBuffer.addValueParam("n", ParamType::TGLfloat, n); |
| paramBuffer.addValueParam("f", ParamType::TGLfloat, f); |
| |
| return CallCapture(gl::EntryPoint::Orthof, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureOrthox(const State &glState, |
| bool isCallValid, |
| GLfixed l, |
| GLfixed r, |
| GLfixed b, |
| GLfixed t, |
| GLfixed n, |
| GLfixed f) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("l", ParamType::TGLfixed, l); |
| paramBuffer.addValueParam("r", ParamType::TGLfixed, r); |
| paramBuffer.addValueParam("b", ParamType::TGLfixed, b); |
| paramBuffer.addValueParam("t", ParamType::TGLfixed, t); |
| paramBuffer.addValueParam("n", ParamType::TGLfixed, n); |
| paramBuffer.addValueParam("f", ParamType::TGLfixed, f); |
| |
| return CallCapture(gl::EntryPoint::Orthox, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameterf(const State &glState, |
| bool isCallValid, |
| PointParameter pnamePacked, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::PointParameterf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameterfv(const State &glState, |
| bool isCallValid, |
| PointParameter pnamePacked, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CapturePointParameterfv_params(glState, isCallValid, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::PointParameterfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameterx(const State &glState, |
| bool isCallValid, |
| PointParameter pnamePacked, |
| GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::PointParameterx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointParameterxv(const State &glState, |
| bool isCallValid, |
| PointParameter pnamePacked, |
| const GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value); |
| CapturePointParameterxv_params(glState, isCallValid, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::PointParameterxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointSize(const State &glState, bool isCallValid, GLfloat size) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLfloat, size); |
| |
| return CallCapture(gl::EntryPoint::PointSize, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePointSizex(const State &glState, bool isCallValid, GLfixed size) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLfixed, size); |
| |
| return CallCapture(gl::EntryPoint::PointSizex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePolygonOffsetx(const State &glState, |
| bool isCallValid, |
| GLfixed factor, |
| GLfixed units) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("factor", ParamType::TGLfixed, factor); |
| paramBuffer.addValueParam("units", ParamType::TGLfixed, units); |
| |
| return CallCapture(gl::EntryPoint::PolygonOffsetx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePopMatrix(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::PopMatrix, std::move(paramBuffer)); |
| } |
| |
| CallCapture CapturePushMatrix(const State &glState, bool isCallValid) |
| { |
| ParamBuffer paramBuffer; |
| |
| return CallCapture(gl::EntryPoint::PushMatrix, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRotatef(const State &glState, |
| bool isCallValid, |
| GLfloat angle, |
| GLfloat x, |
| GLfloat y, |
| GLfloat z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("angle", ParamType::TGLfloat, angle); |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfloat, z); |
| |
| return CallCapture(gl::EntryPoint::Rotatef, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureRotatex(const State &glState, |
| bool isCallValid, |
| GLfixed angle, |
| GLfixed x, |
| GLfixed y, |
| GLfixed z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("angle", ParamType::TGLfixed, angle); |
| paramBuffer.addValueParam("x", ParamType::TGLfixed, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfixed, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfixed, z); |
| |
| return CallCapture(gl::EntryPoint::Rotatex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureSampleCoveragex(const State &glState, |
| bool isCallValid, |
| GLclampx value, |
| GLboolean invert) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("value", ParamType::TGLclampx, value); |
| paramBuffer.addValueParam("invert", ParamType::TGLboolean, invert); |
| |
| return CallCapture(gl::EntryPoint::SampleCoveragex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureScalef(const State &glState, bool isCallValid, GLfloat x, GLfloat y, GLfloat z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfloat, z); |
| |
| return CallCapture(gl::EntryPoint::Scalef, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureScalex(const State &glState, bool isCallValid, GLfixed x, GLfixed y, GLfixed z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfixed, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfixed, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfixed, z); |
| |
| return CallCapture(gl::EntryPoint::Scalex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureShadeModel(const State &glState, bool isCallValid, ShadingModel modePacked) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("modePacked", ParamType::TShadingModel, modePacked); |
| |
| return CallCapture(gl::EntryPoint::ShadeModel, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexCoordPointer(const State &glState, |
| bool isCallValid, |
| GLint size, |
| VertexAttribType typePacked, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLint, size); |
| paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureTexCoordPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer, |
| &pointerParam); |
| paramBuffer.addParam(std::move(pointerParam)); |
| |
| return CallCapture(gl::EntryPoint::TexCoordPointer, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnvf(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLfloat param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfloat, param); |
| |
| return CallCapture(gl::EntryPoint::TexEnvf, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnvfv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| const GLfloat *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer); |
| InitParamValue(ParamType::TGLfloatConstPointer, params, ¶msParam.value); |
| CaptureTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexEnvfv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnvi(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLint param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLint, param); |
| |
| return CallCapture(gl::EntryPoint::TexEnvi, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnviv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| const GLint *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLintConstPointer); |
| InitParamValue(ParamType::TGLintConstPointer, params, ¶msParam.value); |
| CaptureTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexEnviv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnvx(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::TexEnvx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexEnvxv(const State &glState, |
| bool isCallValid, |
| TextureEnvTarget targetPacked, |
| TextureEnvParameter pnamePacked, |
| const GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked); |
| paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value); |
| CaptureTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexEnvxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexParameterx(const State &glState, |
| bool isCallValid, |
| TextureType targetPacked, |
| GLenum pname, |
| GLfixed param) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); |
| paramBuffer.addValueParam("param", ParamType::TGLfixed, param); |
| |
| return CallCapture(gl::EntryPoint::TexParameterx, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTexParameterxv(const State &glState, |
| bool isCallValid, |
| TextureType targetPacked, |
| GLenum pname, |
| const GLfixed *params) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); |
| paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); |
| |
| ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer); |
| InitParamValue(ParamType::TGLfixedConstPointer, params, ¶msParam.value); |
| CaptureTexParameterxv_params(glState, isCallValid, targetPacked, pname, params, ¶msParam); |
| paramBuffer.addParam(std::move(paramsParam)); |
| |
| return CallCapture(gl::EntryPoint::TexParameterxv, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTranslatef(const State &glState, |
| bool isCallValid, |
| GLfloat x, |
| GLfloat y, |
| GLfloat z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfloat, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfloat, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfloat, z); |
| |
| return CallCapture(gl::EntryPoint::Translatef, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureTranslatex(const State &glState, |
| bool isCallValid, |
| GLfixed x, |
| GLfixed y, |
| GLfixed z) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("x", ParamType::TGLfixed, x); |
| paramBuffer.addValueParam("y", ParamType::TGLfixed, y); |
| paramBuffer.addValueParam("z", ParamType::TGLfixed, z); |
| |
| return CallCapture(gl::EntryPoint::Translatex, std::move(paramBuffer)); |
| } |
| |
| CallCapture CaptureVertexPointer(const State &glState, |
| bool isCallValid, |
| GLint size, |
| VertexAttribType typePacked, |
| GLsizei stride, |
| const void *pointer) |
| { |
| ParamBuffer paramBuffer; |
| |
| paramBuffer.addValueParam("size", ParamType::TGLint, size); |
| paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked); |
| paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); |
| |
| ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer); |
| InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value); |
| CaptureVertexPointer_pointer(glState, isCallValid, size, typePacked, stride, pointer, |
| &pointerParam); |
| paramBuffer.addParam(std::move(pointerParam)); |
| |
| return CallCapture(gl::EntryPoint::VertexPointer, std::move(paramBuffer)); |
| } |
| |
| } // namespace gl |