blob: aba4c7679065ec3e56a9ba1128edeffebd8408a0 [file] [log] [blame]
// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// frame_capture_utils_autogen.h:
// ANGLE Frame capture types and helper functions.
#ifndef COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
#define COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
#include "common/PackedEnums.h"
#ifdef ANGLE_ENABLE_CL
# include "common/PackedCLEnums_autogen.h"
# include "libANGLE/CLBitField.h"
#endif
namespace angle
{
#ifdef ANGLE_ENABLE_CL
typedef void(CL_CALLBACK *cl_context_func_type)(const char *, const void *, size_t, void *);
typedef void(CL_CALLBACK *cl_program_func_type)(cl_program, void *);
typedef void(CL_CALLBACK *cl_void_func_type)(void *);
typedef void(CL_CALLBACK *cl_callback_func_type)(cl_event, cl_int, void *);
typedef void(CL_CALLBACK *cl_svm_free_callback_func_type)(cl_command_queue,
cl_uint,
void *[],
void *);
typedef void(CL_CALLBACK *cl_context_destructor_func_type)(cl_context, void *);
typedef void(CL_CALLBACK *cl_mem_destructor_func_type)(cl_mem, void *);
#endif
enum class ParamType
{
TAHardwareBufferConstPointer,
TAddressingMode,
TAlphaTestFunc,
TBufferBinding,
TBufferID,
TBufferIDConstPointer,
TBufferIDPointer,
TBufferUsage,
TClientVertexArrayType,
TClipDepthMode,
TClipOrigin,
TCommandQueueInfo,
TCommandQueueProperties,
TCompositorTiming,
TContextID,
TContextInfo,
TCullFaceMode,
TDeviceInfo,
TDeviceType,
TDrawElementsType,
TEGLAttribConstPointer,
TEGLAttribKHRPointer,
TEGLAttribPointer,
TEGLBoolean,
TEGLBooleanPointer,
TEGLClientBuffer,
TEGLConfigPointer,
TEGLContext,
TEGLDEBUGPROCKHR,
TEGLDeviceEXT,
TEGLDisplay,
TEGLGetBlobFuncANDROID,
TEGLImage,
TEGLImageKHR,
TEGLLabelKHR,
TEGLNativeDisplayType,
TEGLNativePixmapType,
TEGLNativeWindowType,
TEGLObjectKHR,
TEGLSetBlobFuncANDROID,
TEGLStreamKHR,
TEGLSurface,
TEGLSync,
TEGLSyncKHR,
TEGLTime,
TEGLTimeKHR,
TEGLenum,
TEGLint,
TEGLintConstPointer,
TEGLintPointer,
TEGLnsecsANDROID,
TEGLnsecsANDROIDPointer,
TEGLuint64KHR,
TEGLuint64KHRPointer,
TEventInfo,
TFenceNVID,
TFenceNVIDConstPointer,
TFenceNVIDPointer,
TFilterMode,
TFramebufferID,
TFramebufferIDConstPointer,
TFramebufferIDPointer,
TGLDEBUGPROC,
TGLDEBUGPROCKHR,
TGLGETBLOBPROCANGLE,
TGLSETBLOBPROCANGLE,
TGLbitfield,
TGLboolean,
TGLbooleanPointer,
TGLcharConstPointer,
TGLcharConstPointerPointer,
TGLcharPointer,
TGLclampx,
TGLeglClientBufferEXT,
TGLenum,
TGLenumConstPointer,
TGLenumPointer,
TGLfixed,
TGLfixedConstPointer,
TGLfixedPointer,
TGLfloat,
TGLfloatConstPointer,
TGLfloatPointer,
TGLint,
TGLint64,
TGLint64Pointer,
TGLintConstPointer,
TGLintPointer,
TGLintptr,
TGLshort,
TGLshortConstPointer,
TGLsizei,
TGLsizeiConstPointer,
TGLsizeiPointer,
TGLsizeiptr,
TGLsync,
TGLubyte,
TGLubyteConstPointer,
TGLubytePointer,
TGLuint,
TGLuint64,
TGLuint64ConstPointer,
TGLuint64Pointer,
TGLuintConstPointer,
TGLuintPointer,
TGraphicsResetStatus,
THandleType,
TImageID,
TImageInfo,
TKernelArgInfo,
TKernelExecInfo,
TKernelInfo,
TKernelSubGroupInfo,
TKernelWorkGroupInfo,
TLightParameter,
TLogicalOperation,
TMapFlags,
TMaterialParameter,
TMatrixType,
TMemFlags,
TMemInfo,
TMemMigrationFlags,
TMemObjectType,
TMemoryObjectID,
TMemoryObjectIDConstPointer,
TMemoryObjectIDPointer,
TObjectType,
TPipeInfo,
TPlatformInfo,
TPointParameter,
TPolygonMode,
TPrimitiveMode,
TProfilingInfo,
TProgramBuildInfo,
TProgramInfo,
TProgramPipelineID,
TProgramPipelineIDConstPointer,
TProgramPipelineIDPointer,
TProvokingVertexConvention,
TQueryID,
TQueryIDConstPointer,
TQueryIDPointer,
TQueryType,
TRenderbufferID,
TRenderbufferIDConstPointer,
TRenderbufferIDPointer,
TSVM_MemFlags,
TSamplerID,
TSamplerIDConstPointer,
TSamplerIDPointer,
TSamplerInfo,
TSemaphoreID,
TSemaphoreIDConstPointer,
TSemaphoreIDPointer,
TShaderProgramID,
TShaderProgramIDConstPointer,
TShaderProgramIDPointer,
TShaderType,
TShadingModel,
TSurfaceID,
TSyncID,
TTextureEnvParameter,
TTextureEnvTarget,
TTextureID,
TTextureIDConstPointer,
TTextureIDPointer,
TTextureTarget,
TTextureType,
TTimestamp,
TTransformFeedbackID,
TTransformFeedbackIDConstPointer,
TTransformFeedbackIDPointer,
TUniformBlockIndex,
TUniformLocation,
TVertexArrayID,
TVertexArrayIDConstPointer,
TVertexArrayIDPointer,
TVertexAttribType,
TcharConstPointer,
TcharConstPointerPointer,
TcharUnsignedConstPointerPointer,
Tcl_bool,
Tcl_buffer_create_type,
Tcl_callback_func_type,
Tcl_command_queue,
Tcl_command_queue_propertiesPointer,
Tcl_context,
Tcl_context_destructor_func_type,
Tcl_context_func_type,
Tcl_context_propertiesConstPointer,
Tcl_device_id,
Tcl_device_idConstPointer,
Tcl_device_idPointer,
Tcl_device_partition_propertyConstPointer,
Tcl_event,
Tcl_eventConstPointer,
Tcl_eventPointer,
Tcl_image_descConstPointer,
Tcl_image_formatConstPointer,
Tcl_image_formatPointer,
Tcl_int,
Tcl_intPointer,
Tcl_kernel,
Tcl_kernelPointer,
Tcl_mem,
Tcl_memConstPointer,
Tcl_mem_destructor_func_type,
Tcl_mem_propertiesConstPointer,
Tcl_pipe_propertiesConstPointer,
Tcl_platform_id,
Tcl_platform_idPointer,
Tcl_program,
Tcl_programConstPointer,
Tcl_program_func_type,
Tcl_queue_propertiesConstPointer,
Tcl_sampler,
Tcl_sampler_propertiesConstPointer,
Tcl_svm_free_callback_func_type,
Tcl_uint,
Tcl_uintPointer,
Tcl_ulongPointer,
Tcl_void_func_type,
Tegl_ConfigPointer,
Tegl_DevicePointer,
Tegl_DisplayPointer,
Tegl_StreamPointer,
Tegl_SyncID,
Tsize_t,
Tsize_tConstPointer,
Tsize_tPointer,
TvoidConstPointer,
TvoidConstPointerPointer,
TvoidPointer,
TvoidPointerPointer,
};
constexpr uint32_t kParamTypeCount = 234;
union ParamValue
{
ParamValue() {}
~ParamValue() {}
const AHardwareBuffer *AHardwareBufferConstPointerVal;
gl::AlphaTestFunc AlphaTestFuncVal;
gl::BufferBinding BufferBindingVal;
gl::BufferID BufferIDVal;
const gl::BufferID *BufferIDConstPointerVal;
gl::BufferID *BufferIDPointerVal;
gl::BufferUsage BufferUsageVal;
gl::ClientVertexArrayType ClientVertexArrayTypeVal;
gl::ClipDepthMode ClipDepthModeVal;
gl::ClipOrigin ClipOriginVal;
egl::CompositorTiming CompositorTimingVal;
gl::ContextID ContextIDVal;
gl::CullFaceMode CullFaceModeVal;
gl::DrawElementsType DrawElementsTypeVal;
const EGLAttrib *EGLAttribConstPointerVal;
EGLAttribKHR *EGLAttribKHRPointerVal;
EGLAttrib *EGLAttribPointerVal;
EGLBoolean EGLBooleanVal;
EGLBoolean *EGLBooleanPointerVal;
EGLClientBuffer EGLClientBufferVal;
EGLConfig *EGLConfigPointerVal;
EGLContext EGLContextVal;
EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
EGLDeviceEXT EGLDeviceEXTVal;
EGLDisplay EGLDisplayVal;
EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
EGLImage EGLImageVal;
EGLImageKHR EGLImageKHRVal;
EGLLabelKHR EGLLabelKHRVal;
EGLNativeDisplayType EGLNativeDisplayTypeVal;
EGLNativePixmapType EGLNativePixmapTypeVal;
EGLNativeWindowType EGLNativeWindowTypeVal;
EGLObjectKHR EGLObjectKHRVal;
EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
EGLStreamKHR EGLStreamKHRVal;
EGLSurface EGLSurfaceVal;
EGLSync EGLSyncVal;
EGLSyncKHR EGLSyncKHRVal;
EGLTime EGLTimeVal;
EGLTimeKHR EGLTimeKHRVal;
EGLenum EGLenumVal;
EGLint EGLintVal;
const EGLint *EGLintConstPointerVal;
EGLint *EGLintPointerVal;
EGLnsecsANDROID EGLnsecsANDROIDVal;
EGLnsecsANDROID *EGLnsecsANDROIDPointerVal;
EGLuint64KHR EGLuint64KHRVal;
EGLuint64KHR *EGLuint64KHRPointerVal;
gl::FenceNVID FenceNVIDVal;
const gl::FenceNVID *FenceNVIDConstPointerVal;
gl::FenceNVID *FenceNVIDPointerVal;
gl::FramebufferID FramebufferIDVal;
const gl::FramebufferID *FramebufferIDConstPointerVal;
gl::FramebufferID *FramebufferIDPointerVal;
GLDEBUGPROC GLDEBUGPROCVal;
GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
GLGETBLOBPROCANGLE GLGETBLOBPROCANGLEVal;
GLSETBLOBPROCANGLE GLSETBLOBPROCANGLEVal;
GLbitfield GLbitfieldVal;
GLboolean GLbooleanVal;
GLboolean *GLbooleanPointerVal;
const GLchar *GLcharConstPointerVal;
const GLchar *const *GLcharConstPointerPointerVal;
GLchar *GLcharPointerVal;
GLclampx GLclampxVal;
GLeglClientBufferEXT GLeglClientBufferEXTVal;
GLenum GLenumVal;
const GLenum *GLenumConstPointerVal;
GLenum *GLenumPointerVal;
GLfixed GLfixedVal;
const GLfixed *GLfixedConstPointerVal;
GLfixed *GLfixedPointerVal;
GLfloat GLfloatVal;
const GLfloat *GLfloatConstPointerVal;
GLfloat *GLfloatPointerVal;
GLint GLintVal;
GLint64 GLint64Val;
GLint64 *GLint64PointerVal;
const GLint *GLintConstPointerVal;
GLint *GLintPointerVal;
GLintptr GLintptrVal;
GLshort GLshortVal;
const GLshort *GLshortConstPointerVal;
GLsizei GLsizeiVal;
const GLsizei *GLsizeiConstPointerVal;
GLsizei *GLsizeiPointerVal;
GLsizeiptr GLsizeiptrVal;
GLsync GLsyncVal;
GLubyte GLubyteVal;
const GLubyte *GLubyteConstPointerVal;
GLubyte *GLubytePointerVal;
GLuint GLuintVal;
GLuint64 GLuint64Val;
const GLuint64 *GLuint64ConstPointerVal;
GLuint64 *GLuint64PointerVal;
const GLuint *GLuintConstPointerVal;
GLuint *GLuintPointerVal;
gl::GraphicsResetStatus GraphicsResetStatusVal;
gl::HandleType HandleTypeVal;
egl::ImageID ImageIDVal;
gl::LightParameter LightParameterVal;
gl::LogicalOperation LogicalOperationVal;
gl::MaterialParameter MaterialParameterVal;
gl::MatrixType MatrixTypeVal;
gl::MemoryObjectID MemoryObjectIDVal;
const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
gl::MemoryObjectID *MemoryObjectIDPointerVal;
egl::ObjectType ObjectTypeVal;
gl::PointParameter PointParameterVal;
gl::PolygonMode PolygonModeVal;
gl::PrimitiveMode PrimitiveModeVal;
gl::ProgramPipelineID ProgramPipelineIDVal;
const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
gl::ProvokingVertexConvention ProvokingVertexConventionVal;
gl::QueryID QueryIDVal;
const gl::QueryID *QueryIDConstPointerVal;
gl::QueryID *QueryIDPointerVal;
gl::QueryType QueryTypeVal;
gl::RenderbufferID RenderbufferIDVal;
const gl::RenderbufferID *RenderbufferIDConstPointerVal;
gl::RenderbufferID *RenderbufferIDPointerVal;
gl::SamplerID SamplerIDVal;
const gl::SamplerID *SamplerIDConstPointerVal;
gl::SamplerID *SamplerIDPointerVal;
gl::SemaphoreID SemaphoreIDVal;
const gl::SemaphoreID *SemaphoreIDConstPointerVal;
gl::SemaphoreID *SemaphoreIDPointerVal;
gl::ShaderProgramID ShaderProgramIDVal;
const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
gl::ShaderProgramID *ShaderProgramIDPointerVal;
gl::ShaderType ShaderTypeVal;
gl::ShadingModel ShadingModelVal;
egl::SurfaceID SurfaceIDVal;
gl::SyncID SyncIDVal;
gl::TextureEnvParameter TextureEnvParameterVal;
gl::TextureEnvTarget TextureEnvTargetVal;
gl::TextureID TextureIDVal;
const gl::TextureID *TextureIDConstPointerVal;
gl::TextureID *TextureIDPointerVal;
gl::TextureTarget TextureTargetVal;
gl::TextureType TextureTypeVal;
egl::Timestamp TimestampVal;
gl::TransformFeedbackID TransformFeedbackIDVal;
const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
gl::UniformBlockIndex UniformBlockIndexVal;
gl::UniformLocation UniformLocationVal;
gl::VertexArrayID VertexArrayIDVal;
const gl::VertexArrayID *VertexArrayIDConstPointerVal;
gl::VertexArrayID *VertexArrayIDPointerVal;
gl::VertexAttribType VertexAttribTypeVal;
const char *charConstPointerVal;
const char **charConstPointerPointerVal;
const unsigned char **charUnsignedConstPointerPointerVal;
egl::Config *egl_ConfigPointerVal;
egl::Device *egl_DevicePointerVal;
egl::Display *egl_DisplayPointerVal;
egl::Stream *egl_StreamPointerVal;
egl::SyncID egl_SyncIDVal;
size_t size_tVal;
const size_t *size_tConstPointerVal;
size_t *size_tPointerVal;
const void *voidConstPointerVal;
const void **voidConstPointerPointerVal;
void *voidPointerVal;
void **voidPointerPointerVal;
#ifdef ANGLE_ENABLE_CL
cl::AddressingMode AddressingModeVal;
cl::CommandQueueInfo CommandQueueInfoVal;
cl::CommandQueueProperties CommandQueuePropertiesVal;
cl::ContextInfo ContextInfoVal;
cl::DeviceInfo DeviceInfoVal;
cl::DeviceType DeviceTypeVal;
cl::EventInfo EventInfoVal;
cl::FilterMode FilterModeVal;
cl::ImageInfo ImageInfoVal;
cl::KernelArgInfo KernelArgInfoVal;
cl::KernelExecInfo KernelExecInfoVal;
cl::KernelInfo KernelInfoVal;
cl::KernelSubGroupInfo KernelSubGroupInfoVal;
cl::KernelWorkGroupInfo KernelWorkGroupInfoVal;
cl::MapFlags MapFlagsVal;
cl::MemFlags MemFlagsVal;
cl::MemInfo MemInfoVal;
cl::MemMigrationFlags MemMigrationFlagsVal;
cl::MemObjectType MemObjectTypeVal;
cl::PipeInfo PipeInfoVal;
cl::PlatformInfo PlatformInfoVal;
cl::ProfilingInfo ProfilingInfoVal;
cl::ProgramBuildInfo ProgramBuildInfoVal;
cl::ProgramInfo ProgramInfoVal;
cl::SVM_MemFlags SVM_MemFlagsVal;
cl::SamplerInfo SamplerInfoVal;
cl_bool cl_boolVal;
cl_buffer_create_type cl_buffer_create_typeVal;
cl_callback_func_type cl_callback_func_typeVal;
cl_command_queue cl_command_queueVal;
cl_command_queue_properties *cl_command_queue_propertiesPointerVal;
cl_context cl_contextVal;
cl_context_destructor_func_type cl_context_destructor_func_typeVal;
cl_context_func_type cl_context_func_typeVal;
const cl_context_properties *cl_context_propertiesConstPointerVal;
cl_device_id cl_device_idVal;
const cl_device_id *cl_device_idConstPointerVal;
cl_device_id *cl_device_idPointerVal;
const cl_device_partition_property *cl_device_partition_propertyConstPointerVal;
cl_event cl_eventVal;
const cl_event *cl_eventConstPointerVal;
cl_event *cl_eventPointerVal;
const cl_image_desc *cl_image_descConstPointerVal;
const cl_image_format *cl_image_formatConstPointerVal;
cl_image_format *cl_image_formatPointerVal;
cl_int cl_intVal;
cl_int *cl_intPointerVal;
cl_kernel cl_kernelVal;
cl_kernel *cl_kernelPointerVal;
cl_mem cl_memVal;
const cl_mem *cl_memConstPointerVal;
cl_mem_destructor_func_type cl_mem_destructor_func_typeVal;
const cl_mem_properties *cl_mem_propertiesConstPointerVal;
const cl_pipe_properties *cl_pipe_propertiesConstPointerVal;
cl_platform_id cl_platform_idVal;
cl_platform_id *cl_platform_idPointerVal;
cl_program cl_programVal;
const cl_program *cl_programConstPointerVal;
cl_program_func_type cl_program_func_typeVal;
const cl_queue_properties *cl_queue_propertiesConstPointerVal;
cl_sampler cl_samplerVal;
const cl_sampler_properties *cl_sampler_propertiesConstPointerVal;
cl_svm_free_callback_func_type cl_svm_free_callback_func_typeVal;
cl_uint cl_uintVal;
cl_uint *cl_uintPointerVal;
cl_ulong *cl_ulongPointerVal;
cl_void_func_type cl_void_func_typeVal;
#endif
};
template <ParamType PType, typename T>
T GetParamVal(const ParamValue &value);
template <>
inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
const AHardwareBuffer *>(const ParamValue &value)
{
return value.AHardwareBufferConstPointerVal;
}
template <>
inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
const ParamValue &value)
{
return value.AlphaTestFuncVal;
}
template <>
inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
const ParamValue &value)
{
return value.BufferBindingVal;
}
template <>
inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
{
return value.BufferIDVal;
}
template <>
inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
const ParamValue &value)
{
return value.BufferIDConstPointerVal;
}
template <>
inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
const ParamValue &value)
{
return value.BufferIDPointerVal;
}
template <>
inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
const ParamValue &value)
{
return value.BufferUsageVal;
}
template <>
inline gl::ClientVertexArrayType
GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
{
return value.ClientVertexArrayTypeVal;
}
template <>
inline gl::ClipDepthMode GetParamVal<ParamType::TClipDepthMode, gl::ClipDepthMode>(
const ParamValue &value)
{
return value.ClipDepthModeVal;
}
template <>
inline gl::ClipOrigin GetParamVal<ParamType::TClipOrigin, gl::ClipOrigin>(const ParamValue &value)
{
return value.ClipOriginVal;
}
template <>
inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
const ParamValue &value)
{
return value.CompositorTimingVal;
}
template <>
inline gl::ContextID GetParamVal<ParamType::TContextID, gl::ContextID>(const ParamValue &value)
{
return value.ContextIDVal;
}
template <>
inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
const ParamValue &value)
{
return value.CullFaceModeVal;
}
template <>
inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
const ParamValue &value)
{
return value.DrawElementsTypeVal;
}
template <>
inline const EGLAttrib *GetParamVal<ParamType::TEGLAttribConstPointer, const EGLAttrib *>(
const ParamValue &value)
{
return value.EGLAttribConstPointerVal;
}
template <>
inline EGLAttribKHR *GetParamVal<ParamType::TEGLAttribKHRPointer, EGLAttribKHR *>(
const ParamValue &value)
{
return value.EGLAttribKHRPointerVal;
}
template <>
inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const ParamValue &value)
{
return value.EGLAttribPointerVal;
}
template <>
inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
{
return value.EGLBooleanVal;
}
template <>
inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
{
return value.EGLBooleanPointerVal;
}
template <>
inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
const ParamValue &value)
{
return value.EGLClientBufferVal;
}
template <>
inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const ParamValue &value)
{
return value.EGLConfigPointerVal;
}
template <>
inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
{
return value.EGLContextVal;
}
template <>
inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
const ParamValue &value)
{
return value.EGLDEBUGPROCKHRVal;
}
template <>
inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
{
return value.EGLDeviceEXTVal;
}
template <>
inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
{
return value.EGLDisplayVal;
}
template <>
inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
const ParamValue &value)
{
return value.EGLGetBlobFuncANDROIDVal;
}
template <>
inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
{
return value.EGLImageVal;
}
template <>
inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
{
return value.EGLImageKHRVal;
}
template <>
inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
{
return value.EGLLabelKHRVal;
}
template <>
inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
const ParamValue &value)
{
return value.EGLNativeDisplayTypeVal;
}
template <>
inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
const ParamValue &value)
{
return value.EGLNativePixmapTypeVal;
}
template <>
inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
const ParamValue &value)
{
return value.EGLNativeWindowTypeVal;
}
template <>
inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
{
return value.EGLObjectKHRVal;
}
template <>
inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
const ParamValue &value)
{
return value.EGLSetBlobFuncANDROIDVal;
}
template <>
inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
{
return value.EGLStreamKHRVal;
}
template <>
inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
{
return value.EGLSurfaceVal;
}
template <>
inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
{
return value.EGLSyncVal;
}
template <>
inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
{
return value.EGLSyncKHRVal;
}
template <>
inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
{
return value.EGLTimeVal;
}
template <>
inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
{
return value.EGLTimeKHRVal;
}
template <>
inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
{
return value.EGLenumVal;
}
template <>
inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
{
return value.EGLintVal;
}
template <>
inline const EGLint *GetParamVal<ParamType::TEGLintConstPointer, const EGLint *>(
const ParamValue &value)
{
return value.EGLintConstPointerVal;
}
template <>
inline EGLint *GetParamVal<ParamType::TEGLintPointer, EGLint *>(const ParamValue &value)
{
return value.EGLintPointerVal;
}
template <>
inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
const ParamValue &value)
{
return value.EGLnsecsANDROIDVal;
}
template <>
inline EGLnsecsANDROID *GetParamVal<ParamType::TEGLnsecsANDROIDPointer, EGLnsecsANDROID *>(
const ParamValue &value)
{
return value.EGLnsecsANDROIDPointerVal;
}
template <>
inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
{
return value.EGLuint64KHRVal;
}
template <>
inline EGLuint64KHR *GetParamVal<ParamType::TEGLuint64KHRPointer, EGLuint64KHR *>(
const ParamValue &value)
{
return value.EGLuint64KHRPointerVal;
}
template <>
inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
{
return value.FenceNVIDVal;
}
template <>
inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
const ParamValue &value)
{
return value.FenceNVIDConstPointerVal;
}
template <>
inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
const ParamValue &value)
{
return value.FenceNVIDPointerVal;
}
template <>
inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
const ParamValue &value)
{
return value.FramebufferIDVal;
}
template <>
inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
const gl::FramebufferID *>(const ParamValue &value)
{
return value.FramebufferIDConstPointerVal;
}
template <>
inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
const ParamValue &value)
{
return value.FramebufferIDPointerVal;
}
template <>
inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
{
return value.GLDEBUGPROCVal;
}
template <>
inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
const ParamValue &value)
{
return value.GLDEBUGPROCKHRVal;
}
template <>
inline GLGETBLOBPROCANGLE GetParamVal<ParamType::TGLGETBLOBPROCANGLE, GLGETBLOBPROCANGLE>(
const ParamValue &value)
{
return value.GLGETBLOBPROCANGLEVal;
}
template <>
inline GLSETBLOBPROCANGLE GetParamVal<ParamType::TGLSETBLOBPROCANGLE, GLSETBLOBPROCANGLE>(
const ParamValue &value)
{
return value.GLSETBLOBPROCANGLEVal;
}
template <>
inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
{
return value.GLbitfieldVal;
}
template <>
inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
{
return value.GLbooleanVal;
}
template <>
inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
{
return value.GLbooleanPointerVal;
}
template <>
inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
const ParamValue &value)
{
return value.GLcharConstPointerVal;
}
template <>
inline const GLchar *const *
GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
{
return value.GLcharConstPointerPointerVal;
}
template <>
inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
{
return value.GLcharPointerVal;
}
template <>
inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
{
return value.GLclampxVal;
}
template <>
inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
const ParamValue &value)
{
return value.GLeglClientBufferEXTVal;
}
template <>
inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
{
return value.GLenumVal;
}
template <>
inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
const ParamValue &value)
{
return value.GLenumConstPointerVal;
}
template <>
inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
{
return value.GLenumPointerVal;
}
template <>
inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
{
return value.GLfixedVal;
}
template <>
inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
const ParamValue &value)
{
return value.GLfixedConstPointerVal;
}
template <>
inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
{
return value.GLfixedPointerVal;
}
template <>
inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
{
return value.GLfloatVal;
}
template <>
inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
const ParamValue &value)
{
return value.GLfloatConstPointerVal;
}
template <>
inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
{
return value.GLfloatPointerVal;
}
template <>
inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
{
return value.GLintVal;
}
template <>
inline GLint64 GetParamVal<ParamType::TGLint64, GLint64>(const ParamValue &value)
{
return value.GLint64Val;
}
template <>
inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
{
return value.GLint64PointerVal;
}
template <>
inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
const ParamValue &value)
{
return value.GLintConstPointerVal;
}
template <>
inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
{
return value.GLintPointerVal;
}
template <>
inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
{
return value.GLintptrVal;
}
template <>
inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
{
return value.GLshortVal;
}
template <>
inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
const ParamValue &value)
{
return value.GLshortConstPointerVal;
}
template <>
inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
{
return value.GLsizeiVal;
}
template <>
inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
const ParamValue &value)
{
return value.GLsizeiConstPointerVal;
}
template <>
inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
{
return value.GLsizeiPointerVal;
}
template <>
inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
{
return value.GLsizeiptrVal;
}
template <>
inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
{
return value.GLsyncVal;
}
template <>
inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
{
return value.GLubyteVal;
}
template <>
inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
const ParamValue &value)
{
return value.GLubyteConstPointerVal;
}
template <>
inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
{
return value.GLubytePointerVal;
}
template <>
inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
{
return value.GLuintVal;
}
template <>
inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
{
return value.GLuint64Val;
}
template <>
inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
const ParamValue &value)
{
return value.GLuint64ConstPointerVal;
}
template <>
inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
{
return value.GLuint64PointerVal;
}
template <>
inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
const ParamValue &value)
{
return value.GLuintConstPointerVal;
}
template <>
inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
{
return value.GLuintPointerVal;
}
template <>
inline gl::GraphicsResetStatus
GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
{
return value.GraphicsResetStatusVal;
}
template <>
inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
{
return value.HandleTypeVal;
}
template <>
inline egl::ImageID GetParamVal<ParamType::TImageID, egl::ImageID>(const ParamValue &value)
{
return value.ImageIDVal;
}
template <>
inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
const ParamValue &value)
{
return value.LightParameterVal;
}
template <>
inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
const ParamValue &value)
{
return value.LogicalOperationVal;
}
template <>
inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
const ParamValue &value)
{
return value.MaterialParameterVal;
}
template <>
inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
{
return value.MatrixTypeVal;
}
template <>
inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
const ParamValue &value)
{
return value.MemoryObjectIDVal;
}
template <>
inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
const gl::MemoryObjectID *>(const ParamValue &value)
{
return value.MemoryObjectIDConstPointerVal;
}
template <>
inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
const ParamValue &value)
{
return value.MemoryObjectIDPointerVal;
}
template <>
inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
{
return value.ObjectTypeVal;
}
template <>
inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
const ParamValue &value)
{
return value.PointParameterVal;
}
template <>
inline gl::PolygonMode GetParamVal<ParamType::TPolygonMode, gl::PolygonMode>(
const ParamValue &value)
{
return value.PolygonModeVal;
}
template <>
inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
const ParamValue &value)
{
return value.PrimitiveModeVal;
}
template <>
inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
const ParamValue &value)
{
return value.ProgramPipelineIDVal;
}
template <>
inline const gl::ProgramPipelineID *
GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
const ParamValue &value)
{
return value.ProgramPipelineIDConstPointerVal;
}
template <>
inline gl::ProgramPipelineID *
GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
{
return value.ProgramPipelineIDPointerVal;
}
template <>
inline gl::ProvokingVertexConvention
GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
const ParamValue &value)
{
return value.ProvokingVertexConventionVal;
}
template <>
inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
{
return value.QueryIDVal;
}
template <>
inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
const ParamValue &value)
{
return value.QueryIDConstPointerVal;
}
template <>
inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
{
return value.QueryIDPointerVal;
}
template <>
inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
{
return value.QueryTypeVal;
}
template <>
inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
const ParamValue &value)
{
return value.RenderbufferIDVal;
}
template <>
inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
const gl::RenderbufferID *>(const ParamValue &value)
{
return value.RenderbufferIDConstPointerVal;
}
template <>
inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
const ParamValue &value)
{
return value.RenderbufferIDPointerVal;
}
template <>
inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
{
return value.SamplerIDVal;
}
template <>
inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
const ParamValue &value)
{
return value.SamplerIDConstPointerVal;
}
template <>
inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
const ParamValue &value)
{
return value.SamplerIDPointerVal;
}
template <>
inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
const ParamValue &value)
{
return value.SemaphoreIDVal;
}
template <>
inline const gl::SemaphoreID *
GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
{
return value.SemaphoreIDConstPointerVal;
}
template <>
inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
const ParamValue &value)
{
return value.SemaphoreIDPointerVal;
}
template <>
inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
const ParamValue &value)
{
return value.ShaderProgramIDVal;
}
template <>
inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
const gl::ShaderProgramID *>(const ParamValue &value)
{
return value.ShaderProgramIDConstPointerVal;
}
template <>
inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
const ParamValue &value)
{
return value.ShaderProgramIDPointerVal;
}
template <>
inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
{
return value.ShaderTypeVal;
}
template <>
inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
const ParamValue &value)
{
return value.ShadingModelVal;
}
template <>
inline egl::SurfaceID GetParamVal<ParamType::TSurfaceID, egl::SurfaceID>(const ParamValue &value)
{
return value.SurfaceIDVal;
}
template <>
inline gl::SyncID GetParamVal<ParamType::TSyncID, gl::SyncID>(const ParamValue &value)
{
return value.SyncIDVal;
}
template <>
inline gl::TextureEnvParameter
GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
{
return value.TextureEnvParameterVal;
}
template <>
inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
const ParamValue &value)
{
return value.TextureEnvTargetVal;
}
template <>
inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
{
return value.TextureIDVal;
}
template <>
inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
const ParamValue &value)
{
return value.TextureIDConstPointerVal;
}
template <>
inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
const ParamValue &value)
{
return value.TextureIDPointerVal;
}
template <>
inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
const ParamValue &value)
{
return value.TextureTargetVal;
}
template <>
inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
const ParamValue &value)
{
return value.TextureTypeVal;
}
template <>
inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
{
return value.TimestampVal;
}
template <>
inline gl::TransformFeedbackID
GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
{
return value.TransformFeedbackIDVal;
}
template <>
inline const gl::TransformFeedbackID *
GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
const ParamValue &value)
{
return value.TransformFeedbackIDConstPointerVal;
}
template <>
inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
gl::TransformFeedbackID *>(const ParamValue &value)
{
return value.TransformFeedbackIDPointerVal;
}
template <>
inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
const ParamValue &value)
{
return value.UniformBlockIndexVal;
}
template <>
inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
const ParamValue &value)
{
return value.UniformLocationVal;
}
template <>
inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
const ParamValue &value)
{
return value.VertexArrayIDVal;
}
template <>
inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
const gl::VertexArrayID *>(const ParamValue &value)
{
return value.VertexArrayIDConstPointerVal;
}
template <>
inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
const ParamValue &value)
{
return value.VertexArrayIDPointerVal;
}
template <>
inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
const ParamValue &value)
{
return value.VertexAttribTypeVal;
}
template <>
inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
{
return value.charConstPointerVal;
}
template <>
inline const char **GetParamVal<ParamType::TcharConstPointerPointer, const char **>(
const ParamValue &value)
{
return value.charConstPointerPointerVal;
}
template <>
inline const unsigned char **GetParamVal<ParamType::TcharUnsignedConstPointerPointer,
const unsigned char **>(const ParamValue &value)
{
return value.charUnsignedConstPointerPointerVal;
}
template <>
inline egl::Config *GetParamVal<ParamType::Tegl_ConfigPointer, egl::Config *>(
const ParamValue &value)
{
return value.egl_ConfigPointerVal;
}
template <>
inline egl::Device *GetParamVal<ParamType::Tegl_DevicePointer, egl::Device *>(
const ParamValue &value)
{
return value.egl_DevicePointerVal;
}
template <>
inline egl::Display *GetParamVal<ParamType::Tegl_DisplayPointer, egl::Display *>(
const ParamValue &value)
{
return value.egl_DisplayPointerVal;
}
template <>
inline egl::Stream *GetParamVal<ParamType::Tegl_StreamPointer, egl::Stream *>(
const ParamValue &value)
{
return value.egl_StreamPointerVal;
}
template <>
inline egl::SyncID GetParamVal<ParamType::Tegl_SyncID, egl::SyncID>(const ParamValue &value)
{
return value.egl_SyncIDVal;
}
template <>
inline size_t GetParamVal<ParamType::Tsize_t, size_t>(const ParamValue &value)
{
return value.size_tVal;
}
template <>
inline const size_t *GetParamVal<ParamType::Tsize_tConstPointer, const size_t *>(
const ParamValue &value)
{
return value.size_tConstPointerVal;
}
template <>
inline size_t *GetParamVal<ParamType::Tsize_tPointer, size_t *>(const ParamValue &value)
{
return value.size_tPointerVal;
}
template <>
inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
{
return value.voidConstPointerVal;
}
template <>
inline const void **GetParamVal<ParamType::TvoidConstPointerPointer, const void **>(
const ParamValue &value)
{
return value.voidConstPointerPointerVal;
}
template <>
inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
{
return value.voidPointerVal;
}
template <>
inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
{
return value.voidPointerPointerVal;
}
#ifdef ANGLE_ENABLE_CL
template <>
inline cl::AddressingMode GetParamVal<ParamType::TAddressingMode, cl::AddressingMode>(
const ParamValue &value)
{
return value.AddressingModeVal;
}
template <>
inline cl::CommandQueueInfo GetParamVal<ParamType::TCommandQueueInfo, cl::CommandQueueInfo>(
const ParamValue &value)
{
return value.CommandQueueInfoVal;
}
template <>
inline cl::CommandQueueProperties
GetParamVal<ParamType::TCommandQueueProperties, cl::CommandQueueProperties>(const ParamValue &value)
{
return value.CommandQueuePropertiesVal;
}
template <>
inline cl::ContextInfo GetParamVal<ParamType::TContextInfo, cl::ContextInfo>(
const ParamValue &value)
{
return value.ContextInfoVal;
}
template <>
inline cl::DeviceInfo GetParamVal<ParamType::TDeviceInfo, cl::DeviceInfo>(const ParamValue &value)
{
return value.DeviceInfoVal;
}
template <>
inline cl::DeviceType GetParamVal<ParamType::TDeviceType, cl::DeviceType>(const ParamValue &value)
{
return value.DeviceTypeVal;
}
template <>
inline cl::EventInfo GetParamVal<ParamType::TEventInfo, cl::EventInfo>(const ParamValue &value)
{
return value.EventInfoVal;
}
template <>
inline cl::FilterMode GetParamVal<ParamType::TFilterMode, cl::FilterMode>(const ParamValue &value)
{
return value.FilterModeVal;
}
template <>
inline cl::ImageInfo GetParamVal<ParamType::TImageInfo, cl::ImageInfo>(const ParamValue &value)
{
return value.ImageInfoVal;
}
template <>
inline cl::KernelArgInfo GetParamVal<ParamType::TKernelArgInfo, cl::KernelArgInfo>(
const ParamValue &value)
{
return value.KernelArgInfoVal;
}
template <>
inline cl::KernelExecInfo GetParamVal<ParamType::TKernelExecInfo, cl::KernelExecInfo>(
const ParamValue &value)
{
return value.KernelExecInfoVal;
}
template <>
inline cl::KernelInfo GetParamVal<ParamType::TKernelInfo, cl::KernelInfo>(const ParamValue &value)
{
return value.KernelInfoVal;
}
template <>
inline cl::KernelSubGroupInfo GetParamVal<ParamType::TKernelSubGroupInfo, cl::KernelSubGroupInfo>(
const ParamValue &value)
{
return value.KernelSubGroupInfoVal;
}
template <>
inline cl::KernelWorkGroupInfo
GetParamVal<ParamType::TKernelWorkGroupInfo, cl::KernelWorkGroupInfo>(const ParamValue &value)
{
return value.KernelWorkGroupInfoVal;
}
template <>
inline cl::MapFlags GetParamVal<ParamType::TMapFlags, cl::MapFlags>(const ParamValue &value)
{
return value.MapFlagsVal;
}
template <>
inline cl::MemFlags GetParamVal<ParamType::TMemFlags, cl::MemFlags>(const ParamValue &value)
{
return value.MemFlagsVal;
}
template <>
inline cl::MemInfo GetParamVal<ParamType::TMemInfo, cl::MemInfo>(const ParamValue &value)
{
return value.MemInfoVal;
}
template <>
inline cl::MemMigrationFlags GetParamVal<ParamType::TMemMigrationFlags, cl::MemMigrationFlags>(
const ParamValue &value)
{
return value.MemMigrationFlagsVal;
}
template <>
inline cl::MemObjectType GetParamVal<ParamType::TMemObjectType, cl::MemObjectType>(
const ParamValue &value)
{
return value.MemObjectTypeVal;
}
template <>
inline cl::PipeInfo GetParamVal<ParamType::TPipeInfo, cl::PipeInfo>(const ParamValue &value)
{
return value.PipeInfoVal;
}
template <>
inline cl::PlatformInfo GetParamVal<ParamType::TPlatformInfo, cl::PlatformInfo>(
const ParamValue &value)
{
return value.PlatformInfoVal;
}
template <>
inline cl::ProfilingInfo GetParamVal<ParamType::TProfilingInfo, cl::ProfilingInfo>(
const ParamValue &value)
{
return value.ProfilingInfoVal;
}
template <>
inline cl::ProgramBuildInfo GetParamVal<ParamType::TProgramBuildInfo, cl::ProgramBuildInfo>(
const ParamValue &value)
{
return value.ProgramBuildInfoVal;
}
template <>
inline cl::ProgramInfo GetParamVal<ParamType::TProgramInfo, cl::ProgramInfo>(
const ParamValue &value)
{
return value.ProgramInfoVal;
}
template <>
inline cl::SVM_MemFlags GetParamVal<ParamType::TSVM_MemFlags, cl::SVM_MemFlags>(
const ParamValue &value)
{
return value.SVM_MemFlagsVal;
}
template <>
inline cl::SamplerInfo GetParamVal<ParamType::TSamplerInfo, cl::SamplerInfo>(
const ParamValue &value)
{
return value.SamplerInfoVal;
}
template <>
inline cl_bool GetParamVal<ParamType::Tcl_bool, cl_bool>(const ParamValue &value)
{
return value.cl_boolVal;
}
template <>
inline cl_buffer_create_type GetParamVal<ParamType::Tcl_buffer_create_type, cl_buffer_create_type>(
const ParamValue &value)
{
return value.cl_buffer_create_typeVal;
}
template <>
inline cl_callback_func_type GetParamVal<ParamType::Tcl_callback_func_type, cl_callback_func_type>(
const ParamValue &value)
{
return value.cl_callback_func_typeVal;
}
template <>
inline cl_command_queue GetParamVal<ParamType::Tcl_command_queue, cl_command_queue>(
const ParamValue &value)
{
return value.cl_command_queueVal;
}
template <>
inline cl_command_queue_properties *
GetParamVal<ParamType::Tcl_command_queue_propertiesPointer, cl_command_queue_properties *>(
const ParamValue &value)
{
return value.cl_command_queue_propertiesPointerVal;
}
template <>
inline cl_context GetParamVal<ParamType::Tcl_context, cl_context>(const ParamValue &value)
{
return value.cl_contextVal;
}
template <>
inline cl_context_destructor_func_type
GetParamVal<ParamType::Tcl_context_destructor_func_type, cl_context_destructor_func_type>(
const ParamValue &value)
{
return value.cl_context_destructor_func_typeVal;
}
template <>
inline cl_context_func_type GetParamVal<ParamType::Tcl_context_func_type, cl_context_func_type>(
const ParamValue &value)
{
return value.cl_context_func_typeVal;
}
template <>
inline const cl_context_properties *
GetParamVal<ParamType::Tcl_context_propertiesConstPointer, const cl_context_properties *>(
const ParamValue &value)
{
return value.cl_context_propertiesConstPointerVal;
}
template <>
inline cl_device_id GetParamVal<ParamType::Tcl_device_id, cl_device_id>(const ParamValue &value)
{
return value.cl_device_idVal;
}
template <>
inline const cl_device_id *GetParamVal<ParamType::Tcl_device_idConstPointer, const cl_device_id *>(
const ParamValue &value)
{
return value.cl_device_idConstPointerVal;
}
template <>
inline cl_device_id *GetParamVal<ParamType::Tcl_device_idPointer, cl_device_id *>(
const ParamValue &value)
{
return value.cl_device_idPointerVal;
}
template <>
inline const cl_device_partition_property *
GetParamVal<ParamType::Tcl_device_partition_propertyConstPointer,
const cl_device_partition_property *>(const ParamValue &value)
{
return value.cl_device_partition_propertyConstPointerVal;
}
template <>
inline cl_event GetParamVal<ParamType::Tcl_event, cl_event>(const ParamValue &value)
{
return value.cl_eventVal;
}
template <>
inline const cl_event *GetParamVal<ParamType::Tcl_eventConstPointer, const cl_event *>(
const ParamValue &value)
{
return value.cl_eventConstPointerVal;
}
template <>
inline cl_event *GetParamVal<ParamType::Tcl_eventPointer, cl_event *>(const ParamValue &value)
{
return value.cl_eventPointerVal;
}
template <>
inline const cl_image_desc *
GetParamVal<ParamType::Tcl_image_descConstPointer, const cl_image_desc *>(const ParamValue &value)
{
return value.cl_image_descConstPointerVal;
}
template <>
inline const cl_image_format *GetParamVal<ParamType::Tcl_image_formatConstPointer,
const cl_image_format *>(const ParamValue &value)
{
return value.cl_image_formatConstPointerVal;
}
template <>
inline cl_image_format *GetParamVal<ParamType::Tcl_image_formatPointer, cl_image_format *>(
const ParamValue &value)
{
return value.cl_image_formatPointerVal;
}
template <>
inline cl_int GetParamVal<ParamType::Tcl_int, cl_int>(const ParamValue &value)
{
return value.cl_intVal;
}
template <>
inline cl_int *GetParamVal<ParamType::Tcl_intPointer, cl_int *>(const ParamValue &value)
{
return value.cl_intPointerVal;
}
template <>
inline cl_kernel GetParamVal<ParamType::Tcl_kernel, cl_kernel>(const ParamValue &value)
{
return value.cl_kernelVal;
}
template <>
inline cl_kernel *GetParamVal<ParamType::Tcl_kernelPointer, cl_kernel *>(const ParamValue &value)
{
return value.cl_kernelPointerVal;
}
template <>
inline cl_mem GetParamVal<ParamType::Tcl_mem, cl_mem>(const ParamValue &value)
{
return value.cl_memVal;
}
template <>
inline const cl_mem *GetParamVal<ParamType::Tcl_memConstPointer, const cl_mem *>(
const ParamValue &value)
{
return value.cl_memConstPointerVal;
}
template <>
inline cl_mem_destructor_func_type GetParamVal<ParamType::Tcl_mem_destructor_func_type,
cl_mem_destructor_func_type>(const ParamValue &value)
{
return value.cl_mem_destructor_func_typeVal;
}
template <>
inline const cl_mem_properties *GetParamVal<ParamType::Tcl_mem_propertiesConstPointer,
const cl_mem_properties *>(const ParamValue &value)
{
return value.cl_mem_propertiesConstPointerVal;
}
template <>
inline const cl_pipe_properties *GetParamVal<ParamType::Tcl_pipe_propertiesConstPointer,
const cl_pipe_properties *>(const ParamValue &value)
{
return value.cl_pipe_propertiesConstPointerVal;
}
template <>
inline cl_platform_id GetParamVal<ParamType::Tcl_platform_id, cl_platform_id>(
const ParamValue &value)
{
return value.cl_platform_idVal;
}
template <>
inline cl_platform_id *GetParamVal<ParamType::Tcl_platform_idPointer, cl_platform_id *>(
const ParamValue &value)
{
return value.cl_platform_idPointerVal;
}
template <>
inline cl_program GetParamVal<ParamType::Tcl_program, cl_program>(const ParamValue &value)
{
return value.cl_programVal;
}
template <>
inline const cl_program *GetParamVal<ParamType::Tcl_programConstPointer, const cl_program *>(
const ParamValue &value)
{
return value.cl_programConstPointerVal;
}
template <>
inline cl_program_func_type GetParamVal<ParamType::Tcl_program_func_type, cl_program_func_type>(
const ParamValue &value)
{
return value.cl_program_func_typeVal;
}
template <>
inline const cl_queue_properties *GetParamVal<ParamType::Tcl_queue_propertiesConstPointer,
const cl_queue_properties *>(const ParamValue &value)
{
return value.cl_queue_propertiesConstPointerVal;
}
template <>
inline cl_sampler GetParamVal<ParamType::Tcl_sampler, cl_sampler>(const ParamValue &value)
{
return value.cl_samplerVal;
}
template <>
inline const cl_sampler_properties *
GetParamVal<ParamType::Tcl_sampler_propertiesConstPointer, const cl_sampler_properties *>(
const ParamValue &value)
{
return value.cl_sampler_propertiesConstPointerVal;
}
template <>
inline cl_svm_free_callback_func_type
GetParamVal<ParamType::Tcl_svm_free_callback_func_type, cl_svm_free_callback_func_type>(
const ParamValue &value)
{
return value.cl_svm_free_callback_func_typeVal;
}
template <>
inline cl_uint GetParamVal<ParamType::Tcl_uint, cl_uint>(const ParamValue &value)
{
return value.cl_uintVal;
}
template <>
inline cl_uint *GetParamVal<ParamType::Tcl_uintPointer, cl_uint *>(const ParamValue &value)
{
return value.cl_uintPointerVal;
}
template <>
inline cl_ulong *GetParamVal<ParamType::Tcl_ulongPointer, cl_ulong *>(const ParamValue &value)
{
return value.cl_ulongPointerVal;
}
template <>
inline cl_void_func_type GetParamVal<ParamType::Tcl_void_func_type, cl_void_func_type>(
const ParamValue &value)
{
return value.cl_void_func_typeVal;
}
#endif
template <ParamType PType, typename T>
T GetParamVal(const ParamValue &value)
{
UNREACHABLE();
return T();
}
template <typename T>
T AccessParamValue(ParamType paramType, const ParamValue &value)
{
switch (paramType)
{
case ParamType::TAHardwareBufferConstPointer:
return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value);
case ParamType::TAddressingMode:
return GetParamVal<ParamType::TAddressingMode, T>(value);
case ParamType::TAlphaTestFunc:
return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
case ParamType::TBufferBinding:
return GetParamVal<ParamType::TBufferBinding, T>(value);
case ParamType::TBufferID:
return GetParamVal<ParamType::TBufferID, T>(value);
case ParamType::TBufferIDConstPointer:
return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
case ParamType::TBufferIDPointer:
return GetParamVal<ParamType::TBufferIDPointer, T>(value);
case ParamType::TBufferUsage:
return GetParamVal<ParamType::TBufferUsage, T>(value);
case ParamType::TClientVertexArrayType:
return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
case ParamType::TClipDepthMode:
return GetParamVal<ParamType::TClipDepthMode, T>(value);
case ParamType::TClipOrigin:
return GetParamVal<ParamType::TClipOrigin, T>(value);
case ParamType::TCommandQueueInfo:
return GetParamVal<ParamType::TCommandQueueInfo, T>(value);
case ParamType::TCommandQueueProperties:
return GetParamVal<ParamType::TCommandQueueProperties, T>(value);
case ParamType::TCompositorTiming:
return GetParamVal<ParamType::TCompositorTiming, T>(value);
case ParamType::TContextID:
return GetParamVal<ParamType::TContextID, T>(value);
case ParamType::TContextInfo:
return GetParamVal<ParamType::TContextInfo, T>(value);
case ParamType::TCullFaceMode:
return GetParamVal<ParamType::TCullFaceMode, T>(value);
case ParamType::TDeviceInfo:
return GetParamVal<ParamType::TDeviceInfo, T>(value);
case ParamType::TDeviceType:
return GetParamVal<ParamType::TDeviceType, T>(value);
case ParamType::TDrawElementsType:
return GetParamVal<ParamType::TDrawElementsType, T>(value);
case ParamType::TEGLAttribConstPointer:
return GetParamVal<ParamType::TEGLAttribConstPointer, T>(value);
case ParamType::TEGLAttribKHRPointer:
return GetParamVal<ParamType::TEGLAttribKHRPointer, T>(value);
case ParamType::TEGLAttribPointer:
return GetParamVal<ParamType::TEGLAttribPointer, T>(value);
case ParamType::TEGLBoolean:
return GetParamVal<ParamType::TEGLBoolean, T>(value);
case ParamType::TEGLBooleanPointer:
return GetParamVal<ParamType::TEGLBooleanPointer, T>(value);
case ParamType::TEGLClientBuffer:
return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
case ParamType::TEGLConfigPointer:
return GetParamVal<ParamType::TEGLConfigPointer, T>(value);
case ParamType::TEGLContext:
return GetParamVal<ParamType::TEGLContext, T>(value);
case ParamType::TEGLDEBUGPROCKHR:
return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
case ParamType::TEGLDeviceEXT:
return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
case ParamType::TEGLDisplay:
return GetParamVal<ParamType::TEGLDisplay, T>(value);
case ParamType::TEGLGetBlobFuncANDROID:
return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
case ParamType::TEGLImage:
return GetParamVal<ParamType::TEGLImage, T>(value);
case ParamType::TEGLImageKHR:
return GetParamVal<ParamType::TEGLImageKHR, T>(value);
case ParamType::TEGLLabelKHR:
return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
case ParamType::TEGLNativeDisplayType:
return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value);
case ParamType::TEGLNativePixmapType:
return GetParamVal<ParamType::TEGLNativePixmapType, T>(value);
case ParamType::TEGLNativeWindowType:
return GetParamVal<ParamType::TEGLNativeWindowType, T>(value);
case ParamType::TEGLObjectKHR:
return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
case ParamType::TEGLSetBlobFuncANDROID:
return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
case ParamType::TEGLStreamKHR:
return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
case ParamType::TEGLSurface:
return GetParamVal<ParamType::TEGLSurface, T>(value);
case ParamType::TEGLSync:
return GetParamVal<ParamType::TEGLSync, T>(value);
case ParamType::TEGLSyncKHR:
return GetParamVal<ParamType::TEGLSyncKHR, T>(value);
case ParamType::TEGLTime:
return GetParamVal<ParamType::TEGLTime, T>(value);
case ParamType::TEGLTimeKHR:
return GetParamVal<ParamType::TEGLTimeKHR, T>(value);
case ParamType::TEGLenum:
return GetParamVal<ParamType::TEGLenum, T>(value);
case ParamType::TEGLint:
return GetParamVal<ParamType::TEGLint, T>(value);
case ParamType::TEGLintConstPointer:
return GetParamVal<ParamType::TEGLintConstPointer, T>(value);
case ParamType::TEGLintPointer:
return GetParamVal<ParamType::TEGLintPointer, T>(value);
case ParamType::TEGLnsecsANDROID:
return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value);
case ParamType::TEGLnsecsANDROIDPointer:
return GetParamVal<ParamType::TEGLnsecsANDROIDPointer, T>(value);
case ParamType::TEGLuint64KHR:
return GetParamVal<ParamType::TEGLuint64KHR, T>(value);
case ParamType::TEGLuint64KHRPointer:
return GetParamVal<ParamType::TEGLuint64KHRPointer, T>(value);
case ParamType::TEventInfo:
return GetParamVal<ParamType::TEventInfo, T>(value);
case ParamType::TFenceNVID:
return GetParamVal<ParamType::TFenceNVID, T>(value);
case ParamType::TFenceNVIDConstPointer:
return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
case ParamType::TFenceNVIDPointer:
return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
case ParamType::TFilterMode:
return GetParamVal<ParamType::TFilterMode, T>(value);
case ParamType::TFramebufferID:
return GetParamVal<ParamType::TFramebufferID, T>(value);
case ParamType::TFramebufferIDConstPointer:
return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
case ParamType::TFramebufferIDPointer:
return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
case ParamType::TGLDEBUGPROC:
return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
case ParamType::TGLDEBUGPROCKHR:
return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
case ParamType::TGLGETBLOBPROCANGLE:
return GetParamVal<ParamType::TGLGETBLOBPROCANGLE, T>(value);
case ParamType::TGLSETBLOBPROCANGLE:
return GetParamVal<ParamType::TGLSETBLOBPROCANGLE, T>(value);
case ParamType::TGLbitfield:
return GetParamVal<ParamType::TGLbitfield, T>(value);
case ParamType::TGLboolean:
return GetParamVal<ParamType::TGLboolean, T>(value);
case ParamType::TGLbooleanPointer:
return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
case ParamType::TGLcharConstPointer:
return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
case ParamType::TGLcharConstPointerPointer:
return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
case ParamType::TGLcharPointer:
return GetParamVal<ParamType::TGLcharPointer, T>(value);
case ParamType::TGLclampx:
return GetParamVal<ParamType::TGLclampx, T>(value);
case ParamType::TGLeglClientBufferEXT:
return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value);
case ParamType::TGLenum:
return GetParamVal<ParamType::TGLenum, T>(value);
case ParamType::TGLenumConstPointer:
return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
case ParamType::TGLenumPointer:
return GetParamVal<ParamType::TGLenumPointer, T>(value);
case ParamType::TGLfixed:
return GetParamVal<ParamType::TGLfixed, T>(value);
case ParamType::TGLfixedConstPointer:
return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
case ParamType::TGLfixedPointer:
return GetParamVal<ParamType::TGLfixedPointer, T>(value);
case ParamType::TGLfloat:
return GetParamVal<ParamType::TGLfloat, T>(value);
case ParamType::TGLfloatConstPointer:
return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
case ParamType::TGLfloatPointer:
return GetParamVal<ParamType::TGLfloatPointer, T>(value);
case ParamType::TGLint:
return GetParamVal<ParamType::TGLint, T>(value);
case ParamType::TGLint64:
return GetParamVal<ParamType::TGLint64, T>(value);
case ParamType::TGLint64Pointer:
return GetParamVal<ParamType::TGLint64Pointer, T>(value);
case ParamType::TGLintConstPointer:
return GetParamVal<ParamType::TGLintConstPointer, T>(value);
case ParamType::TGLintPointer:
return GetParamVal<ParamType::TGLintPointer, T>(value);
case ParamType::TGLintptr:
return GetParamVal<ParamType::TGLintptr, T>(value);
case ParamType::TGLshort:
return GetParamVal<ParamType::TGLshort, T>(value);
case ParamType::TGLshortConstPointer:
return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
case ParamType::TGLsizei:
return GetParamVal<ParamType::TGLsizei, T>(value);
case ParamType::TGLsizeiConstPointer:
return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
case ParamType::TGLsizeiPointer:
return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
case ParamType::TGLsizeiptr:
return GetParamVal<ParamType::TGLsizeiptr, T>(value);
case ParamType::TGLsync:
return GetParamVal<ParamType::TGLsync, T>(value);
case ParamType::TGLubyte:
return GetParamVal<ParamType::TGLubyte, T>(value);
case ParamType::TGLubyteConstPointer:
return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
case ParamType::TGLubytePointer:
return GetParamVal<ParamType::TGLubytePointer, T>(value);
case ParamType::TGLuint:
return GetParamVal<ParamType::TGLuint, T>(value);
case ParamType::TGLuint64:
return GetParamVal<ParamType::TGLuint64, T>(value);
case ParamType::TGLuint64ConstPointer:
return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
case ParamType::TGLuint64Pointer:
return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
case ParamType::TGLuintConstPointer:
return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
case ParamType::TGLuintPointer:
return GetParamVal<ParamType::TGLuintPointer, T>(value);
case ParamType::TGraphicsResetStatus:
return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
case ParamType::THandleType:
return GetParamVal<ParamType::THandleType, T>(value);
case ParamType::TImageID:
return GetParamVal<ParamType::TImageID, T>(value);
case ParamType::TImageInfo:
return GetParamVal<ParamType::TImageInfo, T>(value);
case ParamType::TKernelArgInfo:
return GetParamVal<ParamType::TKernelArgInfo, T>(value);
case ParamType::TKernelExecInfo:
return GetParamVal<ParamType::TKernelExecInfo, T>(value);
case ParamType::TKernelInfo:
return GetParamVal<ParamType::TKernelInfo, T>(value);
case ParamType::TKernelSubGroupInfo:
return GetParamVal<ParamType::TKernelSubGroupInfo, T>(value);
case ParamType::TKernelWorkGroupInfo:
return GetParamVal<ParamType::TKernelWorkGroupInfo, T>(value);
case ParamType::TLightParameter:
return GetParamVal<ParamType::TLightParameter, T>(value);
case ParamType::TLogicalOperation:
return GetParamVal<ParamType::TLogicalOperation, T>(value);
case ParamType::TMapFlags:
return GetParamVal<ParamType::TMapFlags, T>(value);
case ParamType::TMaterialParameter:
return GetParamVal<ParamType::TMaterialParameter, T>(value);
case ParamType::TMatrixType:
return GetParamVal<ParamType::TMatrixType, T>(value);
case ParamType::TMemFlags:
return GetParamVal<ParamType::TMemFlags, T>(value);
case ParamType::TMemInfo:
return GetParamVal<ParamType::TMemInfo, T>(value);
case ParamType::TMemMigrationFlags:
return GetParamVal<ParamType::TMemMigrationFlags, T>(value);
case ParamType::TMemObjectType:
return GetParamVal<ParamType::TMemObjectType, T>(value);
case ParamType::TMemoryObjectID:
return GetParamVal<ParamType::TMemoryObjectID, T>(value);
case ParamType::TMemoryObjectIDConstPointer:
return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
case ParamType::TMemoryObjectIDPointer:
return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
case ParamType::TObjectType:
return GetParamVal<ParamType::TObjectType, T>(value);
case ParamType::TPipeInfo:
return GetParamVal<ParamType::TPipeInfo, T>(value);
case ParamType::TPlatformInfo:
return GetParamVal<ParamType::TPlatformInfo, T>(value);
case ParamType::TPointParameter:
return GetParamVal<ParamType::TPointParameter, T>(value);
case ParamType::TPolygonMode:
return GetParamVal<ParamType::TPolygonMode, T>(value);
case ParamType::TPrimitiveMode:
return GetParamVal<ParamType::TPrimitiveMode, T>(value);
case ParamType::TProfilingInfo:
return GetParamVal<ParamType::TProfilingInfo, T>(value);
case ParamType::TProgramBuildInfo:
return GetParamVal<ParamType::TProgramBuildInfo, T>(value);
case ParamType::TProgramInfo:
return GetParamVal<ParamType::TProgramInfo, T>(value);
case ParamType::TProgramPipelineID:
return GetParamVal<ParamType::TProgramPipelineID, T>(value);
case ParamType::TProgramPipelineIDConstPointer:
return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
case ParamType::TProgramPipelineIDPointer:
return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
case ParamType::TProvokingVertexConvention:
return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
case ParamType::TQueryID:
return GetParamVal<ParamType::TQueryID, T>(value);
case ParamType::TQueryIDConstPointer:
return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
case ParamType::TQueryIDPointer:
return GetParamVal<ParamType::TQueryIDPointer, T>(value);
case ParamType::TQueryType:
return GetParamVal<ParamType::TQueryType, T>(value);
case ParamType::TRenderbufferID:
return GetParamVal<ParamType::TRenderbufferID, T>(value);
case ParamType::TRenderbufferIDConstPointer:
return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
case ParamType::TRenderbufferIDPointer:
return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
case ParamType::TSVM_MemFlags:
return GetParamVal<ParamType::TSVM_MemFlags, T>(value);
case ParamType::TSamplerID:
return GetParamVal<ParamType::TSamplerID, T>(value);
case ParamType::TSamplerIDConstPointer:
return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
case ParamType::TSamplerIDPointer:
return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
case ParamType::TSamplerInfo:
return GetParamVal<ParamType::TSamplerInfo, T>(value);
case ParamType::TSemaphoreID:
return GetParamVal<ParamType::TSemaphoreID, T>(value);
case ParamType::TSemaphoreIDConstPointer:
return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
case ParamType::TSemaphoreIDPointer:
return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
case ParamType::TShaderProgramID:
return GetParamVal<ParamType::TShaderProgramID, T>(value);
case ParamType::TShaderProgramIDConstPointer:
return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
case ParamType::TShaderProgramIDPointer:
return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
case ParamType::TShaderType:
return GetParamVal<ParamType::TShaderType, T>(value);
case ParamType::TShadingModel:
return GetParamVal<ParamType::TShadingModel, T>(value);
case ParamType::TSurfaceID:
return GetParamVal<ParamType::TSurfaceID, T>(value);
case ParamType::TSyncID:
return GetParamVal<ParamType::TSyncID, T>(value);
case ParamType::TTextureEnvParameter:
return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
case ParamType::TTextureEnvTarget:
return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
case ParamType::TTextureID:
return GetParamVal<ParamType::TTextureID, T>(value);
case ParamType::TTextureIDConstPointer:
return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
case ParamType::TTextureIDPointer:
return GetParamVal<ParamType::TTextureIDPointer, T>(value);
case ParamType::TTextureTarget:
return GetParamVal<ParamType::TTextureTarget, T>(value);
case ParamType::TTextureType:
return GetParamVal<ParamType::TTextureType, T>(value);
case ParamType::TTimestamp:
return GetParamVal<ParamType::TTimestamp, T>(value);
case ParamType::TTransformFeedbackID:
return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
case ParamType::TTransformFeedbackIDConstPointer:
return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
case ParamType::TTransformFeedbackIDPointer:
return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
case ParamType::TUniformBlockIndex:
return GetParamVal<ParamType::TUniformBlockIndex, T>(value);
case ParamType::TUniformLocation:
return GetParamVal<ParamType::TUniformLocation, T>(value);
case ParamType::TVertexArrayID:
return GetParamVal<ParamType::TVertexArrayID, T>(value);
case ParamType::TVertexArrayIDConstPointer:
return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
case ParamType::TVertexArrayIDPointer:
return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
case ParamType::TVertexAttribType:
return GetParamVal<ParamType::TVertexAttribType, T>(value);
case ParamType::TcharConstPointer:
return GetParamVal<ParamType::TcharConstPointer, T>(value);
case ParamType::TcharConstPointerPointer:
return GetParamVal<ParamType::TcharConstPointerPointer, T>(value);
case ParamType::TcharUnsignedConstPointerPointer:
return GetParamVal<ParamType::TcharUnsignedConstPointerPointer, T>(value);
case ParamType::Tcl_bool:
return GetParamVal<ParamType::Tcl_bool, T>(value);
case ParamType::Tcl_buffer_create_type:
return GetParamVal<ParamType::Tcl_buffer_create_type, T>(value);
case ParamType::Tcl_callback_func_type:
return GetParamVal<ParamType::Tcl_callback_func_type, T>(value);
case ParamType::Tcl_command_queue:
return GetParamVal<ParamType::Tcl_command_queue, T>(value);
case ParamType::Tcl_command_queue_propertiesPointer:
return GetParamVal<ParamType::Tcl_command_queue_propertiesPointer, T>(value);
case ParamType::Tcl_context:
return GetParamVal<ParamType::Tcl_context, T>(value);
case ParamType::Tcl_context_destructor_func_type:
return GetParamVal<ParamType::Tcl_context_destructor_func_type, T>(value);
case ParamType::Tcl_context_func_type:
return GetParamVal<ParamType::Tcl_context_func_type, T>(value);
case ParamType::Tcl_context_propertiesConstPointer:
return GetParamVal<ParamType::Tcl_context_propertiesConstPointer, T>(value);
case ParamType::Tcl_device_id:
return GetParamVal<ParamType::Tcl_device_id, T>(value);
case ParamType::Tcl_device_idConstPointer:
return GetParamVal<ParamType::Tcl_device_idConstPointer, T>(value);
case ParamType::Tcl_device_idPointer:
return GetParamVal<ParamType::Tcl_device_idPointer, T>(value);
case ParamType::Tcl_device_partition_propertyConstPointer:
return GetParamVal<ParamType::Tcl_device_partition_propertyConstPointer, T>(value);
case ParamType::Tcl_event:
return GetParamVal<ParamType::Tcl_event, T>(value);
case ParamType::Tcl_eventConstPointer:
return GetParamVal<ParamType::Tcl_eventConstPointer, T>(value);
case ParamType::Tcl_eventPointer:
return GetParamVal<ParamType::Tcl_eventPointer, T>(value);
case ParamType::Tcl_image_descConstPointer:
return GetParamVal<ParamType::Tcl_image_descConstPointer, T>(value);
case ParamType::Tcl_image_formatConstPointer:
return GetParamVal<ParamType::Tcl_image_formatConstPointer, T>(value);
case ParamType::Tcl_image_formatPointer:
return GetParamVal<ParamType::Tcl_image_formatPointer, T>(value);
case ParamType::Tcl_int:
return GetParamVal<ParamType::Tcl_int, T>(value);
case ParamType::Tcl_intPointer:
return GetParamVal<ParamType::Tcl_intPointer, T>(value);
case ParamType::Tcl_kernel:
return GetParamVal<ParamType::Tcl_kernel, T>(value);
case ParamType::Tcl_kernelPointer:
return GetParamVal<ParamType::Tcl_kernelPointer, T>(value);
case ParamType::Tcl_mem:
return GetParamVal<ParamType::Tcl_mem, T>(value);
case ParamType::Tcl_memConstPointer:
return GetParamVal<ParamType::Tcl_memConstPointer, T>(value);
case ParamType::Tcl_mem_destructor_func_type:
return GetParamVal<ParamType::Tcl_mem_destructor_func_type, T>(value);
case ParamType::Tcl_mem_propertiesConstPointer:
return GetParamVal<ParamType::Tcl_mem_propertiesConstPointer, T>(value);
case ParamType::Tcl_pipe_propertiesConstPointer:
return GetParamVal<ParamType::Tcl_pipe_propertiesConstPointer, T>(value);
case ParamType::Tcl_platform_id:
return GetParamVal<ParamType::Tcl_platform_id, T>(value);
case ParamType::Tcl_platform_idPointer:
return GetParamVal<ParamType::Tcl_platform_idPointer, T>(value);
case ParamType::Tcl_program:
return GetParamVal<ParamType::Tcl_program, T>(value);
case ParamType::Tcl_programConstPointer:
return GetParamVal<ParamType::Tcl_programConstPointer, T>(value);
case ParamType::Tcl_program_func_type:
return GetParamVal<ParamType::Tcl_program_func_type, T>(value);
case ParamType::Tcl_queue_propertiesConstPointer:
return GetParamVal<ParamType::Tcl_queue_propertiesConstPointer, T>(value);
case ParamType::Tcl_sampler:
return GetParamVal<ParamType::Tcl_sampler, T>(value);
case ParamType::Tcl_sampler_propertiesConstPointer:
return GetParamVal<ParamType::Tcl_sampler_propertiesConstPointer, T>(value);
case ParamType::Tcl_svm_free_callback_func_type:
return GetParamVal<ParamType::Tcl_svm_free_callback_func_type, T>(value);
case ParamType::Tcl_uint:
return GetParamVal<ParamType::Tcl_uint, T>(value);
case ParamType::Tcl_uintPointer:
return GetParamVal<ParamType::Tcl_uintPointer, T>(value);
case ParamType::Tcl_ulongPointer:
return GetParamVal<ParamType::Tcl_ulongPointer, T>(value);
case ParamType::Tcl_void_func_type:
return GetParamVal<ParamType::Tcl_void_func_type, T>(value);
case ParamType::Tegl_ConfigPointer:
return GetParamVal<ParamType::Tegl_ConfigPointer, T>(value);
case ParamType::Tegl_DevicePointer:
return GetParamVal<ParamType::Tegl_DevicePointer, T>(value);
case ParamType::Tegl_DisplayPointer:
return GetParamVal<ParamType::Tegl_DisplayPointer, T>(value);
case ParamType::Tegl_StreamPointer:
return GetParamVal<ParamType::Tegl_StreamPointer, T>(value);
case ParamType::Tegl_SyncID:
return GetParamVal<ParamType::Tegl_SyncID, T>(value);
case ParamType::Tsize_t:
return GetParamVal<ParamType::Tsize_t, T>(value);
case ParamType::Tsize_tConstPointer:
return GetParamVal<ParamType::Tsize_tConstPointer, T>(value);
case ParamType::Tsize_tPointer:
return GetParamVal<ParamType::Tsize_tPointer, T>(value);
case ParamType::TvoidConstPointer:
return GetParamVal<ParamType::TvoidConstPointer, T>(value);
case ParamType::TvoidConstPointerPointer:
return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
case ParamType::TvoidPointer:
return GetParamVal<ParamType::TvoidPointer, T>(value);
case ParamType::TvoidPointerPointer:
return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
}
UNREACHABLE();
return T();
}
template <ParamType PType, typename T>
void SetParamVal(T valueIn, ParamValue *valueOut);
template <>
inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
ParamValue *valueOut)
{
valueOut->AHardwareBufferConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
{
valueOut->AlphaTestFuncVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
{
valueOut->BufferBindingVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
{
valueOut->BufferIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
ParamValue *valueOut)
{
valueOut->BufferIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
{
valueOut->BufferIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
{
valueOut->BufferUsageVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
ParamValue *valueOut)
{
valueOut->ClientVertexArrayTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TClipDepthMode>(gl::ClipDepthMode valueIn, ParamValue *valueOut)
{
valueOut->ClipDepthModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TClipOrigin>(gl::ClipOrigin valueIn, ParamValue *valueOut)
{
valueOut->ClipOriginVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn,
ParamValue *valueOut)
{
valueOut->CompositorTimingVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TContextID>(gl::ContextID valueIn, ParamValue *valueOut)
{
valueOut->ContextIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
{
valueOut->CullFaceModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
ParamValue *valueOut)
{
valueOut->DrawElementsTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLAttribConstPointer>(const EGLAttrib *valueIn,
ParamValue *valueOut)
{
valueOut->EGLAttribConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLAttribKHRPointer>(EGLAttribKHR *valueIn,
ParamValue *valueOut)
{
valueOut->EGLAttribKHRPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamValue *valueOut)
{
valueOut->EGLAttribPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
{
valueOut->EGLBooleanVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
{
valueOut->EGLBooleanPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
{
valueOut->EGLClientBufferVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamValue *valueOut)
{
valueOut->EGLConfigPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
{
valueOut->EGLContextVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLDEBUGPROCKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
{
valueOut->EGLDeviceEXTVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
{
valueOut->EGLDisplayVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
ParamValue *valueOut)
{
valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
{
valueOut->EGLImageVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLImageKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLLabelKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
ParamValue *valueOut)
{
valueOut->EGLNativeDisplayTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
ParamValue *valueOut)
{
valueOut->EGLNativePixmapTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
ParamValue *valueOut)
{
valueOut->EGLNativeWindowTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLObjectKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
ParamValue *valueOut)
{
valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLStreamKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
{
valueOut->EGLSurfaceVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
{
valueOut->EGLSyncVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLSyncKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
{
valueOut->EGLTimeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
{
valueOut->EGLTimeKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
{
valueOut->EGLenumVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
{
valueOut->EGLintVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLintConstPointer>(const EGLint *valueIn, ParamValue *valueOut)
{
valueOut->EGLintConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLintPointer>(EGLint *valueIn, ParamValue *valueOut)
{
valueOut->EGLintPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
{
valueOut->EGLnsecsANDROIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(EGLnsecsANDROID *valueIn,
ParamValue *valueOut)
{
valueOut->EGLnsecsANDROIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
{
valueOut->EGLuint64KHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEGLuint64KHRPointer>(EGLuint64KHR *valueIn,
ParamValue *valueOut)
{
valueOut->EGLuint64KHRPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
{
valueOut->FenceNVIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
ParamValue *valueOut)
{
valueOut->FenceNVIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
{
valueOut->FenceNVIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
{
valueOut->FramebufferIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
ParamValue *valueOut)
{
valueOut->FramebufferIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
ParamValue *valueOut)
{
valueOut->FramebufferIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
{
valueOut->GLDEBUGPROCVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
{
valueOut->GLDEBUGPROCKHRVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLGETBLOBPROCANGLE>(GLGETBLOBPROCANGLE valueIn,
ParamValue *valueOut)
{
valueOut->GLGETBLOBPROCANGLEVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLSETBLOBPROCANGLE>(GLSETBLOBPROCANGLE valueIn,
ParamValue *valueOut)
{
valueOut->GLSETBLOBPROCANGLEVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
{
valueOut->GLbitfieldVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
{
valueOut->GLbooleanVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
{
valueOut->GLbooleanPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
{
valueOut->GLcharConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
ParamValue *valueOut)
{
valueOut->GLcharConstPointerPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
{
valueOut->GLcharPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
{
valueOut->GLclampxVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
ParamValue *valueOut)
{
valueOut->GLeglClientBufferEXTVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
{
valueOut->GLenumVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
{
valueOut->GLenumConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
{
valueOut->GLenumPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
{
valueOut->GLfixedVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
ParamValue *valueOut)
{
valueOut->GLfixedConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
{
valueOut->GLfixedPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
{
valueOut->GLfloatVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
ParamValue *valueOut)
{
valueOut->GLfloatConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
{
valueOut->GLfloatPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
{
valueOut->GLintVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLint64>(GLint64 valueIn, ParamValue *valueOut)
{
valueOut->GLint64Val = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
{
valueOut->GLint64PointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
{
valueOut->GLintConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
{
valueOut->GLintPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
{
valueOut->GLintptrVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
{
valueOut->GLshortVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
ParamValue *valueOut)
{
valueOut->GLshortConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
{
valueOut->GLsizeiVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
ParamValue *valueOut)
{
valueOut->GLsizeiConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
{
valueOut->GLsizeiPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
{
valueOut->GLsizeiptrVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
{
valueOut->GLsyncVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
{
valueOut->GLubyteVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
ParamValue *valueOut)
{
valueOut->GLubyteConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
{
valueOut->GLubytePointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
{
valueOut->GLuintVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
{
valueOut->GLuint64Val = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
ParamValue *valueOut)
{
valueOut->GLuint64ConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
{
valueOut->GLuint64PointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
{
valueOut->GLuintConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
{
valueOut->GLuintPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
ParamValue *valueOut)
{
valueOut->GraphicsResetStatusVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
{
valueOut->HandleTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TImageID>(egl::ImageID valueIn, ParamValue *valueOut)
{
valueOut->ImageIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
ParamValue *valueOut)
{
valueOut->LightParameterVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
ParamValue *valueOut)
{
valueOut->LogicalOperationVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
ParamValue *valueOut)
{
valueOut->MaterialParameterVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
{
valueOut->MatrixTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
ParamValue *valueOut)
{
valueOut->MemoryObjectIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
ParamValue *valueOut)
{
valueOut->MemoryObjectIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
ParamValue *valueOut)
{
valueOut->MemoryObjectIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
{
valueOut->ObjectTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
ParamValue *valueOut)
{
valueOut->PointParameterVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TPolygonMode>(gl::PolygonMode valueIn, ParamValue *valueOut)
{
valueOut->PolygonModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
{
valueOut->PrimitiveModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
ParamValue *valueOut)
{
valueOut->ProgramPipelineIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
const gl::ProgramPipelineID *valueIn,
ParamValue *valueOut)
{
valueOut->ProgramPipelineIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
ParamValue *valueOut)
{
valueOut->ProgramPipelineIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProvokingVertexConvention>(
gl::ProvokingVertexConvention valueIn,
ParamValue *valueOut)
{
valueOut->ProvokingVertexConventionVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
{
valueOut->QueryIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
ParamValue *valueOut)
{
valueOut->QueryIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
{
valueOut->QueryIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
{
valueOut->QueryTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
ParamValue *valueOut)
{
valueOut->RenderbufferIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
ParamValue *valueOut)
{
valueOut->RenderbufferIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
ParamValue *valueOut)
{
valueOut->RenderbufferIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
{
valueOut->SamplerIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
ParamValue *valueOut)
{
valueOut->SamplerIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
{
valueOut->SamplerIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
{
valueOut->SemaphoreIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
ParamValue *valueOut)
{
valueOut->SemaphoreIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
ParamValue *valueOut)
{
valueOut->SemaphoreIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
ParamValue *valueOut)
{
valueOut->ShaderProgramIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
ParamValue *valueOut)
{
valueOut->ShaderProgramIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
ParamValue *valueOut)
{
valueOut->ShaderProgramIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
{
valueOut->ShaderTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
{
valueOut->ShadingModelVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSurfaceID>(egl::SurfaceID valueIn, ParamValue *valueOut)
{
valueOut->SurfaceIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSyncID>(gl::SyncID valueIn, ParamValue *valueOut)
{
valueOut->SyncIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
ParamValue *valueOut)
{
valueOut->TextureEnvParameterVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
ParamValue *valueOut)
{
valueOut->TextureEnvTargetVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
{
valueOut->TextureIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
ParamValue *valueOut)
{
valueOut->TextureIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
{
valueOut->TextureIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
{
valueOut->TextureTargetVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
{
valueOut->TextureTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
{
valueOut->TimestampVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
ParamValue *valueOut)
{
valueOut->TransformFeedbackIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
const gl::TransformFeedbackID *valueIn,
ParamValue *valueOut)
{
valueOut->TransformFeedbackIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
ParamValue *valueOut)
{
valueOut->TransformFeedbackIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
ParamValue *valueOut)
{
valueOut->UniformBlockIndexVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
ParamValue *valueOut)
{
valueOut->UniformLocationVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
{
valueOut->VertexArrayIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
ParamValue *valueOut)
{
valueOut->VertexArrayIDConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
ParamValue *valueOut)
{
valueOut->VertexArrayIDPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
ParamValue *valueOut)
{
valueOut->VertexAttribTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
{
valueOut->charConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TcharConstPointerPointer>(const char **valueIn,
ParamValue *valueOut)
{
valueOut->charConstPointerPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TcharUnsignedConstPointerPointer>(const unsigned char **valueIn,
ParamValue *valueOut)
{
valueOut->charUnsignedConstPointerPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tegl_ConfigPointer>(egl::Config *valueIn, ParamValue *valueOut)
{
valueOut->egl_ConfigPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tegl_DevicePointer>(egl::Device *valueIn, ParamValue *valueOut)
{
valueOut->egl_DevicePointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tegl_DisplayPointer>(egl::Display *valueIn, ParamValue *valueOut)
{
valueOut->egl_DisplayPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tegl_StreamPointer>(egl::Stream *valueIn, ParamValue *valueOut)
{
valueOut->egl_StreamPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tegl_SyncID>(egl::SyncID valueIn, ParamValue *valueOut)
{
valueOut->egl_SyncIDVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tsize_t>(size_t valueIn, ParamValue *valueOut)
{
valueOut->size_tVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tsize_tConstPointer>(const size_t *valueIn, ParamValue *valueOut)
{
valueOut->size_tConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tsize_tPointer>(size_t *valueIn, ParamValue *valueOut)
{
valueOut->size_tPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
{
valueOut->voidConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void **valueIn,
ParamValue *valueOut)
{
valueOut->voidConstPointerPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
{
valueOut->voidPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
{
valueOut->voidPointerPointerVal = valueIn;
}
#ifdef ANGLE_ENABLE_CL
template <>
inline void SetParamVal<ParamType::TAddressingMode>(cl::AddressingMode valueIn,
ParamValue *valueOut)
{
valueOut->AddressingModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TCommandQueueInfo>(cl::CommandQueueInfo valueIn,
ParamValue *valueOut)
{
valueOut->CommandQueueInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TCommandQueueProperties>(cl::CommandQueueProperties valueIn,
ParamValue *valueOut)
{
valueOut->CommandQueuePropertiesVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TContextInfo>(cl::ContextInfo valueIn, ParamValue *valueOut)
{
valueOut->ContextInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TDeviceInfo>(cl::DeviceInfo valueIn, ParamValue *valueOut)
{
valueOut->DeviceInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TDeviceType>(cl::DeviceType valueIn, ParamValue *valueOut)
{
valueOut->DeviceTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TEventInfo>(cl::EventInfo valueIn, ParamValue *valueOut)
{
valueOut->EventInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TFilterMode>(cl::FilterMode valueIn, ParamValue *valueOut)
{
valueOut->FilterModeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TImageInfo>(cl::ImageInfo valueIn, ParamValue *valueOut)
{
valueOut->ImageInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TKernelArgInfo>(cl::KernelArgInfo valueIn, ParamValue *valueOut)
{
valueOut->KernelArgInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TKernelExecInfo>(cl::KernelExecInfo valueIn,
ParamValue *valueOut)
{
valueOut->KernelExecInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TKernelInfo>(cl::KernelInfo valueIn, ParamValue *valueOut)
{
valueOut->KernelInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TKernelSubGroupInfo>(cl::KernelSubGroupInfo valueIn,
ParamValue *valueOut)
{
valueOut->KernelSubGroupInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TKernelWorkGroupInfo>(cl::KernelWorkGroupInfo valueIn,
ParamValue *valueOut)
{
valueOut->KernelWorkGroupInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMapFlags>(cl::MapFlags valueIn, ParamValue *valueOut)
{
valueOut->MapFlagsVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemFlags>(cl::MemFlags valueIn, ParamValue *valueOut)
{
valueOut->MemFlagsVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemInfo>(cl::MemInfo valueIn, ParamValue *valueOut)
{
valueOut->MemInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemMigrationFlags>(cl::MemMigrationFlags valueIn,
ParamValue *valueOut)
{
valueOut->MemMigrationFlagsVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TMemObjectType>(cl::MemObjectType valueIn, ParamValue *valueOut)
{
valueOut->MemObjectTypeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TPipeInfo>(cl::PipeInfo valueIn, ParamValue *valueOut)
{
valueOut->PipeInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TPlatformInfo>(cl::PlatformInfo valueIn, ParamValue *valueOut)
{
valueOut->PlatformInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProfilingInfo>(cl::ProfilingInfo valueIn, ParamValue *valueOut)
{
valueOut->ProfilingInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProgramBuildInfo>(cl::ProgramBuildInfo valueIn,
ParamValue *valueOut)
{
valueOut->ProgramBuildInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TProgramInfo>(cl::ProgramInfo valueIn, ParamValue *valueOut)
{
valueOut->ProgramInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSVM_MemFlags>(cl::SVM_MemFlags valueIn, ParamValue *valueOut)
{
valueOut->SVM_MemFlagsVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::TSamplerInfo>(cl::SamplerInfo valueIn, ParamValue *valueOut)
{
valueOut->SamplerInfoVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_bool>(cl_bool valueIn, ParamValue *valueOut)
{
valueOut->cl_boolVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_buffer_create_type>(cl_buffer_create_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_buffer_create_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_callback_func_type>(cl_callback_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_callback_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_command_queue>(cl_command_queue valueIn,
ParamValue *valueOut)
{
valueOut->cl_command_queueVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_command_queue_propertiesPointer>(
cl_command_queue_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_command_queue_propertiesPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_context>(cl_context valueIn, ParamValue *valueOut)
{
valueOut->cl_contextVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_context_destructor_func_type>(
cl_context_destructor_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_context_destructor_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_context_func_type>(cl_context_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_context_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_context_propertiesConstPointer>(
const cl_context_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_context_propertiesConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_device_id>(cl_device_id valueIn, ParamValue *valueOut)
{
valueOut->cl_device_idVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_device_idConstPointer>(const cl_device_id *valueIn,
ParamValue *valueOut)
{
valueOut->cl_device_idConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_device_idPointer>(cl_device_id *valueIn,
ParamValue *valueOut)
{
valueOut->cl_device_idPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_device_partition_propertyConstPointer>(
const cl_device_partition_property *valueIn,
ParamValue *valueOut)
{
valueOut->cl_device_partition_propertyConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_event>(cl_event valueIn, ParamValue *valueOut)
{
valueOut->cl_eventVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_eventConstPointer>(const cl_event *valueIn,
ParamValue *valueOut)
{
valueOut->cl_eventConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_eventPointer>(cl_event *valueIn, ParamValue *valueOut)
{
valueOut->cl_eventPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_image_descConstPointer>(const cl_image_desc *valueIn,
ParamValue *valueOut)
{
valueOut->cl_image_descConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_image_formatConstPointer>(const cl_image_format *valueIn,
ParamValue *valueOut)
{
valueOut->cl_image_formatConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_image_formatPointer>(cl_image_format *valueIn,
ParamValue *valueOut)
{
valueOut->cl_image_formatPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_int>(cl_int valueIn, ParamValue *valueOut)
{
valueOut->cl_intVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_intPointer>(cl_int *valueIn, ParamValue *valueOut)
{
valueOut->cl_intPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_kernel>(cl_kernel valueIn, ParamValue *valueOut)
{
valueOut->cl_kernelVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_kernelPointer>(cl_kernel *valueIn, ParamValue *valueOut)
{
valueOut->cl_kernelPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_mem>(cl_mem valueIn, ParamValue *valueOut)
{
valueOut->cl_memVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_memConstPointer>(const cl_mem *valueIn, ParamValue *valueOut)
{
valueOut->cl_memConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_mem_destructor_func_type>(
cl_mem_destructor_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_mem_destructor_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_mem_propertiesConstPointer>(const cl_mem_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_mem_propertiesConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_pipe_propertiesConstPointer>(
const cl_pipe_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_pipe_propertiesConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_platform_id>(cl_platform_id valueIn, ParamValue *valueOut)
{
valueOut->cl_platform_idVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_platform_idPointer>(cl_platform_id *valueIn,
ParamValue *valueOut)
{
valueOut->cl_platform_idPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_program>(cl_program valueIn, ParamValue *valueOut)
{
valueOut->cl_programVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_programConstPointer>(const cl_program *valueIn,
ParamValue *valueOut)
{
valueOut->cl_programConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_program_func_type>(cl_program_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_program_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_queue_propertiesConstPointer>(
const cl_queue_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_queue_propertiesConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_sampler>(cl_sampler valueIn, ParamValue *valueOut)
{
valueOut->cl_samplerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_sampler_propertiesConstPointer>(
const cl_sampler_properties *valueIn,
ParamValue *valueOut)
{
valueOut->cl_sampler_propertiesConstPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_svm_free_callback_func_type>(
cl_svm_free_callback_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_svm_free_callback_func_typeVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_uint>(cl_uint valueIn, ParamValue *valueOut)
{
valueOut->cl_uintVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_uintPointer>(cl_uint *valueIn, ParamValue *valueOut)
{
valueOut->cl_uintPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_ulongPointer>(cl_ulong *valueIn, ParamValue *valueOut)
{
valueOut->cl_ulongPointerVal = valueIn;
}
template <>
inline void SetParamVal<ParamType::Tcl_void_func_type>(cl_void_func_type valueIn,
ParamValue *valueOut)
{
valueOut->cl_void_func_typeVal = valueIn;
}
#endif
template <ParamType PType, typename T>
void SetParamVal(T valueIn, ParamValue *valueOut)
{
UNREACHABLE();
}
template <typename T>
void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
{
switch (paramType)
{
case ParamType::TAHardwareBufferConstPointer:
SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut);
break;
case ParamType::TAddressingMode:
SetParamVal<ParamType::TAddressingMode>(valueIn, valueOut);
break;
case ParamType::TAlphaTestFunc:
SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
break;
case ParamType::TBufferBinding:
SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
break;
case ParamType::TBufferID:
SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
break;
case ParamType::TBufferIDConstPointer:
SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TBufferIDPointer:
SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
break;
case ParamType::TBufferUsage:
SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
break;
case ParamType::TClientVertexArrayType:
SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
break;
case ParamType::TClipDepthMode:
SetParamVal<ParamType::TClipDepthMode>(valueIn, valueOut);
break;
case ParamType::TClipOrigin:
SetParamVal<ParamType::TClipOrigin>(valueIn, valueOut);
break;
case ParamType::TCommandQueueInfo:
SetParamVal<ParamType::TCommandQueueInfo>(valueIn, valueOut);
break;
case ParamType::TCommandQueueProperties:
SetParamVal<ParamType::TCommandQueueProperties>(valueIn, valueOut);
break;
case ParamType::TCompositorTiming:
SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut);
break;
case ParamType::TContextID:
SetParamVal<ParamType::TContextID>(valueIn, valueOut);
break;
case ParamType::TContextInfo:
SetParamVal<ParamType::TContextInfo>(valueIn, valueOut);
break;
case ParamType::TCullFaceMode:
SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
break;
case ParamType::TDeviceInfo:
SetParamVal<ParamType::TDeviceInfo>(valueIn, valueOut);
break;
case ParamType::TDeviceType:
SetParamVal<ParamType::TDeviceType>(valueIn, valueOut);
break;
case ParamType::TDrawElementsType:
SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
break;
case ParamType::TEGLAttribConstPointer:
SetParamVal<ParamType::TEGLAttribConstPointer>(valueIn, valueOut);
break;
case ParamType::TEGLAttribKHRPointer:
SetParamVal<ParamType::TEGLAttribKHRPointer>(valueIn, valueOut);
break;
case ParamType::TEGLAttribPointer:
SetParamVal<ParamType::TEGLAttribPointer>(valueIn, valueOut);
break;
case ParamType::TEGLBoolean:
SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
break;
case ParamType::TEGLBooleanPointer:
SetParamVal<ParamType::TEGLBooleanPointer>(valueIn, valueOut);
break;
case ParamType::TEGLClientBuffer:
SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut);
break;
case ParamType::TEGLConfigPointer:
SetParamVal<ParamType::TEGLConfigPointer>(valueIn, valueOut);
break;
case ParamType::TEGLContext:
SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
break;
case ParamType::TEGLDEBUGPROCKHR:
SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
break;
case ParamType::TEGLDeviceEXT:
SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
break;
case ParamType::TEGLDisplay:
SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
break;
case ParamType::TEGLGetBlobFuncANDROID:
SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
break;
case ParamType::TEGLImage:
SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
break;
case ParamType::TEGLImageKHR:
SetParamVal<ParamType::TEGLImageKHR>(valueIn, valueOut);
break;
case ParamType::TEGLLabelKHR:
SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
break;
case ParamType::TEGLNativeDisplayType:
SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut);
break;
case ParamType::TEGLNativePixmapType:
SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut);
break;
case ParamType::TEGLNativeWindowType:
SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut);
break;
case ParamType::TEGLObjectKHR:
SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut);
break;
case ParamType::TEGLSetBlobFuncANDROID:
SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
break;
case ParamType::TEGLStreamKHR:
SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
break;
case ParamType::TEGLSurface:
SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
break;
case ParamType::TEGLSync:
SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
break;
case ParamType::TEGLSyncKHR:
SetParamVal<ParamType::TEGLSyncKHR>(valueIn, valueOut);
break;
case ParamType::TEGLTime:
SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
break;
case ParamType::TEGLTimeKHR:
SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut);
break;
case ParamType::TEGLenum:
SetParamVal<ParamType::TEGLenum>(valueIn, valueOut);
break;
case ParamType::TEGLint:
SetParamVal<ParamType::TEGLint>(valueIn, valueOut);
break;
case ParamType::TEGLintConstPointer:
SetParamVal<ParamType::TEGLintConstPointer>(valueIn, valueOut);
break;
case ParamType::TEGLintPointer:
SetParamVal<ParamType::TEGLintPointer>(valueIn, valueOut);
break;
case ParamType::TEGLnsecsANDROID:
SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut);
break;
case ParamType::TEGLnsecsANDROIDPointer:
SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(valueIn, valueOut);
break;
case ParamType::TEGLuint64KHR:
SetParamVal<ParamType::TEGLuint64KHR>(valueIn, valueOut);
break;
case ParamType::TEGLuint64KHRPointer:
SetParamVal<ParamType::TEGLuint64KHRPointer>(valueIn, valueOut);
break;
case ParamType::TEventInfo:
SetParamVal<ParamType::TEventInfo>(valueIn, valueOut);
break;
case ParamType::TFenceNVID:
SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
break;
case ParamType::TFenceNVIDConstPointer:
SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TFenceNVIDPointer:
SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
break;
case ParamType::TFilterMode:
SetParamVal<ParamType::TFilterMode>(valueIn, valueOut);
break;
case ParamType::TFramebufferID:
SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
break;
case ParamType::TFramebufferIDConstPointer:
SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TFramebufferIDPointer:
SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
break;
case ParamType::TGLDEBUGPROC:
SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
break;
case ParamType::TGLDEBUGPROCKHR:
SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
break;
case ParamType::TGLGETBLOBPROCANGLE:
SetParamVal<ParamType::TGLGETBLOBPROCANGLE>(valueIn, valueOut);
break;
case ParamType::TGLSETBLOBPROCANGLE:
SetParamVal<ParamType::TGLSETBLOBPROCANGLE>(valueIn, valueOut);
break;
case ParamType::TGLbitfield:
SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
break;
case ParamType::TGLboolean:
SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
break;
case ParamType::TGLbooleanPointer:
SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
break;
case ParamType::TGLcharConstPointer:
SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLcharConstPointerPointer:
SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
break;
case ParamType::TGLcharPointer:
SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
break;
case ParamType::TGLclampx:
SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
break;
case ParamType::TGLeglClientBufferEXT:
SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut);
break;
case ParamType::TGLenum:
SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
break;
case ParamType::TGLenumConstPointer:
SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLenumPointer:
SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
break;
case ParamType::TGLfixed:
SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
break;
case ParamType::TGLfixedConstPointer:
SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLfixedPointer:
SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
break;
case ParamType::TGLfloat:
SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
break;
case ParamType::TGLfloatConstPointer:
SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLfloatPointer:
SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
break;
case ParamType::TGLint:
SetParamVal<ParamType::TGLint>(valueIn, valueOut);
break;
case ParamType::TGLint64:
SetParamVal<ParamType::TGLint64>(valueIn, valueOut);
break;
case ParamType::TGLint64Pointer:
SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
break;
case ParamType::TGLintConstPointer:
SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLintPointer:
SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
break;
case ParamType::TGLintptr:
SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
break;
case ParamType::TGLshort:
SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
break;
case ParamType::TGLshortConstPointer:
SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLsizei:
SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
break;
case ParamType::TGLsizeiConstPointer:
SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLsizeiPointer:
SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
break;
case ParamType::TGLsizeiptr:
SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
break;
case ParamType::TGLsync:
SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
break;
case ParamType::TGLubyte:
SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
break;
case ParamType::TGLubyteConstPointer:
SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLubytePointer:
SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
break;
case ParamType::TGLuint:
SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
break;
case ParamType::TGLuint64:
SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
break;
case ParamType::TGLuint64ConstPointer:
SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLuint64Pointer:
SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
break;
case ParamType::TGLuintConstPointer:
SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
break;
case ParamType::TGLuintPointer:
SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
break;
case ParamType::TGraphicsResetStatus:
SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
break;
case ParamType::THandleType:
SetParamVal<ParamType::THandleType>(valueIn, valueOut);
break;
case ParamType::TImageID:
SetParamVal<ParamType::TImageID>(valueIn, valueOut);
break;
case ParamType::TImageInfo:
SetParamVal<ParamType::TImageInfo>(valueIn, valueOut);
break;
case ParamType::TKernelArgInfo:
SetParamVal<ParamType::TKernelArgInfo>(valueIn, valueOut);
break;
case ParamType::TKernelExecInfo:
SetParamVal<ParamType::TKernelExecInfo>(valueIn, valueOut);
break;
case ParamType::TKernelInfo:
SetParamVal<ParamType::TKernelInfo>(valueIn, valueOut);
break;
case ParamType::TKernelSubGroupInfo:
SetParamVal<ParamType::TKernelSubGroupInfo>(valueIn, valueOut);
break;
case ParamType::TKernelWorkGroupInfo:
SetParamVal<ParamType::TKernelWorkGroupInfo>(valueIn, valueOut);
break;
case ParamType::TLightParameter:
SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
break;
case ParamType::TLogicalOperation:
SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
break;
case ParamType::TMapFlags:
SetParamVal<ParamType::TMapFlags>(valueIn, valueOut);
break;
case ParamType::TMaterialParameter:
SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
break;
case ParamType::TMatrixType:
SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
break;
case ParamType::TMemFlags:
SetParamVal<ParamType::TMemFlags>(valueIn, valueOut);
break;
case ParamType::TMemInfo:
SetParamVal<ParamType::TMemInfo>(valueIn, valueOut);
break;
case ParamType::TMemMigrationFlags:
SetParamVal<ParamType::TMemMigrationFlags>(valueIn, valueOut);
break;
case ParamType::TMemObjectType:
SetParamVal<ParamType::TMemObjectType>(valueIn, valueOut);
break;
case ParamType::TMemoryObjectID:
SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
break;
case ParamType::TMemoryObjectIDConstPointer:
SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TMemoryObjectIDPointer:
SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
break;
case ParamType::TObjectType:
SetParamVal<ParamType::TObjectType>(valueIn, valueOut);
break;
case ParamType::TPipeInfo:
SetParamVal<ParamType::TPipeInfo>(valueIn, valueOut);
break;
case ParamType::TPlatformInfo:
SetParamVal<ParamType::TPlatformInfo>(valueIn, valueOut);
break;
case ParamType::TPointParameter:
SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
break;
case ParamType::TPolygonMode:
SetParamVal<ParamType::TPolygonMode>(valueIn, valueOut);
break;
case ParamType::TPrimitiveMode:
SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
break;
case ParamType::TProfilingInfo:
SetParamVal<ParamType::TProfilingInfo>(valueIn, valueOut);
break;
case ParamType::TProgramBuildInfo:
SetParamVal<ParamType::TProgramBuildInfo>(valueIn, valueOut);
break;
case ParamType::TProgramInfo:
SetParamVal<ParamType::TProgramInfo>(valueIn, valueOut);
break;
case ParamType::TProgramPipelineID:
SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
break;
case ParamType::TProgramPipelineIDConstPointer:
SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TProgramPipelineIDPointer:
SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
break;
case ParamType::TProvokingVertexConvention:
SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
break;
case ParamType::TQueryID:
SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
break;
case ParamType::TQueryIDConstPointer:
SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TQueryIDPointer:
SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
break;
case ParamType::TQueryType:
SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
break;
case ParamType::TRenderbufferID:
SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
break;
case ParamType::TRenderbufferIDConstPointer:
SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TRenderbufferIDPointer:
SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
break;
case ParamType::TSVM_MemFlags:
SetParamVal<ParamType::TSVM_MemFlags>(valueIn, valueOut);
break;
case ParamType::TSamplerID:
SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
break;
case ParamType::TSamplerIDConstPointer:
SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TSamplerIDPointer:
SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
break;
case ParamType::TSamplerInfo:
SetParamVal<ParamType::TSamplerInfo>(valueIn, valueOut);
break;
case ParamType::TSemaphoreID:
SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
break;
case ParamType::TSemaphoreIDConstPointer:
SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TSemaphoreIDPointer:
SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
break;
case ParamType::TShaderProgramID:
SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
break;
case ParamType::TShaderProgramIDConstPointer:
SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TShaderProgramIDPointer:
SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
break;
case ParamType::TShaderType:
SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
break;
case ParamType::TShadingModel:
SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
break;
case ParamType::TSurfaceID:
SetParamVal<ParamType::TSurfaceID>(valueIn, valueOut);
break;
case ParamType::TSyncID:
SetParamVal<ParamType::TSyncID>(valueIn, valueOut);
break;
case ParamType::TTextureEnvParameter:
SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
break;
case ParamType::TTextureEnvTarget:
SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
break;
case ParamType::TTextureID:
SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
break;
case ParamType::TTextureIDConstPointer:
SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TTextureIDPointer:
SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
break;
case ParamType::TTextureTarget:
SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
break;
case ParamType::TTextureType:
SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
break;
case ParamType::TTimestamp:
SetParamVal<ParamType::TTimestamp>(valueIn, valueOut);
break;
case ParamType::TTransformFeedbackID:
SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
break;
case ParamType::TTransformFeedbackIDConstPointer:
SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TTransformFeedbackIDPointer:
SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
break;
case ParamType::TUniformBlockIndex:
SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut);
break;
case ParamType::TUniformLocation:
SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
break;
case ParamType::TVertexArrayID:
SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
break;
case ParamType::TVertexArrayIDConstPointer:
SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
break;
case ParamType::TVertexArrayIDPointer:
SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
break;
case ParamType::TVertexAttribType:
SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
break;
case ParamType::TcharConstPointer:
SetParamVal<ParamType::TcharConstPointer>(valueIn, valueOut);
break;
case ParamType::TcharConstPointerPointer:
SetParamVal<ParamType::TcharConstPointerPointer>(valueIn, valueOut);
break;
case ParamType::TcharUnsignedConstPointerPointer:
SetParamVal<ParamType::TcharUnsignedConstPointerPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_bool:
SetParamVal<ParamType::Tcl_bool>(valueIn, valueOut);
break;
case ParamType::Tcl_buffer_create_type:
SetParamVal<ParamType::Tcl_buffer_create_type>(valueIn, valueOut);
break;
case ParamType::Tcl_callback_func_type:
SetParamVal<ParamType::Tcl_callback_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_command_queue:
SetParamVal<ParamType::Tcl_command_queue>(valueIn, valueOut);
break;
case ParamType::Tcl_command_queue_propertiesPointer:
SetParamVal<ParamType::Tcl_command_queue_propertiesPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_context:
SetParamVal<ParamType::Tcl_context>(valueIn, valueOut);
break;
case ParamType::Tcl_context_destructor_func_type:
SetParamVal<ParamType::Tcl_context_destructor_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_context_func_type:
SetParamVal<ParamType::Tcl_context_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_context_propertiesConstPointer:
SetParamVal<ParamType::Tcl_context_propertiesConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_device_id:
SetParamVal<ParamType::Tcl_device_id>(valueIn, valueOut);
break;
case ParamType::Tcl_device_idConstPointer:
SetParamVal<ParamType::Tcl_device_idConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_device_idPointer:
SetParamVal<ParamType::Tcl_device_idPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_device_partition_propertyConstPointer:
SetParamVal<ParamType::Tcl_device_partition_propertyConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_event:
SetParamVal<ParamType::Tcl_event>(valueIn, valueOut);
break;
case ParamType::Tcl_eventConstPointer:
SetParamVal<ParamType::Tcl_eventConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_eventPointer:
SetParamVal<ParamType::Tcl_eventPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_image_descConstPointer:
SetParamVal<ParamType::Tcl_image_descConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_image_formatConstPointer:
SetParamVal<ParamType::Tcl_image_formatConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_image_formatPointer:
SetParamVal<ParamType::Tcl_image_formatPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_int:
SetParamVal<ParamType::Tcl_int>(valueIn, valueOut);
break;
case ParamType::Tcl_intPointer:
SetParamVal<ParamType::Tcl_intPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_kernel:
SetParamVal<ParamType::Tcl_kernel>(valueIn, valueOut);
break;
case ParamType::Tcl_kernelPointer:
SetParamVal<ParamType::Tcl_kernelPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_mem:
SetParamVal<ParamType::Tcl_mem>(valueIn, valueOut);
break;
case ParamType::Tcl_memConstPointer:
SetParamVal<ParamType::Tcl_memConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_mem_destructor_func_type:
SetParamVal<ParamType::Tcl_mem_destructor_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_mem_propertiesConstPointer:
SetParamVal<ParamType::Tcl_mem_propertiesConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_pipe_propertiesConstPointer:
SetParamVal<ParamType::Tcl_pipe_propertiesConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_platform_id:
SetParamVal<ParamType::Tcl_platform_id>(valueIn, valueOut);
break;
case ParamType::Tcl_platform_idPointer:
SetParamVal<ParamType::Tcl_platform_idPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_program:
SetParamVal<ParamType::Tcl_program>(valueIn, valueOut);
break;
case ParamType::Tcl_programConstPointer:
SetParamVal<ParamType::Tcl_programConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_program_func_type:
SetParamVal<ParamType::Tcl_program_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_queue_propertiesConstPointer:
SetParamVal<ParamType::Tcl_queue_propertiesConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_sampler:
SetParamVal<ParamType::Tcl_sampler>(valueIn, valueOut);
break;
case ParamType::Tcl_sampler_propertiesConstPointer:
SetParamVal<ParamType::Tcl_sampler_propertiesConstPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_svm_free_callback_func_type:
SetParamVal<ParamType::Tcl_svm_free_callback_func_type>(valueIn, valueOut);
break;
case ParamType::Tcl_uint:
SetParamVal<ParamType::Tcl_uint>(valueIn, valueOut);
break;
case ParamType::Tcl_uintPointer:
SetParamVal<ParamType::Tcl_uintPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_ulongPointer:
SetParamVal<ParamType::Tcl_ulongPointer>(valueIn, valueOut);
break;
case ParamType::Tcl_void_func_type:
SetParamVal<ParamType::Tcl_void_func_type>(valueIn, valueOut);
break;
case ParamType::Tegl_ConfigPointer:
SetParamVal<ParamType::Tegl_ConfigPointer>(valueIn, valueOut);
break;
case ParamType::Tegl_DevicePointer:
SetParamVal<ParamType::Tegl_DevicePointer>(valueIn, valueOut);
break;
case ParamType::Tegl_DisplayPointer:
SetParamVal<ParamType::Tegl_DisplayPointer>(valueIn, valueOut);
break;
case ParamType::Tegl_StreamPointer:
SetParamVal<ParamType::Tegl_StreamPointer>(valueIn, valueOut);
break;
case ParamType::Tegl_SyncID:
SetParamVal<ParamType::Tegl_SyncID>(valueIn, valueOut);
break;
case ParamType::Tsize_t:
SetParamVal<ParamType::Tsize_t>(valueIn, valueOut);
break;
case ParamType::Tsize_tConstPointer:
SetParamVal<ParamType::Tsize_tConstPointer>(valueIn, valueOut);
break;
case ParamType::Tsize_tPointer:
SetParamVal<ParamType::Tsize_tPointer>(valueIn, valueOut);
break;
case ParamType::TvoidConstPointer:
SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
break;
case ParamType::TvoidConstPointerPointer:
SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
break;
case ParamType::TvoidPointer:
SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
break;
case ParamType::TvoidPointerPointer:
SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
break;
}
}
struct CallCapture;
struct ParamCapture;
void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture &param);
const char *ParamTypeToString(ParamType paramType);
enum class ResourceIDType
{
Buffer,
Context,
FenceNV,
Framebuffer,
Image,
MemoryObject,
ProgramPipeline,
Query,
Renderbuffer,
Sampler,
Semaphore,
ShaderProgram,
Surface,
Sync,
Texture,
TransformFeedback,
VertexArray,
egl_Sync,
EnumCount,
InvalidEnum = EnumCount
};
ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
template <typename ResourceType>
struct GetResourceIDTypeFromType;
template <>
struct GetResourceIDTypeFromType<gl::BufferID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Buffer;
};
template <>
struct GetResourceIDTypeFromType<gl::ContextID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Context;
};
template <>
struct GetResourceIDTypeFromType<gl::FenceNVID>
{
static constexpr ResourceIDType IDType = ResourceIDType::FenceNV;
};
template <>
struct GetResourceIDTypeFromType<gl::FramebufferID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer;
};
template <>
struct GetResourceIDTypeFromType<egl::ImageID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Image;
};
template <>
struct GetResourceIDTypeFromType<gl::MemoryObjectID>
{
static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject;
};
template <>
struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
{
static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline;
};
template <>
struct GetResourceIDTypeFromType<gl::QueryID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Query;
};
template <>
struct GetResourceIDTypeFromType<gl::RenderbufferID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer;
};
template <>
struct GetResourceIDTypeFromType<gl::SamplerID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Sampler;
};
template <>
struct GetResourceIDTypeFromType<gl::SemaphoreID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Semaphore;
};
template <>
struct GetResourceIDTypeFromType<gl::ShaderProgramID>
{
static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram;
};
template <>
struct GetResourceIDTypeFromType<egl::SurfaceID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Surface;
};
template <>
struct GetResourceIDTypeFromType<gl::SyncID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Sync;
};
template <>
struct GetResourceIDTypeFromType<gl::TextureID>
{
static constexpr ResourceIDType IDType = ResourceIDType::Texture;
};
template <>
struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
{
static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback;
};
template <>
struct GetResourceIDTypeFromType<gl::VertexArrayID>
{
static constexpr ResourceIDType IDType = ResourceIDType::VertexArray;
};
template <>
struct GetResourceIDTypeFromType<egl::SyncID>
{
static constexpr ResourceIDType IDType = ResourceIDType::egl_Sync;
};
} // namespace angle
#endif // COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_