Skip to content

A
angle
Commit 263232ef by Jamie Madill Committed by Commit Bot
Options

Trace/Replay: Pass CallCapture to parameter replay writer.

This will allow more advanced processing when writing the cpp replay for a specific parmeter. For the uniform locations map it'll allow us to look up the specified program from the call parameters. Bug: angleproject:4411 Change-Id: I4e91b3e4c6775c42140d00b2d155344b553a7404 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2067629Reviewed-by: 's avatarCourtney Goeltzenleuchter <courtneygo@google.com> Reviewed-by: 's avatarCody Northrop <cnorthrop@google.com> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent e3aee0b4
Showing with 339 additions and 246 deletions
scripts/code_generation_hashes/GL_EGL_entry_points.json
......@@ -6,7 +6,7 @@
"scripts/entry_point_packed_gl_enums.json":
"63f508a08611e75810daedb297dca0e9",
"scripts/generate_entry_points.py":
"2e6615919533b8ca9042093287589165",
"e12540094b7f57778de97b05c16d2e28",
"scripts/gl.xml":
"2af7b077ec347349b3a92683e8fb8b03",
"scripts/gl_angle_ext.xml":
......@@ -96,9 +96,9 @@
"src/libANGLE/frame_capture_replay_autogen.cpp":
"c0d57704c21e0032a486a6195ddb87e4",
"src/libANGLE/frame_capture_utils_autogen.cpp":
"ef0545342e0458e55e17abf46a8cde60",
"cf2257638fb6df56061721775efda084",
"src/libANGLE/frame_capture_utils_autogen.h":
"637125f7c18f05c17800e5da2516fd6b",
"1cd48ca4faeba4379456943d002ea412",
"src/libANGLE/validationES1_autogen.h":
"c8edb0a5b26303bf7c4692b9d0b05c1f",
"src/libANGLE/validationES2_autogen.h":
......
scripts/generate_entry_points.py
......@@ -563,7 +563,10 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
}}
}}
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue& paramValue);
struct CallCapture;
struct ParamCapture;
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
const char *ParamTypeToString(ParamType paramType);
enum class ResourceIDType
......@@ -594,9 +597,9 @@ template_frame_capture_utils_source = """// GENERATED FILE - DO NOT EDIT.
namespace angle
{{
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue& paramValue)
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param)
{{
switch (paramType)
switch (param.type)
{{
{write_param_type_to_stream_cases}
default:
......@@ -659,7 +662,7 @@ template_init_param_value_case = """ case ParamType::T{enum}:
break;"""
template_write_param_type_to_stream_case = """ case ParamType::T{enum}:
WriteParamValueToStream<ParamType::T{enum}>(os, paramValue.{union_name});
WriteParamValueReplay<ParamType::T{enum}>(os, call, param.value.{union_name});
break;"""
template_param_type_to_string_case = """ case ParamType::T{enum}:
......
src/libANGLE/FrameCapture.cpp
......@@ -487,7 +487,7 @@ void WriteCppReplayForCall(const CallCapture &call,
}
else
{
callOut << param;
WriteParamCaptureReplay(callOut, call, param);
}
}
else
......@@ -2584,12 +2584,6 @@ void FrameCapture::reset()
// necessary.
}
std::ostream &operator<<(std::ostream &os, const ParamCapture &capture)
{
WriteParamTypeToStream(os, capture.type, capture.value);
return os;
}
void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture)
{
std::vector<uint8_t> data(size);
......@@ -2632,7 +2626,9 @@ void CaptureGenHandlesImpl(GLsizei n, GLuint *handles, ParamCapture *paramCaptur
}
template <>
void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean value)
void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
const CallCapture &call,
GLboolean value)
{
switch (value)
{
......@@ -2648,7 +2644,9 @@ void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean
}
template <>
void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, const void *value)
void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
const CallCapture &call,
const void *value)
{
if (value == 0)
{
......@@ -2662,103 +2660,133 @@ void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, con
}
template <>
void WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, GLDEBUGPROCKHR value)
void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
const CallCapture &call,
GLDEBUGPROCKHR value)
{}
template <>
void WriteParamValueToStream<ParamType::TGLDEBUGPROC>(std::ostream &os, GLDEBUGPROC value)
void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
const CallCapture &call,
GLDEBUGPROC value)
{}
template <>
void WriteParamValueToStream<ParamType::TBufferID>(std::ostream &os, gl::BufferID value)
void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
const CallCapture &call,
gl::BufferID value)
{
os << "gBufferMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TFenceNVID>(std::ostream &os, gl::FenceNVID value)
void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
const CallCapture &call,
gl::FenceNVID value)
{
os << "gFenceMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TFramebufferID>(std::ostream &os, gl::FramebufferID value)
void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
const CallCapture &call,
gl::FramebufferID value)
{
os << "gFramebufferMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TMemoryObjectID>(std::ostream &os, gl::MemoryObjectID value)
void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
const CallCapture &call,
gl::MemoryObjectID value)
{
os << "gMemoryObjectMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TPathID>(std::ostream &os, gl::PathID value)
void WriteParamValueReplay<ParamType::TPathID>(std::ostream &os,
const CallCapture &call,
gl::PathID value)
{
os << "gPathMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TProgramPipelineID>(std::ostream &os,
gl::ProgramPipelineID value)
void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
const CallCapture &call,
gl::ProgramPipelineID value)
{
os << "gProgramPipelineMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TQueryID>(std::ostream &os, gl::QueryID value)
void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
const CallCapture &call,
gl::QueryID value)
{
os << "gQueryMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TRenderbufferID>(std::ostream &os, gl::RenderbufferID value)
void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
const CallCapture &call,
gl::RenderbufferID value)
{
os << "gRenderbufferMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TSamplerID>(std::ostream &os, gl::SamplerID value)
void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
const CallCapture &call,
gl::SamplerID value)
{
os << "gSamplerMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TSemaphoreID>(std::ostream &os, gl::SemaphoreID value)
void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
const CallCapture &call,
gl::SemaphoreID value)
{
os << "gSempahoreMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TShaderProgramID>(std::ostream &os,
gl::ShaderProgramID value)
void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
const CallCapture &call,
gl::ShaderProgramID value)
{
os << "gShaderProgramMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TTextureID>(std::ostream &os, gl::TextureID value)
void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
const CallCapture &call,
gl::TextureID value)
{
os << "gTextureMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TTransformFeedbackID>(std::ostream &os,
gl::TransformFeedbackID value)
void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
const CallCapture &call,
gl::TransformFeedbackID value)
{
os << "gTransformFeedbackMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value)
void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
const CallCapture &call,
gl::VertexArrayID value)
{
os << "gVertexArrayMap[" << value.value << "]";
}
template <>
void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
gl::UniformLocation value)
void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
const CallCapture &call,
gl::UniformLocation value)
{
// TODO(jmadill): Uniform locations map. http://anglebug.com/4411
os << value.value;
......
src/libANGLE/FrameCapture.h
......@@ -295,74 +295,106 @@ void CaptureGenHandles(GLsizei n, T *handles, ParamCapture *paramCapture)
}
template <ParamType ParamT, typename T>
void WriteParamValueToStream(std::ostream &os, T value);
void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value);
template <>
void WriteParamValueToStream<ParamType::TGLboolean>(std::ostream &os, GLboolean value);
void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
const CallCapture &call,
GLboolean value);
template <>
void WriteParamValueToStream<ParamType::TvoidConstPointer>(std::ostream &os, const void *value);
void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
const CallCapture &call,
const void *value);
template <>
void WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(std::ostream &os, GLDEBUGPROCKHR value);
void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
const CallCapture &call,
GLDEBUGPROCKHR value);
template <>
void WriteParamValueToStream<ParamType::TGLDEBUGPROC>(std::ostream &os, GLDEBUGPROC value);
void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
const CallCapture &call,
GLDEBUGPROC value);
template <>
void WriteParamValueToStream<ParamType::TBufferID>(std::ostream &os, gl::BufferID value);
void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
const CallCapture &call,
gl::BufferID value);
template <>
void WriteParamValueToStream<ParamType::TFenceNVID>(std::ostream &os, gl::FenceNVID value);
void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
const CallCapture &call,
gl::FenceNVID value);
template <>
void WriteParamValueToStream<ParamType::TFramebufferID>(std::ostream &os, gl::FramebufferID value);
void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
const CallCapture &call,
gl::FramebufferID value);
template <>
void WriteParamValueToStream<ParamType::TMemoryObjectID>(std::ostream &os,
gl::MemoryObjectID value);
void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
const CallCapture &call,
gl::MemoryObjectID value);
template <>
void WriteParamValueToStream<ParamType::TPathID>(std::ostream &os, gl::PathID value);
void WriteParamValueReplay<ParamType::TPathID>(std::ostream &os,
const CallCapture &call,
gl::PathID value);
template <>
void WriteParamValueToStream<ParamType::TProgramPipelineID>(std::ostream &os,
gl::ProgramPipelineID value);
void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
const CallCapture &call,
gl::ProgramPipelineID value);
template <>
void WriteParamValueToStream<ParamType::TQueryID>(std::ostream &os, gl::QueryID value);
void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
const CallCapture &call,
gl::QueryID value);
template <>
void WriteParamValueToStream<ParamType::TRenderbufferID>(std::ostream &os,
gl::RenderbufferID value);
void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
const CallCapture &call,
gl::RenderbufferID value);
template <>
void WriteParamValueToStream<ParamType::TSamplerID>(std::ostream &os, gl::SamplerID value);
void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
const CallCapture &call,
gl::SamplerID value);
template <>
void WriteParamValueToStream<ParamType::TSemaphoreID>(std::ostream &os, gl::SemaphoreID value);
void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
const CallCapture &call,
gl::SemaphoreID value);
template <>
void WriteParamValueToStream<ParamType::TShaderProgramID>(std::ostream &os,
gl::ShaderProgramID value);
void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
const CallCapture &call,
gl::ShaderProgramID value);
template <>
void WriteParamValueToStream<ParamType::TTextureID>(std::ostream &os, gl::TextureID value);
void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
const CallCapture &call,
gl::TextureID value);
template <>
void WriteParamValueToStream<ParamType::TTransformFeedbackID>(std::ostream &os,
gl::TransformFeedbackID value);
void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
const CallCapture &call,
gl::TransformFeedbackID value);
template <>
void WriteParamValueToStream<ParamType::TVertexArrayID>(std::ostream &os, gl::VertexArrayID value);
void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
const CallCapture &call,
gl::VertexArrayID value);
template <>
void WriteParamValueToStream<ParamType::TUniformLocation>(std::ostream &os,
gl::UniformLocation value);
void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
const CallCapture &call,
gl::UniformLocation value);
// General fallback for any unspecific type.
template <ParamType ParamT, typename T>
void WriteParamValueToStream(std::ostream &os, T value)
void WriteParamValueReplay(std::ostream &os, const CallCapture &call, T value)
{
os << value;
}
......
src/libANGLE/frame_capture_utils_autogen.cpp
......@@ -14,430 +14,457 @@
namespace angle
{
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue &paramValue)
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param)
{
switch (paramType)
switch (param.type)
{
case ParamType::TAlphaTestFunc:
WriteParamValueToStream<ParamType::TAlphaTestFunc>(os, paramValue.AlphaTestFuncVal);
WriteParamValueReplay<ParamType::TAlphaTestFunc>(os, call,
param.value.AlphaTestFuncVal);
break;
case ParamType::TBufferBinding:
WriteParamValueToStream<ParamType::TBufferBinding>(os, paramValue.BufferBindingVal);
WriteParamValueReplay<ParamType::TBufferBinding>(os, call,
param.value.BufferBindingVal);
break;
case ParamType::TBufferID:
WriteParamValueToStream<ParamType::TBufferID>(os, paramValue.BufferIDVal);
WriteParamValueReplay<ParamType::TBufferID>(os, call, param.value.BufferIDVal);
break;
case ParamType::TBufferIDConstPointer:
WriteParamValueToStream<ParamType::TBufferIDConstPointer>(
os, paramValue.BufferIDConstPointerVal);
WriteParamValueReplay<ParamType::TBufferIDConstPointer>(
os, call, param.value.BufferIDConstPointerVal);
break;
case ParamType::TBufferIDPointer:
WriteParamValueToStream<ParamType::TBufferIDPointer>(os, paramValue.BufferIDPointerVal);
WriteParamValueReplay<ParamType::TBufferIDPointer>(os, call,
param.value.BufferIDPointerVal);
break;
case ParamType::TBufferUsage:
WriteParamValueToStream<ParamType::TBufferUsage>(os, paramValue.BufferUsageVal);
WriteParamValueReplay<ParamType::TBufferUsage>(os, call, param.value.BufferUsageVal);
break;
case ParamType::TClientVertexArrayType:
WriteParamValueToStream<ParamType::TClientVertexArrayType>(
os, paramValue.ClientVertexArrayTypeVal);
WriteParamValueReplay<ParamType::TClientVertexArrayType>(
os, call, param.value.ClientVertexArrayTypeVal);
break;
case ParamType::TCullFaceMode:
WriteParamValueToStream<ParamType::TCullFaceMode>(os, paramValue.CullFaceModeVal);
WriteParamValueReplay<ParamType::TCullFaceMode>(os, call, param.value.CullFaceModeVal);
break;
case ParamType::TDrawElementsType:
WriteParamValueToStream<ParamType::TDrawElementsType>(os,
paramValue.DrawElementsTypeVal);
WriteParamValueReplay<ParamType::TDrawElementsType>(os, call,
param.value.DrawElementsTypeVal);
break;
case ParamType::TFenceNVID:
WriteParamValueToStream<ParamType::TFenceNVID>(os, paramValue.FenceNVIDVal);
WriteParamValueReplay<ParamType::TFenceNVID>(os, call, param.value.FenceNVIDVal);
break;
case ParamType::TFenceNVIDConstPointer:
WriteParamValueToStream<ParamType::TFenceNVIDConstPointer>(
os, paramValue.FenceNVIDConstPointerVal);
WriteParamValueReplay<ParamType::TFenceNVIDConstPointer>(
os, call, param.value.FenceNVIDConstPointerVal);
break;
case ParamType::TFenceNVIDPointer:
WriteParamValueToStream<ParamType::TFenceNVIDPointer>(os,
paramValue.FenceNVIDPointerVal);
WriteParamValueReplay<ParamType::TFenceNVIDPointer>(os, call,
param.value.FenceNVIDPointerVal);
break;
case ParamType::TFramebufferID:
WriteParamValueToStream<ParamType::TFramebufferID>(os, paramValue.FramebufferIDVal);
WriteParamValueReplay<ParamType::TFramebufferID>(os, call,
param.value.FramebufferIDVal);
break;
case ParamType::TFramebufferIDConstPointer:
WriteParamValueToStream<ParamType::TFramebufferIDConstPointer>(
os, paramValue.FramebufferIDConstPointerVal);
WriteParamValueReplay<ParamType::TFramebufferIDConstPointer>(
os, call, param.value.FramebufferIDConstPointerVal);
break;
case ParamType::TFramebufferIDPointer:
WriteParamValueToStream<ParamType::TFramebufferIDPointer>(
os, paramValue.FramebufferIDPointerVal);
WriteParamValueReplay<ParamType::TFramebufferIDPointer>(
os, call, param.value.FramebufferIDPointerVal);
break;
case ParamType::TGLDEBUGPROC:
WriteParamValueToStream<ParamType::TGLDEBUGPROC>(os, paramValue.GLDEBUGPROCVal);
WriteParamValueReplay<ParamType::TGLDEBUGPROC>(os, call, param.value.GLDEBUGPROCVal);
break;
case ParamType::TGLDEBUGPROCKHR:
WriteParamValueToStream<ParamType::TGLDEBUGPROCKHR>(os, paramValue.GLDEBUGPROCKHRVal);
WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(os, call,
param.value.GLDEBUGPROCKHRVal);
break;
case ParamType::TGLbitfield:
WriteParamValueToStream<ParamType::TGLbitfield>(os, paramValue.GLbitfieldVal);
WriteParamValueReplay<ParamType::TGLbitfield>(os, call, param.value.GLbitfieldVal);
break;
case ParamType::TGLboolean:
WriteParamValueToStream<ParamType::TGLboolean>(os, paramValue.GLbooleanVal);
WriteParamValueReplay<ParamType::TGLboolean>(os, call, param.value.GLbooleanVal);
break;
case ParamType::TGLbooleanConstPointer:
WriteParamValueToStream<ParamType::TGLbooleanConstPointer>(
os, paramValue.GLbooleanConstPointerVal);
WriteParamValueReplay<ParamType::TGLbooleanConstPointer>(
os, call, param.value.GLbooleanConstPointerVal);
break;
case ParamType::TGLbooleanPointer:
WriteParamValueToStream<ParamType::TGLbooleanPointer>(os,
paramValue.GLbooleanPointerVal);
WriteParamValueReplay<ParamType::TGLbooleanPointer>(os, call,
param.value.GLbooleanPointerVal);
break;
case ParamType::TGLbyte:
WriteParamValueToStream<ParamType::TGLbyte>(os, paramValue.GLbyteVal);
WriteParamValueReplay<ParamType::TGLbyte>(os, call, param.value.GLbyteVal);
break;
case ParamType::TGLbyteConstPointer:
WriteParamValueToStream<ParamType::TGLbyteConstPointer>(
os, paramValue.GLbyteConstPointerVal);
WriteParamValueReplay<ParamType::TGLbyteConstPointer>(
os, call, param.value.GLbyteConstPointerVal);
break;
case ParamType::TGLcharConstPointer:
WriteParamValueToStream<ParamType::TGLcharConstPointer>(
os, paramValue.GLcharConstPointerVal);
WriteParamValueReplay<ParamType::TGLcharConstPointer>(
os, call, param.value.GLcharConstPointerVal);
break;
case ParamType::TGLcharConstPointerPointer:
WriteParamValueToStream<ParamType::TGLcharConstPointerPointer>(
os, paramValue.GLcharConstPointerPointerVal);
WriteParamValueReplay<ParamType::TGLcharConstPointerPointer>(
os, call, param.value.GLcharConstPointerPointerVal);
break;
case ParamType::TGLcharPointer:
WriteParamValueToStream<ParamType::TGLcharPointer>(os, paramValue.GLcharPointerVal);
WriteParamValueReplay<ParamType::TGLcharPointer>(os, call,
param.value.GLcharPointerVal);
break;
case ParamType::TGLclampx:
WriteParamValueToStream<ParamType::TGLclampx>(os, paramValue.GLclampxVal);
WriteParamValueReplay<ParamType::TGLclampx>(os, call, param.value.GLclampxVal);
break;
case ParamType::TGLdouble:
WriteParamValueToStream<ParamType::TGLdouble>(os, paramValue.GLdoubleVal);
WriteParamValueReplay<ParamType::TGLdouble>(os, call, param.value.GLdoubleVal);
break;
case ParamType::TGLdoubleConstPointer:
WriteParamValueToStream<ParamType::TGLdoubleConstPointer>(
os, paramValue.GLdoubleConstPointerVal);
WriteParamValueReplay<ParamType::TGLdoubleConstPointer>(
os, call, param.value.GLdoubleConstPointerVal);
break;
case ParamType::TGLdoublePointer:
WriteParamValueToStream<ParamType::TGLdoublePointer>(os, paramValue.GLdoublePointerVal);
WriteParamValueReplay<ParamType::TGLdoublePointer>(os, call,
param.value.GLdoublePointerVal);
break;
case ParamType::TGLeglImageOES:
WriteParamValueToStream<ParamType::TGLeglImageOES>(os, paramValue.GLeglImageOESVal);
WriteParamValueReplay<ParamType::TGLeglImageOES>(os, call,
param.value.GLeglImageOESVal);
break;
case ParamType::TGLenum:
WriteParamValueToStream<ParamType::TGLenum>(os, paramValue.GLenumVal);
WriteParamValueReplay<ParamType::TGLenum>(os, call, param.value.GLenumVal);
break;
case ParamType::TGLenumConstPointer:
WriteParamValueToStream<ParamType::TGLenumConstPointer>(
os, paramValue.GLenumConstPointerVal);
WriteParamValueReplay<ParamType::TGLenumConstPointer>(
os, call, param.value.GLenumConstPointerVal);
break;
case ParamType::TGLenumPointer:
WriteParamValueToStream<ParamType::TGLenumPointer>(os, paramValue.GLenumPointerVal);
WriteParamValueReplay<ParamType::TGLenumPointer>(os, call,
param.value.GLenumPointerVal);
break;
case ParamType::TGLfixed:
WriteParamValueToStream<ParamType::TGLfixed>(os, paramValue.GLfixedVal);
WriteParamValueReplay<ParamType::TGLfixed>(os, call, param.value.GLfixedVal);
break;
case ParamType::TGLfixedConstPointer:
WriteParamValueToStream<ParamType::TGLfixedConstPointer>(
os, paramValue.GLfixedConstPointerVal);
WriteParamValueReplay<ParamType::TGLfixedConstPointer>(
os, call, param.value.GLfixedConstPointerVal);
break;
case ParamType::TGLfixedPointer:
WriteParamValueToStream<ParamType::TGLfixedPointer>(os, paramValue.GLfixedPointerVal);
WriteParamValueReplay<ParamType::TGLfixedPointer>(os, call,
param.value.GLfixedPointerVal);
break;
case ParamType::TGLfloat:
WriteParamValueToStream<ParamType::TGLfloat>(os, paramValue.GLfloatVal);
WriteParamValueReplay<ParamType::TGLfloat>(os, call, param.value.GLfloatVal);
break;
case ParamType::TGLfloatConstPointer:
WriteParamValueToStream<ParamType::TGLfloatConstPointer>(
os, paramValue.GLfloatConstPointerVal);
WriteParamValueReplay<ParamType::TGLfloatConstPointer>(
os, call, param.value.GLfloatConstPointerVal);
break;
case ParamType::TGLfloatPointer:
WriteParamValueToStream<ParamType::TGLfloatPointer>(os, paramValue.GLfloatPointerVal);
WriteParamValueReplay<ParamType::TGLfloatPointer>(os, call,
param.value.GLfloatPointerVal);
break;
case ParamType::TGLint:
WriteParamValueToStream<ParamType::TGLint>(os, paramValue.GLintVal);
WriteParamValueReplay<ParamType::TGLint>(os, call, param.value.GLintVal);
break;
case ParamType::TGLint64Pointer:
WriteParamValueToStream<ParamType::TGLint64Pointer>(os, paramValue.GLint64PointerVal);
WriteParamValueReplay<ParamType::TGLint64Pointer>(os, call,
param.value.GLint64PointerVal);
break;
case ParamType::TGLintConstPointer:
WriteParamValueToStream<ParamType::TGLintConstPointer>(os,
paramValue.GLintConstPointerVal);
WriteParamValueReplay<ParamType::TGLintConstPointer>(os, call,
param.value.GLintConstPointerVal);
break;
case ParamType::TGLintPointer:
WriteParamValueToStream<ParamType::TGLintPointer>(os, paramValue.GLintPointerVal);
WriteParamValueReplay<ParamType::TGLintPointer>(os, call, param.value.GLintPointerVal);
break;
case ParamType::TGLintptr:
WriteParamValueToStream<ParamType::TGLintptr>(os, paramValue.GLintptrVal);
WriteParamValueReplay<ParamType::TGLintptr>(os, call, param.value.GLintptrVal);
break;
case ParamType::TGLintptrConstPointer:
WriteParamValueToStream<ParamType::TGLintptrConstPointer>(
os, paramValue.GLintptrConstPointerVal);
WriteParamValueReplay<ParamType::TGLintptrConstPointer>(
os, call, param.value.GLintptrConstPointerVal);
break;
case ParamType::TGLshort:
WriteParamValueToStream<ParamType::TGLshort>(os, paramValue.GLshortVal);
WriteParamValueReplay<ParamType::TGLshort>(os, call, param.value.GLshortVal);
break;
case ParamType::TGLshortConstPointer:
WriteParamValueToStream<ParamType::TGLshortConstPointer>(
os, paramValue.GLshortConstPointerVal);
WriteParamValueReplay<ParamType::TGLshortConstPointer>(
os, call, param.value.GLshortConstPointerVal);
break;
case ParamType::TGLsizei:
WriteParamValueToStream<ParamType::TGLsizei>(os, paramValue.GLsizeiVal);
WriteParamValueReplay<ParamType::TGLsizei>(os, call, param.value.GLsizeiVal);
break;
case ParamType::TGLsizeiConstPointer:
WriteParamValueToStream<ParamType::TGLsizeiConstPointer>(
os, paramValue.GLsizeiConstPointerVal);
WriteParamValueReplay<ParamType::TGLsizeiConstPointer>(
os, call, param.value.GLsizeiConstPointerVal);
break;
case ParamType::TGLsizeiPointer:
WriteParamValueToStream<ParamType::TGLsizeiPointer>(os, paramValue.GLsizeiPointerVal);
WriteParamValueReplay<ParamType::TGLsizeiPointer>(os, call,
param.value.GLsizeiPointerVal);
break;
case ParamType::TGLsizeiptr:
WriteParamValueToStream<ParamType::TGLsizeiptr>(os, paramValue.GLsizeiptrVal);
WriteParamValueReplay<ParamType::TGLsizeiptr>(os, call, param.value.GLsizeiptrVal);
break;
case ParamType::TGLsizeiptrConstPointer:
WriteParamValueToStream<ParamType::TGLsizeiptrConstPointer>(
os, paramValue.GLsizeiptrConstPointerVal);
WriteParamValueReplay<ParamType::TGLsizeiptrConstPointer>(
os, call, param.value.GLsizeiptrConstPointerVal);
break;
case ParamType::TGLsync:
WriteParamValueToStream<ParamType::TGLsync>(os, paramValue.GLsyncVal);
WriteParamValueReplay<ParamType::TGLsync>(os, call, param.value.GLsyncVal);
break;
case ParamType::TGLubyte:
WriteParamValueToStream<ParamType::TGLubyte>(os, paramValue.GLubyteVal);
WriteParamValueReplay<ParamType::TGLubyte>(os, call, param.value.GLubyteVal);
break;
case ParamType::TGLubyteConstPointer:
WriteParamValueToStream<ParamType::TGLubyteConstPointer>(
os, paramValue.GLubyteConstPointerVal);
WriteParamValueReplay<ParamType::TGLubyteConstPointer>(
os, call, param.value.GLubyteConstPointerVal);
break;
case ParamType::TGLubytePointer:
WriteParamValueToStream<ParamType::TGLubytePointer>(os, paramValue.GLubytePointerVal);
WriteParamValueReplay<ParamType::TGLubytePointer>(os, call,
param.value.GLubytePointerVal);
break;
case ParamType::TGLuint:
WriteParamValueToStream<ParamType::TGLuint>(os, paramValue.GLuintVal);
WriteParamValueReplay<ParamType::TGLuint>(os, call, param.value.GLuintVal);
break;
case ParamType::TGLuint64:
WriteParamValueToStream<ParamType::TGLuint64>(os, paramValue.GLuint64Val);
WriteParamValueReplay<ParamType::TGLuint64>(os, call, param.value.GLuint64Val);
break;
case ParamType::TGLuint64ConstPointer:
WriteParamValueToStream<ParamType::TGLuint64ConstPointer>(
os, paramValue.GLuint64ConstPointerVal);
WriteParamValueReplay<ParamType::TGLuint64ConstPointer>(
os, call, param.value.GLuint64ConstPointerVal);
break;
case ParamType::TGLuint64Pointer:
WriteParamValueToStream<ParamType::TGLuint64Pointer>(os, paramValue.GLuint64PointerVal);
WriteParamValueReplay<ParamType::TGLuint64Pointer>(os, call,
param.value.GLuint64PointerVal);
break;
case ParamType::TGLuintConstPointer:
WriteParamValueToStream<ParamType::TGLuintConstPointer>(
os, paramValue.GLuintConstPointerVal);
WriteParamValueReplay<ParamType::TGLuintConstPointer>(
os, call, param.value.GLuintConstPointerVal);
break;
case ParamType::TGLuintPointer:
WriteParamValueToStream<ParamType::TGLuintPointer>(os, paramValue.GLuintPointerVal);
WriteParamValueReplay<ParamType::TGLuintPointer>(os, call,
param.value.GLuintPointerVal);
break;
case ParamType::TGLushort:
WriteParamValueToStream<ParamType::TGLushort>(os, paramValue.GLushortVal);
WriteParamValueReplay<ParamType::TGLushort>(os, call, param.value.GLushortVal);
break;
case ParamType::TGLushortConstPointer:
WriteParamValueToStream<ParamType::TGLushortConstPointer>(
os, paramValue.GLushortConstPointerVal);
WriteParamValueReplay<ParamType::TGLushortConstPointer>(
os, call, param.value.GLushortConstPointerVal);
break;
case ParamType::TGLushortPointer:
WriteParamValueToStream<ParamType::TGLushortPointer>(os, paramValue.GLushortPointerVal);
WriteParamValueReplay<ParamType::TGLushortPointer>(os, call,
param.value.GLushortPointerVal);
break;
case ParamType::TGLvoidConstPointer:
WriteParamValueToStream<ParamType::TGLvoidConstPointer>(
os, paramValue.GLvoidConstPointerVal);
WriteParamValueReplay<ParamType::TGLvoidConstPointer>(
os, call, param.value.GLvoidConstPointerVal);
break;
case ParamType::TGLvoidConstPointerPointer:
WriteParamValueToStream<ParamType::TGLvoidConstPointerPointer>(
os, paramValue.GLvoidConstPointerPointerVal);
WriteParamValueReplay<ParamType::TGLvoidConstPointerPointer>(
os, call, param.value.GLvoidConstPointerPointerVal);
break;
case ParamType::TGraphicsResetStatus:
WriteParamValueToStream<ParamType::TGraphicsResetStatus>(
os, paramValue.GraphicsResetStatusVal);
WriteParamValueReplay<ParamType::TGraphicsResetStatus>(
os, call, param.value.GraphicsResetStatusVal);
break;
case ParamType::THandleType:
WriteParamValueToStream<ParamType::THandleType>(os, paramValue.HandleTypeVal);
WriteParamValueReplay<ParamType::THandleType>(os, call, param.value.HandleTypeVal);
break;
case ParamType::TLightParameter:
WriteParamValueToStream<ParamType::TLightParameter>(os, paramValue.LightParameterVal);
WriteParamValueReplay<ParamType::TLightParameter>(os, call,
param.value.LightParameterVal);
break;
case ParamType::TLogicalOperation:
WriteParamValueToStream<ParamType::TLogicalOperation>(os,
paramValue.LogicalOperationVal);
WriteParamValueReplay<ParamType::TLogicalOperation>(os, call,
param.value.LogicalOperationVal);
break;
case ParamType::TMaterialParameter:
WriteParamValueToStream<ParamType::TMaterialParameter>(os,
paramValue.MaterialParameterVal);
WriteParamValueReplay<ParamType::TMaterialParameter>(os, call,
param.value.MaterialParameterVal);
break;
case ParamType::TMatrixType:
WriteParamValueToStream<ParamType::TMatrixType>(os, paramValue.MatrixTypeVal);
WriteParamValueReplay<ParamType::TMatrixType>(os, call, param.value.MatrixTypeVal);
break;
case ParamType::TMemoryObjectID:
WriteParamValueToStream<ParamType::TMemoryObjectID>(os, paramValue.MemoryObjectIDVal);
WriteParamValueReplay<ParamType::TMemoryObjectID>(os, call,
param.value.MemoryObjectIDVal);
break;
case ParamType::TMemoryObjectIDConstPointer:
WriteParamValueToStream<ParamType::TMemoryObjectIDConstPointer>(
os, paramValue.MemoryObjectIDConstPointerVal);
WriteParamValueReplay<ParamType::TMemoryObjectIDConstPointer>(
os, call, param.value.MemoryObjectIDConstPointerVal);
break;
case ParamType::TMemoryObjectIDPointer:
WriteParamValueToStream<ParamType::TMemoryObjectIDPointer>(
os, paramValue.MemoryObjectIDPointerVal);
WriteParamValueReplay<ParamType::TMemoryObjectIDPointer>(
os, call, param.value.MemoryObjectIDPointerVal);
break;
case ParamType::TPathID:
WriteParamValueToStream<ParamType::TPathID>(os, paramValue.PathIDVal);
WriteParamValueReplay<ParamType::TPathID>(os, call, param.value.PathIDVal);
break;
case ParamType::TPointParameter:
WriteParamValueToStream<ParamType::TPointParameter>(os, paramValue.PointParameterVal);
WriteParamValueReplay<ParamType::TPointParameter>(os, call,
param.value.PointParameterVal);
break;
case ParamType::TPrimitiveMode:
WriteParamValueToStream<ParamType::TPrimitiveMode>(os, paramValue.PrimitiveModeVal);
WriteParamValueReplay<ParamType::TPrimitiveMode>(os, call,
param.value.PrimitiveModeVal);
break;
case ParamType::TProgramPipelineID:
WriteParamValueToStream<ParamType::TProgramPipelineID>(os,
paramValue.ProgramPipelineIDVal);
WriteParamValueReplay<ParamType::TProgramPipelineID>(os, call,
param.value.ProgramPipelineIDVal);
break;
case ParamType::TProgramPipelineIDConstPointer:
WriteParamValueToStream<ParamType::TProgramPipelineIDConstPointer>(
os, paramValue.ProgramPipelineIDConstPointerVal);
WriteParamValueReplay<ParamType::TProgramPipelineIDConstPointer>(
os, call, param.value.ProgramPipelineIDConstPointerVal);
break;
case ParamType::TProgramPipelineIDPointer:
WriteParamValueToStream<ParamType::TProgramPipelineIDPointer>(
os, paramValue.ProgramPipelineIDPointerVal);
WriteParamValueReplay<ParamType::TProgramPipelineIDPointer>(
os, call, param.value.ProgramPipelineIDPointerVal);
break;
case ParamType::TProvokingVertexConvention:
WriteParamValueToStream<ParamType::TProvokingVertexConvention>(
os, paramValue.ProvokingVertexConventionVal);
WriteParamValueReplay<ParamType::TProvokingVertexConvention>(
os, call, param.value.ProvokingVertexConventionVal);
break;
case ParamType::TQueryID:
WriteParamValueToStream<ParamType::TQueryID>(os, paramValue.QueryIDVal);
WriteParamValueReplay<ParamType::TQueryID>(os, call, param.value.QueryIDVal);
break;
case ParamType::TQueryIDConstPointer:
WriteParamValueToStream<ParamType::TQueryIDConstPointer>(
os, paramValue.QueryIDConstPointerVal);
WriteParamValueReplay<ParamType::TQueryIDConstPointer>(
os, call, param.value.QueryIDConstPointerVal);
break;
case ParamType::TQueryIDPointer:
WriteParamValueToStream<ParamType::TQueryIDPointer>(os, paramValue.QueryIDPointerVal);
WriteParamValueReplay<ParamType::TQueryIDPointer>(os, call,
param.value.QueryIDPointerVal);
break;
case ParamType::TQueryType:
WriteParamValueToStream<ParamType::TQueryType>(os, paramValue.QueryTypeVal);
WriteParamValueReplay<ParamType::TQueryType>(os, call, param.value.QueryTypeVal);
break;
case ParamType::TRenderbufferID:
WriteParamValueToStream<ParamType::TRenderbufferID>(os, paramValue.RenderbufferIDVal);
WriteParamValueReplay<ParamType::TRenderbufferID>(os, call,
param.value.RenderbufferIDVal);
break;
case ParamType::TRenderbufferIDConstPointer:
WriteParamValueToStream<ParamType::TRenderbufferIDConstPointer>(
os, paramValue.RenderbufferIDConstPointerVal);
WriteParamValueReplay<ParamType::TRenderbufferIDConstPointer>(
os, call, param.value.RenderbufferIDConstPointerVal);
break;
case ParamType::TRenderbufferIDPointer:
WriteParamValueToStream<ParamType::TRenderbufferIDPointer>(
os, paramValue.RenderbufferIDPointerVal);
WriteParamValueReplay<ParamType::TRenderbufferIDPointer>(
os, call, param.value.RenderbufferIDPointerVal);
break;
case ParamType::TSamplerID:
WriteParamValueToStream<ParamType::TSamplerID>(os, paramValue.SamplerIDVal);
WriteParamValueReplay<ParamType::TSamplerID>(os, call, param.value.SamplerIDVal);
break;
case ParamType::TSamplerIDConstPointer:
WriteParamValueToStream<ParamType::TSamplerIDConstPointer>(
os, paramValue.SamplerIDConstPointerVal);
WriteParamValueReplay<ParamType::TSamplerIDConstPointer>(
os, call, param.value.SamplerIDConstPointerVal);
break;
case ParamType::TSamplerIDPointer:
WriteParamValueToStream<ParamType::TSamplerIDPointer>(os,
paramValue.SamplerIDPointerVal);
WriteParamValueReplay<ParamType::TSamplerIDPointer>(os, call,
param.value.SamplerIDPointerVal);
break;
case ParamType::TSemaphoreID:
WriteParamValueToStream<ParamType::TSemaphoreID>(os, paramValue.SemaphoreIDVal);
WriteParamValueReplay<ParamType::TSemaphoreID>(os, call, param.value.SemaphoreIDVal);
break;
case ParamType::TSemaphoreIDConstPointer:
WriteParamValueToStream<ParamType::TSemaphoreIDConstPointer>(
os, paramValue.SemaphoreIDConstPointerVal);
WriteParamValueReplay<ParamType::TSemaphoreIDConstPointer>(
os, call, param.value.SemaphoreIDConstPointerVal);
break;
case ParamType::TSemaphoreIDPointer:
WriteParamValueToStream<ParamType::TSemaphoreIDPointer>(
os, paramValue.SemaphoreIDPointerVal);
WriteParamValueReplay<ParamType::TSemaphoreIDPointer>(
os, call, param.value.SemaphoreIDPointerVal);
break;
case ParamType::TShaderProgramID:
WriteParamValueToStream<ParamType::TShaderProgramID>(os, paramValue.ShaderProgramIDVal);
WriteParamValueReplay<ParamType::TShaderProgramID>(os, call,
param.value.ShaderProgramIDVal);
break;
case ParamType::TShaderProgramIDConstPointer:
WriteParamValueToStream<ParamType::TShaderProgramIDConstPointer>(
os, paramValue.ShaderProgramIDConstPointerVal);
WriteParamValueReplay<ParamType::TShaderProgramIDConstPointer>(
os, call, param.value.ShaderProgramIDConstPointerVal);
break;
case ParamType::TShaderProgramIDPointer:
WriteParamValueToStream<ParamType::TShaderProgramIDPointer>(
os, paramValue.ShaderProgramIDPointerVal);
WriteParamValueReplay<ParamType::TShaderProgramIDPointer>(
os, call, param.value.ShaderProgramIDPointerVal);
break;
case ParamType::TShaderType:
WriteParamValueToStream<ParamType::TShaderType>(os, paramValue.ShaderTypeVal);
WriteParamValueReplay<ParamType::TShaderType>(os, call, param.value.ShaderTypeVal);
break;
case ParamType::TShadingModel:
WriteParamValueToStream<ParamType::TShadingModel>(os, paramValue.ShadingModelVal);
WriteParamValueReplay<ParamType::TShadingModel>(os, call, param.value.ShadingModelVal);
break;
case ParamType::TTextureEnvParameter:
WriteParamValueToStream<ParamType::TTextureEnvParameter>(
os, paramValue.TextureEnvParameterVal);
WriteParamValueReplay<ParamType::TTextureEnvParameter>(
os, call, param.value.TextureEnvParameterVal);
break;
case ParamType::TTextureEnvTarget:
WriteParamValueToStream<ParamType::TTextureEnvTarget>(os,
paramValue.TextureEnvTargetVal);
WriteParamValueReplay<ParamType::TTextureEnvTarget>(os, call,
param.value.TextureEnvTargetVal);
break;
case ParamType::TTextureID:
WriteParamValueToStream<ParamType::TTextureID>(os, paramValue.TextureIDVal);
WriteParamValueReplay<ParamType::TTextureID>(os, call, param.value.TextureIDVal);
break;
case ParamType::TTextureIDConstPointer:
WriteParamValueToStream<ParamType::TTextureIDConstPointer>(
os, paramValue.TextureIDConstPointerVal);
WriteParamValueReplay<ParamType::TTextureIDConstPointer>(
os, call, param.value.TextureIDConstPointerVal);
break;
case ParamType::TTextureIDPointer:
WriteParamValueToStream<ParamType::TTextureIDPointer>(os,
paramValue.TextureIDPointerVal);
WriteParamValueReplay<ParamType::TTextureIDPointer>(os, call,
param.value.TextureIDPointerVal);
break;
case ParamType::TTextureTarget:
WriteParamValueToStream<ParamType::TTextureTarget>(os, paramValue.TextureTargetVal);
WriteParamValueReplay<ParamType::TTextureTarget>(os, call,
param.value.TextureTargetVal);
break;
case ParamType::TTextureType:
WriteParamValueToStream<ParamType::TTextureType>(os, paramValue.TextureTypeVal);
WriteParamValueReplay<ParamType::TTextureType>(os, call, param.value.TextureTypeVal);
break;
case ParamType::TTransformFeedbackID:
WriteParamValueToStream<ParamType::TTransformFeedbackID>(
os, paramValue.TransformFeedbackIDVal);
WriteParamValueReplay<ParamType::TTransformFeedbackID>(
os, call, param.value.TransformFeedbackIDVal);
break;
case ParamType::TTransformFeedbackIDConstPointer:
WriteParamValueToStream<ParamType::TTransformFeedbackIDConstPointer>(
os, paramValue.TransformFeedbackIDConstPointerVal);
WriteParamValueReplay<ParamType::TTransformFeedbackIDConstPointer>(
os, call, param.value.TransformFeedbackIDConstPointerVal);
break;
case ParamType::TTransformFeedbackIDPointer:
WriteParamValueToStream<ParamType::TTransformFeedbackIDPointer>(
os, paramValue.TransformFeedbackIDPointerVal);
WriteParamValueReplay<ParamType::TTransformFeedbackIDPointer>(
os, call, param.value.TransformFeedbackIDPointerVal);
break;
case ParamType::TUniformLocation:
WriteParamValueToStream<ParamType::TUniformLocation>(os, paramValue.UniformLocationVal);
WriteParamValueReplay<ParamType::TUniformLocation>(os, call,
param.value.UniformLocationVal);
break;
case ParamType::TVertexArrayID:
WriteParamValueToStream<ParamType::TVertexArrayID>(os, paramValue.VertexArrayIDVal);
WriteParamValueReplay<ParamType::TVertexArrayID>(os, call,
param.value.VertexArrayIDVal);
break;
case ParamType::TVertexArrayIDConstPointer:
WriteParamValueToStream<ParamType::TVertexArrayIDConstPointer>(
os, paramValue.VertexArrayIDConstPointerVal);
WriteParamValueReplay<ParamType::TVertexArrayIDConstPointer>(
os, call, param.value.VertexArrayIDConstPointerVal);
break;
case ParamType::TVertexArrayIDPointer:
WriteParamValueToStream<ParamType::TVertexArrayIDPointer>(
os, paramValue.VertexArrayIDPointerVal);
WriteParamValueReplay<ParamType::TVertexArrayIDPointer>(
os, call, param.value.VertexArrayIDPointerVal);
break;
case ParamType::TVertexAttribType:
WriteParamValueToStream<ParamType::TVertexAttribType>(os,
paramValue.VertexAttribTypeVal);
WriteParamValueReplay<ParamType::TVertexAttribType>(os, call,
param.value.VertexAttribTypeVal);
break;
case ParamType::TvoidConstPointer:
WriteParamValueToStream<ParamType::TvoidConstPointer>(os,
paramValue.voidConstPointerVal);
WriteParamValueReplay<ParamType::TvoidConstPointer>(os, call,
param.value.voidConstPointerVal);
break;
case ParamType::TvoidConstPointerPointer:
WriteParamValueToStream<ParamType::TvoidConstPointerPointer>(
os, paramValue.voidConstPointerPointerVal);
WriteParamValueReplay<ParamType::TvoidConstPointerPointer>(
os, call, param.value.voidConstPointerPointerVal);
break;
case ParamType::TvoidPointer:
WriteParamValueToStream<ParamType::TvoidPointer>(os, paramValue.voidPointerVal);
WriteParamValueReplay<ParamType::TvoidPointer>(os, call, param.value.voidPointerVal);
break;
case ParamType::TvoidPointerPointer:
WriteParamValueToStream<ParamType::TvoidPointerPointer>(
os, paramValue.voidPointerPointerVal);
WriteParamValueReplay<ParamType::TvoidPointerPointer>(
os, call, param.value.voidPointerPointerVal);
break;
default:
os << "unknown";
......
src/libANGLE/frame_capture_utils_autogen.h
......@@ -2491,7 +2491,10 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
}
}
void WriteParamTypeToStream(std::ostream &os, ParamType paramType, const ParamValue &paramValue);
struct CallCapture;
struct ParamCapture;
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
const char *ParamTypeToString(ParamType paramType);
enum class ResourceIDType
......
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