Skip to content

A
angle
Commit bbfbea9d by Manh Nguyen Committed by Commit Bot
Options

Invalid calls' pointer params are no longer captured

Changes call capture methods generation so that invalid calls no longer capture pointer params. Bug: angleproject:4817 Change-Id: I2d83d4d3334da8ba34925f80aed2de859a10fae5 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2346749 Commit-Queue: Manh Nguyen <nguyenmh@google.com> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com>
parent f9de2e20
Showing with 2697 additions and 144 deletions
scripts/code_generation_hashes/GL_EGL_entry_points.json
......@@ -6,7 +6,7 @@
"scripts/entry_point_packed_gl_enums.json":
"776bf87905f92e8bc21abfceb2ccf723",
"scripts/generate_entry_points.py":
"e12540094b7f57778de97b05c16d2e28",
"a324715209392c00e7b7dcf978d8be8b",
"scripts/gl.xml":
"e74a595068cbdd6064300be1e71b7cc9",
"scripts/gl_angle_ext.xml":
......@@ -66,27 +66,27 @@
"src/libANGLE/Context_gles_ext_autogen.h":
"803fd99c6dd45aeeac2245c5e72f6407",
"src/libANGLE/capture_gles_1_0_autogen.cpp":
"96fc0f501e2e696ab911dad8b400dfb2",
"1ee3e4aceb1afa9585aa458c600665a9",
"src/libANGLE/capture_gles_1_0_autogen.h":
"546173090c85ad28a580ca76cd117484",
"src/libANGLE/capture_gles_2_0_autogen.cpp":
"9e47542f50b29581f5fcaf5a69f6b518",
"d512df459dbc2e61f26c2ebb5330eba8",
"src/libANGLE/capture_gles_2_0_autogen.h":
"6985d5e3d0126bc8e02dd982267a904f",
"src/libANGLE/capture_gles_3_0_autogen.cpp":
"a12c9470569b9d1d63ab0b8be910055f",
"6447ab4c579f717a25f86ce3815e49c3",
"src/libANGLE/capture_gles_3_0_autogen.h":
"b963fec070e0becdcf4af69216cd1c7b",
"src/libANGLE/capture_gles_3_1_autogen.cpp":
"c7c4ee0fcebc9bd19f8f4a498f935ac1",
"3cd86e846ed49e68f149805a0ddfea8d",
"src/libANGLE/capture_gles_3_1_autogen.h":
"3d363f4de97b47ecff61e29939dcf11a",
"src/libANGLE/capture_gles_3_2_autogen.cpp":
"e0eced5b0e039ee7f800878b9a1c18ee",
"5b761dc394b15edeb077fa31faacf083",
"src/libANGLE/capture_gles_3_2_autogen.h":
"3d8f561944c8e5c06c7c9e68559ff364",
"src/libANGLE/capture_gles_ext_autogen.cpp":
"8175da2b610b2efd4cd0618b8891ddea",
"a392c54277ac3f609ea31095fe690287",
"src/libANGLE/capture_gles_ext_autogen.h":
"39ba68d335d2a9b1227229c644d8acd1",
"src/libANGLE/entry_points_enum_autogen.cpp":
......
scripts/generate_entry_points.py
......@@ -338,10 +338,19 @@ template_parameter_capture_value = """paramBuffer.addValueParam("{name}", ParamT
template_parameter_capture_gl_enum = """paramBuffer.addEnumParam("{name}", GLenumGroup::{group}, ParamType::T{type}, {name});"""
template_parameter_capture_pointer = """
if (isCallValid)
{{
ParamCapture {name}Param("{name}", ParamType::T{type});
InitParamValue(ParamType::T{type}, {name}, &{name}Param.value);
{capture_name}({params}, &{name}Param);
paramBuffer.addParam(std::move({name}Param));
}}
else
{{
ParamCapture {name}Param("{name}", ParamType::T{type});
InitParamValue(ParamType::T{type}, static_cast<{cast_type}>(nullptr), &{name}Param.value);
paramBuffer.addParam(std::move({name}Param));
}}
"""
template_parameter_capture_pointer_func = """void {name}({params});"""
......@@ -674,7 +683,6 @@ template_param_type_to_resource_id_type_case = """ case ParamType::T{enum
template_resource_id_type_name_case = """ case ResourceIDType::{resource_id_type}:
return "{resource_id_type}";"""
def script_relative(path):
return os.path.join(os.path.dirname(sys.argv[0]), path)
......@@ -909,27 +917,31 @@ def format_capture_method(command, cmd_name, proto, params, all_param_types, cap
param_name = just_the_name_packed(param, packed_gl_enums)
param_type = just_the_type_packed(param, packed_gl_enums).strip()
pointer_count = param_type.count("*")
param_type = get_capture_param_type_name(param_type)
capture_param_type = get_capture_param_type_name(param_type)
if pointer_count > 0:
params = params_just_name
capture_name = "Capture%s_%s" % (cmd_name[2:], param_name)
capture = template_parameter_capture_pointer.format(
name=param_name, type=param_type, capture_name=capture_name, params=params)
name=param_name,
type=capture_param_type,
capture_name=capture_name,
params=params,
cast_type=param_type)
capture_pointer_func = template_parameter_capture_pointer_func.format(
name=capture_name, params=params_with_type + ", angle::ParamCapture *paramCapture")
capture_pointer_funcs += [capture_pointer_func]
elif param_type in ('GLenum', 'GLbitfield'):
elif capture_param_type in ('GLenum', 'GLbitfield'):
gl_enum_group = find_gl_enum_group_in_command(command, param_name)
capture = template_parameter_capture_gl_enum.format(
name=param_name, type=param_type, group=gl_enum_group)
name=param_name, type=capture_param_type, group=gl_enum_group)
else:
capture = template_parameter_capture_value.format(name=param_name, type=param_type)
capture = template_parameter_capture_value.format(
name=param_name, type=capture_param_type)
all_param_types.add(param_type)
all_param_types.add(capture_param_type)
parameter_captures += [capture]
......
src/libANGLE/capture_gles_1_0_autogen.cpp
......@@ -87,10 +87,20 @@ CallCapture CaptureClipPlanef(const State &glState, bool isCallValid, GLenum p,
paramBuffer.addEnumParam("p", GLenumGroup::ClipPlaneName, ParamType::TGLenum, p);
if (isCallValid)
{
ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, eqn, &eqnParam.value);
CaptureClipPlanef_eqn(glState, isCallValid, p, eqn, &eqnParam);
paramBuffer.addParam(std::move(eqnParam));
}
else
{
ParamCapture eqnParam("eqn", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&eqnParam.value);
paramBuffer.addParam(std::move(eqnParam));
}
return CallCapture(gl::EntryPoint::ClipPlanef, std::move(paramBuffer));
}
......@@ -104,10 +114,20 @@ CallCapture CaptureClipPlanex(const State &glState,
paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
if (isCallValid)
{
ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, equation, &equationParam.value);
CaptureClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
paramBuffer.addParam(std::move(equationParam));
}
else
{
ParamCapture equationParam("equation", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&equationParam.value);
paramBuffer.addParam(std::move(equationParam));
}
return CallCapture(gl::EntryPoint::ClipPlanex, std::move(paramBuffer));
}
......@@ -176,11 +196,21 @@ CallCapture CaptureColorPointer(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
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));
}
else
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&pointerParam.value);
paramBuffer.addParam(std::move(pointerParam));
}
return CallCapture(gl::EntryPoint::ColorPointer, std::move(paramBuffer));
}
......@@ -236,10 +266,20 @@ CallCapture CaptureFogfv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureFogfv_params(glState, isCallValid, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::Fogfv, std::move(paramBuffer));
}
......@@ -260,10 +300,20 @@ CallCapture CaptureFogxv(const State &glState, bool isCallValid, GLenum pname, c
paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
CaptureFogxv_param(glState, isCallValid, pname, param, &paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::Fogxv, std::move(paramBuffer));
}
......@@ -319,10 +369,20 @@ CallCapture CaptureGetClipPlanef(const State &glState,
paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
if (isCallValid)
{
ParamCapture equationParam("equation", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, equation, &equationParam.value);
CaptureGetClipPlanef_equation(glState, isCallValid, plane, equation, &equationParam);
paramBuffer.addParam(std::move(equationParam));
}
else
{
ParamCapture equationParam("equation", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&equationParam.value);
paramBuffer.addParam(std::move(equationParam));
}
return CallCapture(gl::EntryPoint::GetClipPlanef, std::move(paramBuffer));
}
......@@ -336,10 +396,20 @@ CallCapture CaptureGetClipPlanex(const State &glState,
paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane);
if (isCallValid)
{
ParamCapture equationParam("equation", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, equation, &equationParam.value);
CaptureGetClipPlanex_equation(glState, isCallValid, plane, equation, &equationParam);
paramBuffer.addParam(std::move(equationParam));
}
else
{
ParamCapture equationParam("equation", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&equationParam.value);
paramBuffer.addParam(std::move(equationParam));
}
return CallCapture(gl::EntryPoint::GetClipPlanex, std::move(paramBuffer));
}
......@@ -350,10 +420,20 @@ CallCapture CaptureGetFixedv(const State &glState, bool isCallValid, GLenum pnam
paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
CaptureGetFixedv_params(glState, isCallValid, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetFixedv, std::move(paramBuffer));
}
......@@ -369,10 +449,20 @@ CallCapture CaptureGetLightfv(const State &glState,
paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetLightfv, std::move(paramBuffer));
}
......@@ -388,10 +478,20 @@ CallCapture CaptureGetLightxv(const State &glState,
paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
CaptureGetLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetLightxv, std::move(paramBuffer));
}
......@@ -407,10 +507,20 @@ CallCapture CaptureGetMaterialfv(const State &glState,
paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetMaterialfv, std::move(paramBuffer));
}
......@@ -426,10 +536,20 @@ CallCapture CaptureGetMaterialxv(const State &glState,
paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
CaptureGetMaterialxv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetMaterialxv, std::move(paramBuffer));
}
......@@ -445,11 +565,21 @@ CallCapture CaptureGetTexEnvfv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexEnvfv, std::move(paramBuffer));
}
......@@ -465,11 +595,20 @@ CallCapture CaptureGetTexEnviv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexEnviv, std::move(paramBuffer));
}
......@@ -485,11 +624,21 @@ CallCapture CaptureGetTexEnvxv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
CaptureGetTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexEnvxv, std::move(paramBuffer));
}
......@@ -505,11 +654,21 @@ CallCapture CaptureGetTexParameterxv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, params, &paramsParam.value);
CaptureGetTexParameterxv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedPointer);
InitParamValue(ParamType::TGLfixedPointer, static_cast<GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexParameterxv, std::move(paramBuffer));
}
......@@ -533,10 +692,20 @@ CallCapture CaptureLightModelfv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureLightModelfv_params(glState, isCallValid, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::LightModelfv, std::move(paramBuffer));
}
......@@ -560,10 +729,20 @@ CallCapture CaptureLightModelxv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
CaptureLightModelxv_param(glState, isCallValid, pname, param, &paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::LightModelxv, std::move(paramBuffer));
}
......@@ -594,10 +773,20 @@ CallCapture CaptureLightfv(const State &glState,
paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureLightfv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::Lightfv, std::move(paramBuffer));
}
......@@ -628,10 +817,20 @@ CallCapture CaptureLightxv(const State &glState,
paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light);
paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
CaptureLightxv_params(glState, isCallValid, light, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::Lightxv, std::move(paramBuffer));
}
......@@ -656,10 +855,20 @@ CallCapture CaptureLoadMatrixf(const State &glState, bool isCallValid, const GLf
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
CaptureLoadMatrixf_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(gl::EntryPoint::LoadMatrixf, std::move(paramBuffer));
}
......@@ -668,10 +877,20 @@ CallCapture CaptureLoadMatrixx(const State &glState, bool isCallValid, const GLf
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
CaptureLoadMatrixx_m(glState, isCallValid, m, &mParam);
paramBuffer.addParam(std::move(mParam));
}
else
{
ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&mParam.value);
paramBuffer.addParam(std::move(mParam));
}
return CallCapture(gl::EntryPoint::LoadMatrixx, std::move(paramBuffer));
}
......@@ -711,10 +930,20 @@ CallCapture CaptureMaterialfv(const State &glState,
paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureMaterialfv_params(glState, isCallValid, face, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::Materialfv, std::move(paramBuffer));
}
......@@ -745,10 +974,20 @@ CallCapture CaptureMaterialxv(const State &glState,
paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face);
paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, param, &paramParam.value);
CaptureMaterialxv_param(glState, isCallValid, face, pnamePacked, param, &paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::Materialxv, std::move(paramBuffer));
}
......@@ -766,10 +1005,20 @@ CallCapture CaptureMultMatrixf(const State &glState, bool isCallValid, const GLf
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture mParam("m", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, m, &mParam.value);
CaptureMultMatrixf_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(gl::EntryPoint::MultMatrixf, std::move(paramBuffer));
}
......@@ -778,10 +1027,20 @@ CallCapture CaptureMultMatrixx(const State &glState, bool isCallValid, const GLf
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, m, &mParam.value);
CaptureMultMatrixx_m(glState, isCallValid, m, &mParam);
paramBuffer.addParam(std::move(mParam));
}
else
{
ParamCapture mParam("m", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&mParam.value);
paramBuffer.addParam(std::move(mParam));
}
return CallCapture(gl::EntryPoint::MultMatrixx, std::move(paramBuffer));
}
......@@ -865,10 +1124,21 @@ CallCapture CaptureNormalPointer(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
CaptureNormalPointer_pointer(glState, isCallValid, typePacked, stride, pointer, &pointerParam);
CaptureNormalPointer_pointer(glState, isCallValid, typePacked, 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(gl::EntryPoint::NormalPointer, std::move(paramBuffer));
}
......@@ -937,10 +1207,20 @@ CallCapture CapturePointParameterfv(const State &glState,
paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CapturePointParameterfv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::PointParameterfv, std::move(paramBuffer));
}
......@@ -967,10 +1247,20 @@ CallCapture CapturePointParameterxv(const State &glState,
paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
CapturePointParameterxv_params(glState, isCallValid, pnamePacked, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::PointParameterxv, std::move(paramBuffer));
}
......@@ -1111,11 +1401,21 @@ CallCapture CaptureTexCoordPointer(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
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));
}
else
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&pointerParam.value);
paramBuffer.addParam(std::move(pointerParam));
}
return CallCapture(gl::EntryPoint::TexCoordPointer, std::move(paramBuffer));
}
......@@ -1146,10 +1446,21 @@ CallCapture CaptureTexEnvfv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
CaptureTexEnvfv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexEnvfv, std::move(paramBuffer));
}
......@@ -1180,10 +1491,21 @@ CallCapture CaptureTexEnviv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
CaptureTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
CaptureTexEnviv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexEnviv, std::move(paramBuffer));
}
......@@ -1214,10 +1536,21 @@ CallCapture CaptureTexEnvxv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureEnvTarget, targetPacked);
paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
CaptureTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
CaptureTexEnvxv_params(glState, isCallValid, targetPacked, pnamePacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexEnvxv, std::move(paramBuffer));
}
......@@ -1248,10 +1581,21 @@ CallCapture CaptureTexParameterxv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, params, &paramsParam.value);
CaptureTexParameterxv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
CaptureTexParameterxv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfixedConstPointer);
InitParamValue(ParamType::TGLfixedConstPointer, static_cast<const GLfixed *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexParameterxv, std::move(paramBuffer));
}
......@@ -1299,11 +1643,21 @@ CallCapture CaptureVertexPointer(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
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));
}
else
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&pointerParam.value);
paramBuffer.addParam(std::move(pointerParam));
}
return CallCapture(gl::EntryPoint::VertexPointer, std::move(paramBuffer));
}
......
src/libANGLE/capture_gles_2_0_autogen.cpp
......@@ -53,10 +53,21 @@ CallCapture CaptureBindAttribLocation(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureBindAttribLocation_name(glState, isCallValid, programPacked, index, name, &nameParam);
CaptureBindAttribLocation_name(glState, isCallValid, programPacked, index, name,
&nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
return CallCapture(gl::EntryPoint::BindAttribLocation, std::move(paramBuffer));
}
......@@ -197,10 +208,21 @@ CallCapture CaptureBufferData(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
CaptureBufferData_data(glState, isCallValid, targetPacked, size, data, usagePacked, &dataParam);
CaptureBufferData_data(glState, isCallValid, targetPacked, size, data, usagePacked,
&dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
paramBuffer.addValueParam("usagePacked", ParamType::TBufferUsage, usagePacked);
......@@ -220,10 +242,21 @@ CallCapture CaptureBufferSubData(const State &glState,
paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
CaptureBufferSubData_data(glState, isCallValid, targetPacked, offset, size, data, &dataParam);
CaptureBufferSubData_data(glState, isCallValid, targetPacked, offset, size, data,
&dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::BufferSubData, std::move(paramBuffer));
}
......@@ -338,11 +371,21 @@ CallCapture CaptureCompressedTexImage2D(const State &glState,
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);
CaptureCompressedTexImage2D_data(glState, isCallValid, targetPacked, level, internalformat,
width, height, 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(gl::EntryPoint::CompressedTexImage2D, std::move(paramBuffer));
}
......@@ -370,11 +413,22 @@ CallCapture CaptureCompressedTexSubImage2D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
CaptureCompressedTexSubImage2D_data(glState, isCallValid, targetPacked, level, xoffset, yoffset,
width, height, format, imageSize, data, &dataParam);
CaptureCompressedTexSubImage2D_data(glState, isCallValid, targetPacked, level, xoffset,
yoffset, width, height, format, imageSize, data,
&dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::CompressedTexSubImage2D, std::move(paramBuffer));
}
......@@ -475,10 +529,21 @@ CallCapture CaptureDeleteBuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
InitParamValue(ParamType::TBufferIDConstPointer, buffersPacked, &buffersPackedParam.value);
CaptureDeleteBuffers_buffersPacked(glState, isCallValid, n, buffersPacked, &buffersPackedParam);
CaptureDeleteBuffers_buffersPacked(glState, isCallValid, n, buffersPacked,
&buffersPackedParam);
paramBuffer.addParam(std::move(buffersPackedParam));
}
else
{
ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDConstPointer);
InitParamValue(ParamType::TBufferIDConstPointer, static_cast<const BufferID *>(nullptr),
&buffersPackedParam.value);
paramBuffer.addParam(std::move(buffersPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteBuffers, std::move(paramBuffer));
}
......@@ -492,6 +557,8 @@ CallCapture CaptureDeleteFramebuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture framebuffersPackedParam("framebuffersPacked",
ParamType::TFramebufferIDConstPointer);
InitParamValue(ParamType::TFramebufferIDConstPointer, framebuffersPacked,
......@@ -499,6 +566,15 @@ CallCapture CaptureDeleteFramebuffers(const State &glState,
CaptureDeleteFramebuffers_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
&framebuffersPackedParam);
paramBuffer.addParam(std::move(framebuffersPackedParam));
}
else
{
ParamCapture framebuffersPackedParam("framebuffersPacked",
ParamType::TFramebufferIDConstPointer);
InitParamValue(ParamType::TFramebufferIDConstPointer,
static_cast<const FramebufferID *>(nullptr), &framebuffersPackedParam.value);
paramBuffer.addParam(std::move(framebuffersPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteFramebuffers, std::move(paramBuffer));
}
......@@ -523,6 +599,8 @@ CallCapture CaptureDeleteRenderbuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture renderbuffersPackedParam("renderbuffersPacked",
ParamType::TRenderbufferIDConstPointer);
InitParamValue(ParamType::TRenderbufferIDConstPointer, renderbuffersPacked,
......@@ -530,6 +608,16 @@ CallCapture CaptureDeleteRenderbuffers(const State &glState,
CaptureDeleteRenderbuffers_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
&renderbuffersPackedParam);
paramBuffer.addParam(std::move(renderbuffersPackedParam));
}
else
{
ParamCapture renderbuffersPackedParam("renderbuffersPacked",
ParamType::TRenderbufferIDConstPointer);
InitParamValue(ParamType::TRenderbufferIDConstPointer,
static_cast<const RenderbufferID *>(nullptr),
&renderbuffersPackedParam.value);
paramBuffer.addParam(std::move(renderbuffersPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteRenderbuffers, std::move(paramBuffer));
}
......@@ -554,11 +642,22 @@ CallCapture CaptureDeleteTextures(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked, &texturesPackedParam.value);
InitParamValue(ParamType::TTextureIDConstPointer, texturesPacked,
&texturesPackedParam.value);
CaptureDeleteTextures_texturesPacked(glState, isCallValid, n, texturesPacked,
&texturesPackedParam);
paramBuffer.addParam(std::move(texturesPackedParam));
}
else
{
ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDConstPointer);
InitParamValue(ParamType::TTextureIDConstPointer, static_cast<const TextureID *>(nullptr),
&texturesPackedParam.value);
paramBuffer.addParam(std::move(texturesPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteTextures, std::move(paramBuffer));
}
......@@ -650,11 +749,21 @@ CallCapture CaptureDrawElements(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawElements_indices(glState, isCallValid, modePacked, count, typePacked, indices,
&indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
return CallCapture(gl::EntryPoint::DrawElements, std::move(paramBuffer));
}
......@@ -748,10 +857,21 @@ CallCapture CaptureGenBuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDPointer);
InitParamValue(ParamType::TBufferIDPointer, buffersPacked, &buffersPackedParam.value);
CaptureGenBuffers_buffersPacked(glState, isCallValid, n, buffersPacked, &buffersPackedParam);
CaptureGenBuffers_buffersPacked(glState, isCallValid, n, buffersPacked,
&buffersPackedParam);
paramBuffer.addParam(std::move(buffersPackedParam));
}
else
{
ParamCapture buffersPackedParam("buffersPacked", ParamType::TBufferIDPointer);
InitParamValue(ParamType::TBufferIDPointer, static_cast<BufferID *>(nullptr),
&buffersPackedParam.value);
paramBuffer.addParam(std::move(buffersPackedParam));
}
return CallCapture(gl::EntryPoint::GenBuffers, std::move(paramBuffer));
}
......@@ -765,12 +885,24 @@ CallCapture CaptureGenFramebuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
ParamCapture framebuffersPackedParam("framebuffersPacked", ParamType::TFramebufferIDPointer);
if (isCallValid)
{
ParamCapture framebuffersPackedParam("framebuffersPacked",
ParamType::TFramebufferIDPointer);
InitParamValue(ParamType::TFramebufferIDPointer, framebuffersPacked,
&framebuffersPackedParam.value);
CaptureGenFramebuffers_framebuffersPacked(glState, isCallValid, n, framebuffersPacked,
&framebuffersPackedParam);
paramBuffer.addParam(std::move(framebuffersPackedParam));
}
else
{
ParamCapture framebuffersPackedParam("framebuffersPacked",
ParamType::TFramebufferIDPointer);
InitParamValue(ParamType::TFramebufferIDPointer, static_cast<FramebufferID *>(nullptr),
&framebuffersPackedParam.value);
paramBuffer.addParam(std::move(framebuffersPackedParam));
}
return CallCapture(gl::EntryPoint::GenFramebuffers, std::move(paramBuffer));
}
......@@ -784,12 +916,24 @@ CallCapture CaptureGenRenderbuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
ParamCapture renderbuffersPackedParam("renderbuffersPacked", ParamType::TRenderbufferIDPointer);
if (isCallValid)
{
ParamCapture renderbuffersPackedParam("renderbuffersPacked",
ParamType::TRenderbufferIDPointer);
InitParamValue(ParamType::TRenderbufferIDPointer, renderbuffersPacked,
&renderbuffersPackedParam.value);
CaptureGenRenderbuffers_renderbuffersPacked(glState, isCallValid, n, renderbuffersPacked,
&renderbuffersPackedParam);
paramBuffer.addParam(std::move(renderbuffersPackedParam));
}
else
{
ParamCapture renderbuffersPackedParam("renderbuffersPacked",
ParamType::TRenderbufferIDPointer);
InitParamValue(ParamType::TRenderbufferIDPointer, static_cast<RenderbufferID *>(nullptr),
&renderbuffersPackedParam.value);
paramBuffer.addParam(std::move(renderbuffersPackedParam));
}
return CallCapture(gl::EntryPoint::GenRenderbuffers, std::move(paramBuffer));
}
......@@ -803,11 +947,21 @@ CallCapture CaptureGenTextures(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDPointer);
InitParamValue(ParamType::TTextureIDPointer, texturesPacked, &texturesPackedParam.value);
CaptureGenTextures_texturesPacked(glState, isCallValid, n, texturesPacked,
&texturesPackedParam);
paramBuffer.addParam(std::move(texturesPackedParam));
}
else
{
ParamCapture texturesPackedParam("texturesPacked", ParamType::TTextureIDPointer);
InitParamValue(ParamType::TTextureIDPointer, static_cast<TextureID *>(nullptr),
&texturesPackedParam.value);
paramBuffer.addParam(std::move(texturesPackedParam));
}
return CallCapture(gl::EntryPoint::GenTextures, std::move(paramBuffer));
}
......@@ -837,29 +991,66 @@ CallCapture CaptureGetActiveAttrib(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetActiveAttrib_length(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &lengthParam);
CaptureGetActiveAttrib_length(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture sizeParam("size", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, size, &sizeParam.value);
CaptureGetActiveAttrib_size(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &sizeParam);
CaptureGetActiveAttrib_size(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &sizeParam);
paramBuffer.addParam(std::move(sizeParam));
}
else
{
ParamCapture sizeParam("size", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &sizeParam.value);
paramBuffer.addParam(std::move(sizeParam));
}
if (isCallValid)
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, type, &typeParam.value);
CaptureGetActiveAttrib_type(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &typeParam);
CaptureGetActiveAttrib_type(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &typeParam);
paramBuffer.addParam(std::move(typeParam));
}
else
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr), &typeParam.value);
paramBuffer.addParam(std::move(typeParam));
}
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
CaptureGetActiveAttrib_name(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &nameParam);
CaptureGetActiveAttrib_name(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
return CallCapture(gl::EntryPoint::GetActiveAttrib, std::move(paramBuffer));
}
......@@ -880,29 +1071,66 @@ CallCapture CaptureGetActiveUniform(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetActiveUniform_length(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture sizeParam("size", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, size, &sizeParam.value);
CaptureGetActiveUniform_size(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &sizeParam);
CaptureGetActiveUniform_size(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &sizeParam);
paramBuffer.addParam(std::move(sizeParam));
}
else
{
ParamCapture sizeParam("size", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &sizeParam.value);
paramBuffer.addParam(std::move(sizeParam));
}
if (isCallValid)
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, type, &typeParam.value);
CaptureGetActiveUniform_type(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &typeParam);
CaptureGetActiveUniform_type(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &typeParam);
paramBuffer.addParam(std::move(typeParam));
}
else
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr), &typeParam.value);
paramBuffer.addParam(std::move(typeParam));
}
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
CaptureGetActiveUniform_name(glState, isCallValid, programPacked, index, bufSize, length, size,
type, name, &nameParam);
CaptureGetActiveUniform_name(glState, isCallValid, programPacked, index, bufSize, length,
size, type, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
return CallCapture(gl::EntryPoint::GetActiveUniform, std::move(paramBuffer));
}
......@@ -919,17 +1147,38 @@ CallCapture CaptureGetAttachedShaders(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("maxCount", ParamType::TGLsizei, maxCount);
if (isCallValid)
{
ParamCapture countParam("count", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, count, &countParam.value);
CaptureGetAttachedShaders_count(glState, isCallValid, programPacked, maxCount, count,
shadersPacked, &countParam);
paramBuffer.addParam(std::move(countParam));
}
else
{
ParamCapture countParam("count", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&countParam.value);
paramBuffer.addParam(std::move(countParam));
}
if (isCallValid)
{
ParamCapture shadersPackedParam("shadersPacked", ParamType::TShaderProgramIDPointer);
InitParamValue(ParamType::TShaderProgramIDPointer, shadersPacked,
&shadersPackedParam.value);
CaptureGetAttachedShaders_shadersPacked(glState, isCallValid, programPacked, maxCount,
count, shadersPacked, &shadersPackedParam);
paramBuffer.addParam(std::move(shadersPackedParam));
}
else
{
ParamCapture shadersPackedParam("shadersPacked", ParamType::TShaderProgramIDPointer);
InitParamValue(ParamType::TShaderProgramIDPointer, shadersPacked, &shadersPackedParam.value);
CaptureGetAttachedShaders_shadersPacked(glState, isCallValid, programPacked, maxCount, count,
shadersPacked, &shadersPackedParam);
InitParamValue(ParamType::TShaderProgramIDPointer, static_cast<ShaderProgramID *>(nullptr),
&shadersPackedParam.value);
paramBuffer.addParam(std::move(shadersPackedParam));
}
return CallCapture(gl::EntryPoint::GetAttachedShaders, std::move(paramBuffer));
}
......@@ -944,10 +1193,20 @@ CallCapture CaptureGetAttribLocation(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureGetAttribLocation_name(glState, isCallValid, programPacked, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
......@@ -965,10 +1224,20 @@ CallCapture CaptureGetBooleanv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
CaptureGetBooleanv_data(glState, isCallValid, pname, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetBooleanv, std::move(paramBuffer));
}
......@@ -984,11 +1253,20 @@ CallCapture CaptureGetBufferParameteriv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetBufferParameteriv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetBufferParameteriv, std::move(paramBuffer));
}
......@@ -1010,10 +1288,20 @@ CallCapture CaptureGetFloatv(const State &glState, bool isCallValid, GLenum pnam
paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, data, &dataParam.value);
CaptureGetFloatv_data(glState, isCallValid, pname, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetFloatv, std::move(paramBuffer));
}
......@@ -1033,11 +1321,20 @@ CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName,
ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetFramebufferAttachmentParameteriv_params(glState, isCallValid, target, attachment,
pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameteriv, std::move(paramBuffer));
}
......@@ -1048,10 +1345,19 @@ CallCapture CaptureGetIntegerv(const State &glState, bool isCallValid, GLenum pn
paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
CaptureGetIntegerv_data(glState, isCallValid, pname, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetIntegerv, std::move(paramBuffer));
}
......@@ -1068,17 +1374,37 @@ CallCapture CaptureGetProgramInfoLog(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetProgramInfoLog_length(glState, isCallValid, programPacked, bufSize, length, infoLog,
&lengthParam);
CaptureGetProgramInfoLog_length(glState, isCallValid, programPacked, bufSize, length,
infoLog, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
CaptureGetProgramInfoLog_infoLog(glState, isCallValid, programPacked, bufSize, length, infoLog,
&infoLogParam);
CaptureGetProgramInfoLog_infoLog(glState, isCallValid, programPacked, bufSize, length,
infoLog, &infoLogParam);
paramBuffer.addParam(std::move(infoLogParam));
}
else
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&infoLogParam.value);
paramBuffer.addParam(std::move(infoLogParam));
}
return CallCapture(gl::EntryPoint::GetProgramInfoLog, std::move(paramBuffer));
}
......@@ -1094,10 +1420,20 @@ CallCapture CaptureGetProgramiv(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::ProgramPropertyARB, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetProgramiv_params(glState, isCallValid, programPacked, pname, params, &paramsParam);
CaptureGetProgramiv_params(glState, isCallValid, programPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetProgramiv, std::move(paramBuffer));
}
......@@ -1114,11 +1450,20 @@ CallCapture CaptureGetRenderbufferParameteriv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum,
pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetRenderbufferParameteriv_params(glState, isCallValid, target, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetRenderbufferParameteriv, std::move(paramBuffer));
}
......@@ -1135,17 +1480,37 @@ CallCapture CaptureGetShaderInfoLog(const State &glState,
paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetShaderInfoLog_length(glState, isCallValid, shaderPacked, bufSize, length, infoLog,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
CaptureGetShaderInfoLog_infoLog(glState, isCallValid, shaderPacked, bufSize, length, infoLog,
&infoLogParam);
CaptureGetShaderInfoLog_infoLog(glState, isCallValid, shaderPacked, bufSize, length,
infoLog, &infoLogParam);
paramBuffer.addParam(std::move(infoLogParam));
}
else
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&infoLogParam.value);
paramBuffer.addParam(std::move(infoLogParam));
}
return CallCapture(gl::EntryPoint::GetShaderInfoLog, std::move(paramBuffer));
}
......@@ -1163,17 +1528,36 @@ CallCapture CaptureGetShaderPrecisionFormat(const State &glState,
paramBuffer.addEnumParam("precisiontype", GLenumGroup::PrecisionType, ParamType::TGLenum,
precisiontype);
if (isCallValid)
{
ParamCapture rangeParam("range", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, range, &rangeParam.value);
CaptureGetShaderPrecisionFormat_range(glState, isCallValid, shadertype, precisiontype, range,
precision, &rangeParam);
CaptureGetShaderPrecisionFormat_range(glState, isCallValid, shadertype, precisiontype,
range, precision, &rangeParam);
paramBuffer.addParam(std::move(rangeParam));
}
else
{
ParamCapture rangeParam("range", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &rangeParam.value);
paramBuffer.addParam(std::move(rangeParam));
}
if (isCallValid)
{
ParamCapture precisionParam("precision", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, precision, &precisionParam.value);
CaptureGetShaderPrecisionFormat_precision(glState, isCallValid, shadertype, precisiontype,
range, precision, &precisionParam);
paramBuffer.addParam(std::move(precisionParam));
}
else
{
ParamCapture precisionParam("precision", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr),
&precisionParam.value);
paramBuffer.addParam(std::move(precisionParam));
}
return CallCapture(gl::EntryPoint::GetShaderPrecisionFormat, std::move(paramBuffer));
}
......@@ -1190,17 +1574,37 @@ CallCapture CaptureGetShaderSource(const State &glState,
paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetShaderSource_length(glState, isCallValid, shaderPacked, bufSize, length, source,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture sourceParam("source", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value);
CaptureGetShaderSource_source(glState, isCallValid, shaderPacked, bufSize, length, source,
&sourceParam);
paramBuffer.addParam(std::move(sourceParam));
}
else
{
ParamCapture sourceParam("source", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&sourceParam.value);
paramBuffer.addParam(std::move(sourceParam));
}
return CallCapture(gl::EntryPoint::GetShaderSource, std::move(paramBuffer));
}
......@@ -1216,10 +1620,19 @@ CallCapture CaptureGetShaderiv(const State &glState,
paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::ShaderParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetShaderiv_params(glState, isCallValid, shaderPacked, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetShaderiv, std::move(paramBuffer));
}
......@@ -1251,11 +1664,21 @@ CallCapture CaptureGetTexParameterfv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetTexParameterfv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexParameterfv, std::move(paramBuffer));
}
......@@ -1271,11 +1694,20 @@ CallCapture CaptureGetTexParameteriv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetTexParameteriv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexParameteriv, std::move(paramBuffer));
}
......@@ -1290,10 +1722,20 @@ CallCapture CaptureGetUniformLocation(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureGetUniformLocation_name(glState, isCallValid, programPacked, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
......@@ -1313,11 +1755,21 @@ CallCapture CaptureGetUniformfv(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetUniformfv_params(glState, isCallValid, programPacked, locationPacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetUniformfv, std::move(paramBuffer));
}
......@@ -1333,11 +1785,20 @@ CallCapture CaptureGetUniformiv(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetUniformiv_params(glState, isCallValid, programPacked, locationPacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetUniformiv, std::move(paramBuffer));
}
......@@ -1353,11 +1814,21 @@ CallCapture CaptureGetVertexAttribPointerv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, pointer, &pointerParam.value);
CaptureGetVertexAttribPointerv_pointer(glState, isCallValid, index, pname, pointer,
&pointerParam);
paramBuffer.addParam(std::move(pointerParam));
}
else
{
ParamCapture pointerParam("pointer", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
&pointerParam.value);
paramBuffer.addParam(std::move(pointerParam));
}
return CallCapture(gl::EntryPoint::GetVertexAttribPointerv, std::move(paramBuffer));
}
......@@ -1373,10 +1844,20 @@ CallCapture CaptureGetVertexAttribfv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetVertexAttribfv_params(glState, isCallValid, index, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetVertexAttribfv, std::move(paramBuffer));
}
......@@ -1392,10 +1873,19 @@ CallCapture CaptureGetVertexAttribiv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetVertexAttribiv_params(glState, isCallValid, index, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetVertexAttribiv, std::move(paramBuffer));
}
......@@ -1584,11 +2074,20 @@ CallCapture CaptureReadPixels(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
if (isCallValid)
{
ParamCapture pixelsParam("pixels", ParamType::TvoidPointer);
InitParamValue(ParamType::TvoidPointer, pixels, &pixelsParam.value);
CaptureReadPixels_pixels(glState, isCallValid, x, y, width, height, 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(gl::EntryPoint::ReadPixels, std::move(paramBuffer));
}
......@@ -1660,21 +2159,41 @@ CallCapture CaptureShaderBinary(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture shadersPackedParam("shadersPacked", ParamType::TShaderProgramIDConstPointer);
InitParamValue(ParamType::TShaderProgramIDConstPointer, shadersPacked,
&shadersPackedParam.value);
CaptureShaderBinary_shadersPacked(glState, isCallValid, count, shadersPacked, binaryformat,
binary, length, &shadersPackedParam);
paramBuffer.addParam(std::move(shadersPackedParam));
}
else
{
ParamCapture shadersPackedParam("shadersPacked", ParamType::TShaderProgramIDConstPointer);
InitParamValue(ParamType::TShaderProgramIDConstPointer,
static_cast<const ShaderProgramID *>(nullptr), &shadersPackedParam.value);
paramBuffer.addParam(std::move(shadersPackedParam));
}
paramBuffer.addEnumParam("binaryformat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
binaryformat);
if (isCallValid)
{
ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
CaptureShaderBinary_binary(glState, isCallValid, count, shadersPacked, binaryformat, binary,
length, &binaryParam);
paramBuffer.addParam(std::move(binaryParam));
}
else
{
ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&binaryParam.value);
paramBuffer.addParam(std::move(binaryParam));
}
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
......@@ -1693,17 +2212,37 @@ CallCapture CaptureShaderSource(const State &glState,
paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture stringParam("string", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer, string, &stringParam.value);
CaptureShaderSource_string(glState, isCallValid, shaderPacked, count, string, length,
&stringParam);
paramBuffer.addParam(std::move(stringParam));
}
else
{
ParamCapture stringParam("string", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer,
static_cast<const GLchar *const *>(nullptr), &stringParam.value);
paramBuffer.addParam(std::move(stringParam));
}
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, length, &lengthParam.value);
CaptureShaderSource_length(glState, isCallValid, shaderPacked, count, string, length,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
return CallCapture(gl::EntryPoint::ShaderSource, std::move(paramBuffer));
}
......@@ -1817,11 +2356,21 @@ CallCapture CaptureTexImage2D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
if (isCallValid)
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
CaptureTexImage2D_pixels(glState, isCallValid, targetPacked, level, internalformat, width,
height, 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(gl::EntryPoint::TexImage2D, std::move(paramBuffer));
}
......@@ -1852,10 +2401,21 @@ CallCapture CaptureTexParameterfv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, params, &paramsParam.value);
CaptureTexParameterfv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
CaptureTexParameterfv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexParameterfv, std::move(paramBuffer));
}
......@@ -1886,10 +2446,21 @@ CallCapture CaptureTexParameteriv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
CaptureTexParameteriv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
CaptureTexParameteriv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexParameteriv, std::move(paramBuffer));
}
......@@ -1917,11 +2488,21 @@ CallCapture CaptureTexSubImage2D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
if (isCallValid)
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
CaptureTexSubImage2D_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset, width,
height, format, type, pixels, &pixelsParam);
CaptureTexSubImage2D_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
width, height, format, type, pixels, &pixelsParam);
paramBuffer.addParam(std::move(pixelsParam));
}
else
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&pixelsParam.value);
paramBuffer.addParam(std::move(pixelsParam));
}
return CallCapture(gl::EntryPoint::TexSubImage2D, std::move(paramBuffer));
}
......@@ -1950,10 +2531,20 @@ CallCapture CaptureUniform1fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniform1fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform1fv, std::move(paramBuffer));
}
......@@ -1982,10 +2573,20 @@ CallCapture CaptureUniform1iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureUniform1iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform1iv, std::move(paramBuffer));
}
......@@ -2016,10 +2617,20 @@ CallCapture CaptureUniform2fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniform2fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform2fv, std::move(paramBuffer));
}
......@@ -2050,10 +2661,20 @@ CallCapture CaptureUniform2iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureUniform2iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform2iv, std::move(paramBuffer));
}
......@@ -2086,10 +2707,20 @@ CallCapture CaptureUniform3fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniform3fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform3fv, std::move(paramBuffer));
}
......@@ -2122,10 +2753,20 @@ CallCapture CaptureUniform3iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureUniform3iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform3iv, std::move(paramBuffer));
}
......@@ -2160,10 +2801,20 @@ CallCapture CaptureUniform4fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniform4fv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform4fv, std::move(paramBuffer));
}
......@@ -2198,10 +2849,20 @@ CallCapture CaptureUniform4iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureUniform4iv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform4iv, std::move(paramBuffer));
}
......@@ -2219,11 +2880,21 @@ CallCapture CaptureUniformMatrix2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix2fv, std::move(paramBuffer));
}
......@@ -2241,11 +2912,21 @@ CallCapture CaptureUniformMatrix3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix3fv, std::move(paramBuffer));
}
......@@ -2263,11 +2944,21 @@ CallCapture CaptureUniformMatrix4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix4fv, std::move(paramBuffer));
}
......@@ -2311,10 +3002,20 @@ CallCapture CaptureVertexAttrib1fv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
CaptureVertexAttrib1fv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttrib1fv, std::move(paramBuffer));
}
......@@ -2343,10 +3044,20 @@ CallCapture CaptureVertexAttrib2fv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
CaptureVertexAttrib2fv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttrib2fv, std::move(paramBuffer));
}
......@@ -2377,10 +3088,20 @@ CallCapture CaptureVertexAttrib3fv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
CaptureVertexAttrib3fv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttrib3fv, std::move(paramBuffer));
}
......@@ -2413,10 +3134,20 @@ CallCapture CaptureVertexAttrib4fv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, v, &vParam.value);
CaptureVertexAttrib4fv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttrib4fv, std::move(paramBuffer));
}
......@@ -2438,11 +3169,21 @@ CallCapture CaptureVertexAttribPointer(const State &glState,
paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
CaptureVertexAttribPointer_pointer(glState, isCallValid, index, size, typePacked, normalized,
stride, pointer, &pointerParam);
CaptureVertexAttribPointer_pointer(glState, isCallValid, index, size, typePacked,
normalized, 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(gl::EntryPoint::VertexAttribPointer, std::move(paramBuffer));
}
......
src/libANGLE/capture_gles_3_0_autogen.cpp
......@@ -175,10 +175,20 @@ CallCapture CaptureClearBufferfv(const State &glState,
paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureClearBufferfv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ClearBufferfv, std::move(paramBuffer));
}
......@@ -194,10 +204,20 @@ CallCapture CaptureClearBufferiv(const State &glState,
paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureClearBufferiv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ClearBufferiv, std::move(paramBuffer));
}
......@@ -213,10 +233,20 @@ CallCapture CaptureClearBufferuiv(const State &glState,
paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer);
paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureClearBufferuiv_value(glState, isCallValid, buffer, drawbuffer, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ClearBufferuiv, std::move(paramBuffer));
}
......@@ -265,11 +295,21 @@ CallCapture CaptureCompressedTexImage3D(const State &glState,
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);
CaptureCompressedTexImage3D_data(glState, isCallValid, targetPacked, level, internalformat,
width, height, depth, 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(gl::EntryPoint::CompressedTexImage3D, std::move(paramBuffer));
}
......@@ -301,12 +341,22 @@ CallCapture CaptureCompressedTexSubImage3D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, data, &dataParam.value);
CaptureCompressedTexSubImage3D_data(glState, isCallValid, targetPacked, level, xoffset, yoffset,
zoffset, width, height, depth, format, imageSize, data,
&dataParam);
CaptureCompressedTexSubImage3D_data(glState, isCallValid, targetPacked, level, xoffset,
yoffset, zoffset, width, height, depth, format,
imageSize, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::CompressedTexSubImage3D, std::move(paramBuffer));
}
......@@ -366,10 +416,20 @@ CallCapture CaptureDeleteQueries(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
InitParamValue(ParamType::TQueryIDConstPointer, idsPacked, &idsPackedParam.value);
CaptureDeleteQueries_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
paramBuffer.addParam(std::move(idsPackedParam));
}
else
{
ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDConstPointer);
InitParamValue(ParamType::TQueryIDConstPointer, static_cast<const QueryID *>(nullptr),
&idsPackedParam.value);
paramBuffer.addParam(std::move(idsPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteQueries, std::move(paramBuffer));
}
......@@ -383,11 +443,22 @@ CallCapture CaptureDeleteSamplers(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDConstPointer);
InitParamValue(ParamType::TSamplerIDConstPointer, samplersPacked, &samplersPackedParam.value);
InitParamValue(ParamType::TSamplerIDConstPointer, samplersPacked,
&samplersPackedParam.value);
CaptureDeleteSamplers_samplersPacked(glState, isCallValid, count, samplersPacked,
&samplersPackedParam);
paramBuffer.addParam(std::move(samplersPackedParam));
}
else
{
ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDConstPointer);
InitParamValue(ParamType::TSamplerIDConstPointer, static_cast<const SamplerID *>(nullptr),
&samplersPackedParam.value);
paramBuffer.addParam(std::move(samplersPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteSamplers, std::move(paramBuffer));
}
......@@ -410,10 +481,22 @@ CallCapture CaptureDeleteTransformFeedbacks(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDConstPointer);
InitParamValue(ParamType::TTransformFeedbackIDConstPointer, idsPacked, &idsPackedParam.value);
CaptureDeleteTransformFeedbacks_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
InitParamValue(ParamType::TTransformFeedbackIDConstPointer, idsPacked,
&idsPackedParam.value);
CaptureDeleteTransformFeedbacks_idsPacked(glState, isCallValid, n, idsPacked,
&idsPackedParam);
paramBuffer.addParam(std::move(idsPackedParam));
}
else
{
ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDConstPointer);
InitParamValue(ParamType::TTransformFeedbackIDConstPointer,
static_cast<const TransformFeedbackID *>(nullptr), &idsPackedParam.value);
paramBuffer.addParam(std::move(idsPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteTransformFeedbacks, std::move(paramBuffer));
}
......@@ -427,11 +510,22 @@ CallCapture CaptureDeleteVertexArrays(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked, &arraysPackedParam.value);
InitParamValue(ParamType::TVertexArrayIDConstPointer, arraysPacked,
&arraysPackedParam.value);
CaptureDeleteVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked,
&arraysPackedParam);
paramBuffer.addParam(std::move(arraysPackedParam));
}
else
{
ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDConstPointer);
InitParamValue(ParamType::TVertexArrayIDConstPointer,
static_cast<const VertexArrayID *>(nullptr), &arraysPackedParam.value);
paramBuffer.addParam(std::move(arraysPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteVertexArrays, std::move(paramBuffer));
}
......@@ -462,10 +556,20 @@ CallCapture CaptureDrawBuffers(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, bufs, &bufsParam.value);
CaptureDrawBuffers_bufs(glState, isCallValid, n, bufs, &bufsParam);
paramBuffer.addParam(std::move(bufsParam));
}
else
{
ParamCapture bufsParam("bufs", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
&bufsParam.value);
paramBuffer.addParam(std::move(bufsParam));
}
return CallCapture(gl::EntryPoint::DrawBuffers, std::move(paramBuffer));
}
......@@ -484,11 +588,21 @@ CallCapture CaptureDrawElementsInstanced(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawElementsInstanced_indices(glState, isCallValid, modePacked, count, typePacked,
indices, instancecount, &indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
......@@ -512,11 +626,21 @@ CallCapture CaptureDrawRangeElements(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawRangeElements_indices(glState, isCallValid, modePacked, start, end, count,
typePacked, indices, &indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
return CallCapture(gl::EntryPoint::DrawRangeElements, std::move(paramBuffer));
}
......@@ -597,10 +721,20 @@ CallCapture CaptureGenQueries(const State &glState, bool isCallValid, GLsizei n,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
InitParamValue(ParamType::TQueryIDPointer, idsPacked, &idsPackedParam.value);
CaptureGenQueries_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
paramBuffer.addParam(std::move(idsPackedParam));
}
else
{
ParamCapture idsPackedParam("idsPacked", ParamType::TQueryIDPointer);
InitParamValue(ParamType::TQueryIDPointer, static_cast<QueryID *>(nullptr),
&idsPackedParam.value);
paramBuffer.addParam(std::move(idsPackedParam));
}
return CallCapture(gl::EntryPoint::GenQueries, std::move(paramBuffer));
}
......@@ -614,11 +748,21 @@ CallCapture CaptureGenSamplers(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDPointer);
InitParamValue(ParamType::TSamplerIDPointer, samplersPacked, &samplersPackedParam.value);
CaptureGenSamplers_samplersPacked(glState, isCallValid, count, samplersPacked,
&samplersPackedParam);
paramBuffer.addParam(std::move(samplersPackedParam));
}
else
{
ParamCapture samplersPackedParam("samplersPacked", ParamType::TSamplerIDPointer);
InitParamValue(ParamType::TSamplerIDPointer, static_cast<SamplerID *>(nullptr),
&samplersPackedParam.value);
paramBuffer.addParam(std::move(samplersPackedParam));
}
return CallCapture(gl::EntryPoint::GenSamplers, std::move(paramBuffer));
}
......@@ -632,10 +776,20 @@ CallCapture CaptureGenTransformFeedbacks(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDPointer);
InitParamValue(ParamType::TTransformFeedbackIDPointer, idsPacked, &idsPackedParam.value);
CaptureGenTransformFeedbacks_idsPacked(glState, isCallValid, n, idsPacked, &idsPackedParam);
paramBuffer.addParam(std::move(idsPackedParam));
}
else
{
ParamCapture idsPackedParam("idsPacked", ParamType::TTransformFeedbackIDPointer);
InitParamValue(ParamType::TTransformFeedbackIDPointer,
static_cast<TransformFeedbackID *>(nullptr), &idsPackedParam.value);
paramBuffer.addParam(std::move(idsPackedParam));
}
return CallCapture(gl::EntryPoint::GenTransformFeedbacks, std::move(paramBuffer));
}
......@@ -649,10 +803,21 @@ CallCapture CaptureGenVertexArrays(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
InitParamValue(ParamType::TVertexArrayIDPointer, arraysPacked, &arraysPackedParam.value);
CaptureGenVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked, &arraysPackedParam);
CaptureGenVertexArrays_arraysPacked(glState, isCallValid, n, arraysPacked,
&arraysPackedParam);
paramBuffer.addParam(std::move(arraysPackedParam));
}
else
{
ParamCapture arraysPackedParam("arraysPacked", ParamType::TVertexArrayIDPointer);
InitParamValue(ParamType::TVertexArrayIDPointer, static_cast<VertexArrayID *>(nullptr),
&arraysPackedParam.value);
paramBuffer.addParam(std::move(arraysPackedParam));
}
return CallCapture(gl::EntryPoint::GenVertexArrays, std::move(paramBuffer));
}
......@@ -671,18 +836,39 @@ CallCapture CaptureGetActiveUniformBlockName(const State &glState,
paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetActiveUniformBlockName_length(glState, isCallValid, programPacked, uniformBlockIndex,
bufSize, length, uniformBlockName, &lengthParam);
CaptureGetActiveUniformBlockName_length(glState, isCallValid, programPacked,
uniformBlockIndex, bufSize, length,
uniformBlockName, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, uniformBlockName, &uniformBlockNameParam.value);
CaptureGetActiveUniformBlockName_uniformBlockName(glState, isCallValid, programPacked,
uniformBlockIndex, bufSize, length,
uniformBlockName, &uniformBlockNameParam);
paramBuffer.addParam(std::move(uniformBlockNameParam));
}
else
{
ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&uniformBlockNameParam.value);
paramBuffer.addParam(std::move(uniformBlockNameParam));
}
return CallCapture(gl::EntryPoint::GetActiveUniformBlockName, std::move(paramBuffer));
}
......@@ -700,11 +886,20 @@ CallCapture CaptureGetActiveUniformBlockiv(const State &glState,
paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
paramBuffer.addEnumParam("pname", GLenumGroup::UniformBlockPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetActiveUniformBlockiv_params(glState, isCallValid, programPacked, uniformBlockIndex,
pname, params, &paramsParam);
CaptureGetActiveUniformBlockiv_params(glState, isCallValid, programPacked,
uniformBlockIndex, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetActiveUniformBlockiv, std::move(paramBuffer));
}
......@@ -722,19 +917,39 @@ CallCapture CaptureGetActiveUniformsiv(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount);
if (isCallValid)
{
ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, uniformIndices, &uniformIndicesParam.value);
CaptureGetActiveUniformsiv_uniformIndices(glState, isCallValid, programPacked, uniformCount,
uniformIndices, pname, params, &uniformIndicesParam);
uniformIndices, pname, params,
&uniformIndicesParam);
paramBuffer.addParam(std::move(uniformIndicesParam));
}
else
{
ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&uniformIndicesParam.value);
paramBuffer.addParam(std::move(uniformIndicesParam));
}
paramBuffer.addEnumParam("pname", GLenumGroup::UniformPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetActiveUniformsiv_params(glState, isCallValid, programPacked, uniformCount,
uniformIndices, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetActiveUniformsiv, std::move(paramBuffer));
}
......@@ -750,11 +965,21 @@ CallCapture CaptureGetBufferParameteri64v(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, params, &paramsParam.value);
CaptureGetBufferParameteri64v_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetBufferParameteri64v, std::move(paramBuffer));
}
......@@ -770,11 +995,21 @@ CallCapture CaptureGetBufferPointerv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, params, &paramsParam.value);
CaptureGetBufferPointerv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetBufferPointerv, std::move(paramBuffer));
}
......@@ -789,10 +1024,20 @@ CallCapture CaptureGetFragDataLocation(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureGetFragDataLocation_name(glState, isCallValid, programPacked, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
......@@ -812,10 +1057,20 @@ CallCapture CaptureGetInteger64i_v(const State &glState,
paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target);
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
CaptureGetInteger64i_v_data(glState, isCallValid, target, index, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetInteger64i_v, std::move(paramBuffer));
}
......@@ -829,10 +1084,20 @@ CallCapture CaptureGetInteger64v(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, data, &dataParam.value);
CaptureGetInteger64v_data(glState, isCallValid, pname, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLint64Pointer);
InitParamValue(ParamType::TGLint64Pointer, static_cast<GLint64 *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetInteger64v, std::move(paramBuffer));
}
......@@ -848,10 +1113,19 @@ CallCapture CaptureGetIntegeri_v(const State &glState,
paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target);
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, data, &dataParam.value);
CaptureGetIntegeri_v_data(glState, isCallValid, target, index, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetIntegeri_v, std::move(paramBuffer));
}
......@@ -872,11 +1146,20 @@ CallCapture CaptureGetInternalformativ(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::InternalFormatPName, ParamType::TGLenum, pname);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetInternalformativ_params(glState, isCallValid, target, internalformat, pname, bufSize,
params, &paramsParam);
CaptureGetInternalformativ_params(glState, isCallValid, target, internalformat, pname,
bufSize, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetInternalformativ, std::move(paramBuffer));
}
......@@ -894,23 +1177,52 @@ CallCapture CaptureGetProgramBinary(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetProgramBinary_length(glState, isCallValid, programPacked, bufSize, length,
binaryFormat, binary, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, binaryFormat, &binaryFormatParam.value);
CaptureGetProgramBinary_binaryFormat(glState, isCallValid, programPacked, bufSize, length,
binaryFormat, binary, &binaryFormatParam);
paramBuffer.addParam(std::move(binaryFormatParam));
}
else
{
ParamCapture binaryFormatParam("binaryFormat", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
&binaryFormatParam.value);
paramBuffer.addParam(std::move(binaryFormatParam));
}
if (isCallValid)
{
ParamCapture binaryParam("binary", ParamType::TvoidPointer);
InitParamValue(ParamType::TvoidPointer, binary, &binaryParam.value);
CaptureGetProgramBinary_binary(glState, isCallValid, programPacked, bufSize, length,
binaryFormat, binary, &binaryParam);
paramBuffer.addParam(std::move(binaryParam));
}
else
{
ParamCapture binaryParam("binary", ParamType::TvoidPointer);
InitParamValue(ParamType::TvoidPointer, static_cast<void *>(nullptr), &binaryParam.value);
paramBuffer.addParam(std::move(binaryParam));
}
return CallCapture(gl::EntryPoint::GetProgramBinary, std::move(paramBuffer));
}
......@@ -927,10 +1239,21 @@ CallCapture CaptureGetQueryObjectuiv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum,
pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetQueryObjectuiv_params(glState, isCallValid, idPacked, pname, params, &paramsParam);
CaptureGetQueryObjectuiv_params(glState, isCallValid, idPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetQueryObjectuiv, std::move(paramBuffer));
}
......@@ -946,10 +1269,19 @@ CallCapture CaptureGetQueryiv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetQueryiv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetQueryiv, std::move(paramBuffer));
}
......@@ -965,11 +1297,21 @@ CallCapture CaptureGetSamplerParameterfv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetSamplerParameterfv_params(glState, isCallValid, samplerPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetSamplerParameterfv, std::move(paramBuffer));
}
......@@ -985,11 +1327,20 @@ CallCapture CaptureGetSamplerParameteriv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetSamplerParameteriv_params(glState, isCallValid, samplerPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetSamplerParameteriv, std::move(paramBuffer));
}
......@@ -1026,17 +1377,36 @@ CallCapture CaptureGetSynciv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::SyncParameterName, ParamType::TGLenum, pname);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetSynciv_length(glState, isCallValid, sync, pname, bufSize, length, values,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture valuesParam("values", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value);
CaptureGetSynciv_values(glState, isCallValid, sync, pname, bufSize, length, values,
&valuesParam);
paramBuffer.addParam(std::move(valuesParam));
}
else
{
ParamCapture valuesParam("values", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &valuesParam.value);
paramBuffer.addParam(std::move(valuesParam));
}
return CallCapture(gl::EntryPoint::GetSynciv, std::move(paramBuffer));
}
......@@ -1057,29 +1427,67 @@ CallCapture CaptureGetTransformFeedbackVarying(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetTransformFeedbackVarying_length(glState, isCallValid, programPacked, index, bufSize,
length, size, type, name, &lengthParam);
CaptureGetTransformFeedbackVarying_length(glState, isCallValid, programPacked, index,
bufSize, length, size, type, name, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture sizeParam("size", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, size, &sizeParam.value);
CaptureGetTransformFeedbackVarying_size(glState, isCallValid, programPacked, index, bufSize,
length, size, type, name, &sizeParam);
paramBuffer.addParam(std::move(sizeParam));
}
else
{
ParamCapture sizeParam("size", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&sizeParam.value);
paramBuffer.addParam(std::move(sizeParam));
}
if (isCallValid)
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, type, &typeParam.value);
CaptureGetTransformFeedbackVarying_type(glState, isCallValid, programPacked, index, bufSize,
length, size, type, name, &typeParam);
paramBuffer.addParam(std::move(typeParam));
}
else
{
ParamCapture typeParam("type", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr), &typeParam.value);
paramBuffer.addParam(std::move(typeParam));
}
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
CaptureGetTransformFeedbackVarying_name(glState, isCallValid, programPacked, index, bufSize,
length, size, type, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
return CallCapture(gl::EntryPoint::GetTransformFeedbackVarying, std::move(paramBuffer));
}
......@@ -1094,11 +1502,22 @@ CallCapture CaptureGetUniformBlockIndex(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
if (isCallValid)
{
ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, uniformBlockName, &uniformBlockNameParam.value);
InitParamValue(ParamType::TGLcharConstPointer, uniformBlockName,
&uniformBlockNameParam.value);
CaptureGetUniformBlockIndex_uniformBlockName(glState, isCallValid, programPacked,
uniformBlockName, &uniformBlockNameParam);
paramBuffer.addParam(std::move(uniformBlockNameParam));
}
else
{
ParamCapture uniformBlockNameParam("uniformBlockName", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&uniformBlockNameParam.value);
paramBuffer.addParam(std::move(uniformBlockNameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
......@@ -1119,17 +1538,38 @@ CallCapture CaptureGetUniformIndices(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("uniformCount", ParamType::TGLsizei, uniformCount);
if (isCallValid)
{
ParamCapture uniformNamesParam("uniformNames", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer, uniformNames, &uniformNamesParam.value);
InitParamValue(ParamType::TGLcharConstPointerPointer, uniformNames,
&uniformNamesParam.value);
CaptureGetUniformIndices_uniformNames(glState, isCallValid, programPacked, uniformCount,
uniformNames, uniformIndices, &uniformNamesParam);
paramBuffer.addParam(std::move(uniformNamesParam));
}
else
{
ParamCapture uniformNamesParam("uniformNames", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer,
static_cast<const GLchar *const *>(nullptr), &uniformNamesParam.value);
paramBuffer.addParam(std::move(uniformNamesParam));
}
if (isCallValid)
{
ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, uniformIndices, &uniformIndicesParam.value);
CaptureGetUniformIndices_uniformIndices(glState, isCallValid, programPacked, uniformCount,
uniformNames, uniformIndices, &uniformIndicesParam);
paramBuffer.addParam(std::move(uniformIndicesParam));
}
else
{
ParamCapture uniformIndicesParam("uniformIndices", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&uniformIndicesParam.value);
paramBuffer.addParam(std::move(uniformIndicesParam));
}
return CallCapture(gl::EntryPoint::GetUniformIndices, std::move(paramBuffer));
}
......@@ -1145,11 +1585,21 @@ CallCapture CaptureGetUniformuiv(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetUniformuiv_params(glState, isCallValid, programPacked, locationPacked, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetUniformuiv, std::move(paramBuffer));
}
......@@ -1165,10 +1615,19 @@ CallCapture CaptureGetVertexAttribIiv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetVertexAttribIiv_params(glState, isCallValid, index, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetVertexAttribIiv, std::move(paramBuffer));
}
......@@ -1184,10 +1643,20 @@ CallCapture CaptureGetVertexAttribIuiv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetVertexAttribIuiv_params(glState, isCallValid, index, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetVertexAttribIuiv, std::move(paramBuffer));
}
......@@ -1203,11 +1672,21 @@ CallCapture CaptureInvalidateFramebuffer(const State &glState,
paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target);
paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
if (isCallValid)
{
ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
CaptureInvalidateFramebuffer_attachments(glState, isCallValid, target, numAttachments,
attachments, &attachmentsParam);
paramBuffer.addParam(std::move(attachmentsParam));
}
else
{
ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
&attachmentsParam.value);
paramBuffer.addParam(std::move(attachmentsParam));
}
return CallCapture(gl::EntryPoint::InvalidateFramebuffer, std::move(paramBuffer));
}
......@@ -1227,12 +1706,22 @@ CallCapture CaptureInvalidateSubFramebuffer(const State &glState,
paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target);
paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments);
if (isCallValid)
{
ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, attachments, &attachmentsParam.value);
CaptureInvalidateSubFramebuffer_attachments(glState, isCallValid, target, numAttachments,
attachments, x, y, width, height,
&attachmentsParam);
paramBuffer.addParam(std::move(attachmentsParam));
}
else
{
ParamCapture attachmentsParam("attachments", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
&attachmentsParam.value);
paramBuffer.addParam(std::move(attachmentsParam));
}
paramBuffer.addValueParam("x", ParamType::TGLint, x);
paramBuffer.addValueParam("y", ParamType::TGLint, y);
......@@ -1365,11 +1854,21 @@ CallCapture CaptureProgramBinary(const State &glState,
paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum,
binaryFormat);
if (isCallValid)
{
ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value);
CaptureProgramBinary_binary(glState, isCallValid, programPacked, binaryFormat, binary, length,
&binaryParam);
CaptureProgramBinary_binary(glState, isCallValid, programPacked, binaryFormat, binary,
length, &binaryParam);
paramBuffer.addParam(std::move(binaryParam));
}
else
{
ParamCapture binaryParam("binary", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&binaryParam.value);
paramBuffer.addParam(std::move(binaryParam));
}
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
......@@ -1454,10 +1953,21 @@ CallCapture CaptureSamplerParameterfv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, param, &paramParam.value);
CaptureSamplerParameterfv_param(glState, isCallValid, samplerPacked, pname, param, &paramParam);
CaptureSamplerParameterfv_param(glState, isCallValid, samplerPacked, pname, param,
&paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::SamplerParameterfv, std::move(paramBuffer));
}
......@@ -1488,10 +1998,21 @@ CallCapture CaptureSamplerParameteriv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, param, &paramParam.value);
CaptureSamplerParameteriv_param(glState, isCallValid, samplerPacked, pname, param, &paramParam);
CaptureSamplerParameteriv_param(glState, isCallValid, samplerPacked, pname, param,
&paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::SamplerParameteriv, std::move(paramBuffer));
}
......@@ -1521,11 +2042,21 @@ CallCapture CaptureTexImage3D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
if (isCallValid)
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
CaptureTexImage3D_pixels(glState, isCallValid, targetPacked, level, internalformat, width,
height, depth, 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(gl::EntryPoint::TexImage3D, std::move(paramBuffer));
}
......@@ -1599,11 +2130,22 @@ CallCapture CaptureTexSubImage3D(const State &glState,
paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format);
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
if (isCallValid)
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pixels, &pixelsParam.value);
CaptureTexSubImage3D_pixels(glState, isCallValid, targetPacked, level, xoffset, yoffset,
zoffset, width, height, depth, format, type, pixels, &pixelsParam);
zoffset, width, height, depth, format, type, pixels,
&pixelsParam);
paramBuffer.addParam(std::move(pixelsParam));
}
else
{
ParamCapture pixelsParam("pixels", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&pixelsParam.value);
paramBuffer.addParam(std::move(pixelsParam));
}
return CallCapture(gl::EntryPoint::TexSubImage3D, std::move(paramBuffer));
}
......@@ -1620,11 +2162,21 @@ CallCapture CaptureTransformFeedbackVaryings(const State &glState,
paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture varyingsParam("varyings", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer, varyings, &varyingsParam.value);
CaptureTransformFeedbackVaryings_varyings(glState, isCallValid, programPacked, count, varyings,
bufferMode, &varyingsParam);
CaptureTransformFeedbackVaryings_varyings(glState, isCallValid, programPacked, count,
varyings, bufferMode, &varyingsParam);
paramBuffer.addParam(std::move(varyingsParam));
}
else
{
ParamCapture varyingsParam("varyings", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer,
static_cast<const GLchar *const *>(nullptr), &varyingsParam.value);
paramBuffer.addParam(std::move(varyingsParam));
}
paramBuffer.addEnumParam("bufferMode", GLenumGroup::DefaultGroup, ParamType::TGLenum,
bufferMode);
......@@ -1656,10 +2208,20 @@ CallCapture CaptureUniform1uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureUniform1uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform1uiv, std::move(paramBuffer));
}
......@@ -1690,10 +2252,20 @@ CallCapture CaptureUniform2uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureUniform2uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform2uiv, std::move(paramBuffer));
}
......@@ -1726,10 +2298,20 @@ CallCapture CaptureUniform3uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureUniform3uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform3uiv, std::move(paramBuffer));
}
......@@ -1764,10 +2346,20 @@ CallCapture CaptureUniform4uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureUniform4uiv_value(glState, isCallValid, locationPacked, count, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::Uniform4uiv, std::move(paramBuffer));
}
......@@ -1800,11 +2392,21 @@ CallCapture CaptureUniformMatrix2x3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix2x3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix2x3fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix2x3fv, std::move(paramBuffer));
}
......@@ -1822,11 +2424,21 @@ CallCapture CaptureUniformMatrix2x4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix2x4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix2x4fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix2x4fv, std::move(paramBuffer));
}
......@@ -1844,11 +2456,21 @@ CallCapture CaptureUniformMatrix3x2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix3x2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix3x2fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix3x2fv, std::move(paramBuffer));
}
......@@ -1866,11 +2488,21 @@ CallCapture CaptureUniformMatrix3x4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix3x4fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix3x4fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix3x4fv, std::move(paramBuffer));
}
......@@ -1888,11 +2520,21 @@ CallCapture CaptureUniformMatrix4x2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix4x2fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix4x2fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix4x2fv, std::move(paramBuffer));
}
......@@ -1910,11 +2552,21 @@ CallCapture CaptureUniformMatrix4x3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureUniformMatrix4x3fv_value(glState, isCallValid, locationPacked, count, transpose, value,
&valueParam);
CaptureUniformMatrix4x3fv_value(glState, isCallValid, locationPacked, count, transpose,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::UniformMatrix4x3fv, std::move(paramBuffer));
}
......@@ -1976,10 +2628,20 @@ CallCapture CaptureVertexAttribI4iv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, v, &vParam.value);
CaptureVertexAttribI4iv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttribI4iv, std::move(paramBuffer));
}
......@@ -2012,10 +2674,20 @@ CallCapture CaptureVertexAttribI4uiv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture vParam("v", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, v, &vParam.value);
CaptureVertexAttribI4uiv_v(glState, isCallValid, index, v, &vParam);
paramBuffer.addParam(std::move(vParam));
}
else
{
ParamCapture vParam("v", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&vParam.value);
paramBuffer.addParam(std::move(vParam));
}
return CallCapture(gl::EntryPoint::VertexAttribI4uiv, std::move(paramBuffer));
}
......@@ -2035,11 +2707,21 @@ CallCapture CaptureVertexAttribIPointer(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
if (isCallValid)
{
ParamCapture pointerParam("pointer", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, pointer, &pointerParam.value);
CaptureVertexAttribIPointer_pointer(glState, isCallValid, index, size, typePacked, 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(gl::EntryPoint::VertexAttribIPointer, std::move(paramBuffer));
}
......
src/libANGLE/capture_gles_3_1_autogen.cpp
......@@ -96,11 +96,21 @@ CallCapture CaptureCreateShaderProgramv(const State &glState,
paramBuffer.addValueParam("typePacked", ParamType::TShaderType, typePacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer, strings, &stringsParam.value);
CaptureCreateShaderProgramv_strings(glState, isCallValid, typePacked, count, strings,
&stringsParam);
paramBuffer.addParam(std::move(stringsParam));
}
else
{
ParamCapture stringsParam("strings", ParamType::TGLcharConstPointerPointer);
InitParamValue(ParamType::TGLcharConstPointerPointer,
static_cast<const GLchar *const *>(nullptr), &stringsParam.value);
paramBuffer.addParam(std::move(stringsParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
......@@ -118,12 +128,25 @@ CallCapture CaptureDeleteProgramPipelines(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDConstPointer);
if (isCallValid)
{
ParamCapture pipelinesPackedParam("pipelinesPacked",
ParamType::TProgramPipelineIDConstPointer);
InitParamValue(ParamType::TProgramPipelineIDConstPointer, pipelinesPacked,
&pipelinesPackedParam.value);
CaptureDeleteProgramPipelines_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
&pipelinesPackedParam);
paramBuffer.addParam(std::move(pipelinesPackedParam));
}
else
{
ParamCapture pipelinesPackedParam("pipelinesPacked",
ParamType::TProgramPipelineIDConstPointer);
InitParamValue(ParamType::TProgramPipelineIDConstPointer,
static_cast<const ProgramPipelineID *>(nullptr),
&pipelinesPackedParam.value);
paramBuffer.addParam(std::move(pipelinesPackedParam));
}
return CallCapture(gl::EntryPoint::DeleteProgramPipelines, std::move(paramBuffer));
}
......@@ -163,10 +186,21 @@ CallCapture CaptureDrawArraysIndirect(const State &glState,
paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
if (isCallValid)
{
ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
CaptureDrawArraysIndirect_indirect(glState, isCallValid, modePacked, indirect, &indirectParam);
CaptureDrawArraysIndirect_indirect(glState, isCallValid, modePacked, indirect,
&indirectParam);
paramBuffer.addParam(std::move(indirectParam));
}
else
{
ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indirectParam.value);
paramBuffer.addParam(std::move(indirectParam));
}
return CallCapture(gl::EntryPoint::DrawArraysIndirect, std::move(paramBuffer));
}
......@@ -182,11 +216,21 @@ CallCapture CaptureDrawElementsIndirect(const State &glState,
paramBuffer.addValueParam("modePacked", ParamType::TPrimitiveMode, modePacked);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indirect, &indirectParam.value);
CaptureDrawElementsIndirect_indirect(glState, isCallValid, modePacked, typePacked, indirect,
&indirectParam);
paramBuffer.addParam(std::move(indirectParam));
}
else
{
ParamCapture indirectParam("indirect", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indirectParam.value);
paramBuffer.addParam(std::move(indirectParam));
}
return CallCapture(gl::EntryPoint::DrawElementsIndirect, std::move(paramBuffer));
}
......@@ -216,12 +260,22 @@ CallCapture CaptureGenProgramPipelines(const State &glState,
paramBuffer.addValueParam("n", ParamType::TGLsizei, n);
if (isCallValid)
{
ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
InitParamValue(ParamType::TProgramPipelineIDPointer, pipelinesPacked,
&pipelinesPackedParam.value);
CaptureGenProgramPipelines_pipelinesPacked(glState, isCallValid, n, pipelinesPacked,
&pipelinesPackedParam);
paramBuffer.addParam(std::move(pipelinesPackedParam));
}
else
{
ParamCapture pipelinesPackedParam("pipelinesPacked", ParamType::TProgramPipelineIDPointer);
InitParamValue(ParamType::TProgramPipelineIDPointer,
static_cast<ProgramPipelineID *>(nullptr), &pipelinesPackedParam.value);
paramBuffer.addParam(std::move(pipelinesPackedParam));
}
return CallCapture(gl::EntryPoint::GenProgramPipelines, std::move(paramBuffer));
}
......@@ -237,10 +291,20 @@ CallCapture CaptureGetBooleani_v(const State &glState,
paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target);
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
InitParamValue(ParamType::TGLbooleanPointer, data, &dataParam.value);
CaptureGetBooleani_v_data(glState, isCallValid, target, index, data, &dataParam);
paramBuffer.addParam(std::move(dataParam));
}
else
{
ParamCapture dataParam("data", ParamType::TGLbooleanPointer);
InitParamValue(ParamType::TGLbooleanPointer, static_cast<GLboolean *>(nullptr),
&dataParam.value);
paramBuffer.addParam(std::move(dataParam));
}
return CallCapture(gl::EntryPoint::GetBooleani_v, std::move(paramBuffer));
}
......@@ -257,11 +321,20 @@ CallCapture CaptureGetFramebufferParameteriv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName,
ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetFramebufferParameteriv_params(glState, isCallValid, target, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetFramebufferParameteriv, std::move(paramBuffer));
}
......@@ -277,10 +350,20 @@ CallCapture CaptureGetMultisamplefv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname);
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
if (isCallValid)
{
ParamCapture valParam("val", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, val, &valParam.value);
CaptureGetMultisamplefv_val(glState, isCallValid, pname, index, val, &valParam);
paramBuffer.addParam(std::move(valParam));
}
else
{
ParamCapture valParam("val", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&valParam.value);
paramBuffer.addParam(std::move(valParam));
}
return CallCapture(gl::EntryPoint::GetMultisamplefv, std::move(paramBuffer));
}
......@@ -300,11 +383,20 @@ CallCapture CaptureGetProgramInterfaceiv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::ProgramInterfacePName, ParamType::TGLenum,
pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetProgramInterfaceiv_params(glState, isCallValid, programPacked, programInterface,
pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetProgramInterfaceiv, std::move(paramBuffer));
}
......@@ -321,17 +413,37 @@ CallCapture CaptureGetProgramPipelineInfoLog(const State &glState,
paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetProgramPipelineInfoLog_length(glState, isCallValid, pipelinePacked, bufSize, length,
infoLog, &lengthParam);
CaptureGetProgramPipelineInfoLog_length(glState, isCallValid, pipelinePacked, bufSize,
length, infoLog, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, infoLog, &infoLogParam.value);
CaptureGetProgramPipelineInfoLog_infoLog(glState, isCallValid, pipelinePacked, bufSize, length,
infoLog, &infoLogParam);
CaptureGetProgramPipelineInfoLog_infoLog(glState, isCallValid, pipelinePacked, bufSize,
length, infoLog, &infoLogParam);
paramBuffer.addParam(std::move(infoLogParam));
}
else
{
ParamCapture infoLogParam("infoLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&infoLogParam.value);
paramBuffer.addParam(std::move(infoLogParam));
}
return CallCapture(gl::EntryPoint::GetProgramPipelineInfoLog, std::move(paramBuffer));
}
......@@ -348,11 +460,20 @@ CallCapture CaptureGetProgramPipelineiv(const State &glState,
paramBuffer.addEnumParam("pname", GLenumGroup::PipelineParameterName, ParamType::TGLenum,
pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetProgramPipelineiv_params(glState, isCallValid, pipelinePacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetProgramPipelineiv, std::move(paramBuffer));
}
......@@ -370,11 +491,21 @@ CallCapture CaptureGetProgramResourceIndex(const State &glState,
paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
programInterface);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureGetProgramResourceIndex_name(glState, isCallValid, programPacked, programInterface, name,
&nameParam);
CaptureGetProgramResourceIndex_name(glState, isCallValid, programPacked, programInterface,
name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
......@@ -396,11 +527,21 @@ CallCapture CaptureGetProgramResourceLocation(const State &glState,
paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum,
programInterface);
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, name, &nameParam.value);
CaptureGetProgramResourceLocation_name(glState, isCallValid, programPacked, programInterface,
name, &nameParam);
CaptureGetProgramResourceLocation_name(glState, isCallValid, programPacked,
programInterface, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLint);
InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
......@@ -426,17 +567,36 @@ CallCapture CaptureGetProgramResourceName(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetProgramResourceName_length(glState, isCallValid, programPacked, programInterface,
index, bufSize, length, name, &lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value);
CaptureGetProgramResourceName_name(glState, isCallValid, programPacked, programInterface, index,
bufSize, length, name, &nameParam);
CaptureGetProgramResourceName_name(glState, isCallValid, programPacked, programInterface,
index, bufSize, length, name, &nameParam);
paramBuffer.addParam(std::move(nameParam));
}
else
{
ParamCapture nameParam("name", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr), &nameParam.value);
paramBuffer.addParam(std::move(nameParam));
}
return CallCapture(gl::EntryPoint::GetProgramResourceName, std::move(paramBuffer));
}
......@@ -460,25 +620,57 @@ CallCapture CaptureGetProgramResourceiv(const State &glState,
paramBuffer.addValueParam("index", ParamType::TGLuint, index);
paramBuffer.addValueParam("propCount", ParamType::TGLsizei, propCount);
if (isCallValid)
{
ParamCapture propsParam("props", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, props, &propsParam.value);
CaptureGetProgramResourceiv_props(glState, isCallValid, programPacked, programInterface, index,
propCount, props, bufSize, length, params, &propsParam);
CaptureGetProgramResourceiv_props(glState, isCallValid, programPacked, programInterface,
index, propCount, props, bufSize, length, params,
&propsParam);
paramBuffer.addParam(std::move(propsParam));
}
else
{
ParamCapture propsParam("props", ParamType::TGLenumConstPointer);
InitParamValue(ParamType::TGLenumConstPointer, static_cast<const GLenum *>(nullptr),
&propsParam.value);
paramBuffer.addParam(std::move(propsParam));
}
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetProgramResourceiv_length(glState, isCallValid, programPacked, programInterface, index,
propCount, props, bufSize, length, params, &lengthParam);
CaptureGetProgramResourceiv_length(glState, isCallValid, programPacked, programInterface,
index, propCount, props, bufSize, length, params,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetProgramResourceiv_params(glState, isCallValid, programPacked, programInterface, index,
propCount, props, bufSize, length, params, &paramsParam);
CaptureGetProgramResourceiv_params(glState, isCallValid, programPacked, programInterface,
index, propCount, props, bufSize, length, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetProgramResourceiv, std::move(paramBuffer));
}
......@@ -496,11 +688,21 @@ CallCapture CaptureGetTexLevelParameterfv(const State &glState,
paramBuffer.addValueParam("level", ParamType::TGLint, level);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetTexLevelParameterfv_params(glState, isCallValid, targetPacked, level, pname, params,
&paramsParam);
CaptureGetTexLevelParameterfv_params(glState, isCallValid, targetPacked, level, pname,
params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexLevelParameterfv, std::move(paramBuffer));
}
......@@ -518,11 +720,20 @@ CallCapture CaptureGetTexLevelParameteriv(const State &glState,
paramBuffer.addValueParam("level", ParamType::TGLint, level);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetTexLevelParameteriv_params(glState, isCallValid, targetPacked, level, pname, params,
&paramsParam);
CaptureGetTexLevelParameteriv_params(glState, isCallValid, targetPacked, level, pname,
params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexLevelParameteriv, std::move(paramBuffer));
}
......@@ -593,11 +804,21 @@ CallCapture CaptureProgramUniform1fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniform1fv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform1fv, std::move(paramBuffer));
}
......@@ -630,11 +851,21 @@ CallCapture CaptureProgramUniform1iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureProgramUniform1iv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform1iv, std::move(paramBuffer));
}
......@@ -667,11 +898,21 @@ CallCapture CaptureProgramUniform1uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureProgramUniform1uiv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform1uiv, std::move(paramBuffer));
}
......@@ -706,11 +947,21 @@ CallCapture CaptureProgramUniform2fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniform2fv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform2fv, std::move(paramBuffer));
}
......@@ -745,11 +996,21 @@ CallCapture CaptureProgramUniform2iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureProgramUniform2iv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform2iv, std::move(paramBuffer));
}
......@@ -784,11 +1045,21 @@ CallCapture CaptureProgramUniform2uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureProgramUniform2uiv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform2uiv, std::move(paramBuffer));
}
......@@ -825,11 +1096,21 @@ CallCapture CaptureProgramUniform3fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniform3fv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform3fv, std::move(paramBuffer));
}
......@@ -866,11 +1147,21 @@ CallCapture CaptureProgramUniform3iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureProgramUniform3iv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform3iv, std::move(paramBuffer));
}
......@@ -907,11 +1198,21 @@ CallCapture CaptureProgramUniform3uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureProgramUniform3uiv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform3uiv, std::move(paramBuffer));
}
......@@ -950,11 +1251,21 @@ CallCapture CaptureProgramUniform4fv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniform4fv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform4fv, std::move(paramBuffer));
}
......@@ -993,11 +1304,21 @@ CallCapture CaptureProgramUniform4iv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, value, &valueParam.value);
CaptureProgramUniform4iv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform4iv, std::move(paramBuffer));
}
......@@ -1036,11 +1357,21 @@ CallCapture CaptureProgramUniform4uiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, value, &valueParam.value);
CaptureProgramUniform4uiv_value(glState, isCallValid, programPacked, locationPacked, count,
value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniform4uiv, std::move(paramBuffer));
}
......@@ -1060,11 +1391,21 @@ CallCapture CaptureProgramUniformMatrix2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix2fv_value(glState, isCallValid, programPacked, locationPacked, count,
transpose, value, &valueParam);
CaptureProgramUniformMatrix2fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix2fv, std::move(paramBuffer));
}
......@@ -1084,11 +1425,21 @@ CallCapture CaptureProgramUniformMatrix2x3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix2x3fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x3fv, std::move(paramBuffer));
}
......@@ -1108,11 +1459,21 @@ CallCapture CaptureProgramUniformMatrix2x4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix2x4fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x4fv, std::move(paramBuffer));
}
......@@ -1132,11 +1493,21 @@ CallCapture CaptureProgramUniformMatrix3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix3fv_value(glState, isCallValid, programPacked, locationPacked, count,
transpose, value, &valueParam);
CaptureProgramUniformMatrix3fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix3fv, std::move(paramBuffer));
}
......@@ -1156,11 +1527,21 @@ CallCapture CaptureProgramUniformMatrix3x2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix3x2fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x2fv, std::move(paramBuffer));
}
......@@ -1180,11 +1561,21 @@ CallCapture CaptureProgramUniformMatrix3x4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix3x4fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x4fv, std::move(paramBuffer));
}
......@@ -1204,11 +1595,21 @@ CallCapture CaptureProgramUniformMatrix4fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix4fv_value(glState, isCallValid, programPacked, locationPacked, count,
transpose, value, &valueParam);
CaptureProgramUniformMatrix4fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix4fv, std::move(paramBuffer));
}
......@@ -1228,11 +1629,21 @@ CallCapture CaptureProgramUniformMatrix4x2fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix4x2fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x2fv, std::move(paramBuffer));
}
......@@ -1252,11 +1663,21 @@ CallCapture CaptureProgramUniformMatrix4x3fv(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("transpose", ParamType::TGLboolean, transpose);
if (isCallValid)
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, value, &valueParam.value);
CaptureProgramUniformMatrix4x3fv_value(glState, isCallValid, programPacked, locationPacked,
count, transpose, value, &valueParam);
paramBuffer.addParam(std::move(valueParam));
}
else
{
ParamCapture valueParam("value", ParamType::TGLfloatConstPointer);
InitParamValue(ParamType::TGLfloatConstPointer, static_cast<const GLfloat *>(nullptr),
&valueParam.value);
paramBuffer.addParam(std::move(valueParam));
}
return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x3fv, std::move(paramBuffer));
}
......
src/libANGLE/capture_gles_3_2_autogen.cpp
......@@ -157,11 +157,21 @@ CallCapture CaptureDebugMessageCallback(const State &glState,
paramBuffer.addValueParam("callback", ParamType::TGLDEBUGPROC, callback);
if (isCallValid)
{
ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, userParam, &userParamParam.value);
CaptureDebugMessageCallback_userParam(glState, isCallValid, callback, userParam,
&userParamParam);
paramBuffer.addParam(std::move(userParamParam));
}
else
{
ParamCapture userParamParam("userParam", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&userParamParam.value);
paramBuffer.addParam(std::move(userParamParam));
}
return CallCapture(gl::EntryPoint::DebugMessageCallback, std::move(paramBuffer));
}
......@@ -182,11 +192,21 @@ CallCapture CaptureDebugMessageControl(const State &glState,
paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
if (isCallValid)
{
ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, ids, &idsParam.value);
CaptureDebugMessageControl_ids(glState, isCallValid, source, type, severity, count, ids,
enabled, &idsParam);
paramBuffer.addParam(std::move(idsParam));
}
else
{
ParamCapture idsParam("ids", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&idsParam.value);
paramBuffer.addParam(std::move(idsParam));
}
paramBuffer.addValueParam("enabled", ParamType::TGLboolean, enabled);
......@@ -210,11 +230,21 @@ CallCapture CaptureDebugMessageInsert(const State &glState,
paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity);
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
if (isCallValid)
{
ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, buf, &bufParam.value);
CaptureDebugMessageInsert_buf(glState, isCallValid, source, type, id, severity, length, buf,
&bufParam);
paramBuffer.addParam(std::move(bufParam));
}
else
{
ParamCapture bufParam("buf", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&bufParam.value);
paramBuffer.addParam(std::move(bufParam));
}
return CallCapture(gl::EntryPoint::DebugMessageInsert, std::move(paramBuffer));
}
......@@ -243,11 +273,21 @@ CallCapture CaptureDrawElementsBaseVertex(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawElementsBaseVertex_indices(glState, isCallValid, modePacked, count, typePacked,
indices, basevertex, &indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
......@@ -269,12 +309,22 @@ CallCapture CaptureDrawElementsInstancedBaseVertex(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawElementsInstancedBaseVertex_indices(glState, isCallValid, modePacked, count,
typePacked, indices, instancecount, basevertex,
&indicesParam);
typePacked, indices, instancecount,
basevertex, &indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
......@@ -300,11 +350,22 @@ CallCapture CaptureDrawRangeElementsBaseVertex(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
paramBuffer.addValueParam("typePacked", ParamType::TDrawElementsType, typePacked);
if (isCallValid)
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, indices, &indicesParam.value);
CaptureDrawRangeElementsBaseVertex_indices(glState, isCallValid, modePacked, start, end, count,
typePacked, indices, basevertex, &indicesParam);
CaptureDrawRangeElementsBaseVertex_indices(glState, isCallValid, modePacked, start, end,
count, typePacked, indices, basevertex,
&indicesParam);
paramBuffer.addParam(std::move(indicesParam));
}
else
{
ParamCapture indicesParam("indices", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&indicesParam.value);
paramBuffer.addParam(std::move(indicesParam));
}
paramBuffer.addValueParam("basevertex", ParamType::TGLint, basevertex);
......@@ -356,41 +417,102 @@ CallCapture CaptureGetDebugMessageLog(const State &glState,
paramBuffer.addValueParam("count", ParamType::TGLuint, count);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, sources, &sourcesParam.value);
CaptureGetDebugMessageLog_sources(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &sourcesParam);
paramBuffer.addParam(std::move(sourcesParam));
}
else
{
ParamCapture sourcesParam("sources", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
&sourcesParam.value);
paramBuffer.addParam(std::move(sourcesParam));
}
if (isCallValid)
{
ParamCapture typesParam("types", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, types, &typesParam.value);
CaptureGetDebugMessageLog_types(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &typesParam);
paramBuffer.addParam(std::move(typesParam));
}
else
{
ParamCapture typesParam("types", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
&typesParam.value);
paramBuffer.addParam(std::move(typesParam));
}
if (isCallValid)
{
ParamCapture idsParam("ids", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, ids, &idsParam.value);
CaptureGetDebugMessageLog_ids(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &idsParam);
paramBuffer.addParam(std::move(idsParam));
}
else
{
ParamCapture idsParam("ids", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr), &idsParam.value);
paramBuffer.addParam(std::move(idsParam));
}
if (isCallValid)
{
ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, severities, &severitiesParam.value);
CaptureGetDebugMessageLog_severities(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &severitiesParam);
CaptureGetDebugMessageLog_severities(glState, isCallValid, count, bufSize, sources, types,
ids, severities, lengths, messageLog,
&severitiesParam);
paramBuffer.addParam(std::move(severitiesParam));
}
else
{
ParamCapture severitiesParam("severities", ParamType::TGLenumPointer);
InitParamValue(ParamType::TGLenumPointer, static_cast<GLenum *>(nullptr),
&severitiesParam.value);
paramBuffer.addParam(std::move(severitiesParam));
}
if (isCallValid)
{
ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, lengths, &lengthsParam.value);
CaptureGetDebugMessageLog_lengths(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &lengthsParam);
paramBuffer.addParam(std::move(lengthsParam));
}
else
{
ParamCapture lengthsParam("lengths", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthsParam.value);
paramBuffer.addParam(std::move(lengthsParam));
}
if (isCallValid)
{
ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, messageLog, &messageLogParam.value);
CaptureGetDebugMessageLog_messageLog(glState, isCallValid, count, bufSize, sources, types, ids,
severities, lengths, messageLog, &messageLogParam);
CaptureGetDebugMessageLog_messageLog(glState, isCallValid, count, bufSize, sources, types,
ids, severities, lengths, messageLog,
&messageLogParam);
paramBuffer.addParam(std::move(messageLogParam));
}
else
{
ParamCapture messageLogParam("messageLog", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&messageLogParam.value);
paramBuffer.addParam(std::move(messageLogParam));
}
ParamCapture returnValueCapture("returnValue", ParamType::TGLuint);
InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
......@@ -427,17 +549,37 @@ CallCapture CaptureGetObjectLabel(const State &glState,
paramBuffer.addValueParam("name", ParamType::TGLuint, name);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetObjectLabel_length(glState, isCallValid, identifier, name, bufSize, length, label,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture labelParam("label", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
CaptureGetObjectLabel_label(glState, isCallValid, identifier, name, bufSize, length, label,
&labelParam);
paramBuffer.addParam(std::move(labelParam));
}
else
{
ParamCapture labelParam("label", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&labelParam.value);
paramBuffer.addParam(std::move(labelParam));
}
return CallCapture(gl::EntryPoint::GetObjectLabel, std::move(paramBuffer));
}
......@@ -451,23 +593,54 @@ CallCapture CaptureGetObjectPtrLabel(const State &glState,
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
CaptureGetObjectPtrLabel_ptr(glState, isCallValid, ptr, bufSize, length, label, &ptrParam);
paramBuffer.addParam(std::move(ptrParam));
}
else
{
ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&ptrParam.value);
paramBuffer.addParam(std::move(ptrParam));
}
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value);
CaptureGetObjectPtrLabel_length(glState, isCallValid, ptr, bufSize, length, label,
&lengthParam);
paramBuffer.addParam(std::move(lengthParam));
}
else
{
ParamCapture lengthParam("length", ParamType::TGLsizeiPointer);
InitParamValue(ParamType::TGLsizeiPointer, static_cast<GLsizei *>(nullptr),
&lengthParam.value);
paramBuffer.addParam(std::move(lengthParam));
}
if (isCallValid)
{
ParamCapture labelParam("label", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, label, &labelParam.value);
CaptureGetObjectPtrLabel_label(glState, isCallValid, ptr, bufSize, length, label, &labelParam);
CaptureGetObjectPtrLabel_label(glState, isCallValid, ptr, bufSize, length, label,
&labelParam);
paramBuffer.addParam(std::move(labelParam));
}
else
{
ParamCapture labelParam("label", ParamType::TGLcharPointer);
InitParamValue(ParamType::TGLcharPointer, static_cast<GLchar *>(nullptr),
&labelParam.value);
paramBuffer.addParam(std::move(labelParam));
}
return CallCapture(gl::EntryPoint::GetObjectPtrLabel, std::move(paramBuffer));
}
......@@ -478,10 +651,20 @@ CallCapture CaptureGetPointerv(const State &glState, bool isCallValid, GLenum pn
paramBuffer.addEnumParam("pname", GLenumGroup::GetPointervPName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, params, &paramsParam.value);
CaptureGetPointerv_params(glState, isCallValid, pname, params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TvoidPointerPointer);
InitParamValue(ParamType::TvoidPointerPointer, static_cast<void **>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetPointerv, std::move(paramBuffer));
}
......@@ -497,11 +680,20 @@ CallCapture CaptureGetSamplerParameterIiv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetSamplerParameterIiv_params(glState, isCallValid, samplerPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetSamplerParameterIiv, std::move(paramBuffer));
}
......@@ -517,11 +709,21 @@ CallCapture CaptureGetSamplerParameterIuiv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetSamplerParameterIuiv_params(glState, isCallValid, samplerPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetSamplerParameterIuiv, std::move(paramBuffer));
}
......@@ -537,11 +739,20 @@ CallCapture CaptureGetTexParameterIiv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetTexParameterIiv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexParameterIiv, std::move(paramBuffer));
}
......@@ -557,11 +768,21 @@ CallCapture CaptureGetTexParameterIuiv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetTexParameterIuiv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetTexParameterIuiv, std::move(paramBuffer));
}
......@@ -579,11 +800,21 @@ CallCapture CaptureGetnUniformfv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, params, &paramsParam.value);
CaptureGetnUniformfv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLfloatPointer);
InitParamValue(ParamType::TGLfloatPointer, static_cast<GLfloat *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetnUniformfv, std::move(paramBuffer));
}
......@@ -601,11 +832,20 @@ CallCapture CaptureGetnUniformiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, params, &paramsParam.value);
CaptureGetnUniformiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintPointer);
InitParamValue(ParamType::TGLintPointer, static_cast<GLint *>(nullptr), &paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetnUniformiv, std::move(paramBuffer));
}
......@@ -623,11 +863,21 @@ CallCapture CaptureGetnUniformuiv(const State &glState,
paramBuffer.addValueParam("locationPacked", ParamType::TUniformLocation, locationPacked);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, params, &paramsParam.value);
CaptureGetnUniformuiv_params(glState, isCallValid, programPacked, locationPacked, bufSize,
params, &paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintPointer);
InitParamValue(ParamType::TGLuintPointer, static_cast<GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::GetnUniformuiv, std::move(paramBuffer));
}
......@@ -673,10 +923,21 @@ CallCapture CaptureObjectLabel(const State &glState,
paramBuffer.addValueParam("name", ParamType::TGLuint, name);
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
if (isCallValid)
{
ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
CaptureObjectLabel_label(glState, isCallValid, identifier, name, length, label, &labelParam);
CaptureObjectLabel_label(glState, isCallValid, identifier, name, length, label,
&labelParam);
paramBuffer.addParam(std::move(labelParam));
}
else
{
ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&labelParam.value);
paramBuffer.addParam(std::move(labelParam));
}
return CallCapture(gl::EntryPoint::ObjectLabel, std::move(paramBuffer));
}
......@@ -689,17 +950,37 @@ CallCapture CaptureObjectPtrLabel(const State &glState,
{
ParamBuffer paramBuffer;
if (isCallValid)
{
ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, ptr, &ptrParam.value);
CaptureObjectPtrLabel_ptr(glState, isCallValid, ptr, length, label, &ptrParam);
paramBuffer.addParam(std::move(ptrParam));
}
else
{
ParamCapture ptrParam("ptr", ParamType::TvoidConstPointer);
InitParamValue(ParamType::TvoidConstPointer, static_cast<const void *>(nullptr),
&ptrParam.value);
paramBuffer.addParam(std::move(ptrParam));
}
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
if (isCallValid)
{
ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, label, &labelParam.value);
CaptureObjectPtrLabel_label(glState, isCallValid, ptr, length, label, &labelParam);
paramBuffer.addParam(std::move(labelParam));
}
else
{
ParamCapture labelParam("label", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&labelParam.value);
paramBuffer.addParam(std::move(labelParam));
}
return CallCapture(gl::EntryPoint::ObjectPtrLabel, std::move(paramBuffer));
}
......@@ -762,10 +1043,21 @@ CallCapture CapturePushDebugGroup(const State &glState,
paramBuffer.addValueParam("id", ParamType::TGLuint, id);
paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
if (isCallValid)
{
ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, message, &messageParam.value);
CapturePushDebugGroup_message(glState, isCallValid, source, id, length, message, &messageParam);
CapturePushDebugGroup_message(glState, isCallValid, source, id, length, message,
&messageParam);
paramBuffer.addParam(std::move(messageParam));
}
else
{
ParamCapture messageParam("message", ParamType::TGLcharConstPointer);
InitParamValue(ParamType::TGLcharConstPointer, static_cast<const GLchar *>(nullptr),
&messageParam.value);
paramBuffer.addParam(std::move(messageParam));
}
return CallCapture(gl::EntryPoint::PushDebugGroup, std::move(paramBuffer));
}
......@@ -791,11 +1083,20 @@ CallCapture CaptureReadnPixels(const State &glState,
paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type);
paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize);
if (isCallValid)
{
ParamCapture dataParam("data", ParamType::TvoidPointer);
InitParamValue(ParamType::TvoidPointer, data, &dataParam.value);
CaptureReadnPixels_data(glState, isCallValid, x, y, width, height, format, type, bufSize, data,
&dataParam);
CaptureReadnPixels_data(glState, isCallValid, x, y, width, height, format, type, bufSize,
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(gl::EntryPoint::ReadnPixels, std::move(paramBuffer));
}
......@@ -811,11 +1112,21 @@ CallCapture CaptureSamplerParameterIiv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, param, &paramParam.value);
CaptureSamplerParameterIiv_param(glState, isCallValid, samplerPacked, pname, param,
&paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::SamplerParameterIiv, std::move(paramBuffer));
}
......@@ -831,11 +1142,21 @@ CallCapture CaptureSamplerParameterIuiv(const State &glState,
paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, param, &paramParam.value);
CaptureSamplerParameterIuiv_param(glState, isCallValid, samplerPacked, pname, param,
&paramParam);
paramBuffer.addParam(std::move(paramParam));
}
else
{
ParamCapture paramParam("param", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&paramParam.value);
paramBuffer.addParam(std::move(paramParam));
}
return CallCapture(gl::EntryPoint::SamplerParameterIuiv, std::move(paramBuffer));
}
......@@ -887,10 +1208,21 @@ CallCapture CaptureTexParameterIiv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, params, &paramsParam.value);
CaptureTexParameterIiv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
CaptureTexParameterIiv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLintConstPointer);
InitParamValue(ParamType::TGLintConstPointer, static_cast<const GLint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexParameterIiv, std::move(paramBuffer));
}
......@@ -906,10 +1238,21 @@ CallCapture CaptureTexParameterIuiv(const State &glState,
paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname);
if (isCallValid)
{
ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, params, &paramsParam.value);
CaptureTexParameterIuiv_params(glState, isCallValid, targetPacked, pname, params, &paramsParam);
CaptureTexParameterIuiv_params(glState, isCallValid, targetPacked, pname, params,
&paramsParam);
paramBuffer.addParam(std::move(paramsParam));
}
else
{
ParamCapture paramsParam("params", ParamType::TGLuintConstPointer);
InitParamValue(ParamType::TGLuintConstPointer, static_cast<const GLuint *>(nullptr),
&paramsParam.value);
paramBuffer.addParam(std::move(paramsParam));
}
return CallCapture(gl::EntryPoint::TexParameterIuiv, std::move(paramBuffer));
}
......
src/libANGLE/capture_gles_ext_autogen.cpp
This source diff could not be displayed because it is too large. You can view the blob instead.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment