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