1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2020 The ANGLE Project Authors. All rights reserved.
5 // Use of this source code is governed by a BSD-style license that can be
6 // found in the LICENSE file.
7 //
8 // frame_capture_utils_autogen.h:
9 // ANGLE Frame capture types and helper functions.
10
11 #ifndef COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
12 #define COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
13
14 #include "common/PackedEnums.h"
15 #ifdef ANGLE_ENABLE_CL
16 # include "common/PackedCLEnums_autogen.h"
17 # include "libANGLE/CLBitField.h"
18 #endif
19
20 namespace angle
21 {
22
23 #ifdef ANGLE_ENABLE_CL
24 typedef void(CL_CALLBACK *cl_context_func_type)(const char *, const void *, size_t, void *);
25 typedef void(CL_CALLBACK *cl_program_func_type)(cl_program, void *);
26 typedef void(CL_CALLBACK *cl_void_func_type)(void *);
27 typedef void(CL_CALLBACK *cl_callback_func_type)(cl_event, cl_int, void *);
28 typedef void(CL_CALLBACK *cl_svm_free_callback_func_type)(cl_command_queue,
29 cl_uint,
30 void *[],
31 void *);
32 typedef void(CL_CALLBACK *cl_context_destructor_func_type)(cl_context, void *);
33 typedef void(CL_CALLBACK *cl_mem_destructor_func_type)(cl_mem, void *);
34 #endif
35
36 enum class ParamType
37 {
38 TAHardwareBufferConstPointer,
39 TAddressingMode,
40 TAlphaTestFunc,
41 TBufferBinding,
42 TBufferID,
43 TBufferIDConstPointer,
44 TBufferIDPointer,
45 TBufferUsage,
46 TClientVertexArrayType,
47 TClipDepthMode,
48 TClipOrigin,
49 TCommandQueueInfo,
50 TCommandQueueProperties,
51 TCompositorTiming,
52 TContextID,
53 TContextInfo,
54 TCullFaceMode,
55 TDeviceInfo,
56 TDeviceType,
57 TDrawElementsType,
58 TEGLAttribConstPointer,
59 TEGLAttribKHRPointer,
60 TEGLAttribPointer,
61 TEGLBoolean,
62 TEGLBooleanPointer,
63 TEGLClientBuffer,
64 TEGLConfigPointer,
65 TEGLContext,
66 TEGLDEBUGPROCKHR,
67 TEGLDeviceEXT,
68 TEGLDisplay,
69 TEGLGetBlobFuncANDROID,
70 TEGLImage,
71 TEGLImageKHR,
72 TEGLLabelKHR,
73 TEGLNativeDisplayType,
74 TEGLNativePixmapType,
75 TEGLNativeWindowType,
76 TEGLObjectKHR,
77 TEGLSetBlobFuncANDROID,
78 TEGLStreamKHR,
79 TEGLSurface,
80 TEGLSync,
81 TEGLSyncKHR,
82 TEGLTime,
83 TEGLTimeKHR,
84 TEGLenum,
85 TEGLint,
86 TEGLintConstPointer,
87 TEGLintPointer,
88 TEGLnsecsANDROID,
89 TEGLnsecsANDROIDPointer,
90 TEGLuint64KHR,
91 TEGLuint64KHRPointer,
92 TEventInfo,
93 TFenceNVID,
94 TFenceNVIDConstPointer,
95 TFenceNVIDPointer,
96 TFilterMode,
97 TFramebufferID,
98 TFramebufferIDConstPointer,
99 TFramebufferIDPointer,
100 TGLDEBUGPROC,
101 TGLDEBUGPROCKHR,
102 TGLGETBLOBPROCANGLE,
103 TGLSETBLOBPROCANGLE,
104 TGLbitfield,
105 TGLboolean,
106 TGLbooleanPointer,
107 TGLcharConstPointer,
108 TGLcharConstPointerPointer,
109 TGLcharPointer,
110 TGLclampx,
111 TGLeglClientBufferEXT,
112 TGLenum,
113 TGLenumConstPointer,
114 TGLenumPointer,
115 TGLfixed,
116 TGLfixedConstPointer,
117 TGLfixedPointer,
118 TGLfloat,
119 TGLfloatConstPointer,
120 TGLfloatPointer,
121 TGLint,
122 TGLint64,
123 TGLint64Pointer,
124 TGLintConstPointer,
125 TGLintPointer,
126 TGLintptr,
127 TGLshort,
128 TGLshortConstPointer,
129 TGLsizei,
130 TGLsizeiConstPointer,
131 TGLsizeiPointer,
132 TGLsizeiptr,
133 TGLsync,
134 TGLubyte,
135 TGLubyteConstPointer,
136 TGLubytePointer,
137 TGLuint,
138 TGLuint64,
139 TGLuint64ConstPointer,
140 TGLuint64Pointer,
141 TGLuintConstPointer,
142 TGLuintPointer,
143 TGraphicsResetStatus,
144 THandleType,
145 TImageID,
146 TImageInfo,
147 TKernelArgInfo,
148 TKernelExecInfo,
149 TKernelInfo,
150 TKernelSubGroupInfo,
151 TKernelWorkGroupInfo,
152 TLightParameter,
153 TLogicalOperation,
154 TMapFlags,
155 TMaterialParameter,
156 TMatrixType,
157 TMemFlags,
158 TMemInfo,
159 TMemMigrationFlags,
160 TMemObjectType,
161 TMemoryObjectID,
162 TMemoryObjectIDConstPointer,
163 TMemoryObjectIDPointer,
164 TObjectType,
165 TPipeInfo,
166 TPlatformInfo,
167 TPointParameter,
168 TPolygonMode,
169 TPrimitiveMode,
170 TProfilingInfo,
171 TProgramBuildInfo,
172 TProgramInfo,
173 TProgramPipelineID,
174 TProgramPipelineIDConstPointer,
175 TProgramPipelineIDPointer,
176 TProvokingVertexConvention,
177 TQueryID,
178 TQueryIDConstPointer,
179 TQueryIDPointer,
180 TQueryType,
181 TRenderbufferID,
182 TRenderbufferIDConstPointer,
183 TRenderbufferIDPointer,
184 TSVM_MemFlags,
185 TSamplerID,
186 TSamplerIDConstPointer,
187 TSamplerIDPointer,
188 TSamplerInfo,
189 TSemaphoreID,
190 TSemaphoreIDConstPointer,
191 TSemaphoreIDPointer,
192 TShaderProgramID,
193 TShaderProgramIDConstPointer,
194 TShaderProgramIDPointer,
195 TShaderType,
196 TShadingModel,
197 TSurfaceID,
198 TSyncID,
199 TTextureEnvParameter,
200 TTextureEnvTarget,
201 TTextureID,
202 TTextureIDConstPointer,
203 TTextureIDPointer,
204 TTextureTarget,
205 TTextureType,
206 TTimestamp,
207 TTransformFeedbackID,
208 TTransformFeedbackIDConstPointer,
209 TTransformFeedbackIDPointer,
210 TUniformBlockIndex,
211 TUniformLocation,
212 TVertexArrayID,
213 TVertexArrayIDConstPointer,
214 TVertexArrayIDPointer,
215 TVertexAttribType,
216 TcharConstPointer,
217 TcharConstPointerPointer,
218 TcharUnsignedConstPointerPointer,
219 Tcl_bool,
220 Tcl_buffer_create_type,
221 Tcl_callback_func_type,
222 Tcl_command_queue,
223 Tcl_command_queue_propertiesPointer,
224 Tcl_context,
225 Tcl_context_destructor_func_type,
226 Tcl_context_func_type,
227 Tcl_context_propertiesConstPointer,
228 Tcl_device_id,
229 Tcl_device_idConstPointer,
230 Tcl_device_idPointer,
231 Tcl_device_partition_propertyConstPointer,
232 Tcl_event,
233 Tcl_eventConstPointer,
234 Tcl_eventPointer,
235 Tcl_image_descConstPointer,
236 Tcl_image_formatConstPointer,
237 Tcl_image_formatPointer,
238 Tcl_int,
239 Tcl_intPointer,
240 Tcl_kernel,
241 Tcl_kernelPointer,
242 Tcl_mem,
243 Tcl_memConstPointer,
244 Tcl_mem_destructor_func_type,
245 Tcl_mem_propertiesConstPointer,
246 Tcl_pipe_propertiesConstPointer,
247 Tcl_platform_id,
248 Tcl_platform_idPointer,
249 Tcl_program,
250 Tcl_programConstPointer,
251 Tcl_program_func_type,
252 Tcl_queue_propertiesConstPointer,
253 Tcl_sampler,
254 Tcl_sampler_propertiesConstPointer,
255 Tcl_svm_free_callback_func_type,
256 Tcl_uint,
257 Tcl_uintPointer,
258 Tcl_ulongPointer,
259 Tcl_void_func_type,
260 Tegl_ConfigPointer,
261 Tegl_DevicePointer,
262 Tegl_DisplayPointer,
263 Tegl_StreamPointer,
264 Tegl_SyncID,
265 Tsize_t,
266 Tsize_tConstPointer,
267 Tsize_tPointer,
268 TvoidConstPointer,
269 TvoidConstPointerPointer,
270 TvoidPointer,
271 TvoidPointerPointer,
272 };
273
274 constexpr uint32_t kParamTypeCount = 234;
275
276 union ParamValue
277 {
ParamValue()278 ParamValue() {}
~ParamValue()279 ~ParamValue() {}
280 const AHardwareBuffer *AHardwareBufferConstPointerVal;
281 gl::AlphaTestFunc AlphaTestFuncVal;
282 gl::BufferBinding BufferBindingVal;
283 gl::BufferID BufferIDVal;
284 const gl::BufferID *BufferIDConstPointerVal;
285 gl::BufferID *BufferIDPointerVal;
286 gl::BufferUsage BufferUsageVal;
287 gl::ClientVertexArrayType ClientVertexArrayTypeVal;
288 gl::ClipDepthMode ClipDepthModeVal;
289 gl::ClipOrigin ClipOriginVal;
290 egl::CompositorTiming CompositorTimingVal;
291 gl::ContextID ContextIDVal;
292 gl::CullFaceMode CullFaceModeVal;
293 gl::DrawElementsType DrawElementsTypeVal;
294 const EGLAttrib *EGLAttribConstPointerVal;
295 EGLAttribKHR *EGLAttribKHRPointerVal;
296 EGLAttrib *EGLAttribPointerVal;
297 EGLBoolean EGLBooleanVal;
298 EGLBoolean *EGLBooleanPointerVal;
299 EGLClientBuffer EGLClientBufferVal;
300 EGLConfig *EGLConfigPointerVal;
301 EGLContext EGLContextVal;
302 EGLDEBUGPROCKHR EGLDEBUGPROCKHRVal;
303 EGLDeviceEXT EGLDeviceEXTVal;
304 EGLDisplay EGLDisplayVal;
305 EGLGetBlobFuncANDROID EGLGetBlobFuncANDROIDVal;
306 EGLImage EGLImageVal;
307 EGLImageKHR EGLImageKHRVal;
308 EGLLabelKHR EGLLabelKHRVal;
309 EGLNativeDisplayType EGLNativeDisplayTypeVal;
310 EGLNativePixmapType EGLNativePixmapTypeVal;
311 EGLNativeWindowType EGLNativeWindowTypeVal;
312 EGLObjectKHR EGLObjectKHRVal;
313 EGLSetBlobFuncANDROID EGLSetBlobFuncANDROIDVal;
314 EGLStreamKHR EGLStreamKHRVal;
315 EGLSurface EGLSurfaceVal;
316 EGLSync EGLSyncVal;
317 EGLSyncKHR EGLSyncKHRVal;
318 EGLTime EGLTimeVal;
319 EGLTimeKHR EGLTimeKHRVal;
320 EGLenum EGLenumVal;
321 EGLint EGLintVal;
322 const EGLint *EGLintConstPointerVal;
323 EGLint *EGLintPointerVal;
324 EGLnsecsANDROID EGLnsecsANDROIDVal;
325 EGLnsecsANDROID *EGLnsecsANDROIDPointerVal;
326 EGLuint64KHR EGLuint64KHRVal;
327 EGLuint64KHR *EGLuint64KHRPointerVal;
328 gl::FenceNVID FenceNVIDVal;
329 const gl::FenceNVID *FenceNVIDConstPointerVal;
330 gl::FenceNVID *FenceNVIDPointerVal;
331 gl::FramebufferID FramebufferIDVal;
332 const gl::FramebufferID *FramebufferIDConstPointerVal;
333 gl::FramebufferID *FramebufferIDPointerVal;
334 GLDEBUGPROC GLDEBUGPROCVal;
335 GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
336 GLGETBLOBPROCANGLE GLGETBLOBPROCANGLEVal;
337 GLSETBLOBPROCANGLE GLSETBLOBPROCANGLEVal;
338 GLbitfield GLbitfieldVal;
339 GLboolean GLbooleanVal;
340 GLboolean *GLbooleanPointerVal;
341 const GLchar *GLcharConstPointerVal;
342 const GLchar *const *GLcharConstPointerPointerVal;
343 GLchar *GLcharPointerVal;
344 GLclampx GLclampxVal;
345 GLeglClientBufferEXT GLeglClientBufferEXTVal;
346 GLenum GLenumVal;
347 const GLenum *GLenumConstPointerVal;
348 GLenum *GLenumPointerVal;
349 GLfixed GLfixedVal;
350 const GLfixed *GLfixedConstPointerVal;
351 GLfixed *GLfixedPointerVal;
352 GLfloat GLfloatVal;
353 const GLfloat *GLfloatConstPointerVal;
354 GLfloat *GLfloatPointerVal;
355 GLint GLintVal;
356 GLint64 GLint64Val;
357 GLint64 *GLint64PointerVal;
358 const GLint *GLintConstPointerVal;
359 GLint *GLintPointerVal;
360 GLintptr GLintptrVal;
361 GLshort GLshortVal;
362 const GLshort *GLshortConstPointerVal;
363 GLsizei GLsizeiVal;
364 const GLsizei *GLsizeiConstPointerVal;
365 GLsizei *GLsizeiPointerVal;
366 GLsizeiptr GLsizeiptrVal;
367 GLsync GLsyncVal;
368 GLubyte GLubyteVal;
369 const GLubyte *GLubyteConstPointerVal;
370 GLubyte *GLubytePointerVal;
371 GLuint GLuintVal;
372 GLuint64 GLuint64Val;
373 const GLuint64 *GLuint64ConstPointerVal;
374 GLuint64 *GLuint64PointerVal;
375 const GLuint *GLuintConstPointerVal;
376 GLuint *GLuintPointerVal;
377 gl::GraphicsResetStatus GraphicsResetStatusVal;
378 gl::HandleType HandleTypeVal;
379 egl::ImageID ImageIDVal;
380 gl::LightParameter LightParameterVal;
381 gl::LogicalOperation LogicalOperationVal;
382 gl::MaterialParameter MaterialParameterVal;
383 gl::MatrixType MatrixTypeVal;
384 gl::MemoryObjectID MemoryObjectIDVal;
385 const gl::MemoryObjectID *MemoryObjectIDConstPointerVal;
386 gl::MemoryObjectID *MemoryObjectIDPointerVal;
387 egl::ObjectType ObjectTypeVal;
388 gl::PointParameter PointParameterVal;
389 gl::PolygonMode PolygonModeVal;
390 gl::PrimitiveMode PrimitiveModeVal;
391 gl::ProgramPipelineID ProgramPipelineIDVal;
392 const gl::ProgramPipelineID *ProgramPipelineIDConstPointerVal;
393 gl::ProgramPipelineID *ProgramPipelineIDPointerVal;
394 gl::ProvokingVertexConvention ProvokingVertexConventionVal;
395 gl::QueryID QueryIDVal;
396 const gl::QueryID *QueryIDConstPointerVal;
397 gl::QueryID *QueryIDPointerVal;
398 gl::QueryType QueryTypeVal;
399 gl::RenderbufferID RenderbufferIDVal;
400 const gl::RenderbufferID *RenderbufferIDConstPointerVal;
401 gl::RenderbufferID *RenderbufferIDPointerVal;
402 gl::SamplerID SamplerIDVal;
403 const gl::SamplerID *SamplerIDConstPointerVal;
404 gl::SamplerID *SamplerIDPointerVal;
405 gl::SemaphoreID SemaphoreIDVal;
406 const gl::SemaphoreID *SemaphoreIDConstPointerVal;
407 gl::SemaphoreID *SemaphoreIDPointerVal;
408 gl::ShaderProgramID ShaderProgramIDVal;
409 const gl::ShaderProgramID *ShaderProgramIDConstPointerVal;
410 gl::ShaderProgramID *ShaderProgramIDPointerVal;
411 gl::ShaderType ShaderTypeVal;
412 gl::ShadingModel ShadingModelVal;
413 egl::SurfaceID SurfaceIDVal;
414 gl::SyncID SyncIDVal;
415 gl::TextureEnvParameter TextureEnvParameterVal;
416 gl::TextureEnvTarget TextureEnvTargetVal;
417 gl::TextureID TextureIDVal;
418 const gl::TextureID *TextureIDConstPointerVal;
419 gl::TextureID *TextureIDPointerVal;
420 gl::TextureTarget TextureTargetVal;
421 gl::TextureType TextureTypeVal;
422 egl::Timestamp TimestampVal;
423 gl::TransformFeedbackID TransformFeedbackIDVal;
424 const gl::TransformFeedbackID *TransformFeedbackIDConstPointerVal;
425 gl::TransformFeedbackID *TransformFeedbackIDPointerVal;
426 gl::UniformBlockIndex UniformBlockIndexVal;
427 gl::UniformLocation UniformLocationVal;
428 gl::VertexArrayID VertexArrayIDVal;
429 const gl::VertexArrayID *VertexArrayIDConstPointerVal;
430 gl::VertexArrayID *VertexArrayIDPointerVal;
431 gl::VertexAttribType VertexAttribTypeVal;
432 const char *charConstPointerVal;
433 const char **charConstPointerPointerVal;
434 const unsigned char **charUnsignedConstPointerPointerVal;
435 egl::Config *egl_ConfigPointerVal;
436 egl::Device *egl_DevicePointerVal;
437 egl::Display *egl_DisplayPointerVal;
438 egl::Stream *egl_StreamPointerVal;
439 egl::SyncID egl_SyncIDVal;
440 size_t size_tVal;
441 const size_t *size_tConstPointerVal;
442 size_t *size_tPointerVal;
443 const void *voidConstPointerVal;
444 const void **voidConstPointerPointerVal;
445 void *voidPointerVal;
446 void **voidPointerPointerVal;
447 #ifdef ANGLE_ENABLE_CL
448 cl::AddressingMode AddressingModeVal;
449 cl::CommandQueueInfo CommandQueueInfoVal;
450 cl::CommandQueueProperties CommandQueuePropertiesVal;
451 cl::ContextInfo ContextInfoVal;
452 cl::DeviceInfo DeviceInfoVal;
453 cl::DeviceType DeviceTypeVal;
454 cl::EventInfo EventInfoVal;
455 cl::FilterMode FilterModeVal;
456 cl::ImageInfo ImageInfoVal;
457 cl::KernelArgInfo KernelArgInfoVal;
458 cl::KernelExecInfo KernelExecInfoVal;
459 cl::KernelInfo KernelInfoVal;
460 cl::KernelSubGroupInfo KernelSubGroupInfoVal;
461 cl::KernelWorkGroupInfo KernelWorkGroupInfoVal;
462 cl::MapFlags MapFlagsVal;
463 cl::MemFlags MemFlagsVal;
464 cl::MemInfo MemInfoVal;
465 cl::MemMigrationFlags MemMigrationFlagsVal;
466 cl::MemObjectType MemObjectTypeVal;
467 cl::PipeInfo PipeInfoVal;
468 cl::PlatformInfo PlatformInfoVal;
469 cl::ProfilingInfo ProfilingInfoVal;
470 cl::ProgramBuildInfo ProgramBuildInfoVal;
471 cl::ProgramInfo ProgramInfoVal;
472 cl::SVM_MemFlags SVM_MemFlagsVal;
473 cl::SamplerInfo SamplerInfoVal;
474 cl_bool cl_boolVal;
475 cl_buffer_create_type cl_buffer_create_typeVal;
476 cl_callback_func_type cl_callback_func_typeVal;
477 cl_command_queue cl_command_queueVal;
478 cl_command_queue_properties *cl_command_queue_propertiesPointerVal;
479 cl_context cl_contextVal;
480 cl_context_destructor_func_type cl_context_destructor_func_typeVal;
481 cl_context_func_type cl_context_func_typeVal;
482 const cl_context_properties *cl_context_propertiesConstPointerVal;
483 cl_device_id cl_device_idVal;
484 const cl_device_id *cl_device_idConstPointerVal;
485 cl_device_id *cl_device_idPointerVal;
486 const cl_device_partition_property *cl_device_partition_propertyConstPointerVal;
487 cl_event cl_eventVal;
488 const cl_event *cl_eventConstPointerVal;
489 cl_event *cl_eventPointerVal;
490 const cl_image_desc *cl_image_descConstPointerVal;
491 const cl_image_format *cl_image_formatConstPointerVal;
492 cl_image_format *cl_image_formatPointerVal;
493 cl_int cl_intVal;
494 cl_int *cl_intPointerVal;
495 cl_kernel cl_kernelVal;
496 cl_kernel *cl_kernelPointerVal;
497 cl_mem cl_memVal;
498 const cl_mem *cl_memConstPointerVal;
499 cl_mem_destructor_func_type cl_mem_destructor_func_typeVal;
500 const cl_mem_properties *cl_mem_propertiesConstPointerVal;
501 const cl_pipe_properties *cl_pipe_propertiesConstPointerVal;
502 cl_platform_id cl_platform_idVal;
503 cl_platform_id *cl_platform_idPointerVal;
504 cl_program cl_programVal;
505 const cl_program *cl_programConstPointerVal;
506 cl_program_func_type cl_program_func_typeVal;
507 const cl_queue_properties *cl_queue_propertiesConstPointerVal;
508 cl_sampler cl_samplerVal;
509 const cl_sampler_properties *cl_sampler_propertiesConstPointerVal;
510 cl_svm_free_callback_func_type cl_svm_free_callback_func_typeVal;
511 cl_uint cl_uintVal;
512 cl_uint *cl_uintPointerVal;
513 cl_ulong *cl_ulongPointerVal;
514 cl_void_func_type cl_void_func_typeVal;
515 #endif
516 };
517
518 template <ParamType PType, typename T>
519 T GetParamVal(const ParamValue &value);
520
521 template <>
522 inline const AHardwareBuffer *GetParamVal<ParamType::TAHardwareBufferConstPointer,
523 const AHardwareBuffer *>(const ParamValue &value)
524 {
525 return value.AHardwareBufferConstPointerVal;
526 }
527
528 template <>
529 inline gl::AlphaTestFunc GetParamVal<ParamType::TAlphaTestFunc, gl::AlphaTestFunc>(
530 const ParamValue &value)
531 {
532 return value.AlphaTestFuncVal;
533 }
534
535 template <>
536 inline gl::BufferBinding GetParamVal<ParamType::TBufferBinding, gl::BufferBinding>(
537 const ParamValue &value)
538 {
539 return value.BufferBindingVal;
540 }
541
542 template <>
543 inline gl::BufferID GetParamVal<ParamType::TBufferID, gl::BufferID>(const ParamValue &value)
544 {
545 return value.BufferIDVal;
546 }
547
548 template <>
549 inline const gl::BufferID *GetParamVal<ParamType::TBufferIDConstPointer, const gl::BufferID *>(
550 const ParamValue &value)
551 {
552 return value.BufferIDConstPointerVal;
553 }
554
555 template <>
556 inline gl::BufferID *GetParamVal<ParamType::TBufferIDPointer, gl::BufferID *>(
557 const ParamValue &value)
558 {
559 return value.BufferIDPointerVal;
560 }
561
562 template <>
563 inline gl::BufferUsage GetParamVal<ParamType::TBufferUsage, gl::BufferUsage>(
564 const ParamValue &value)
565 {
566 return value.BufferUsageVal;
567 }
568
569 template <>
570 inline gl::ClientVertexArrayType
571 GetParamVal<ParamType::TClientVertexArrayType, gl::ClientVertexArrayType>(const ParamValue &value)
572 {
573 return value.ClientVertexArrayTypeVal;
574 }
575
576 template <>
577 inline gl::ClipDepthMode GetParamVal<ParamType::TClipDepthMode, gl::ClipDepthMode>(
578 const ParamValue &value)
579 {
580 return value.ClipDepthModeVal;
581 }
582
583 template <>
584 inline gl::ClipOrigin GetParamVal<ParamType::TClipOrigin, gl::ClipOrigin>(const ParamValue &value)
585 {
586 return value.ClipOriginVal;
587 }
588
589 template <>
590 inline egl::CompositorTiming GetParamVal<ParamType::TCompositorTiming, egl::CompositorTiming>(
591 const ParamValue &value)
592 {
593 return value.CompositorTimingVal;
594 }
595
596 template <>
597 inline gl::ContextID GetParamVal<ParamType::TContextID, gl::ContextID>(const ParamValue &value)
598 {
599 return value.ContextIDVal;
600 }
601
602 template <>
603 inline gl::CullFaceMode GetParamVal<ParamType::TCullFaceMode, gl::CullFaceMode>(
604 const ParamValue &value)
605 {
606 return value.CullFaceModeVal;
607 }
608
609 template <>
610 inline gl::DrawElementsType GetParamVal<ParamType::TDrawElementsType, gl::DrawElementsType>(
611 const ParamValue &value)
612 {
613 return value.DrawElementsTypeVal;
614 }
615
616 template <>
617 inline const EGLAttrib *GetParamVal<ParamType::TEGLAttribConstPointer, const EGLAttrib *>(
618 const ParamValue &value)
619 {
620 return value.EGLAttribConstPointerVal;
621 }
622
623 template <>
624 inline EGLAttribKHR *GetParamVal<ParamType::TEGLAttribKHRPointer, EGLAttribKHR *>(
625 const ParamValue &value)
626 {
627 return value.EGLAttribKHRPointerVal;
628 }
629
630 template <>
631 inline EGLAttrib *GetParamVal<ParamType::TEGLAttribPointer, EGLAttrib *>(const ParamValue &value)
632 {
633 return value.EGLAttribPointerVal;
634 }
635
636 template <>
637 inline EGLBoolean GetParamVal<ParamType::TEGLBoolean, EGLBoolean>(const ParamValue &value)
638 {
639 return value.EGLBooleanVal;
640 }
641
642 template <>
643 inline EGLBoolean *GetParamVal<ParamType::TEGLBooleanPointer, EGLBoolean *>(const ParamValue &value)
644 {
645 return value.EGLBooleanPointerVal;
646 }
647
648 template <>
649 inline EGLClientBuffer GetParamVal<ParamType::TEGLClientBuffer, EGLClientBuffer>(
650 const ParamValue &value)
651 {
652 return value.EGLClientBufferVal;
653 }
654
655 template <>
656 inline EGLConfig *GetParamVal<ParamType::TEGLConfigPointer, EGLConfig *>(const ParamValue &value)
657 {
658 return value.EGLConfigPointerVal;
659 }
660
661 template <>
662 inline EGLContext GetParamVal<ParamType::TEGLContext, EGLContext>(const ParamValue &value)
663 {
664 return value.EGLContextVal;
665 }
666
667 template <>
668 inline EGLDEBUGPROCKHR GetParamVal<ParamType::TEGLDEBUGPROCKHR, EGLDEBUGPROCKHR>(
669 const ParamValue &value)
670 {
671 return value.EGLDEBUGPROCKHRVal;
672 }
673
674 template <>
675 inline EGLDeviceEXT GetParamVal<ParamType::TEGLDeviceEXT, EGLDeviceEXT>(const ParamValue &value)
676 {
677 return value.EGLDeviceEXTVal;
678 }
679
680 template <>
681 inline EGLDisplay GetParamVal<ParamType::TEGLDisplay, EGLDisplay>(const ParamValue &value)
682 {
683 return value.EGLDisplayVal;
684 }
685
686 template <>
687 inline EGLGetBlobFuncANDROID GetParamVal<ParamType::TEGLGetBlobFuncANDROID, EGLGetBlobFuncANDROID>(
688 const ParamValue &value)
689 {
690 return value.EGLGetBlobFuncANDROIDVal;
691 }
692
693 template <>
694 inline EGLImage GetParamVal<ParamType::TEGLImage, EGLImage>(const ParamValue &value)
695 {
696 return value.EGLImageVal;
697 }
698
699 template <>
700 inline EGLImageKHR GetParamVal<ParamType::TEGLImageKHR, EGLImageKHR>(const ParamValue &value)
701 {
702 return value.EGLImageKHRVal;
703 }
704
705 template <>
706 inline EGLLabelKHR GetParamVal<ParamType::TEGLLabelKHR, EGLLabelKHR>(const ParamValue &value)
707 {
708 return value.EGLLabelKHRVal;
709 }
710
711 template <>
712 inline EGLNativeDisplayType GetParamVal<ParamType::TEGLNativeDisplayType, EGLNativeDisplayType>(
713 const ParamValue &value)
714 {
715 return value.EGLNativeDisplayTypeVal;
716 }
717
718 template <>
719 inline EGLNativePixmapType GetParamVal<ParamType::TEGLNativePixmapType, EGLNativePixmapType>(
720 const ParamValue &value)
721 {
722 return value.EGLNativePixmapTypeVal;
723 }
724
725 template <>
726 inline EGLNativeWindowType GetParamVal<ParamType::TEGLNativeWindowType, EGLNativeWindowType>(
727 const ParamValue &value)
728 {
729 return value.EGLNativeWindowTypeVal;
730 }
731
732 template <>
733 inline EGLObjectKHR GetParamVal<ParamType::TEGLObjectKHR, EGLObjectKHR>(const ParamValue &value)
734 {
735 return value.EGLObjectKHRVal;
736 }
737
738 template <>
739 inline EGLSetBlobFuncANDROID GetParamVal<ParamType::TEGLSetBlobFuncANDROID, EGLSetBlobFuncANDROID>(
740 const ParamValue &value)
741 {
742 return value.EGLSetBlobFuncANDROIDVal;
743 }
744
745 template <>
746 inline EGLStreamKHR GetParamVal<ParamType::TEGLStreamKHR, EGLStreamKHR>(const ParamValue &value)
747 {
748 return value.EGLStreamKHRVal;
749 }
750
751 template <>
752 inline EGLSurface GetParamVal<ParamType::TEGLSurface, EGLSurface>(const ParamValue &value)
753 {
754 return value.EGLSurfaceVal;
755 }
756
757 template <>
758 inline EGLSync GetParamVal<ParamType::TEGLSync, EGLSync>(const ParamValue &value)
759 {
760 return value.EGLSyncVal;
761 }
762
763 template <>
764 inline EGLSyncKHR GetParamVal<ParamType::TEGLSyncKHR, EGLSyncKHR>(const ParamValue &value)
765 {
766 return value.EGLSyncKHRVal;
767 }
768
769 template <>
770 inline EGLTime GetParamVal<ParamType::TEGLTime, EGLTime>(const ParamValue &value)
771 {
772 return value.EGLTimeVal;
773 }
774
775 template <>
776 inline EGLTimeKHR GetParamVal<ParamType::TEGLTimeKHR, EGLTimeKHR>(const ParamValue &value)
777 {
778 return value.EGLTimeKHRVal;
779 }
780
781 template <>
782 inline EGLenum GetParamVal<ParamType::TEGLenum, EGLenum>(const ParamValue &value)
783 {
784 return value.EGLenumVal;
785 }
786
787 template <>
788 inline EGLint GetParamVal<ParamType::TEGLint, EGLint>(const ParamValue &value)
789 {
790 return value.EGLintVal;
791 }
792
793 template <>
794 inline const EGLint *GetParamVal<ParamType::TEGLintConstPointer, const EGLint *>(
795 const ParamValue &value)
796 {
797 return value.EGLintConstPointerVal;
798 }
799
800 template <>
801 inline EGLint *GetParamVal<ParamType::TEGLintPointer, EGLint *>(const ParamValue &value)
802 {
803 return value.EGLintPointerVal;
804 }
805
806 template <>
807 inline EGLnsecsANDROID GetParamVal<ParamType::TEGLnsecsANDROID, EGLnsecsANDROID>(
808 const ParamValue &value)
809 {
810 return value.EGLnsecsANDROIDVal;
811 }
812
813 template <>
814 inline EGLnsecsANDROID *GetParamVal<ParamType::TEGLnsecsANDROIDPointer, EGLnsecsANDROID *>(
815 const ParamValue &value)
816 {
817 return value.EGLnsecsANDROIDPointerVal;
818 }
819
820 template <>
821 inline EGLuint64KHR GetParamVal<ParamType::TEGLuint64KHR, EGLuint64KHR>(const ParamValue &value)
822 {
823 return value.EGLuint64KHRVal;
824 }
825
826 template <>
827 inline EGLuint64KHR *GetParamVal<ParamType::TEGLuint64KHRPointer, EGLuint64KHR *>(
828 const ParamValue &value)
829 {
830 return value.EGLuint64KHRPointerVal;
831 }
832
833 template <>
834 inline gl::FenceNVID GetParamVal<ParamType::TFenceNVID, gl::FenceNVID>(const ParamValue &value)
835 {
836 return value.FenceNVIDVal;
837 }
838
839 template <>
840 inline const gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDConstPointer, const gl::FenceNVID *>(
841 const ParamValue &value)
842 {
843 return value.FenceNVIDConstPointerVal;
844 }
845
846 template <>
847 inline gl::FenceNVID *GetParamVal<ParamType::TFenceNVIDPointer, gl::FenceNVID *>(
848 const ParamValue &value)
849 {
850 return value.FenceNVIDPointerVal;
851 }
852
853 template <>
854 inline gl::FramebufferID GetParamVal<ParamType::TFramebufferID, gl::FramebufferID>(
855 const ParamValue &value)
856 {
857 return value.FramebufferIDVal;
858 }
859
860 template <>
861 inline const gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDConstPointer,
862 const gl::FramebufferID *>(const ParamValue &value)
863 {
864 return value.FramebufferIDConstPointerVal;
865 }
866
867 template <>
868 inline gl::FramebufferID *GetParamVal<ParamType::TFramebufferIDPointer, gl::FramebufferID *>(
869 const ParamValue &value)
870 {
871 return value.FramebufferIDPointerVal;
872 }
873
874 template <>
875 inline GLDEBUGPROC GetParamVal<ParamType::TGLDEBUGPROC, GLDEBUGPROC>(const ParamValue &value)
876 {
877 return value.GLDEBUGPROCVal;
878 }
879
880 template <>
881 inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
882 const ParamValue &value)
883 {
884 return value.GLDEBUGPROCKHRVal;
885 }
886
887 template <>
888 inline GLGETBLOBPROCANGLE GetParamVal<ParamType::TGLGETBLOBPROCANGLE, GLGETBLOBPROCANGLE>(
889 const ParamValue &value)
890 {
891 return value.GLGETBLOBPROCANGLEVal;
892 }
893
894 template <>
895 inline GLSETBLOBPROCANGLE GetParamVal<ParamType::TGLSETBLOBPROCANGLE, GLSETBLOBPROCANGLE>(
896 const ParamValue &value)
897 {
898 return value.GLSETBLOBPROCANGLEVal;
899 }
900
901 template <>
902 inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
903 {
904 return value.GLbitfieldVal;
905 }
906
907 template <>
908 inline GLboolean GetParamVal<ParamType::TGLboolean, GLboolean>(const ParamValue &value)
909 {
910 return value.GLbooleanVal;
911 }
912
913 template <>
914 inline GLboolean *GetParamVal<ParamType::TGLbooleanPointer, GLboolean *>(const ParamValue &value)
915 {
916 return value.GLbooleanPointerVal;
917 }
918
919 template <>
920 inline const GLchar *GetParamVal<ParamType::TGLcharConstPointer, const GLchar *>(
921 const ParamValue &value)
922 {
923 return value.GLcharConstPointerVal;
924 }
925
926 template <>
927 inline const GLchar *const *
928 GetParamVal<ParamType::TGLcharConstPointerPointer, const GLchar *const *>(const ParamValue &value)
929 {
930 return value.GLcharConstPointerPointerVal;
931 }
932
933 template <>
934 inline GLchar *GetParamVal<ParamType::TGLcharPointer, GLchar *>(const ParamValue &value)
935 {
936 return value.GLcharPointerVal;
937 }
938
939 template <>
940 inline GLclampx GetParamVal<ParamType::TGLclampx, GLclampx>(const ParamValue &value)
941 {
942 return value.GLclampxVal;
943 }
944
945 template <>
946 inline GLeglClientBufferEXT GetParamVal<ParamType::TGLeglClientBufferEXT, GLeglClientBufferEXT>(
947 const ParamValue &value)
948 {
949 return value.GLeglClientBufferEXTVal;
950 }
951
952 template <>
953 inline GLenum GetParamVal<ParamType::TGLenum, GLenum>(const ParamValue &value)
954 {
955 return value.GLenumVal;
956 }
957
958 template <>
959 inline const GLenum *GetParamVal<ParamType::TGLenumConstPointer, const GLenum *>(
960 const ParamValue &value)
961 {
962 return value.GLenumConstPointerVal;
963 }
964
965 template <>
966 inline GLenum *GetParamVal<ParamType::TGLenumPointer, GLenum *>(const ParamValue &value)
967 {
968 return value.GLenumPointerVal;
969 }
970
971 template <>
972 inline GLfixed GetParamVal<ParamType::TGLfixed, GLfixed>(const ParamValue &value)
973 {
974 return value.GLfixedVal;
975 }
976
977 template <>
978 inline const GLfixed *GetParamVal<ParamType::TGLfixedConstPointer, const GLfixed *>(
979 const ParamValue &value)
980 {
981 return value.GLfixedConstPointerVal;
982 }
983
984 template <>
985 inline GLfixed *GetParamVal<ParamType::TGLfixedPointer, GLfixed *>(const ParamValue &value)
986 {
987 return value.GLfixedPointerVal;
988 }
989
990 template <>
991 inline GLfloat GetParamVal<ParamType::TGLfloat, GLfloat>(const ParamValue &value)
992 {
993 return value.GLfloatVal;
994 }
995
996 template <>
997 inline const GLfloat *GetParamVal<ParamType::TGLfloatConstPointer, const GLfloat *>(
998 const ParamValue &value)
999 {
1000 return value.GLfloatConstPointerVal;
1001 }
1002
1003 template <>
1004 inline GLfloat *GetParamVal<ParamType::TGLfloatPointer, GLfloat *>(const ParamValue &value)
1005 {
1006 return value.GLfloatPointerVal;
1007 }
1008
1009 template <>
1010 inline GLint GetParamVal<ParamType::TGLint, GLint>(const ParamValue &value)
1011 {
1012 return value.GLintVal;
1013 }
1014
1015 template <>
1016 inline GLint64 GetParamVal<ParamType::TGLint64, GLint64>(const ParamValue &value)
1017 {
1018 return value.GLint64Val;
1019 }
1020
1021 template <>
1022 inline GLint64 *GetParamVal<ParamType::TGLint64Pointer, GLint64 *>(const ParamValue &value)
1023 {
1024 return value.GLint64PointerVal;
1025 }
1026
1027 template <>
1028 inline const GLint *GetParamVal<ParamType::TGLintConstPointer, const GLint *>(
1029 const ParamValue &value)
1030 {
1031 return value.GLintConstPointerVal;
1032 }
1033
1034 template <>
1035 inline GLint *GetParamVal<ParamType::TGLintPointer, GLint *>(const ParamValue &value)
1036 {
1037 return value.GLintPointerVal;
1038 }
1039
1040 template <>
1041 inline GLintptr GetParamVal<ParamType::TGLintptr, GLintptr>(const ParamValue &value)
1042 {
1043 return value.GLintptrVal;
1044 }
1045
1046 template <>
1047 inline GLshort GetParamVal<ParamType::TGLshort, GLshort>(const ParamValue &value)
1048 {
1049 return value.GLshortVal;
1050 }
1051
1052 template <>
1053 inline const GLshort *GetParamVal<ParamType::TGLshortConstPointer, const GLshort *>(
1054 const ParamValue &value)
1055 {
1056 return value.GLshortConstPointerVal;
1057 }
1058
1059 template <>
1060 inline GLsizei GetParamVal<ParamType::TGLsizei, GLsizei>(const ParamValue &value)
1061 {
1062 return value.GLsizeiVal;
1063 }
1064
1065 template <>
1066 inline const GLsizei *GetParamVal<ParamType::TGLsizeiConstPointer, const GLsizei *>(
1067 const ParamValue &value)
1068 {
1069 return value.GLsizeiConstPointerVal;
1070 }
1071
1072 template <>
1073 inline GLsizei *GetParamVal<ParamType::TGLsizeiPointer, GLsizei *>(const ParamValue &value)
1074 {
1075 return value.GLsizeiPointerVal;
1076 }
1077
1078 template <>
1079 inline GLsizeiptr GetParamVal<ParamType::TGLsizeiptr, GLsizeiptr>(const ParamValue &value)
1080 {
1081 return value.GLsizeiptrVal;
1082 }
1083
1084 template <>
1085 inline GLsync GetParamVal<ParamType::TGLsync, GLsync>(const ParamValue &value)
1086 {
1087 return value.GLsyncVal;
1088 }
1089
1090 template <>
1091 inline GLubyte GetParamVal<ParamType::TGLubyte, GLubyte>(const ParamValue &value)
1092 {
1093 return value.GLubyteVal;
1094 }
1095
1096 template <>
1097 inline const GLubyte *GetParamVal<ParamType::TGLubyteConstPointer, const GLubyte *>(
1098 const ParamValue &value)
1099 {
1100 return value.GLubyteConstPointerVal;
1101 }
1102
1103 template <>
1104 inline GLubyte *GetParamVal<ParamType::TGLubytePointer, GLubyte *>(const ParamValue &value)
1105 {
1106 return value.GLubytePointerVal;
1107 }
1108
1109 template <>
1110 inline GLuint GetParamVal<ParamType::TGLuint, GLuint>(const ParamValue &value)
1111 {
1112 return value.GLuintVal;
1113 }
1114
1115 template <>
1116 inline GLuint64 GetParamVal<ParamType::TGLuint64, GLuint64>(const ParamValue &value)
1117 {
1118 return value.GLuint64Val;
1119 }
1120
1121 template <>
1122 inline const GLuint64 *GetParamVal<ParamType::TGLuint64ConstPointer, const GLuint64 *>(
1123 const ParamValue &value)
1124 {
1125 return value.GLuint64ConstPointerVal;
1126 }
1127
1128 template <>
1129 inline GLuint64 *GetParamVal<ParamType::TGLuint64Pointer, GLuint64 *>(const ParamValue &value)
1130 {
1131 return value.GLuint64PointerVal;
1132 }
1133
1134 template <>
1135 inline const GLuint *GetParamVal<ParamType::TGLuintConstPointer, const GLuint *>(
1136 const ParamValue &value)
1137 {
1138 return value.GLuintConstPointerVal;
1139 }
1140
1141 template <>
1142 inline GLuint *GetParamVal<ParamType::TGLuintPointer, GLuint *>(const ParamValue &value)
1143 {
1144 return value.GLuintPointerVal;
1145 }
1146
1147 template <>
1148 inline gl::GraphicsResetStatus
1149 GetParamVal<ParamType::TGraphicsResetStatus, gl::GraphicsResetStatus>(const ParamValue &value)
1150 {
1151 return value.GraphicsResetStatusVal;
1152 }
1153
1154 template <>
1155 inline gl::HandleType GetParamVal<ParamType::THandleType, gl::HandleType>(const ParamValue &value)
1156 {
1157 return value.HandleTypeVal;
1158 }
1159
1160 template <>
1161 inline egl::ImageID GetParamVal<ParamType::TImageID, egl::ImageID>(const ParamValue &value)
1162 {
1163 return value.ImageIDVal;
1164 }
1165
1166 template <>
1167 inline gl::LightParameter GetParamVal<ParamType::TLightParameter, gl::LightParameter>(
1168 const ParamValue &value)
1169 {
1170 return value.LightParameterVal;
1171 }
1172
1173 template <>
1174 inline gl::LogicalOperation GetParamVal<ParamType::TLogicalOperation, gl::LogicalOperation>(
1175 const ParamValue &value)
1176 {
1177 return value.LogicalOperationVal;
1178 }
1179
1180 template <>
1181 inline gl::MaterialParameter GetParamVal<ParamType::TMaterialParameter, gl::MaterialParameter>(
1182 const ParamValue &value)
1183 {
1184 return value.MaterialParameterVal;
1185 }
1186
1187 template <>
1188 inline gl::MatrixType GetParamVal<ParamType::TMatrixType, gl::MatrixType>(const ParamValue &value)
1189 {
1190 return value.MatrixTypeVal;
1191 }
1192
1193 template <>
1194 inline gl::MemoryObjectID GetParamVal<ParamType::TMemoryObjectID, gl::MemoryObjectID>(
1195 const ParamValue &value)
1196 {
1197 return value.MemoryObjectIDVal;
1198 }
1199
1200 template <>
1201 inline const gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDConstPointer,
1202 const gl::MemoryObjectID *>(const ParamValue &value)
1203 {
1204 return value.MemoryObjectIDConstPointerVal;
1205 }
1206
1207 template <>
1208 inline gl::MemoryObjectID *GetParamVal<ParamType::TMemoryObjectIDPointer, gl::MemoryObjectID *>(
1209 const ParamValue &value)
1210 {
1211 return value.MemoryObjectIDPointerVal;
1212 }
1213
1214 template <>
1215 inline egl::ObjectType GetParamVal<ParamType::TObjectType, egl::ObjectType>(const ParamValue &value)
1216 {
1217 return value.ObjectTypeVal;
1218 }
1219
1220 template <>
1221 inline gl::PointParameter GetParamVal<ParamType::TPointParameter, gl::PointParameter>(
1222 const ParamValue &value)
1223 {
1224 return value.PointParameterVal;
1225 }
1226
1227 template <>
1228 inline gl::PolygonMode GetParamVal<ParamType::TPolygonMode, gl::PolygonMode>(
1229 const ParamValue &value)
1230 {
1231 return value.PolygonModeVal;
1232 }
1233
1234 template <>
1235 inline gl::PrimitiveMode GetParamVal<ParamType::TPrimitiveMode, gl::PrimitiveMode>(
1236 const ParamValue &value)
1237 {
1238 return value.PrimitiveModeVal;
1239 }
1240
1241 template <>
1242 inline gl::ProgramPipelineID GetParamVal<ParamType::TProgramPipelineID, gl::ProgramPipelineID>(
1243 const ParamValue &value)
1244 {
1245 return value.ProgramPipelineIDVal;
1246 }
1247
1248 template <>
1249 inline const gl::ProgramPipelineID *
1250 GetParamVal<ParamType::TProgramPipelineIDConstPointer, const gl::ProgramPipelineID *>(
1251 const ParamValue &value)
1252 {
1253 return value.ProgramPipelineIDConstPointerVal;
1254 }
1255
1256 template <>
1257 inline gl::ProgramPipelineID *
1258 GetParamVal<ParamType::TProgramPipelineIDPointer, gl::ProgramPipelineID *>(const ParamValue &value)
1259 {
1260 return value.ProgramPipelineIDPointerVal;
1261 }
1262
1263 template <>
1264 inline gl::ProvokingVertexConvention
1265 GetParamVal<ParamType::TProvokingVertexConvention, gl::ProvokingVertexConvention>(
1266 const ParamValue &value)
1267 {
1268 return value.ProvokingVertexConventionVal;
1269 }
1270
1271 template <>
1272 inline gl::QueryID GetParamVal<ParamType::TQueryID, gl::QueryID>(const ParamValue &value)
1273 {
1274 return value.QueryIDVal;
1275 }
1276
1277 template <>
1278 inline const gl::QueryID *GetParamVal<ParamType::TQueryIDConstPointer, const gl::QueryID *>(
1279 const ParamValue &value)
1280 {
1281 return value.QueryIDConstPointerVal;
1282 }
1283
1284 template <>
1285 inline gl::QueryID *GetParamVal<ParamType::TQueryIDPointer, gl::QueryID *>(const ParamValue &value)
1286 {
1287 return value.QueryIDPointerVal;
1288 }
1289
1290 template <>
1291 inline gl::QueryType GetParamVal<ParamType::TQueryType, gl::QueryType>(const ParamValue &value)
1292 {
1293 return value.QueryTypeVal;
1294 }
1295
1296 template <>
1297 inline gl::RenderbufferID GetParamVal<ParamType::TRenderbufferID, gl::RenderbufferID>(
1298 const ParamValue &value)
1299 {
1300 return value.RenderbufferIDVal;
1301 }
1302
1303 template <>
1304 inline const gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDConstPointer,
1305 const gl::RenderbufferID *>(const ParamValue &value)
1306 {
1307 return value.RenderbufferIDConstPointerVal;
1308 }
1309
1310 template <>
1311 inline gl::RenderbufferID *GetParamVal<ParamType::TRenderbufferIDPointer, gl::RenderbufferID *>(
1312 const ParamValue &value)
1313 {
1314 return value.RenderbufferIDPointerVal;
1315 }
1316
1317 template <>
1318 inline gl::SamplerID GetParamVal<ParamType::TSamplerID, gl::SamplerID>(const ParamValue &value)
1319 {
1320 return value.SamplerIDVal;
1321 }
1322
1323 template <>
1324 inline const gl::SamplerID *GetParamVal<ParamType::TSamplerIDConstPointer, const gl::SamplerID *>(
1325 const ParamValue &value)
1326 {
1327 return value.SamplerIDConstPointerVal;
1328 }
1329
1330 template <>
1331 inline gl::SamplerID *GetParamVal<ParamType::TSamplerIDPointer, gl::SamplerID *>(
1332 const ParamValue &value)
1333 {
1334 return value.SamplerIDPointerVal;
1335 }
1336
1337 template <>
1338 inline gl::SemaphoreID GetParamVal<ParamType::TSemaphoreID, gl::SemaphoreID>(
1339 const ParamValue &value)
1340 {
1341 return value.SemaphoreIDVal;
1342 }
1343
1344 template <>
1345 inline const gl::SemaphoreID *
1346 GetParamVal<ParamType::TSemaphoreIDConstPointer, const gl::SemaphoreID *>(const ParamValue &value)
1347 {
1348 return value.SemaphoreIDConstPointerVal;
1349 }
1350
1351 template <>
1352 inline gl::SemaphoreID *GetParamVal<ParamType::TSemaphoreIDPointer, gl::SemaphoreID *>(
1353 const ParamValue &value)
1354 {
1355 return value.SemaphoreIDPointerVal;
1356 }
1357
1358 template <>
1359 inline gl::ShaderProgramID GetParamVal<ParamType::TShaderProgramID, gl::ShaderProgramID>(
1360 const ParamValue &value)
1361 {
1362 return value.ShaderProgramIDVal;
1363 }
1364
1365 template <>
1366 inline const gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDConstPointer,
1367 const gl::ShaderProgramID *>(const ParamValue &value)
1368 {
1369 return value.ShaderProgramIDConstPointerVal;
1370 }
1371
1372 template <>
1373 inline gl::ShaderProgramID *GetParamVal<ParamType::TShaderProgramIDPointer, gl::ShaderProgramID *>(
1374 const ParamValue &value)
1375 {
1376 return value.ShaderProgramIDPointerVal;
1377 }
1378
1379 template <>
1380 inline gl::ShaderType GetParamVal<ParamType::TShaderType, gl::ShaderType>(const ParamValue &value)
1381 {
1382 return value.ShaderTypeVal;
1383 }
1384
1385 template <>
1386 inline gl::ShadingModel GetParamVal<ParamType::TShadingModel, gl::ShadingModel>(
1387 const ParamValue &value)
1388 {
1389 return value.ShadingModelVal;
1390 }
1391
1392 template <>
1393 inline egl::SurfaceID GetParamVal<ParamType::TSurfaceID, egl::SurfaceID>(const ParamValue &value)
1394 {
1395 return value.SurfaceIDVal;
1396 }
1397
1398 template <>
1399 inline gl::SyncID GetParamVal<ParamType::TSyncID, gl::SyncID>(const ParamValue &value)
1400 {
1401 return value.SyncIDVal;
1402 }
1403
1404 template <>
1405 inline gl::TextureEnvParameter
1406 GetParamVal<ParamType::TTextureEnvParameter, gl::TextureEnvParameter>(const ParamValue &value)
1407 {
1408 return value.TextureEnvParameterVal;
1409 }
1410
1411 template <>
1412 inline gl::TextureEnvTarget GetParamVal<ParamType::TTextureEnvTarget, gl::TextureEnvTarget>(
1413 const ParamValue &value)
1414 {
1415 return value.TextureEnvTargetVal;
1416 }
1417
1418 template <>
1419 inline gl::TextureID GetParamVal<ParamType::TTextureID, gl::TextureID>(const ParamValue &value)
1420 {
1421 return value.TextureIDVal;
1422 }
1423
1424 template <>
1425 inline const gl::TextureID *GetParamVal<ParamType::TTextureIDConstPointer, const gl::TextureID *>(
1426 const ParamValue &value)
1427 {
1428 return value.TextureIDConstPointerVal;
1429 }
1430
1431 template <>
1432 inline gl::TextureID *GetParamVal<ParamType::TTextureIDPointer, gl::TextureID *>(
1433 const ParamValue &value)
1434 {
1435 return value.TextureIDPointerVal;
1436 }
1437
1438 template <>
1439 inline gl::TextureTarget GetParamVal<ParamType::TTextureTarget, gl::TextureTarget>(
1440 const ParamValue &value)
1441 {
1442 return value.TextureTargetVal;
1443 }
1444
1445 template <>
1446 inline gl::TextureType GetParamVal<ParamType::TTextureType, gl::TextureType>(
1447 const ParamValue &value)
1448 {
1449 return value.TextureTypeVal;
1450 }
1451
1452 template <>
1453 inline egl::Timestamp GetParamVal<ParamType::TTimestamp, egl::Timestamp>(const ParamValue &value)
1454 {
1455 return value.TimestampVal;
1456 }
1457
1458 template <>
1459 inline gl::TransformFeedbackID
1460 GetParamVal<ParamType::TTransformFeedbackID, gl::TransformFeedbackID>(const ParamValue &value)
1461 {
1462 return value.TransformFeedbackIDVal;
1463 }
1464
1465 template <>
1466 inline const gl::TransformFeedbackID *
1467 GetParamVal<ParamType::TTransformFeedbackIDConstPointer, const gl::TransformFeedbackID *>(
1468 const ParamValue &value)
1469 {
1470 return value.TransformFeedbackIDConstPointerVal;
1471 }
1472
1473 template <>
1474 inline gl::TransformFeedbackID *GetParamVal<ParamType::TTransformFeedbackIDPointer,
1475 gl::TransformFeedbackID *>(const ParamValue &value)
1476 {
1477 return value.TransformFeedbackIDPointerVal;
1478 }
1479
1480 template <>
1481 inline gl::UniformBlockIndex GetParamVal<ParamType::TUniformBlockIndex, gl::UniformBlockIndex>(
1482 const ParamValue &value)
1483 {
1484 return value.UniformBlockIndexVal;
1485 }
1486
1487 template <>
1488 inline gl::UniformLocation GetParamVal<ParamType::TUniformLocation, gl::UniformLocation>(
1489 const ParamValue &value)
1490 {
1491 return value.UniformLocationVal;
1492 }
1493
1494 template <>
1495 inline gl::VertexArrayID GetParamVal<ParamType::TVertexArrayID, gl::VertexArrayID>(
1496 const ParamValue &value)
1497 {
1498 return value.VertexArrayIDVal;
1499 }
1500
1501 template <>
1502 inline const gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDConstPointer,
1503 const gl::VertexArrayID *>(const ParamValue &value)
1504 {
1505 return value.VertexArrayIDConstPointerVal;
1506 }
1507
1508 template <>
1509 inline gl::VertexArrayID *GetParamVal<ParamType::TVertexArrayIDPointer, gl::VertexArrayID *>(
1510 const ParamValue &value)
1511 {
1512 return value.VertexArrayIDPointerVal;
1513 }
1514
1515 template <>
1516 inline gl::VertexAttribType GetParamVal<ParamType::TVertexAttribType, gl::VertexAttribType>(
1517 const ParamValue &value)
1518 {
1519 return value.VertexAttribTypeVal;
1520 }
1521
1522 template <>
1523 inline const char *GetParamVal<ParamType::TcharConstPointer, const char *>(const ParamValue &value)
1524 {
1525 return value.charConstPointerVal;
1526 }
1527
1528 template <>
1529 inline const char **GetParamVal<ParamType::TcharConstPointerPointer, const char **>(
1530 const ParamValue &value)
1531 {
1532 return value.charConstPointerPointerVal;
1533 }
1534
1535 template <>
1536 inline const unsigned char **GetParamVal<ParamType::TcharUnsignedConstPointerPointer,
1537 const unsigned char **>(const ParamValue &value)
1538 {
1539 return value.charUnsignedConstPointerPointerVal;
1540 }
1541
1542 template <>
1543 inline egl::Config *GetParamVal<ParamType::Tegl_ConfigPointer, egl::Config *>(
1544 const ParamValue &value)
1545 {
1546 return value.egl_ConfigPointerVal;
1547 }
1548
1549 template <>
1550 inline egl::Device *GetParamVal<ParamType::Tegl_DevicePointer, egl::Device *>(
1551 const ParamValue &value)
1552 {
1553 return value.egl_DevicePointerVal;
1554 }
1555
1556 template <>
1557 inline egl::Display *GetParamVal<ParamType::Tegl_DisplayPointer, egl::Display *>(
1558 const ParamValue &value)
1559 {
1560 return value.egl_DisplayPointerVal;
1561 }
1562
1563 template <>
1564 inline egl::Stream *GetParamVal<ParamType::Tegl_StreamPointer, egl::Stream *>(
1565 const ParamValue &value)
1566 {
1567 return value.egl_StreamPointerVal;
1568 }
1569
1570 template <>
1571 inline egl::SyncID GetParamVal<ParamType::Tegl_SyncID, egl::SyncID>(const ParamValue &value)
1572 {
1573 return value.egl_SyncIDVal;
1574 }
1575
1576 template <>
1577 inline size_t GetParamVal<ParamType::Tsize_t, size_t>(const ParamValue &value)
1578 {
1579 return value.size_tVal;
1580 }
1581
1582 template <>
1583 inline const size_t *GetParamVal<ParamType::Tsize_tConstPointer, const size_t *>(
1584 const ParamValue &value)
1585 {
1586 return value.size_tConstPointerVal;
1587 }
1588
1589 template <>
1590 inline size_t *GetParamVal<ParamType::Tsize_tPointer, size_t *>(const ParamValue &value)
1591 {
1592 return value.size_tPointerVal;
1593 }
1594
1595 template <>
1596 inline const void *GetParamVal<ParamType::TvoidConstPointer, const void *>(const ParamValue &value)
1597 {
1598 return value.voidConstPointerVal;
1599 }
1600
1601 template <>
1602 inline const void **GetParamVal<ParamType::TvoidConstPointerPointer, const void **>(
1603 const ParamValue &value)
1604 {
1605 return value.voidConstPointerPointerVal;
1606 }
1607
1608 template <>
1609 inline void *GetParamVal<ParamType::TvoidPointer, void *>(const ParamValue &value)
1610 {
1611 return value.voidPointerVal;
1612 }
1613
1614 template <>
1615 inline void **GetParamVal<ParamType::TvoidPointerPointer, void **>(const ParamValue &value)
1616 {
1617 return value.voidPointerPointerVal;
1618 }
1619
1620 #ifdef ANGLE_ENABLE_CL
1621 template <>
1622 inline cl::AddressingMode GetParamVal<ParamType::TAddressingMode, cl::AddressingMode>(
1623 const ParamValue &value)
1624 {
1625 return value.AddressingModeVal;
1626 }
1627
1628 template <>
1629 inline cl::CommandQueueInfo GetParamVal<ParamType::TCommandQueueInfo, cl::CommandQueueInfo>(
1630 const ParamValue &value)
1631 {
1632 return value.CommandQueueInfoVal;
1633 }
1634
1635 template <>
1636 inline cl::CommandQueueProperties
1637 GetParamVal<ParamType::TCommandQueueProperties, cl::CommandQueueProperties>(const ParamValue &value)
1638 {
1639 return value.CommandQueuePropertiesVal;
1640 }
1641
1642 template <>
1643 inline cl::ContextInfo GetParamVal<ParamType::TContextInfo, cl::ContextInfo>(
1644 const ParamValue &value)
1645 {
1646 return value.ContextInfoVal;
1647 }
1648
1649 template <>
1650 inline cl::DeviceInfo GetParamVal<ParamType::TDeviceInfo, cl::DeviceInfo>(const ParamValue &value)
1651 {
1652 return value.DeviceInfoVal;
1653 }
1654
1655 template <>
1656 inline cl::DeviceType GetParamVal<ParamType::TDeviceType, cl::DeviceType>(const ParamValue &value)
1657 {
1658 return value.DeviceTypeVal;
1659 }
1660
1661 template <>
1662 inline cl::EventInfo GetParamVal<ParamType::TEventInfo, cl::EventInfo>(const ParamValue &value)
1663 {
1664 return value.EventInfoVal;
1665 }
1666
1667 template <>
1668 inline cl::FilterMode GetParamVal<ParamType::TFilterMode, cl::FilterMode>(const ParamValue &value)
1669 {
1670 return value.FilterModeVal;
1671 }
1672
1673 template <>
1674 inline cl::ImageInfo GetParamVal<ParamType::TImageInfo, cl::ImageInfo>(const ParamValue &value)
1675 {
1676 return value.ImageInfoVal;
1677 }
1678
1679 template <>
1680 inline cl::KernelArgInfo GetParamVal<ParamType::TKernelArgInfo, cl::KernelArgInfo>(
1681 const ParamValue &value)
1682 {
1683 return value.KernelArgInfoVal;
1684 }
1685
1686 template <>
1687 inline cl::KernelExecInfo GetParamVal<ParamType::TKernelExecInfo, cl::KernelExecInfo>(
1688 const ParamValue &value)
1689 {
1690 return value.KernelExecInfoVal;
1691 }
1692
1693 template <>
1694 inline cl::KernelInfo GetParamVal<ParamType::TKernelInfo, cl::KernelInfo>(const ParamValue &value)
1695 {
1696 return value.KernelInfoVal;
1697 }
1698
1699 template <>
1700 inline cl::KernelSubGroupInfo GetParamVal<ParamType::TKernelSubGroupInfo, cl::KernelSubGroupInfo>(
1701 const ParamValue &value)
1702 {
1703 return value.KernelSubGroupInfoVal;
1704 }
1705
1706 template <>
1707 inline cl::KernelWorkGroupInfo
1708 GetParamVal<ParamType::TKernelWorkGroupInfo, cl::KernelWorkGroupInfo>(const ParamValue &value)
1709 {
1710 return value.KernelWorkGroupInfoVal;
1711 }
1712
1713 template <>
1714 inline cl::MapFlags GetParamVal<ParamType::TMapFlags, cl::MapFlags>(const ParamValue &value)
1715 {
1716 return value.MapFlagsVal;
1717 }
1718
1719 template <>
1720 inline cl::MemFlags GetParamVal<ParamType::TMemFlags, cl::MemFlags>(const ParamValue &value)
1721 {
1722 return value.MemFlagsVal;
1723 }
1724
1725 template <>
1726 inline cl::MemInfo GetParamVal<ParamType::TMemInfo, cl::MemInfo>(const ParamValue &value)
1727 {
1728 return value.MemInfoVal;
1729 }
1730
1731 template <>
1732 inline cl::MemMigrationFlags GetParamVal<ParamType::TMemMigrationFlags, cl::MemMigrationFlags>(
1733 const ParamValue &value)
1734 {
1735 return value.MemMigrationFlagsVal;
1736 }
1737
1738 template <>
1739 inline cl::MemObjectType GetParamVal<ParamType::TMemObjectType, cl::MemObjectType>(
1740 const ParamValue &value)
1741 {
1742 return value.MemObjectTypeVal;
1743 }
1744
1745 template <>
1746 inline cl::PipeInfo GetParamVal<ParamType::TPipeInfo, cl::PipeInfo>(const ParamValue &value)
1747 {
1748 return value.PipeInfoVal;
1749 }
1750
1751 template <>
1752 inline cl::PlatformInfo GetParamVal<ParamType::TPlatformInfo, cl::PlatformInfo>(
1753 const ParamValue &value)
1754 {
1755 return value.PlatformInfoVal;
1756 }
1757
1758 template <>
1759 inline cl::ProfilingInfo GetParamVal<ParamType::TProfilingInfo, cl::ProfilingInfo>(
1760 const ParamValue &value)
1761 {
1762 return value.ProfilingInfoVal;
1763 }
1764
1765 template <>
1766 inline cl::ProgramBuildInfo GetParamVal<ParamType::TProgramBuildInfo, cl::ProgramBuildInfo>(
1767 const ParamValue &value)
1768 {
1769 return value.ProgramBuildInfoVal;
1770 }
1771
1772 template <>
1773 inline cl::ProgramInfo GetParamVal<ParamType::TProgramInfo, cl::ProgramInfo>(
1774 const ParamValue &value)
1775 {
1776 return value.ProgramInfoVal;
1777 }
1778
1779 template <>
1780 inline cl::SVM_MemFlags GetParamVal<ParamType::TSVM_MemFlags, cl::SVM_MemFlags>(
1781 const ParamValue &value)
1782 {
1783 return value.SVM_MemFlagsVal;
1784 }
1785
1786 template <>
1787 inline cl::SamplerInfo GetParamVal<ParamType::TSamplerInfo, cl::SamplerInfo>(
1788 const ParamValue &value)
1789 {
1790 return value.SamplerInfoVal;
1791 }
1792
1793 template <>
1794 inline cl_bool GetParamVal<ParamType::Tcl_bool, cl_bool>(const ParamValue &value)
1795 {
1796 return value.cl_boolVal;
1797 }
1798
1799 template <>
1800 inline cl_buffer_create_type GetParamVal<ParamType::Tcl_buffer_create_type, cl_buffer_create_type>(
1801 const ParamValue &value)
1802 {
1803 return value.cl_buffer_create_typeVal;
1804 }
1805
1806 template <>
1807 inline cl_callback_func_type GetParamVal<ParamType::Tcl_callback_func_type, cl_callback_func_type>(
1808 const ParamValue &value)
1809 {
1810 return value.cl_callback_func_typeVal;
1811 }
1812
1813 template <>
1814 inline cl_command_queue GetParamVal<ParamType::Tcl_command_queue, cl_command_queue>(
1815 const ParamValue &value)
1816 {
1817 return value.cl_command_queueVal;
1818 }
1819
1820 template <>
1821 inline cl_command_queue_properties *
1822 GetParamVal<ParamType::Tcl_command_queue_propertiesPointer, cl_command_queue_properties *>(
1823 const ParamValue &value)
1824 {
1825 return value.cl_command_queue_propertiesPointerVal;
1826 }
1827
1828 template <>
1829 inline cl_context GetParamVal<ParamType::Tcl_context, cl_context>(const ParamValue &value)
1830 {
1831 return value.cl_contextVal;
1832 }
1833
1834 template <>
1835 inline cl_context_destructor_func_type
1836 GetParamVal<ParamType::Tcl_context_destructor_func_type, cl_context_destructor_func_type>(
1837 const ParamValue &value)
1838 {
1839 return value.cl_context_destructor_func_typeVal;
1840 }
1841
1842 template <>
1843 inline cl_context_func_type GetParamVal<ParamType::Tcl_context_func_type, cl_context_func_type>(
1844 const ParamValue &value)
1845 {
1846 return value.cl_context_func_typeVal;
1847 }
1848
1849 template <>
1850 inline const cl_context_properties *
1851 GetParamVal<ParamType::Tcl_context_propertiesConstPointer, const cl_context_properties *>(
1852 const ParamValue &value)
1853 {
1854 return value.cl_context_propertiesConstPointerVal;
1855 }
1856
1857 template <>
1858 inline cl_device_id GetParamVal<ParamType::Tcl_device_id, cl_device_id>(const ParamValue &value)
1859 {
1860 return value.cl_device_idVal;
1861 }
1862
1863 template <>
1864 inline const cl_device_id *GetParamVal<ParamType::Tcl_device_idConstPointer, const cl_device_id *>(
1865 const ParamValue &value)
1866 {
1867 return value.cl_device_idConstPointerVal;
1868 }
1869
1870 template <>
1871 inline cl_device_id *GetParamVal<ParamType::Tcl_device_idPointer, cl_device_id *>(
1872 const ParamValue &value)
1873 {
1874 return value.cl_device_idPointerVal;
1875 }
1876
1877 template <>
1878 inline const cl_device_partition_property *
1879 GetParamVal<ParamType::Tcl_device_partition_propertyConstPointer,
1880 const cl_device_partition_property *>(const ParamValue &value)
1881 {
1882 return value.cl_device_partition_propertyConstPointerVal;
1883 }
1884
1885 template <>
1886 inline cl_event GetParamVal<ParamType::Tcl_event, cl_event>(const ParamValue &value)
1887 {
1888 return value.cl_eventVal;
1889 }
1890
1891 template <>
1892 inline const cl_event *GetParamVal<ParamType::Tcl_eventConstPointer, const cl_event *>(
1893 const ParamValue &value)
1894 {
1895 return value.cl_eventConstPointerVal;
1896 }
1897
1898 template <>
1899 inline cl_event *GetParamVal<ParamType::Tcl_eventPointer, cl_event *>(const ParamValue &value)
1900 {
1901 return value.cl_eventPointerVal;
1902 }
1903
1904 template <>
1905 inline const cl_image_desc *
1906 GetParamVal<ParamType::Tcl_image_descConstPointer, const cl_image_desc *>(const ParamValue &value)
1907 {
1908 return value.cl_image_descConstPointerVal;
1909 }
1910
1911 template <>
1912 inline const cl_image_format *GetParamVal<ParamType::Tcl_image_formatConstPointer,
1913 const cl_image_format *>(const ParamValue &value)
1914 {
1915 return value.cl_image_formatConstPointerVal;
1916 }
1917
1918 template <>
1919 inline cl_image_format *GetParamVal<ParamType::Tcl_image_formatPointer, cl_image_format *>(
1920 const ParamValue &value)
1921 {
1922 return value.cl_image_formatPointerVal;
1923 }
1924
1925 template <>
1926 inline cl_int GetParamVal<ParamType::Tcl_int, cl_int>(const ParamValue &value)
1927 {
1928 return value.cl_intVal;
1929 }
1930
1931 template <>
1932 inline cl_int *GetParamVal<ParamType::Tcl_intPointer, cl_int *>(const ParamValue &value)
1933 {
1934 return value.cl_intPointerVal;
1935 }
1936
1937 template <>
1938 inline cl_kernel GetParamVal<ParamType::Tcl_kernel, cl_kernel>(const ParamValue &value)
1939 {
1940 return value.cl_kernelVal;
1941 }
1942
1943 template <>
1944 inline cl_kernel *GetParamVal<ParamType::Tcl_kernelPointer, cl_kernel *>(const ParamValue &value)
1945 {
1946 return value.cl_kernelPointerVal;
1947 }
1948
1949 template <>
1950 inline cl_mem GetParamVal<ParamType::Tcl_mem, cl_mem>(const ParamValue &value)
1951 {
1952 return value.cl_memVal;
1953 }
1954
1955 template <>
1956 inline const cl_mem *GetParamVal<ParamType::Tcl_memConstPointer, const cl_mem *>(
1957 const ParamValue &value)
1958 {
1959 return value.cl_memConstPointerVal;
1960 }
1961
1962 template <>
1963 inline cl_mem_destructor_func_type GetParamVal<ParamType::Tcl_mem_destructor_func_type,
1964 cl_mem_destructor_func_type>(const ParamValue &value)
1965 {
1966 return value.cl_mem_destructor_func_typeVal;
1967 }
1968
1969 template <>
1970 inline const cl_mem_properties *GetParamVal<ParamType::Tcl_mem_propertiesConstPointer,
1971 const cl_mem_properties *>(const ParamValue &value)
1972 {
1973 return value.cl_mem_propertiesConstPointerVal;
1974 }
1975
1976 template <>
1977 inline const cl_pipe_properties *GetParamVal<ParamType::Tcl_pipe_propertiesConstPointer,
1978 const cl_pipe_properties *>(const ParamValue &value)
1979 {
1980 return value.cl_pipe_propertiesConstPointerVal;
1981 }
1982
1983 template <>
1984 inline cl_platform_id GetParamVal<ParamType::Tcl_platform_id, cl_platform_id>(
1985 const ParamValue &value)
1986 {
1987 return value.cl_platform_idVal;
1988 }
1989
1990 template <>
1991 inline cl_platform_id *GetParamVal<ParamType::Tcl_platform_idPointer, cl_platform_id *>(
1992 const ParamValue &value)
1993 {
1994 return value.cl_platform_idPointerVal;
1995 }
1996
1997 template <>
1998 inline cl_program GetParamVal<ParamType::Tcl_program, cl_program>(const ParamValue &value)
1999 {
2000 return value.cl_programVal;
2001 }
2002
2003 template <>
2004 inline const cl_program *GetParamVal<ParamType::Tcl_programConstPointer, const cl_program *>(
2005 const ParamValue &value)
2006 {
2007 return value.cl_programConstPointerVal;
2008 }
2009
2010 template <>
2011 inline cl_program_func_type GetParamVal<ParamType::Tcl_program_func_type, cl_program_func_type>(
2012 const ParamValue &value)
2013 {
2014 return value.cl_program_func_typeVal;
2015 }
2016
2017 template <>
2018 inline const cl_queue_properties *GetParamVal<ParamType::Tcl_queue_propertiesConstPointer,
2019 const cl_queue_properties *>(const ParamValue &value)
2020 {
2021 return value.cl_queue_propertiesConstPointerVal;
2022 }
2023
2024 template <>
2025 inline cl_sampler GetParamVal<ParamType::Tcl_sampler, cl_sampler>(const ParamValue &value)
2026 {
2027 return value.cl_samplerVal;
2028 }
2029
2030 template <>
2031 inline const cl_sampler_properties *
2032 GetParamVal<ParamType::Tcl_sampler_propertiesConstPointer, const cl_sampler_properties *>(
2033 const ParamValue &value)
2034 {
2035 return value.cl_sampler_propertiesConstPointerVal;
2036 }
2037
2038 template <>
2039 inline cl_svm_free_callback_func_type
2040 GetParamVal<ParamType::Tcl_svm_free_callback_func_type, cl_svm_free_callback_func_type>(
2041 const ParamValue &value)
2042 {
2043 return value.cl_svm_free_callback_func_typeVal;
2044 }
2045
2046 template <>
2047 inline cl_uint GetParamVal<ParamType::Tcl_uint, cl_uint>(const ParamValue &value)
2048 {
2049 return value.cl_uintVal;
2050 }
2051
2052 template <>
2053 inline cl_uint *GetParamVal<ParamType::Tcl_uintPointer, cl_uint *>(const ParamValue &value)
2054 {
2055 return value.cl_uintPointerVal;
2056 }
2057
2058 template <>
2059 inline cl_ulong *GetParamVal<ParamType::Tcl_ulongPointer, cl_ulong *>(const ParamValue &value)
2060 {
2061 return value.cl_ulongPointerVal;
2062 }
2063
2064 template <>
2065 inline cl_void_func_type GetParamVal<ParamType::Tcl_void_func_type, cl_void_func_type>(
2066 const ParamValue &value)
2067 {
2068 return value.cl_void_func_typeVal;
2069 }
2070 #endif
2071
2072 template <ParamType PType, typename T>
GetParamVal(const ParamValue & value)2073 T GetParamVal(const ParamValue &value)
2074 {
2075 UNREACHABLE();
2076 return T();
2077 }
2078
2079 template <typename T>
AccessParamValue(ParamType paramType,const ParamValue & value)2080 T AccessParamValue(ParamType paramType, const ParamValue &value)
2081 {
2082 switch (paramType)
2083 {
2084 case ParamType::TAHardwareBufferConstPointer:
2085 return GetParamVal<ParamType::TAHardwareBufferConstPointer, T>(value);
2086 case ParamType::TAddressingMode:
2087 return GetParamVal<ParamType::TAddressingMode, T>(value);
2088 case ParamType::TAlphaTestFunc:
2089 return GetParamVal<ParamType::TAlphaTestFunc, T>(value);
2090 case ParamType::TBufferBinding:
2091 return GetParamVal<ParamType::TBufferBinding, T>(value);
2092 case ParamType::TBufferID:
2093 return GetParamVal<ParamType::TBufferID, T>(value);
2094 case ParamType::TBufferIDConstPointer:
2095 return GetParamVal<ParamType::TBufferIDConstPointer, T>(value);
2096 case ParamType::TBufferIDPointer:
2097 return GetParamVal<ParamType::TBufferIDPointer, T>(value);
2098 case ParamType::TBufferUsage:
2099 return GetParamVal<ParamType::TBufferUsage, T>(value);
2100 case ParamType::TClientVertexArrayType:
2101 return GetParamVal<ParamType::TClientVertexArrayType, T>(value);
2102 case ParamType::TClipDepthMode:
2103 return GetParamVal<ParamType::TClipDepthMode, T>(value);
2104 case ParamType::TClipOrigin:
2105 return GetParamVal<ParamType::TClipOrigin, T>(value);
2106 case ParamType::TCommandQueueInfo:
2107 return GetParamVal<ParamType::TCommandQueueInfo, T>(value);
2108 case ParamType::TCommandQueueProperties:
2109 return GetParamVal<ParamType::TCommandQueueProperties, T>(value);
2110 case ParamType::TCompositorTiming:
2111 return GetParamVal<ParamType::TCompositorTiming, T>(value);
2112 case ParamType::TContextID:
2113 return GetParamVal<ParamType::TContextID, T>(value);
2114 case ParamType::TContextInfo:
2115 return GetParamVal<ParamType::TContextInfo, T>(value);
2116 case ParamType::TCullFaceMode:
2117 return GetParamVal<ParamType::TCullFaceMode, T>(value);
2118 case ParamType::TDeviceInfo:
2119 return GetParamVal<ParamType::TDeviceInfo, T>(value);
2120 case ParamType::TDeviceType:
2121 return GetParamVal<ParamType::TDeviceType, T>(value);
2122 case ParamType::TDrawElementsType:
2123 return GetParamVal<ParamType::TDrawElementsType, T>(value);
2124 case ParamType::TEGLAttribConstPointer:
2125 return GetParamVal<ParamType::TEGLAttribConstPointer, T>(value);
2126 case ParamType::TEGLAttribKHRPointer:
2127 return GetParamVal<ParamType::TEGLAttribKHRPointer, T>(value);
2128 case ParamType::TEGLAttribPointer:
2129 return GetParamVal<ParamType::TEGLAttribPointer, T>(value);
2130 case ParamType::TEGLBoolean:
2131 return GetParamVal<ParamType::TEGLBoolean, T>(value);
2132 case ParamType::TEGLBooleanPointer:
2133 return GetParamVal<ParamType::TEGLBooleanPointer, T>(value);
2134 case ParamType::TEGLClientBuffer:
2135 return GetParamVal<ParamType::TEGLClientBuffer, T>(value);
2136 case ParamType::TEGLConfigPointer:
2137 return GetParamVal<ParamType::TEGLConfigPointer, T>(value);
2138 case ParamType::TEGLContext:
2139 return GetParamVal<ParamType::TEGLContext, T>(value);
2140 case ParamType::TEGLDEBUGPROCKHR:
2141 return GetParamVal<ParamType::TEGLDEBUGPROCKHR, T>(value);
2142 case ParamType::TEGLDeviceEXT:
2143 return GetParamVal<ParamType::TEGLDeviceEXT, T>(value);
2144 case ParamType::TEGLDisplay:
2145 return GetParamVal<ParamType::TEGLDisplay, T>(value);
2146 case ParamType::TEGLGetBlobFuncANDROID:
2147 return GetParamVal<ParamType::TEGLGetBlobFuncANDROID, T>(value);
2148 case ParamType::TEGLImage:
2149 return GetParamVal<ParamType::TEGLImage, T>(value);
2150 case ParamType::TEGLImageKHR:
2151 return GetParamVal<ParamType::TEGLImageKHR, T>(value);
2152 case ParamType::TEGLLabelKHR:
2153 return GetParamVal<ParamType::TEGLLabelKHR, T>(value);
2154 case ParamType::TEGLNativeDisplayType:
2155 return GetParamVal<ParamType::TEGLNativeDisplayType, T>(value);
2156 case ParamType::TEGLNativePixmapType:
2157 return GetParamVal<ParamType::TEGLNativePixmapType, T>(value);
2158 case ParamType::TEGLNativeWindowType:
2159 return GetParamVal<ParamType::TEGLNativeWindowType, T>(value);
2160 case ParamType::TEGLObjectKHR:
2161 return GetParamVal<ParamType::TEGLObjectKHR, T>(value);
2162 case ParamType::TEGLSetBlobFuncANDROID:
2163 return GetParamVal<ParamType::TEGLSetBlobFuncANDROID, T>(value);
2164 case ParamType::TEGLStreamKHR:
2165 return GetParamVal<ParamType::TEGLStreamKHR, T>(value);
2166 case ParamType::TEGLSurface:
2167 return GetParamVal<ParamType::TEGLSurface, T>(value);
2168 case ParamType::TEGLSync:
2169 return GetParamVal<ParamType::TEGLSync, T>(value);
2170 case ParamType::TEGLSyncKHR:
2171 return GetParamVal<ParamType::TEGLSyncKHR, T>(value);
2172 case ParamType::TEGLTime:
2173 return GetParamVal<ParamType::TEGLTime, T>(value);
2174 case ParamType::TEGLTimeKHR:
2175 return GetParamVal<ParamType::TEGLTimeKHR, T>(value);
2176 case ParamType::TEGLenum:
2177 return GetParamVal<ParamType::TEGLenum, T>(value);
2178 case ParamType::TEGLint:
2179 return GetParamVal<ParamType::TEGLint, T>(value);
2180 case ParamType::TEGLintConstPointer:
2181 return GetParamVal<ParamType::TEGLintConstPointer, T>(value);
2182 case ParamType::TEGLintPointer:
2183 return GetParamVal<ParamType::TEGLintPointer, T>(value);
2184 case ParamType::TEGLnsecsANDROID:
2185 return GetParamVal<ParamType::TEGLnsecsANDROID, T>(value);
2186 case ParamType::TEGLnsecsANDROIDPointer:
2187 return GetParamVal<ParamType::TEGLnsecsANDROIDPointer, T>(value);
2188 case ParamType::TEGLuint64KHR:
2189 return GetParamVal<ParamType::TEGLuint64KHR, T>(value);
2190 case ParamType::TEGLuint64KHRPointer:
2191 return GetParamVal<ParamType::TEGLuint64KHRPointer, T>(value);
2192 case ParamType::TEventInfo:
2193 return GetParamVal<ParamType::TEventInfo, T>(value);
2194 case ParamType::TFenceNVID:
2195 return GetParamVal<ParamType::TFenceNVID, T>(value);
2196 case ParamType::TFenceNVIDConstPointer:
2197 return GetParamVal<ParamType::TFenceNVIDConstPointer, T>(value);
2198 case ParamType::TFenceNVIDPointer:
2199 return GetParamVal<ParamType::TFenceNVIDPointer, T>(value);
2200 case ParamType::TFilterMode:
2201 return GetParamVal<ParamType::TFilterMode, T>(value);
2202 case ParamType::TFramebufferID:
2203 return GetParamVal<ParamType::TFramebufferID, T>(value);
2204 case ParamType::TFramebufferIDConstPointer:
2205 return GetParamVal<ParamType::TFramebufferIDConstPointer, T>(value);
2206 case ParamType::TFramebufferIDPointer:
2207 return GetParamVal<ParamType::TFramebufferIDPointer, T>(value);
2208 case ParamType::TGLDEBUGPROC:
2209 return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
2210 case ParamType::TGLDEBUGPROCKHR:
2211 return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
2212 case ParamType::TGLGETBLOBPROCANGLE:
2213 return GetParamVal<ParamType::TGLGETBLOBPROCANGLE, T>(value);
2214 case ParamType::TGLSETBLOBPROCANGLE:
2215 return GetParamVal<ParamType::TGLSETBLOBPROCANGLE, T>(value);
2216 case ParamType::TGLbitfield:
2217 return GetParamVal<ParamType::TGLbitfield, T>(value);
2218 case ParamType::TGLboolean:
2219 return GetParamVal<ParamType::TGLboolean, T>(value);
2220 case ParamType::TGLbooleanPointer:
2221 return GetParamVal<ParamType::TGLbooleanPointer, T>(value);
2222 case ParamType::TGLcharConstPointer:
2223 return GetParamVal<ParamType::TGLcharConstPointer, T>(value);
2224 case ParamType::TGLcharConstPointerPointer:
2225 return GetParamVal<ParamType::TGLcharConstPointerPointer, T>(value);
2226 case ParamType::TGLcharPointer:
2227 return GetParamVal<ParamType::TGLcharPointer, T>(value);
2228 case ParamType::TGLclampx:
2229 return GetParamVal<ParamType::TGLclampx, T>(value);
2230 case ParamType::TGLeglClientBufferEXT:
2231 return GetParamVal<ParamType::TGLeglClientBufferEXT, T>(value);
2232 case ParamType::TGLenum:
2233 return GetParamVal<ParamType::TGLenum, T>(value);
2234 case ParamType::TGLenumConstPointer:
2235 return GetParamVal<ParamType::TGLenumConstPointer, T>(value);
2236 case ParamType::TGLenumPointer:
2237 return GetParamVal<ParamType::TGLenumPointer, T>(value);
2238 case ParamType::TGLfixed:
2239 return GetParamVal<ParamType::TGLfixed, T>(value);
2240 case ParamType::TGLfixedConstPointer:
2241 return GetParamVal<ParamType::TGLfixedConstPointer, T>(value);
2242 case ParamType::TGLfixedPointer:
2243 return GetParamVal<ParamType::TGLfixedPointer, T>(value);
2244 case ParamType::TGLfloat:
2245 return GetParamVal<ParamType::TGLfloat, T>(value);
2246 case ParamType::TGLfloatConstPointer:
2247 return GetParamVal<ParamType::TGLfloatConstPointer, T>(value);
2248 case ParamType::TGLfloatPointer:
2249 return GetParamVal<ParamType::TGLfloatPointer, T>(value);
2250 case ParamType::TGLint:
2251 return GetParamVal<ParamType::TGLint, T>(value);
2252 case ParamType::TGLint64:
2253 return GetParamVal<ParamType::TGLint64, T>(value);
2254 case ParamType::TGLint64Pointer:
2255 return GetParamVal<ParamType::TGLint64Pointer, T>(value);
2256 case ParamType::TGLintConstPointer:
2257 return GetParamVal<ParamType::TGLintConstPointer, T>(value);
2258 case ParamType::TGLintPointer:
2259 return GetParamVal<ParamType::TGLintPointer, T>(value);
2260 case ParamType::TGLintptr:
2261 return GetParamVal<ParamType::TGLintptr, T>(value);
2262 case ParamType::TGLshort:
2263 return GetParamVal<ParamType::TGLshort, T>(value);
2264 case ParamType::TGLshortConstPointer:
2265 return GetParamVal<ParamType::TGLshortConstPointer, T>(value);
2266 case ParamType::TGLsizei:
2267 return GetParamVal<ParamType::TGLsizei, T>(value);
2268 case ParamType::TGLsizeiConstPointer:
2269 return GetParamVal<ParamType::TGLsizeiConstPointer, T>(value);
2270 case ParamType::TGLsizeiPointer:
2271 return GetParamVal<ParamType::TGLsizeiPointer, T>(value);
2272 case ParamType::TGLsizeiptr:
2273 return GetParamVal<ParamType::TGLsizeiptr, T>(value);
2274 case ParamType::TGLsync:
2275 return GetParamVal<ParamType::TGLsync, T>(value);
2276 case ParamType::TGLubyte:
2277 return GetParamVal<ParamType::TGLubyte, T>(value);
2278 case ParamType::TGLubyteConstPointer:
2279 return GetParamVal<ParamType::TGLubyteConstPointer, T>(value);
2280 case ParamType::TGLubytePointer:
2281 return GetParamVal<ParamType::TGLubytePointer, T>(value);
2282 case ParamType::TGLuint:
2283 return GetParamVal<ParamType::TGLuint, T>(value);
2284 case ParamType::TGLuint64:
2285 return GetParamVal<ParamType::TGLuint64, T>(value);
2286 case ParamType::TGLuint64ConstPointer:
2287 return GetParamVal<ParamType::TGLuint64ConstPointer, T>(value);
2288 case ParamType::TGLuint64Pointer:
2289 return GetParamVal<ParamType::TGLuint64Pointer, T>(value);
2290 case ParamType::TGLuintConstPointer:
2291 return GetParamVal<ParamType::TGLuintConstPointer, T>(value);
2292 case ParamType::TGLuintPointer:
2293 return GetParamVal<ParamType::TGLuintPointer, T>(value);
2294 case ParamType::TGraphicsResetStatus:
2295 return GetParamVal<ParamType::TGraphicsResetStatus, T>(value);
2296 case ParamType::THandleType:
2297 return GetParamVal<ParamType::THandleType, T>(value);
2298 case ParamType::TImageID:
2299 return GetParamVal<ParamType::TImageID, T>(value);
2300 case ParamType::TImageInfo:
2301 return GetParamVal<ParamType::TImageInfo, T>(value);
2302 case ParamType::TKernelArgInfo:
2303 return GetParamVal<ParamType::TKernelArgInfo, T>(value);
2304 case ParamType::TKernelExecInfo:
2305 return GetParamVal<ParamType::TKernelExecInfo, T>(value);
2306 case ParamType::TKernelInfo:
2307 return GetParamVal<ParamType::TKernelInfo, T>(value);
2308 case ParamType::TKernelSubGroupInfo:
2309 return GetParamVal<ParamType::TKernelSubGroupInfo, T>(value);
2310 case ParamType::TKernelWorkGroupInfo:
2311 return GetParamVal<ParamType::TKernelWorkGroupInfo, T>(value);
2312 case ParamType::TLightParameter:
2313 return GetParamVal<ParamType::TLightParameter, T>(value);
2314 case ParamType::TLogicalOperation:
2315 return GetParamVal<ParamType::TLogicalOperation, T>(value);
2316 case ParamType::TMapFlags:
2317 return GetParamVal<ParamType::TMapFlags, T>(value);
2318 case ParamType::TMaterialParameter:
2319 return GetParamVal<ParamType::TMaterialParameter, T>(value);
2320 case ParamType::TMatrixType:
2321 return GetParamVal<ParamType::TMatrixType, T>(value);
2322 case ParamType::TMemFlags:
2323 return GetParamVal<ParamType::TMemFlags, T>(value);
2324 case ParamType::TMemInfo:
2325 return GetParamVal<ParamType::TMemInfo, T>(value);
2326 case ParamType::TMemMigrationFlags:
2327 return GetParamVal<ParamType::TMemMigrationFlags, T>(value);
2328 case ParamType::TMemObjectType:
2329 return GetParamVal<ParamType::TMemObjectType, T>(value);
2330 case ParamType::TMemoryObjectID:
2331 return GetParamVal<ParamType::TMemoryObjectID, T>(value);
2332 case ParamType::TMemoryObjectIDConstPointer:
2333 return GetParamVal<ParamType::TMemoryObjectIDConstPointer, T>(value);
2334 case ParamType::TMemoryObjectIDPointer:
2335 return GetParamVal<ParamType::TMemoryObjectIDPointer, T>(value);
2336 case ParamType::TObjectType:
2337 return GetParamVal<ParamType::TObjectType, T>(value);
2338 case ParamType::TPipeInfo:
2339 return GetParamVal<ParamType::TPipeInfo, T>(value);
2340 case ParamType::TPlatformInfo:
2341 return GetParamVal<ParamType::TPlatformInfo, T>(value);
2342 case ParamType::TPointParameter:
2343 return GetParamVal<ParamType::TPointParameter, T>(value);
2344 case ParamType::TPolygonMode:
2345 return GetParamVal<ParamType::TPolygonMode, T>(value);
2346 case ParamType::TPrimitiveMode:
2347 return GetParamVal<ParamType::TPrimitiveMode, T>(value);
2348 case ParamType::TProfilingInfo:
2349 return GetParamVal<ParamType::TProfilingInfo, T>(value);
2350 case ParamType::TProgramBuildInfo:
2351 return GetParamVal<ParamType::TProgramBuildInfo, T>(value);
2352 case ParamType::TProgramInfo:
2353 return GetParamVal<ParamType::TProgramInfo, T>(value);
2354 case ParamType::TProgramPipelineID:
2355 return GetParamVal<ParamType::TProgramPipelineID, T>(value);
2356 case ParamType::TProgramPipelineIDConstPointer:
2357 return GetParamVal<ParamType::TProgramPipelineIDConstPointer, T>(value);
2358 case ParamType::TProgramPipelineIDPointer:
2359 return GetParamVal<ParamType::TProgramPipelineIDPointer, T>(value);
2360 case ParamType::TProvokingVertexConvention:
2361 return GetParamVal<ParamType::TProvokingVertexConvention, T>(value);
2362 case ParamType::TQueryID:
2363 return GetParamVal<ParamType::TQueryID, T>(value);
2364 case ParamType::TQueryIDConstPointer:
2365 return GetParamVal<ParamType::TQueryIDConstPointer, T>(value);
2366 case ParamType::TQueryIDPointer:
2367 return GetParamVal<ParamType::TQueryIDPointer, T>(value);
2368 case ParamType::TQueryType:
2369 return GetParamVal<ParamType::TQueryType, T>(value);
2370 case ParamType::TRenderbufferID:
2371 return GetParamVal<ParamType::TRenderbufferID, T>(value);
2372 case ParamType::TRenderbufferIDConstPointer:
2373 return GetParamVal<ParamType::TRenderbufferIDConstPointer, T>(value);
2374 case ParamType::TRenderbufferIDPointer:
2375 return GetParamVal<ParamType::TRenderbufferIDPointer, T>(value);
2376 case ParamType::TSVM_MemFlags:
2377 return GetParamVal<ParamType::TSVM_MemFlags, T>(value);
2378 case ParamType::TSamplerID:
2379 return GetParamVal<ParamType::TSamplerID, T>(value);
2380 case ParamType::TSamplerIDConstPointer:
2381 return GetParamVal<ParamType::TSamplerIDConstPointer, T>(value);
2382 case ParamType::TSamplerIDPointer:
2383 return GetParamVal<ParamType::TSamplerIDPointer, T>(value);
2384 case ParamType::TSamplerInfo:
2385 return GetParamVal<ParamType::TSamplerInfo, T>(value);
2386 case ParamType::TSemaphoreID:
2387 return GetParamVal<ParamType::TSemaphoreID, T>(value);
2388 case ParamType::TSemaphoreIDConstPointer:
2389 return GetParamVal<ParamType::TSemaphoreIDConstPointer, T>(value);
2390 case ParamType::TSemaphoreIDPointer:
2391 return GetParamVal<ParamType::TSemaphoreIDPointer, T>(value);
2392 case ParamType::TShaderProgramID:
2393 return GetParamVal<ParamType::TShaderProgramID, T>(value);
2394 case ParamType::TShaderProgramIDConstPointer:
2395 return GetParamVal<ParamType::TShaderProgramIDConstPointer, T>(value);
2396 case ParamType::TShaderProgramIDPointer:
2397 return GetParamVal<ParamType::TShaderProgramIDPointer, T>(value);
2398 case ParamType::TShaderType:
2399 return GetParamVal<ParamType::TShaderType, T>(value);
2400 case ParamType::TShadingModel:
2401 return GetParamVal<ParamType::TShadingModel, T>(value);
2402 case ParamType::TSurfaceID:
2403 return GetParamVal<ParamType::TSurfaceID, T>(value);
2404 case ParamType::TSyncID:
2405 return GetParamVal<ParamType::TSyncID, T>(value);
2406 case ParamType::TTextureEnvParameter:
2407 return GetParamVal<ParamType::TTextureEnvParameter, T>(value);
2408 case ParamType::TTextureEnvTarget:
2409 return GetParamVal<ParamType::TTextureEnvTarget, T>(value);
2410 case ParamType::TTextureID:
2411 return GetParamVal<ParamType::TTextureID, T>(value);
2412 case ParamType::TTextureIDConstPointer:
2413 return GetParamVal<ParamType::TTextureIDConstPointer, T>(value);
2414 case ParamType::TTextureIDPointer:
2415 return GetParamVal<ParamType::TTextureIDPointer, T>(value);
2416 case ParamType::TTextureTarget:
2417 return GetParamVal<ParamType::TTextureTarget, T>(value);
2418 case ParamType::TTextureType:
2419 return GetParamVal<ParamType::TTextureType, T>(value);
2420 case ParamType::TTimestamp:
2421 return GetParamVal<ParamType::TTimestamp, T>(value);
2422 case ParamType::TTransformFeedbackID:
2423 return GetParamVal<ParamType::TTransformFeedbackID, T>(value);
2424 case ParamType::TTransformFeedbackIDConstPointer:
2425 return GetParamVal<ParamType::TTransformFeedbackIDConstPointer, T>(value);
2426 case ParamType::TTransformFeedbackIDPointer:
2427 return GetParamVal<ParamType::TTransformFeedbackIDPointer, T>(value);
2428 case ParamType::TUniformBlockIndex:
2429 return GetParamVal<ParamType::TUniformBlockIndex, T>(value);
2430 case ParamType::TUniformLocation:
2431 return GetParamVal<ParamType::TUniformLocation, T>(value);
2432 case ParamType::TVertexArrayID:
2433 return GetParamVal<ParamType::TVertexArrayID, T>(value);
2434 case ParamType::TVertexArrayIDConstPointer:
2435 return GetParamVal<ParamType::TVertexArrayIDConstPointer, T>(value);
2436 case ParamType::TVertexArrayIDPointer:
2437 return GetParamVal<ParamType::TVertexArrayIDPointer, T>(value);
2438 case ParamType::TVertexAttribType:
2439 return GetParamVal<ParamType::TVertexAttribType, T>(value);
2440 case ParamType::TcharConstPointer:
2441 return GetParamVal<ParamType::TcharConstPointer, T>(value);
2442 case ParamType::TcharConstPointerPointer:
2443 return GetParamVal<ParamType::TcharConstPointerPointer, T>(value);
2444 case ParamType::TcharUnsignedConstPointerPointer:
2445 return GetParamVal<ParamType::TcharUnsignedConstPointerPointer, T>(value);
2446 case ParamType::Tcl_bool:
2447 return GetParamVal<ParamType::Tcl_bool, T>(value);
2448 case ParamType::Tcl_buffer_create_type:
2449 return GetParamVal<ParamType::Tcl_buffer_create_type, T>(value);
2450 case ParamType::Tcl_callback_func_type:
2451 return GetParamVal<ParamType::Tcl_callback_func_type, T>(value);
2452 case ParamType::Tcl_command_queue:
2453 return GetParamVal<ParamType::Tcl_command_queue, T>(value);
2454 case ParamType::Tcl_command_queue_propertiesPointer:
2455 return GetParamVal<ParamType::Tcl_command_queue_propertiesPointer, T>(value);
2456 case ParamType::Tcl_context:
2457 return GetParamVal<ParamType::Tcl_context, T>(value);
2458 case ParamType::Tcl_context_destructor_func_type:
2459 return GetParamVal<ParamType::Tcl_context_destructor_func_type, T>(value);
2460 case ParamType::Tcl_context_func_type:
2461 return GetParamVal<ParamType::Tcl_context_func_type, T>(value);
2462 case ParamType::Tcl_context_propertiesConstPointer:
2463 return GetParamVal<ParamType::Tcl_context_propertiesConstPointer, T>(value);
2464 case ParamType::Tcl_device_id:
2465 return GetParamVal<ParamType::Tcl_device_id, T>(value);
2466 case ParamType::Tcl_device_idConstPointer:
2467 return GetParamVal<ParamType::Tcl_device_idConstPointer, T>(value);
2468 case ParamType::Tcl_device_idPointer:
2469 return GetParamVal<ParamType::Tcl_device_idPointer, T>(value);
2470 case ParamType::Tcl_device_partition_propertyConstPointer:
2471 return GetParamVal<ParamType::Tcl_device_partition_propertyConstPointer, T>(value);
2472 case ParamType::Tcl_event:
2473 return GetParamVal<ParamType::Tcl_event, T>(value);
2474 case ParamType::Tcl_eventConstPointer:
2475 return GetParamVal<ParamType::Tcl_eventConstPointer, T>(value);
2476 case ParamType::Tcl_eventPointer:
2477 return GetParamVal<ParamType::Tcl_eventPointer, T>(value);
2478 case ParamType::Tcl_image_descConstPointer:
2479 return GetParamVal<ParamType::Tcl_image_descConstPointer, T>(value);
2480 case ParamType::Tcl_image_formatConstPointer:
2481 return GetParamVal<ParamType::Tcl_image_formatConstPointer, T>(value);
2482 case ParamType::Tcl_image_formatPointer:
2483 return GetParamVal<ParamType::Tcl_image_formatPointer, T>(value);
2484 case ParamType::Tcl_int:
2485 return GetParamVal<ParamType::Tcl_int, T>(value);
2486 case ParamType::Tcl_intPointer:
2487 return GetParamVal<ParamType::Tcl_intPointer, T>(value);
2488 case ParamType::Tcl_kernel:
2489 return GetParamVal<ParamType::Tcl_kernel, T>(value);
2490 case ParamType::Tcl_kernelPointer:
2491 return GetParamVal<ParamType::Tcl_kernelPointer, T>(value);
2492 case ParamType::Tcl_mem:
2493 return GetParamVal<ParamType::Tcl_mem, T>(value);
2494 case ParamType::Tcl_memConstPointer:
2495 return GetParamVal<ParamType::Tcl_memConstPointer, T>(value);
2496 case ParamType::Tcl_mem_destructor_func_type:
2497 return GetParamVal<ParamType::Tcl_mem_destructor_func_type, T>(value);
2498 case ParamType::Tcl_mem_propertiesConstPointer:
2499 return GetParamVal<ParamType::Tcl_mem_propertiesConstPointer, T>(value);
2500 case ParamType::Tcl_pipe_propertiesConstPointer:
2501 return GetParamVal<ParamType::Tcl_pipe_propertiesConstPointer, T>(value);
2502 case ParamType::Tcl_platform_id:
2503 return GetParamVal<ParamType::Tcl_platform_id, T>(value);
2504 case ParamType::Tcl_platform_idPointer:
2505 return GetParamVal<ParamType::Tcl_platform_idPointer, T>(value);
2506 case ParamType::Tcl_program:
2507 return GetParamVal<ParamType::Tcl_program, T>(value);
2508 case ParamType::Tcl_programConstPointer:
2509 return GetParamVal<ParamType::Tcl_programConstPointer, T>(value);
2510 case ParamType::Tcl_program_func_type:
2511 return GetParamVal<ParamType::Tcl_program_func_type, T>(value);
2512 case ParamType::Tcl_queue_propertiesConstPointer:
2513 return GetParamVal<ParamType::Tcl_queue_propertiesConstPointer, T>(value);
2514 case ParamType::Tcl_sampler:
2515 return GetParamVal<ParamType::Tcl_sampler, T>(value);
2516 case ParamType::Tcl_sampler_propertiesConstPointer:
2517 return GetParamVal<ParamType::Tcl_sampler_propertiesConstPointer, T>(value);
2518 case ParamType::Tcl_svm_free_callback_func_type:
2519 return GetParamVal<ParamType::Tcl_svm_free_callback_func_type, T>(value);
2520 case ParamType::Tcl_uint:
2521 return GetParamVal<ParamType::Tcl_uint, T>(value);
2522 case ParamType::Tcl_uintPointer:
2523 return GetParamVal<ParamType::Tcl_uintPointer, T>(value);
2524 case ParamType::Tcl_ulongPointer:
2525 return GetParamVal<ParamType::Tcl_ulongPointer, T>(value);
2526 case ParamType::Tcl_void_func_type:
2527 return GetParamVal<ParamType::Tcl_void_func_type, T>(value);
2528 case ParamType::Tegl_ConfigPointer:
2529 return GetParamVal<ParamType::Tegl_ConfigPointer, T>(value);
2530 case ParamType::Tegl_DevicePointer:
2531 return GetParamVal<ParamType::Tegl_DevicePointer, T>(value);
2532 case ParamType::Tegl_DisplayPointer:
2533 return GetParamVal<ParamType::Tegl_DisplayPointer, T>(value);
2534 case ParamType::Tegl_StreamPointer:
2535 return GetParamVal<ParamType::Tegl_StreamPointer, T>(value);
2536 case ParamType::Tegl_SyncID:
2537 return GetParamVal<ParamType::Tegl_SyncID, T>(value);
2538 case ParamType::Tsize_t:
2539 return GetParamVal<ParamType::Tsize_t, T>(value);
2540 case ParamType::Tsize_tConstPointer:
2541 return GetParamVal<ParamType::Tsize_tConstPointer, T>(value);
2542 case ParamType::Tsize_tPointer:
2543 return GetParamVal<ParamType::Tsize_tPointer, T>(value);
2544 case ParamType::TvoidConstPointer:
2545 return GetParamVal<ParamType::TvoidConstPointer, T>(value);
2546 case ParamType::TvoidConstPointerPointer:
2547 return GetParamVal<ParamType::TvoidConstPointerPointer, T>(value);
2548 case ParamType::TvoidPointer:
2549 return GetParamVal<ParamType::TvoidPointer, T>(value);
2550 case ParamType::TvoidPointerPointer:
2551 return GetParamVal<ParamType::TvoidPointerPointer, T>(value);
2552 }
2553 UNREACHABLE();
2554 return T();
2555 }
2556
2557 template <ParamType PType, typename T>
2558 void SetParamVal(T valueIn, ParamValue *valueOut);
2559
2560 template <>
2561 inline void SetParamVal<ParamType::TAHardwareBufferConstPointer>(const AHardwareBuffer *valueIn,
2562 ParamValue *valueOut)
2563 {
2564 valueOut->AHardwareBufferConstPointerVal = valueIn;
2565 }
2566
2567 template <>
2568 inline void SetParamVal<ParamType::TAlphaTestFunc>(gl::AlphaTestFunc valueIn, ParamValue *valueOut)
2569 {
2570 valueOut->AlphaTestFuncVal = valueIn;
2571 }
2572
2573 template <>
2574 inline void SetParamVal<ParamType::TBufferBinding>(gl::BufferBinding valueIn, ParamValue *valueOut)
2575 {
2576 valueOut->BufferBindingVal = valueIn;
2577 }
2578
2579 template <>
2580 inline void SetParamVal<ParamType::TBufferID>(gl::BufferID valueIn, ParamValue *valueOut)
2581 {
2582 valueOut->BufferIDVal = valueIn;
2583 }
2584
2585 template <>
2586 inline void SetParamVal<ParamType::TBufferIDConstPointer>(const gl::BufferID *valueIn,
2587 ParamValue *valueOut)
2588 {
2589 valueOut->BufferIDConstPointerVal = valueIn;
2590 }
2591
2592 template <>
2593 inline void SetParamVal<ParamType::TBufferIDPointer>(gl::BufferID *valueIn, ParamValue *valueOut)
2594 {
2595 valueOut->BufferIDPointerVal = valueIn;
2596 }
2597
2598 template <>
2599 inline void SetParamVal<ParamType::TBufferUsage>(gl::BufferUsage valueIn, ParamValue *valueOut)
2600 {
2601 valueOut->BufferUsageVal = valueIn;
2602 }
2603
2604 template <>
2605 inline void SetParamVal<ParamType::TClientVertexArrayType>(gl::ClientVertexArrayType valueIn,
2606 ParamValue *valueOut)
2607 {
2608 valueOut->ClientVertexArrayTypeVal = valueIn;
2609 }
2610
2611 template <>
2612 inline void SetParamVal<ParamType::TClipDepthMode>(gl::ClipDepthMode valueIn, ParamValue *valueOut)
2613 {
2614 valueOut->ClipDepthModeVal = valueIn;
2615 }
2616
2617 template <>
2618 inline void SetParamVal<ParamType::TClipOrigin>(gl::ClipOrigin valueIn, ParamValue *valueOut)
2619 {
2620 valueOut->ClipOriginVal = valueIn;
2621 }
2622
2623 template <>
2624 inline void SetParamVal<ParamType::TCompositorTiming>(egl::CompositorTiming valueIn,
2625 ParamValue *valueOut)
2626 {
2627 valueOut->CompositorTimingVal = valueIn;
2628 }
2629
2630 template <>
2631 inline void SetParamVal<ParamType::TContextID>(gl::ContextID valueIn, ParamValue *valueOut)
2632 {
2633 valueOut->ContextIDVal = valueIn;
2634 }
2635
2636 template <>
2637 inline void SetParamVal<ParamType::TCullFaceMode>(gl::CullFaceMode valueIn, ParamValue *valueOut)
2638 {
2639 valueOut->CullFaceModeVal = valueIn;
2640 }
2641
2642 template <>
2643 inline void SetParamVal<ParamType::TDrawElementsType>(gl::DrawElementsType valueIn,
2644 ParamValue *valueOut)
2645 {
2646 valueOut->DrawElementsTypeVal = valueIn;
2647 }
2648
2649 template <>
2650 inline void SetParamVal<ParamType::TEGLAttribConstPointer>(const EGLAttrib *valueIn,
2651 ParamValue *valueOut)
2652 {
2653 valueOut->EGLAttribConstPointerVal = valueIn;
2654 }
2655
2656 template <>
2657 inline void SetParamVal<ParamType::TEGLAttribKHRPointer>(EGLAttribKHR *valueIn,
2658 ParamValue *valueOut)
2659 {
2660 valueOut->EGLAttribKHRPointerVal = valueIn;
2661 }
2662
2663 template <>
2664 inline void SetParamVal<ParamType::TEGLAttribPointer>(EGLAttrib *valueIn, ParamValue *valueOut)
2665 {
2666 valueOut->EGLAttribPointerVal = valueIn;
2667 }
2668
2669 template <>
2670 inline void SetParamVal<ParamType::TEGLBoolean>(EGLBoolean valueIn, ParamValue *valueOut)
2671 {
2672 valueOut->EGLBooleanVal = valueIn;
2673 }
2674
2675 template <>
2676 inline void SetParamVal<ParamType::TEGLBooleanPointer>(EGLBoolean *valueIn, ParamValue *valueOut)
2677 {
2678 valueOut->EGLBooleanPointerVal = valueIn;
2679 }
2680
2681 template <>
2682 inline void SetParamVal<ParamType::TEGLClientBuffer>(EGLClientBuffer valueIn, ParamValue *valueOut)
2683 {
2684 valueOut->EGLClientBufferVal = valueIn;
2685 }
2686
2687 template <>
2688 inline void SetParamVal<ParamType::TEGLConfigPointer>(EGLConfig *valueIn, ParamValue *valueOut)
2689 {
2690 valueOut->EGLConfigPointerVal = valueIn;
2691 }
2692
2693 template <>
2694 inline void SetParamVal<ParamType::TEGLContext>(EGLContext valueIn, ParamValue *valueOut)
2695 {
2696 valueOut->EGLContextVal = valueIn;
2697 }
2698
2699 template <>
2700 inline void SetParamVal<ParamType::TEGLDEBUGPROCKHR>(EGLDEBUGPROCKHR valueIn, ParamValue *valueOut)
2701 {
2702 valueOut->EGLDEBUGPROCKHRVal = valueIn;
2703 }
2704
2705 template <>
2706 inline void SetParamVal<ParamType::TEGLDeviceEXT>(EGLDeviceEXT valueIn, ParamValue *valueOut)
2707 {
2708 valueOut->EGLDeviceEXTVal = valueIn;
2709 }
2710
2711 template <>
2712 inline void SetParamVal<ParamType::TEGLDisplay>(EGLDisplay valueIn, ParamValue *valueOut)
2713 {
2714 valueOut->EGLDisplayVal = valueIn;
2715 }
2716
2717 template <>
2718 inline void SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(EGLGetBlobFuncANDROID valueIn,
2719 ParamValue *valueOut)
2720 {
2721 valueOut->EGLGetBlobFuncANDROIDVal = valueIn;
2722 }
2723
2724 template <>
2725 inline void SetParamVal<ParamType::TEGLImage>(EGLImage valueIn, ParamValue *valueOut)
2726 {
2727 valueOut->EGLImageVal = valueIn;
2728 }
2729
2730 template <>
2731 inline void SetParamVal<ParamType::TEGLImageKHR>(EGLImageKHR valueIn, ParamValue *valueOut)
2732 {
2733 valueOut->EGLImageKHRVal = valueIn;
2734 }
2735
2736 template <>
2737 inline void SetParamVal<ParamType::TEGLLabelKHR>(EGLLabelKHR valueIn, ParamValue *valueOut)
2738 {
2739 valueOut->EGLLabelKHRVal = valueIn;
2740 }
2741
2742 template <>
2743 inline void SetParamVal<ParamType::TEGLNativeDisplayType>(EGLNativeDisplayType valueIn,
2744 ParamValue *valueOut)
2745 {
2746 valueOut->EGLNativeDisplayTypeVal = valueIn;
2747 }
2748
2749 template <>
2750 inline void SetParamVal<ParamType::TEGLNativePixmapType>(EGLNativePixmapType valueIn,
2751 ParamValue *valueOut)
2752 {
2753 valueOut->EGLNativePixmapTypeVal = valueIn;
2754 }
2755
2756 template <>
2757 inline void SetParamVal<ParamType::TEGLNativeWindowType>(EGLNativeWindowType valueIn,
2758 ParamValue *valueOut)
2759 {
2760 valueOut->EGLNativeWindowTypeVal = valueIn;
2761 }
2762
2763 template <>
2764 inline void SetParamVal<ParamType::TEGLObjectKHR>(EGLObjectKHR valueIn, ParamValue *valueOut)
2765 {
2766 valueOut->EGLObjectKHRVal = valueIn;
2767 }
2768
2769 template <>
2770 inline void SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(EGLSetBlobFuncANDROID valueIn,
2771 ParamValue *valueOut)
2772 {
2773 valueOut->EGLSetBlobFuncANDROIDVal = valueIn;
2774 }
2775
2776 template <>
2777 inline void SetParamVal<ParamType::TEGLStreamKHR>(EGLStreamKHR valueIn, ParamValue *valueOut)
2778 {
2779 valueOut->EGLStreamKHRVal = valueIn;
2780 }
2781
2782 template <>
2783 inline void SetParamVal<ParamType::TEGLSurface>(EGLSurface valueIn, ParamValue *valueOut)
2784 {
2785 valueOut->EGLSurfaceVal = valueIn;
2786 }
2787
2788 template <>
2789 inline void SetParamVal<ParamType::TEGLSync>(EGLSync valueIn, ParamValue *valueOut)
2790 {
2791 valueOut->EGLSyncVal = valueIn;
2792 }
2793
2794 template <>
2795 inline void SetParamVal<ParamType::TEGLSyncKHR>(EGLSyncKHR valueIn, ParamValue *valueOut)
2796 {
2797 valueOut->EGLSyncKHRVal = valueIn;
2798 }
2799
2800 template <>
2801 inline void SetParamVal<ParamType::TEGLTime>(EGLTime valueIn, ParamValue *valueOut)
2802 {
2803 valueOut->EGLTimeVal = valueIn;
2804 }
2805
2806 template <>
2807 inline void SetParamVal<ParamType::TEGLTimeKHR>(EGLTimeKHR valueIn, ParamValue *valueOut)
2808 {
2809 valueOut->EGLTimeKHRVal = valueIn;
2810 }
2811
2812 template <>
2813 inline void SetParamVal<ParamType::TEGLenum>(EGLenum valueIn, ParamValue *valueOut)
2814 {
2815 valueOut->EGLenumVal = valueIn;
2816 }
2817
2818 template <>
2819 inline void SetParamVal<ParamType::TEGLint>(EGLint valueIn, ParamValue *valueOut)
2820 {
2821 valueOut->EGLintVal = valueIn;
2822 }
2823
2824 template <>
2825 inline void SetParamVal<ParamType::TEGLintConstPointer>(const EGLint *valueIn, ParamValue *valueOut)
2826 {
2827 valueOut->EGLintConstPointerVal = valueIn;
2828 }
2829
2830 template <>
2831 inline void SetParamVal<ParamType::TEGLintPointer>(EGLint *valueIn, ParamValue *valueOut)
2832 {
2833 valueOut->EGLintPointerVal = valueIn;
2834 }
2835
2836 template <>
2837 inline void SetParamVal<ParamType::TEGLnsecsANDROID>(EGLnsecsANDROID valueIn, ParamValue *valueOut)
2838 {
2839 valueOut->EGLnsecsANDROIDVal = valueIn;
2840 }
2841
2842 template <>
2843 inline void SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(EGLnsecsANDROID *valueIn,
2844 ParamValue *valueOut)
2845 {
2846 valueOut->EGLnsecsANDROIDPointerVal = valueIn;
2847 }
2848
2849 template <>
2850 inline void SetParamVal<ParamType::TEGLuint64KHR>(EGLuint64KHR valueIn, ParamValue *valueOut)
2851 {
2852 valueOut->EGLuint64KHRVal = valueIn;
2853 }
2854
2855 template <>
2856 inline void SetParamVal<ParamType::TEGLuint64KHRPointer>(EGLuint64KHR *valueIn,
2857 ParamValue *valueOut)
2858 {
2859 valueOut->EGLuint64KHRPointerVal = valueIn;
2860 }
2861
2862 template <>
2863 inline void SetParamVal<ParamType::TFenceNVID>(gl::FenceNVID valueIn, ParamValue *valueOut)
2864 {
2865 valueOut->FenceNVIDVal = valueIn;
2866 }
2867
2868 template <>
2869 inline void SetParamVal<ParamType::TFenceNVIDConstPointer>(const gl::FenceNVID *valueIn,
2870 ParamValue *valueOut)
2871 {
2872 valueOut->FenceNVIDConstPointerVal = valueIn;
2873 }
2874
2875 template <>
2876 inline void SetParamVal<ParamType::TFenceNVIDPointer>(gl::FenceNVID *valueIn, ParamValue *valueOut)
2877 {
2878 valueOut->FenceNVIDPointerVal = valueIn;
2879 }
2880
2881 template <>
2882 inline void SetParamVal<ParamType::TFramebufferID>(gl::FramebufferID valueIn, ParamValue *valueOut)
2883 {
2884 valueOut->FramebufferIDVal = valueIn;
2885 }
2886
2887 template <>
2888 inline void SetParamVal<ParamType::TFramebufferIDConstPointer>(const gl::FramebufferID *valueIn,
2889 ParamValue *valueOut)
2890 {
2891 valueOut->FramebufferIDConstPointerVal = valueIn;
2892 }
2893
2894 template <>
2895 inline void SetParamVal<ParamType::TFramebufferIDPointer>(gl::FramebufferID *valueIn,
2896 ParamValue *valueOut)
2897 {
2898 valueOut->FramebufferIDPointerVal = valueIn;
2899 }
2900
2901 template <>
2902 inline void SetParamVal<ParamType::TGLDEBUGPROC>(GLDEBUGPROC valueIn, ParamValue *valueOut)
2903 {
2904 valueOut->GLDEBUGPROCVal = valueIn;
2905 }
2906
2907 template <>
2908 inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, ParamValue *valueOut)
2909 {
2910 valueOut->GLDEBUGPROCKHRVal = valueIn;
2911 }
2912
2913 template <>
2914 inline void SetParamVal<ParamType::TGLGETBLOBPROCANGLE>(GLGETBLOBPROCANGLE valueIn,
2915 ParamValue *valueOut)
2916 {
2917 valueOut->GLGETBLOBPROCANGLEVal = valueIn;
2918 }
2919
2920 template <>
2921 inline void SetParamVal<ParamType::TGLSETBLOBPROCANGLE>(GLSETBLOBPROCANGLE valueIn,
2922 ParamValue *valueOut)
2923 {
2924 valueOut->GLSETBLOBPROCANGLEVal = valueIn;
2925 }
2926
2927 template <>
2928 inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
2929 {
2930 valueOut->GLbitfieldVal = valueIn;
2931 }
2932
2933 template <>
2934 inline void SetParamVal<ParamType::TGLboolean>(GLboolean valueIn, ParamValue *valueOut)
2935 {
2936 valueOut->GLbooleanVal = valueIn;
2937 }
2938
2939 template <>
2940 inline void SetParamVal<ParamType::TGLbooleanPointer>(GLboolean *valueIn, ParamValue *valueOut)
2941 {
2942 valueOut->GLbooleanPointerVal = valueIn;
2943 }
2944
2945 template <>
2946 inline void SetParamVal<ParamType::TGLcharConstPointer>(const GLchar *valueIn, ParamValue *valueOut)
2947 {
2948 valueOut->GLcharConstPointerVal = valueIn;
2949 }
2950
2951 template <>
2952 inline void SetParamVal<ParamType::TGLcharConstPointerPointer>(const GLchar *const *valueIn,
2953 ParamValue *valueOut)
2954 {
2955 valueOut->GLcharConstPointerPointerVal = valueIn;
2956 }
2957
2958 template <>
2959 inline void SetParamVal<ParamType::TGLcharPointer>(GLchar *valueIn, ParamValue *valueOut)
2960 {
2961 valueOut->GLcharPointerVal = valueIn;
2962 }
2963
2964 template <>
2965 inline void SetParamVal<ParamType::TGLclampx>(GLclampx valueIn, ParamValue *valueOut)
2966 {
2967 valueOut->GLclampxVal = valueIn;
2968 }
2969
2970 template <>
2971 inline void SetParamVal<ParamType::TGLeglClientBufferEXT>(GLeglClientBufferEXT valueIn,
2972 ParamValue *valueOut)
2973 {
2974 valueOut->GLeglClientBufferEXTVal = valueIn;
2975 }
2976
2977 template <>
2978 inline void SetParamVal<ParamType::TGLenum>(GLenum valueIn, ParamValue *valueOut)
2979 {
2980 valueOut->GLenumVal = valueIn;
2981 }
2982
2983 template <>
2984 inline void SetParamVal<ParamType::TGLenumConstPointer>(const GLenum *valueIn, ParamValue *valueOut)
2985 {
2986 valueOut->GLenumConstPointerVal = valueIn;
2987 }
2988
2989 template <>
2990 inline void SetParamVal<ParamType::TGLenumPointer>(GLenum *valueIn, ParamValue *valueOut)
2991 {
2992 valueOut->GLenumPointerVal = valueIn;
2993 }
2994
2995 template <>
2996 inline void SetParamVal<ParamType::TGLfixed>(GLfixed valueIn, ParamValue *valueOut)
2997 {
2998 valueOut->GLfixedVal = valueIn;
2999 }
3000
3001 template <>
3002 inline void SetParamVal<ParamType::TGLfixedConstPointer>(const GLfixed *valueIn,
3003 ParamValue *valueOut)
3004 {
3005 valueOut->GLfixedConstPointerVal = valueIn;
3006 }
3007
3008 template <>
3009 inline void SetParamVal<ParamType::TGLfixedPointer>(GLfixed *valueIn, ParamValue *valueOut)
3010 {
3011 valueOut->GLfixedPointerVal = valueIn;
3012 }
3013
3014 template <>
3015 inline void SetParamVal<ParamType::TGLfloat>(GLfloat valueIn, ParamValue *valueOut)
3016 {
3017 valueOut->GLfloatVal = valueIn;
3018 }
3019
3020 template <>
3021 inline void SetParamVal<ParamType::TGLfloatConstPointer>(const GLfloat *valueIn,
3022 ParamValue *valueOut)
3023 {
3024 valueOut->GLfloatConstPointerVal = valueIn;
3025 }
3026
3027 template <>
3028 inline void SetParamVal<ParamType::TGLfloatPointer>(GLfloat *valueIn, ParamValue *valueOut)
3029 {
3030 valueOut->GLfloatPointerVal = valueIn;
3031 }
3032
3033 template <>
3034 inline void SetParamVal<ParamType::TGLint>(GLint valueIn, ParamValue *valueOut)
3035 {
3036 valueOut->GLintVal = valueIn;
3037 }
3038
3039 template <>
3040 inline void SetParamVal<ParamType::TGLint64>(GLint64 valueIn, ParamValue *valueOut)
3041 {
3042 valueOut->GLint64Val = valueIn;
3043 }
3044
3045 template <>
3046 inline void SetParamVal<ParamType::TGLint64Pointer>(GLint64 *valueIn, ParamValue *valueOut)
3047 {
3048 valueOut->GLint64PointerVal = valueIn;
3049 }
3050
3051 template <>
3052 inline void SetParamVal<ParamType::TGLintConstPointer>(const GLint *valueIn, ParamValue *valueOut)
3053 {
3054 valueOut->GLintConstPointerVal = valueIn;
3055 }
3056
3057 template <>
3058 inline void SetParamVal<ParamType::TGLintPointer>(GLint *valueIn, ParamValue *valueOut)
3059 {
3060 valueOut->GLintPointerVal = valueIn;
3061 }
3062
3063 template <>
3064 inline void SetParamVal<ParamType::TGLintptr>(GLintptr valueIn, ParamValue *valueOut)
3065 {
3066 valueOut->GLintptrVal = valueIn;
3067 }
3068
3069 template <>
3070 inline void SetParamVal<ParamType::TGLshort>(GLshort valueIn, ParamValue *valueOut)
3071 {
3072 valueOut->GLshortVal = valueIn;
3073 }
3074
3075 template <>
3076 inline void SetParamVal<ParamType::TGLshortConstPointer>(const GLshort *valueIn,
3077 ParamValue *valueOut)
3078 {
3079 valueOut->GLshortConstPointerVal = valueIn;
3080 }
3081
3082 template <>
3083 inline void SetParamVal<ParamType::TGLsizei>(GLsizei valueIn, ParamValue *valueOut)
3084 {
3085 valueOut->GLsizeiVal = valueIn;
3086 }
3087
3088 template <>
3089 inline void SetParamVal<ParamType::TGLsizeiConstPointer>(const GLsizei *valueIn,
3090 ParamValue *valueOut)
3091 {
3092 valueOut->GLsizeiConstPointerVal = valueIn;
3093 }
3094
3095 template <>
3096 inline void SetParamVal<ParamType::TGLsizeiPointer>(GLsizei *valueIn, ParamValue *valueOut)
3097 {
3098 valueOut->GLsizeiPointerVal = valueIn;
3099 }
3100
3101 template <>
3102 inline void SetParamVal<ParamType::TGLsizeiptr>(GLsizeiptr valueIn, ParamValue *valueOut)
3103 {
3104 valueOut->GLsizeiptrVal = valueIn;
3105 }
3106
3107 template <>
3108 inline void SetParamVal<ParamType::TGLsync>(GLsync valueIn, ParamValue *valueOut)
3109 {
3110 valueOut->GLsyncVal = valueIn;
3111 }
3112
3113 template <>
3114 inline void SetParamVal<ParamType::TGLubyte>(GLubyte valueIn, ParamValue *valueOut)
3115 {
3116 valueOut->GLubyteVal = valueIn;
3117 }
3118
3119 template <>
3120 inline void SetParamVal<ParamType::TGLubyteConstPointer>(const GLubyte *valueIn,
3121 ParamValue *valueOut)
3122 {
3123 valueOut->GLubyteConstPointerVal = valueIn;
3124 }
3125
3126 template <>
3127 inline void SetParamVal<ParamType::TGLubytePointer>(GLubyte *valueIn, ParamValue *valueOut)
3128 {
3129 valueOut->GLubytePointerVal = valueIn;
3130 }
3131
3132 template <>
3133 inline void SetParamVal<ParamType::TGLuint>(GLuint valueIn, ParamValue *valueOut)
3134 {
3135 valueOut->GLuintVal = valueIn;
3136 }
3137
3138 template <>
3139 inline void SetParamVal<ParamType::TGLuint64>(GLuint64 valueIn, ParamValue *valueOut)
3140 {
3141 valueOut->GLuint64Val = valueIn;
3142 }
3143
3144 template <>
3145 inline void SetParamVal<ParamType::TGLuint64ConstPointer>(const GLuint64 *valueIn,
3146 ParamValue *valueOut)
3147 {
3148 valueOut->GLuint64ConstPointerVal = valueIn;
3149 }
3150
3151 template <>
3152 inline void SetParamVal<ParamType::TGLuint64Pointer>(GLuint64 *valueIn, ParamValue *valueOut)
3153 {
3154 valueOut->GLuint64PointerVal = valueIn;
3155 }
3156
3157 template <>
3158 inline void SetParamVal<ParamType::TGLuintConstPointer>(const GLuint *valueIn, ParamValue *valueOut)
3159 {
3160 valueOut->GLuintConstPointerVal = valueIn;
3161 }
3162
3163 template <>
3164 inline void SetParamVal<ParamType::TGLuintPointer>(GLuint *valueIn, ParamValue *valueOut)
3165 {
3166 valueOut->GLuintPointerVal = valueIn;
3167 }
3168
3169 template <>
3170 inline void SetParamVal<ParamType::TGraphicsResetStatus>(gl::GraphicsResetStatus valueIn,
3171 ParamValue *valueOut)
3172 {
3173 valueOut->GraphicsResetStatusVal = valueIn;
3174 }
3175
3176 template <>
3177 inline void SetParamVal<ParamType::THandleType>(gl::HandleType valueIn, ParamValue *valueOut)
3178 {
3179 valueOut->HandleTypeVal = valueIn;
3180 }
3181
3182 template <>
3183 inline void SetParamVal<ParamType::TImageID>(egl::ImageID valueIn, ParamValue *valueOut)
3184 {
3185 valueOut->ImageIDVal = valueIn;
3186 }
3187
3188 template <>
3189 inline void SetParamVal<ParamType::TLightParameter>(gl::LightParameter valueIn,
3190 ParamValue *valueOut)
3191 {
3192 valueOut->LightParameterVal = valueIn;
3193 }
3194
3195 template <>
3196 inline void SetParamVal<ParamType::TLogicalOperation>(gl::LogicalOperation valueIn,
3197 ParamValue *valueOut)
3198 {
3199 valueOut->LogicalOperationVal = valueIn;
3200 }
3201
3202 template <>
3203 inline void SetParamVal<ParamType::TMaterialParameter>(gl::MaterialParameter valueIn,
3204 ParamValue *valueOut)
3205 {
3206 valueOut->MaterialParameterVal = valueIn;
3207 }
3208
3209 template <>
3210 inline void SetParamVal<ParamType::TMatrixType>(gl::MatrixType valueIn, ParamValue *valueOut)
3211 {
3212 valueOut->MatrixTypeVal = valueIn;
3213 }
3214
3215 template <>
3216 inline void SetParamVal<ParamType::TMemoryObjectID>(gl::MemoryObjectID valueIn,
3217 ParamValue *valueOut)
3218 {
3219 valueOut->MemoryObjectIDVal = valueIn;
3220 }
3221
3222 template <>
3223 inline void SetParamVal<ParamType::TMemoryObjectIDConstPointer>(const gl::MemoryObjectID *valueIn,
3224 ParamValue *valueOut)
3225 {
3226 valueOut->MemoryObjectIDConstPointerVal = valueIn;
3227 }
3228
3229 template <>
3230 inline void SetParamVal<ParamType::TMemoryObjectIDPointer>(gl::MemoryObjectID *valueIn,
3231 ParamValue *valueOut)
3232 {
3233 valueOut->MemoryObjectIDPointerVal = valueIn;
3234 }
3235
3236 template <>
3237 inline void SetParamVal<ParamType::TObjectType>(egl::ObjectType valueIn, ParamValue *valueOut)
3238 {
3239 valueOut->ObjectTypeVal = valueIn;
3240 }
3241
3242 template <>
3243 inline void SetParamVal<ParamType::TPointParameter>(gl::PointParameter valueIn,
3244 ParamValue *valueOut)
3245 {
3246 valueOut->PointParameterVal = valueIn;
3247 }
3248
3249 template <>
3250 inline void SetParamVal<ParamType::TPolygonMode>(gl::PolygonMode valueIn, ParamValue *valueOut)
3251 {
3252 valueOut->PolygonModeVal = valueIn;
3253 }
3254
3255 template <>
3256 inline void SetParamVal<ParamType::TPrimitiveMode>(gl::PrimitiveMode valueIn, ParamValue *valueOut)
3257 {
3258 valueOut->PrimitiveModeVal = valueIn;
3259 }
3260
3261 template <>
3262 inline void SetParamVal<ParamType::TProgramPipelineID>(gl::ProgramPipelineID valueIn,
3263 ParamValue *valueOut)
3264 {
3265 valueOut->ProgramPipelineIDVal = valueIn;
3266 }
3267
3268 template <>
3269 inline void SetParamVal<ParamType::TProgramPipelineIDConstPointer>(
3270 const gl::ProgramPipelineID *valueIn,
3271 ParamValue *valueOut)
3272 {
3273 valueOut->ProgramPipelineIDConstPointerVal = valueIn;
3274 }
3275
3276 template <>
3277 inline void SetParamVal<ParamType::TProgramPipelineIDPointer>(gl::ProgramPipelineID *valueIn,
3278 ParamValue *valueOut)
3279 {
3280 valueOut->ProgramPipelineIDPointerVal = valueIn;
3281 }
3282
3283 template <>
3284 inline void SetParamVal<ParamType::TProvokingVertexConvention>(
3285 gl::ProvokingVertexConvention valueIn,
3286 ParamValue *valueOut)
3287 {
3288 valueOut->ProvokingVertexConventionVal = valueIn;
3289 }
3290
3291 template <>
3292 inline void SetParamVal<ParamType::TQueryID>(gl::QueryID valueIn, ParamValue *valueOut)
3293 {
3294 valueOut->QueryIDVal = valueIn;
3295 }
3296
3297 template <>
3298 inline void SetParamVal<ParamType::TQueryIDConstPointer>(const gl::QueryID *valueIn,
3299 ParamValue *valueOut)
3300 {
3301 valueOut->QueryIDConstPointerVal = valueIn;
3302 }
3303
3304 template <>
3305 inline void SetParamVal<ParamType::TQueryIDPointer>(gl::QueryID *valueIn, ParamValue *valueOut)
3306 {
3307 valueOut->QueryIDPointerVal = valueIn;
3308 }
3309
3310 template <>
3311 inline void SetParamVal<ParamType::TQueryType>(gl::QueryType valueIn, ParamValue *valueOut)
3312 {
3313 valueOut->QueryTypeVal = valueIn;
3314 }
3315
3316 template <>
3317 inline void SetParamVal<ParamType::TRenderbufferID>(gl::RenderbufferID valueIn,
3318 ParamValue *valueOut)
3319 {
3320 valueOut->RenderbufferIDVal = valueIn;
3321 }
3322
3323 template <>
3324 inline void SetParamVal<ParamType::TRenderbufferIDConstPointer>(const gl::RenderbufferID *valueIn,
3325 ParamValue *valueOut)
3326 {
3327 valueOut->RenderbufferIDConstPointerVal = valueIn;
3328 }
3329
3330 template <>
3331 inline void SetParamVal<ParamType::TRenderbufferIDPointer>(gl::RenderbufferID *valueIn,
3332 ParamValue *valueOut)
3333 {
3334 valueOut->RenderbufferIDPointerVal = valueIn;
3335 }
3336
3337 template <>
3338 inline void SetParamVal<ParamType::TSamplerID>(gl::SamplerID valueIn, ParamValue *valueOut)
3339 {
3340 valueOut->SamplerIDVal = valueIn;
3341 }
3342
3343 template <>
3344 inline void SetParamVal<ParamType::TSamplerIDConstPointer>(const gl::SamplerID *valueIn,
3345 ParamValue *valueOut)
3346 {
3347 valueOut->SamplerIDConstPointerVal = valueIn;
3348 }
3349
3350 template <>
3351 inline void SetParamVal<ParamType::TSamplerIDPointer>(gl::SamplerID *valueIn, ParamValue *valueOut)
3352 {
3353 valueOut->SamplerIDPointerVal = valueIn;
3354 }
3355
3356 template <>
3357 inline void SetParamVal<ParamType::TSemaphoreID>(gl::SemaphoreID valueIn, ParamValue *valueOut)
3358 {
3359 valueOut->SemaphoreIDVal = valueIn;
3360 }
3361
3362 template <>
3363 inline void SetParamVal<ParamType::TSemaphoreIDConstPointer>(const gl::SemaphoreID *valueIn,
3364 ParamValue *valueOut)
3365 {
3366 valueOut->SemaphoreIDConstPointerVal = valueIn;
3367 }
3368
3369 template <>
3370 inline void SetParamVal<ParamType::TSemaphoreIDPointer>(gl::SemaphoreID *valueIn,
3371 ParamValue *valueOut)
3372 {
3373 valueOut->SemaphoreIDPointerVal = valueIn;
3374 }
3375
3376 template <>
3377 inline void SetParamVal<ParamType::TShaderProgramID>(gl::ShaderProgramID valueIn,
3378 ParamValue *valueOut)
3379 {
3380 valueOut->ShaderProgramIDVal = valueIn;
3381 }
3382
3383 template <>
3384 inline void SetParamVal<ParamType::TShaderProgramIDConstPointer>(const gl::ShaderProgramID *valueIn,
3385 ParamValue *valueOut)
3386 {
3387 valueOut->ShaderProgramIDConstPointerVal = valueIn;
3388 }
3389
3390 template <>
3391 inline void SetParamVal<ParamType::TShaderProgramIDPointer>(gl::ShaderProgramID *valueIn,
3392 ParamValue *valueOut)
3393 {
3394 valueOut->ShaderProgramIDPointerVal = valueIn;
3395 }
3396
3397 template <>
3398 inline void SetParamVal<ParamType::TShaderType>(gl::ShaderType valueIn, ParamValue *valueOut)
3399 {
3400 valueOut->ShaderTypeVal = valueIn;
3401 }
3402
3403 template <>
3404 inline void SetParamVal<ParamType::TShadingModel>(gl::ShadingModel valueIn, ParamValue *valueOut)
3405 {
3406 valueOut->ShadingModelVal = valueIn;
3407 }
3408
3409 template <>
3410 inline void SetParamVal<ParamType::TSurfaceID>(egl::SurfaceID valueIn, ParamValue *valueOut)
3411 {
3412 valueOut->SurfaceIDVal = valueIn;
3413 }
3414
3415 template <>
3416 inline void SetParamVal<ParamType::TSyncID>(gl::SyncID valueIn, ParamValue *valueOut)
3417 {
3418 valueOut->SyncIDVal = valueIn;
3419 }
3420
3421 template <>
3422 inline void SetParamVal<ParamType::TTextureEnvParameter>(gl::TextureEnvParameter valueIn,
3423 ParamValue *valueOut)
3424 {
3425 valueOut->TextureEnvParameterVal = valueIn;
3426 }
3427
3428 template <>
3429 inline void SetParamVal<ParamType::TTextureEnvTarget>(gl::TextureEnvTarget valueIn,
3430 ParamValue *valueOut)
3431 {
3432 valueOut->TextureEnvTargetVal = valueIn;
3433 }
3434
3435 template <>
3436 inline void SetParamVal<ParamType::TTextureID>(gl::TextureID valueIn, ParamValue *valueOut)
3437 {
3438 valueOut->TextureIDVal = valueIn;
3439 }
3440
3441 template <>
3442 inline void SetParamVal<ParamType::TTextureIDConstPointer>(const gl::TextureID *valueIn,
3443 ParamValue *valueOut)
3444 {
3445 valueOut->TextureIDConstPointerVal = valueIn;
3446 }
3447
3448 template <>
3449 inline void SetParamVal<ParamType::TTextureIDPointer>(gl::TextureID *valueIn, ParamValue *valueOut)
3450 {
3451 valueOut->TextureIDPointerVal = valueIn;
3452 }
3453
3454 template <>
3455 inline void SetParamVal<ParamType::TTextureTarget>(gl::TextureTarget valueIn, ParamValue *valueOut)
3456 {
3457 valueOut->TextureTargetVal = valueIn;
3458 }
3459
3460 template <>
3461 inline void SetParamVal<ParamType::TTextureType>(gl::TextureType valueIn, ParamValue *valueOut)
3462 {
3463 valueOut->TextureTypeVal = valueIn;
3464 }
3465
3466 template <>
3467 inline void SetParamVal<ParamType::TTimestamp>(egl::Timestamp valueIn, ParamValue *valueOut)
3468 {
3469 valueOut->TimestampVal = valueIn;
3470 }
3471
3472 template <>
3473 inline void SetParamVal<ParamType::TTransformFeedbackID>(gl::TransformFeedbackID valueIn,
3474 ParamValue *valueOut)
3475 {
3476 valueOut->TransformFeedbackIDVal = valueIn;
3477 }
3478
3479 template <>
3480 inline void SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(
3481 const gl::TransformFeedbackID *valueIn,
3482 ParamValue *valueOut)
3483 {
3484 valueOut->TransformFeedbackIDConstPointerVal = valueIn;
3485 }
3486
3487 template <>
3488 inline void SetParamVal<ParamType::TTransformFeedbackIDPointer>(gl::TransformFeedbackID *valueIn,
3489 ParamValue *valueOut)
3490 {
3491 valueOut->TransformFeedbackIDPointerVal = valueIn;
3492 }
3493
3494 template <>
3495 inline void SetParamVal<ParamType::TUniformBlockIndex>(gl::UniformBlockIndex valueIn,
3496 ParamValue *valueOut)
3497 {
3498 valueOut->UniformBlockIndexVal = valueIn;
3499 }
3500
3501 template <>
3502 inline void SetParamVal<ParamType::TUniformLocation>(gl::UniformLocation valueIn,
3503 ParamValue *valueOut)
3504 {
3505 valueOut->UniformLocationVal = valueIn;
3506 }
3507
3508 template <>
3509 inline void SetParamVal<ParamType::TVertexArrayID>(gl::VertexArrayID valueIn, ParamValue *valueOut)
3510 {
3511 valueOut->VertexArrayIDVal = valueIn;
3512 }
3513
3514 template <>
3515 inline void SetParamVal<ParamType::TVertexArrayIDConstPointer>(const gl::VertexArrayID *valueIn,
3516 ParamValue *valueOut)
3517 {
3518 valueOut->VertexArrayIDConstPointerVal = valueIn;
3519 }
3520
3521 template <>
3522 inline void SetParamVal<ParamType::TVertexArrayIDPointer>(gl::VertexArrayID *valueIn,
3523 ParamValue *valueOut)
3524 {
3525 valueOut->VertexArrayIDPointerVal = valueIn;
3526 }
3527
3528 template <>
3529 inline void SetParamVal<ParamType::TVertexAttribType>(gl::VertexAttribType valueIn,
3530 ParamValue *valueOut)
3531 {
3532 valueOut->VertexAttribTypeVal = valueIn;
3533 }
3534
3535 template <>
3536 inline void SetParamVal<ParamType::TcharConstPointer>(const char *valueIn, ParamValue *valueOut)
3537 {
3538 valueOut->charConstPointerVal = valueIn;
3539 }
3540
3541 template <>
3542 inline void SetParamVal<ParamType::TcharConstPointerPointer>(const char **valueIn,
3543 ParamValue *valueOut)
3544 {
3545 valueOut->charConstPointerPointerVal = valueIn;
3546 }
3547
3548 template <>
3549 inline void SetParamVal<ParamType::TcharUnsignedConstPointerPointer>(const unsigned char **valueIn,
3550 ParamValue *valueOut)
3551 {
3552 valueOut->charUnsignedConstPointerPointerVal = valueIn;
3553 }
3554
3555 template <>
3556 inline void SetParamVal<ParamType::Tegl_ConfigPointer>(egl::Config *valueIn, ParamValue *valueOut)
3557 {
3558 valueOut->egl_ConfigPointerVal = valueIn;
3559 }
3560
3561 template <>
3562 inline void SetParamVal<ParamType::Tegl_DevicePointer>(egl::Device *valueIn, ParamValue *valueOut)
3563 {
3564 valueOut->egl_DevicePointerVal = valueIn;
3565 }
3566
3567 template <>
3568 inline void SetParamVal<ParamType::Tegl_DisplayPointer>(egl::Display *valueIn, ParamValue *valueOut)
3569 {
3570 valueOut->egl_DisplayPointerVal = valueIn;
3571 }
3572
3573 template <>
3574 inline void SetParamVal<ParamType::Tegl_StreamPointer>(egl::Stream *valueIn, ParamValue *valueOut)
3575 {
3576 valueOut->egl_StreamPointerVal = valueIn;
3577 }
3578
3579 template <>
3580 inline void SetParamVal<ParamType::Tegl_SyncID>(egl::SyncID valueIn, ParamValue *valueOut)
3581 {
3582 valueOut->egl_SyncIDVal = valueIn;
3583 }
3584
3585 template <>
3586 inline void SetParamVal<ParamType::Tsize_t>(size_t valueIn, ParamValue *valueOut)
3587 {
3588 valueOut->size_tVal = valueIn;
3589 }
3590
3591 template <>
3592 inline void SetParamVal<ParamType::Tsize_tConstPointer>(const size_t *valueIn, ParamValue *valueOut)
3593 {
3594 valueOut->size_tConstPointerVal = valueIn;
3595 }
3596
3597 template <>
3598 inline void SetParamVal<ParamType::Tsize_tPointer>(size_t *valueIn, ParamValue *valueOut)
3599 {
3600 valueOut->size_tPointerVal = valueIn;
3601 }
3602
3603 template <>
3604 inline void SetParamVal<ParamType::TvoidConstPointer>(const void *valueIn, ParamValue *valueOut)
3605 {
3606 valueOut->voidConstPointerVal = valueIn;
3607 }
3608
3609 template <>
3610 inline void SetParamVal<ParamType::TvoidConstPointerPointer>(const void **valueIn,
3611 ParamValue *valueOut)
3612 {
3613 valueOut->voidConstPointerPointerVal = valueIn;
3614 }
3615
3616 template <>
3617 inline void SetParamVal<ParamType::TvoidPointer>(void *valueIn, ParamValue *valueOut)
3618 {
3619 valueOut->voidPointerVal = valueIn;
3620 }
3621
3622 template <>
3623 inline void SetParamVal<ParamType::TvoidPointerPointer>(void **valueIn, ParamValue *valueOut)
3624 {
3625 valueOut->voidPointerPointerVal = valueIn;
3626 }
3627
3628 #ifdef ANGLE_ENABLE_CL
3629 template <>
3630 inline void SetParamVal<ParamType::TAddressingMode>(cl::AddressingMode valueIn,
3631 ParamValue *valueOut)
3632 {
3633 valueOut->AddressingModeVal = valueIn;
3634 }
3635
3636 template <>
3637 inline void SetParamVal<ParamType::TCommandQueueInfo>(cl::CommandQueueInfo valueIn,
3638 ParamValue *valueOut)
3639 {
3640 valueOut->CommandQueueInfoVal = valueIn;
3641 }
3642
3643 template <>
3644 inline void SetParamVal<ParamType::TCommandQueueProperties>(cl::CommandQueueProperties valueIn,
3645 ParamValue *valueOut)
3646 {
3647 valueOut->CommandQueuePropertiesVal = valueIn;
3648 }
3649
3650 template <>
3651 inline void SetParamVal<ParamType::TContextInfo>(cl::ContextInfo valueIn, ParamValue *valueOut)
3652 {
3653 valueOut->ContextInfoVal = valueIn;
3654 }
3655
3656 template <>
3657 inline void SetParamVal<ParamType::TDeviceInfo>(cl::DeviceInfo valueIn, ParamValue *valueOut)
3658 {
3659 valueOut->DeviceInfoVal = valueIn;
3660 }
3661
3662 template <>
3663 inline void SetParamVal<ParamType::TDeviceType>(cl::DeviceType valueIn, ParamValue *valueOut)
3664 {
3665 valueOut->DeviceTypeVal = valueIn;
3666 }
3667
3668 template <>
3669 inline void SetParamVal<ParamType::TEventInfo>(cl::EventInfo valueIn, ParamValue *valueOut)
3670 {
3671 valueOut->EventInfoVal = valueIn;
3672 }
3673
3674 template <>
3675 inline void SetParamVal<ParamType::TFilterMode>(cl::FilterMode valueIn, ParamValue *valueOut)
3676 {
3677 valueOut->FilterModeVal = valueIn;
3678 }
3679
3680 template <>
3681 inline void SetParamVal<ParamType::TImageInfo>(cl::ImageInfo valueIn, ParamValue *valueOut)
3682 {
3683 valueOut->ImageInfoVal = valueIn;
3684 }
3685
3686 template <>
3687 inline void SetParamVal<ParamType::TKernelArgInfo>(cl::KernelArgInfo valueIn, ParamValue *valueOut)
3688 {
3689 valueOut->KernelArgInfoVal = valueIn;
3690 }
3691
3692 template <>
3693 inline void SetParamVal<ParamType::TKernelExecInfo>(cl::KernelExecInfo valueIn,
3694 ParamValue *valueOut)
3695 {
3696 valueOut->KernelExecInfoVal = valueIn;
3697 }
3698
3699 template <>
3700 inline void SetParamVal<ParamType::TKernelInfo>(cl::KernelInfo valueIn, ParamValue *valueOut)
3701 {
3702 valueOut->KernelInfoVal = valueIn;
3703 }
3704
3705 template <>
3706 inline void SetParamVal<ParamType::TKernelSubGroupInfo>(cl::KernelSubGroupInfo valueIn,
3707 ParamValue *valueOut)
3708 {
3709 valueOut->KernelSubGroupInfoVal = valueIn;
3710 }
3711
3712 template <>
3713 inline void SetParamVal<ParamType::TKernelWorkGroupInfo>(cl::KernelWorkGroupInfo valueIn,
3714 ParamValue *valueOut)
3715 {
3716 valueOut->KernelWorkGroupInfoVal = valueIn;
3717 }
3718
3719 template <>
3720 inline void SetParamVal<ParamType::TMapFlags>(cl::MapFlags valueIn, ParamValue *valueOut)
3721 {
3722 valueOut->MapFlagsVal = valueIn;
3723 }
3724
3725 template <>
3726 inline void SetParamVal<ParamType::TMemFlags>(cl::MemFlags valueIn, ParamValue *valueOut)
3727 {
3728 valueOut->MemFlagsVal = valueIn;
3729 }
3730
3731 template <>
3732 inline void SetParamVal<ParamType::TMemInfo>(cl::MemInfo valueIn, ParamValue *valueOut)
3733 {
3734 valueOut->MemInfoVal = valueIn;
3735 }
3736
3737 template <>
3738 inline void SetParamVal<ParamType::TMemMigrationFlags>(cl::MemMigrationFlags valueIn,
3739 ParamValue *valueOut)
3740 {
3741 valueOut->MemMigrationFlagsVal = valueIn;
3742 }
3743
3744 template <>
3745 inline void SetParamVal<ParamType::TMemObjectType>(cl::MemObjectType valueIn, ParamValue *valueOut)
3746 {
3747 valueOut->MemObjectTypeVal = valueIn;
3748 }
3749
3750 template <>
3751 inline void SetParamVal<ParamType::TPipeInfo>(cl::PipeInfo valueIn, ParamValue *valueOut)
3752 {
3753 valueOut->PipeInfoVal = valueIn;
3754 }
3755
3756 template <>
3757 inline void SetParamVal<ParamType::TPlatformInfo>(cl::PlatformInfo valueIn, ParamValue *valueOut)
3758 {
3759 valueOut->PlatformInfoVal = valueIn;
3760 }
3761
3762 template <>
3763 inline void SetParamVal<ParamType::TProfilingInfo>(cl::ProfilingInfo valueIn, ParamValue *valueOut)
3764 {
3765 valueOut->ProfilingInfoVal = valueIn;
3766 }
3767
3768 template <>
3769 inline void SetParamVal<ParamType::TProgramBuildInfo>(cl::ProgramBuildInfo valueIn,
3770 ParamValue *valueOut)
3771 {
3772 valueOut->ProgramBuildInfoVal = valueIn;
3773 }
3774
3775 template <>
3776 inline void SetParamVal<ParamType::TProgramInfo>(cl::ProgramInfo valueIn, ParamValue *valueOut)
3777 {
3778 valueOut->ProgramInfoVal = valueIn;
3779 }
3780
3781 template <>
3782 inline void SetParamVal<ParamType::TSVM_MemFlags>(cl::SVM_MemFlags valueIn, ParamValue *valueOut)
3783 {
3784 valueOut->SVM_MemFlagsVal = valueIn;
3785 }
3786
3787 template <>
3788 inline void SetParamVal<ParamType::TSamplerInfo>(cl::SamplerInfo valueIn, ParamValue *valueOut)
3789 {
3790 valueOut->SamplerInfoVal = valueIn;
3791 }
3792
3793 template <>
3794 inline void SetParamVal<ParamType::Tcl_bool>(cl_bool valueIn, ParamValue *valueOut)
3795 {
3796 valueOut->cl_boolVal = valueIn;
3797 }
3798
3799 template <>
3800 inline void SetParamVal<ParamType::Tcl_buffer_create_type>(cl_buffer_create_type valueIn,
3801 ParamValue *valueOut)
3802 {
3803 valueOut->cl_buffer_create_typeVal = valueIn;
3804 }
3805
3806 template <>
3807 inline void SetParamVal<ParamType::Tcl_callback_func_type>(cl_callback_func_type valueIn,
3808 ParamValue *valueOut)
3809 {
3810 valueOut->cl_callback_func_typeVal = valueIn;
3811 }
3812
3813 template <>
3814 inline void SetParamVal<ParamType::Tcl_command_queue>(cl_command_queue valueIn,
3815 ParamValue *valueOut)
3816 {
3817 valueOut->cl_command_queueVal = valueIn;
3818 }
3819
3820 template <>
3821 inline void SetParamVal<ParamType::Tcl_command_queue_propertiesPointer>(
3822 cl_command_queue_properties *valueIn,
3823 ParamValue *valueOut)
3824 {
3825 valueOut->cl_command_queue_propertiesPointerVal = valueIn;
3826 }
3827
3828 template <>
3829 inline void SetParamVal<ParamType::Tcl_context>(cl_context valueIn, ParamValue *valueOut)
3830 {
3831 valueOut->cl_contextVal = valueIn;
3832 }
3833
3834 template <>
3835 inline void SetParamVal<ParamType::Tcl_context_destructor_func_type>(
3836 cl_context_destructor_func_type valueIn,
3837 ParamValue *valueOut)
3838 {
3839 valueOut->cl_context_destructor_func_typeVal = valueIn;
3840 }
3841
3842 template <>
3843 inline void SetParamVal<ParamType::Tcl_context_func_type>(cl_context_func_type valueIn,
3844 ParamValue *valueOut)
3845 {
3846 valueOut->cl_context_func_typeVal = valueIn;
3847 }
3848
3849 template <>
3850 inline void SetParamVal<ParamType::Tcl_context_propertiesConstPointer>(
3851 const cl_context_properties *valueIn,
3852 ParamValue *valueOut)
3853 {
3854 valueOut->cl_context_propertiesConstPointerVal = valueIn;
3855 }
3856
3857 template <>
3858 inline void SetParamVal<ParamType::Tcl_device_id>(cl_device_id valueIn, ParamValue *valueOut)
3859 {
3860 valueOut->cl_device_idVal = valueIn;
3861 }
3862
3863 template <>
3864 inline void SetParamVal<ParamType::Tcl_device_idConstPointer>(const cl_device_id *valueIn,
3865 ParamValue *valueOut)
3866 {
3867 valueOut->cl_device_idConstPointerVal = valueIn;
3868 }
3869
3870 template <>
3871 inline void SetParamVal<ParamType::Tcl_device_idPointer>(cl_device_id *valueIn,
3872 ParamValue *valueOut)
3873 {
3874 valueOut->cl_device_idPointerVal = valueIn;
3875 }
3876
3877 template <>
3878 inline void SetParamVal<ParamType::Tcl_device_partition_propertyConstPointer>(
3879 const cl_device_partition_property *valueIn,
3880 ParamValue *valueOut)
3881 {
3882 valueOut->cl_device_partition_propertyConstPointerVal = valueIn;
3883 }
3884
3885 template <>
3886 inline void SetParamVal<ParamType::Tcl_event>(cl_event valueIn, ParamValue *valueOut)
3887 {
3888 valueOut->cl_eventVal = valueIn;
3889 }
3890
3891 template <>
3892 inline void SetParamVal<ParamType::Tcl_eventConstPointer>(const cl_event *valueIn,
3893 ParamValue *valueOut)
3894 {
3895 valueOut->cl_eventConstPointerVal = valueIn;
3896 }
3897
3898 template <>
3899 inline void SetParamVal<ParamType::Tcl_eventPointer>(cl_event *valueIn, ParamValue *valueOut)
3900 {
3901 valueOut->cl_eventPointerVal = valueIn;
3902 }
3903
3904 template <>
3905 inline void SetParamVal<ParamType::Tcl_image_descConstPointer>(const cl_image_desc *valueIn,
3906 ParamValue *valueOut)
3907 {
3908 valueOut->cl_image_descConstPointerVal = valueIn;
3909 }
3910
3911 template <>
3912 inline void SetParamVal<ParamType::Tcl_image_formatConstPointer>(const cl_image_format *valueIn,
3913 ParamValue *valueOut)
3914 {
3915 valueOut->cl_image_formatConstPointerVal = valueIn;
3916 }
3917
3918 template <>
3919 inline void SetParamVal<ParamType::Tcl_image_formatPointer>(cl_image_format *valueIn,
3920 ParamValue *valueOut)
3921 {
3922 valueOut->cl_image_formatPointerVal = valueIn;
3923 }
3924
3925 template <>
3926 inline void SetParamVal<ParamType::Tcl_int>(cl_int valueIn, ParamValue *valueOut)
3927 {
3928 valueOut->cl_intVal = valueIn;
3929 }
3930
3931 template <>
3932 inline void SetParamVal<ParamType::Tcl_intPointer>(cl_int *valueIn, ParamValue *valueOut)
3933 {
3934 valueOut->cl_intPointerVal = valueIn;
3935 }
3936
3937 template <>
3938 inline void SetParamVal<ParamType::Tcl_kernel>(cl_kernel valueIn, ParamValue *valueOut)
3939 {
3940 valueOut->cl_kernelVal = valueIn;
3941 }
3942
3943 template <>
3944 inline void SetParamVal<ParamType::Tcl_kernelPointer>(cl_kernel *valueIn, ParamValue *valueOut)
3945 {
3946 valueOut->cl_kernelPointerVal = valueIn;
3947 }
3948
3949 template <>
3950 inline void SetParamVal<ParamType::Tcl_mem>(cl_mem valueIn, ParamValue *valueOut)
3951 {
3952 valueOut->cl_memVal = valueIn;
3953 }
3954
3955 template <>
3956 inline void SetParamVal<ParamType::Tcl_memConstPointer>(const cl_mem *valueIn, ParamValue *valueOut)
3957 {
3958 valueOut->cl_memConstPointerVal = valueIn;
3959 }
3960
3961 template <>
3962 inline void SetParamVal<ParamType::Tcl_mem_destructor_func_type>(
3963 cl_mem_destructor_func_type valueIn,
3964 ParamValue *valueOut)
3965 {
3966 valueOut->cl_mem_destructor_func_typeVal = valueIn;
3967 }
3968
3969 template <>
3970 inline void SetParamVal<ParamType::Tcl_mem_propertiesConstPointer>(const cl_mem_properties *valueIn,
3971 ParamValue *valueOut)
3972 {
3973 valueOut->cl_mem_propertiesConstPointerVal = valueIn;
3974 }
3975
3976 template <>
3977 inline void SetParamVal<ParamType::Tcl_pipe_propertiesConstPointer>(
3978 const cl_pipe_properties *valueIn,
3979 ParamValue *valueOut)
3980 {
3981 valueOut->cl_pipe_propertiesConstPointerVal = valueIn;
3982 }
3983
3984 template <>
3985 inline void SetParamVal<ParamType::Tcl_platform_id>(cl_platform_id valueIn, ParamValue *valueOut)
3986 {
3987 valueOut->cl_platform_idVal = valueIn;
3988 }
3989
3990 template <>
3991 inline void SetParamVal<ParamType::Tcl_platform_idPointer>(cl_platform_id *valueIn,
3992 ParamValue *valueOut)
3993 {
3994 valueOut->cl_platform_idPointerVal = valueIn;
3995 }
3996
3997 template <>
3998 inline void SetParamVal<ParamType::Tcl_program>(cl_program valueIn, ParamValue *valueOut)
3999 {
4000 valueOut->cl_programVal = valueIn;
4001 }
4002
4003 template <>
4004 inline void SetParamVal<ParamType::Tcl_programConstPointer>(const cl_program *valueIn,
4005 ParamValue *valueOut)
4006 {
4007 valueOut->cl_programConstPointerVal = valueIn;
4008 }
4009
4010 template <>
4011 inline void SetParamVal<ParamType::Tcl_program_func_type>(cl_program_func_type valueIn,
4012 ParamValue *valueOut)
4013 {
4014 valueOut->cl_program_func_typeVal = valueIn;
4015 }
4016
4017 template <>
4018 inline void SetParamVal<ParamType::Tcl_queue_propertiesConstPointer>(
4019 const cl_queue_properties *valueIn,
4020 ParamValue *valueOut)
4021 {
4022 valueOut->cl_queue_propertiesConstPointerVal = valueIn;
4023 }
4024
4025 template <>
4026 inline void SetParamVal<ParamType::Tcl_sampler>(cl_sampler valueIn, ParamValue *valueOut)
4027 {
4028 valueOut->cl_samplerVal = valueIn;
4029 }
4030
4031 template <>
4032 inline void SetParamVal<ParamType::Tcl_sampler_propertiesConstPointer>(
4033 const cl_sampler_properties *valueIn,
4034 ParamValue *valueOut)
4035 {
4036 valueOut->cl_sampler_propertiesConstPointerVal = valueIn;
4037 }
4038
4039 template <>
4040 inline void SetParamVal<ParamType::Tcl_svm_free_callback_func_type>(
4041 cl_svm_free_callback_func_type valueIn,
4042 ParamValue *valueOut)
4043 {
4044 valueOut->cl_svm_free_callback_func_typeVal = valueIn;
4045 }
4046
4047 template <>
4048 inline void SetParamVal<ParamType::Tcl_uint>(cl_uint valueIn, ParamValue *valueOut)
4049 {
4050 valueOut->cl_uintVal = valueIn;
4051 }
4052
4053 template <>
4054 inline void SetParamVal<ParamType::Tcl_uintPointer>(cl_uint *valueIn, ParamValue *valueOut)
4055 {
4056 valueOut->cl_uintPointerVal = valueIn;
4057 }
4058
4059 template <>
4060 inline void SetParamVal<ParamType::Tcl_ulongPointer>(cl_ulong *valueIn, ParamValue *valueOut)
4061 {
4062 valueOut->cl_ulongPointerVal = valueIn;
4063 }
4064
4065 template <>
4066 inline void SetParamVal<ParamType::Tcl_void_func_type>(cl_void_func_type valueIn,
4067 ParamValue *valueOut)
4068 {
4069 valueOut->cl_void_func_typeVal = valueIn;
4070 }
4071 #endif
4072
4073 template <ParamType PType, typename T>
SetParamVal(T valueIn,ParamValue * valueOut)4074 void SetParamVal(T valueIn, ParamValue *valueOut)
4075 {
4076 UNREACHABLE();
4077 }
4078
4079 template <typename T>
InitParamValue(ParamType paramType,T valueIn,ParamValue * valueOut)4080 void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
4081 {
4082 switch (paramType)
4083 {
4084 case ParamType::TAHardwareBufferConstPointer:
4085 SetParamVal<ParamType::TAHardwareBufferConstPointer>(valueIn, valueOut);
4086 break;
4087 case ParamType::TAddressingMode:
4088 SetParamVal<ParamType::TAddressingMode>(valueIn, valueOut);
4089 break;
4090 case ParamType::TAlphaTestFunc:
4091 SetParamVal<ParamType::TAlphaTestFunc>(valueIn, valueOut);
4092 break;
4093 case ParamType::TBufferBinding:
4094 SetParamVal<ParamType::TBufferBinding>(valueIn, valueOut);
4095 break;
4096 case ParamType::TBufferID:
4097 SetParamVal<ParamType::TBufferID>(valueIn, valueOut);
4098 break;
4099 case ParamType::TBufferIDConstPointer:
4100 SetParamVal<ParamType::TBufferIDConstPointer>(valueIn, valueOut);
4101 break;
4102 case ParamType::TBufferIDPointer:
4103 SetParamVal<ParamType::TBufferIDPointer>(valueIn, valueOut);
4104 break;
4105 case ParamType::TBufferUsage:
4106 SetParamVal<ParamType::TBufferUsage>(valueIn, valueOut);
4107 break;
4108 case ParamType::TClientVertexArrayType:
4109 SetParamVal<ParamType::TClientVertexArrayType>(valueIn, valueOut);
4110 break;
4111 case ParamType::TClipDepthMode:
4112 SetParamVal<ParamType::TClipDepthMode>(valueIn, valueOut);
4113 break;
4114 case ParamType::TClipOrigin:
4115 SetParamVal<ParamType::TClipOrigin>(valueIn, valueOut);
4116 break;
4117 case ParamType::TCommandQueueInfo:
4118 SetParamVal<ParamType::TCommandQueueInfo>(valueIn, valueOut);
4119 break;
4120 case ParamType::TCommandQueueProperties:
4121 SetParamVal<ParamType::TCommandQueueProperties>(valueIn, valueOut);
4122 break;
4123 case ParamType::TCompositorTiming:
4124 SetParamVal<ParamType::TCompositorTiming>(valueIn, valueOut);
4125 break;
4126 case ParamType::TContextID:
4127 SetParamVal<ParamType::TContextID>(valueIn, valueOut);
4128 break;
4129 case ParamType::TContextInfo:
4130 SetParamVal<ParamType::TContextInfo>(valueIn, valueOut);
4131 break;
4132 case ParamType::TCullFaceMode:
4133 SetParamVal<ParamType::TCullFaceMode>(valueIn, valueOut);
4134 break;
4135 case ParamType::TDeviceInfo:
4136 SetParamVal<ParamType::TDeviceInfo>(valueIn, valueOut);
4137 break;
4138 case ParamType::TDeviceType:
4139 SetParamVal<ParamType::TDeviceType>(valueIn, valueOut);
4140 break;
4141 case ParamType::TDrawElementsType:
4142 SetParamVal<ParamType::TDrawElementsType>(valueIn, valueOut);
4143 break;
4144 case ParamType::TEGLAttribConstPointer:
4145 SetParamVal<ParamType::TEGLAttribConstPointer>(valueIn, valueOut);
4146 break;
4147 case ParamType::TEGLAttribKHRPointer:
4148 SetParamVal<ParamType::TEGLAttribKHRPointer>(valueIn, valueOut);
4149 break;
4150 case ParamType::TEGLAttribPointer:
4151 SetParamVal<ParamType::TEGLAttribPointer>(valueIn, valueOut);
4152 break;
4153 case ParamType::TEGLBoolean:
4154 SetParamVal<ParamType::TEGLBoolean>(valueIn, valueOut);
4155 break;
4156 case ParamType::TEGLBooleanPointer:
4157 SetParamVal<ParamType::TEGLBooleanPointer>(valueIn, valueOut);
4158 break;
4159 case ParamType::TEGLClientBuffer:
4160 SetParamVal<ParamType::TEGLClientBuffer>(valueIn, valueOut);
4161 break;
4162 case ParamType::TEGLConfigPointer:
4163 SetParamVal<ParamType::TEGLConfigPointer>(valueIn, valueOut);
4164 break;
4165 case ParamType::TEGLContext:
4166 SetParamVal<ParamType::TEGLContext>(valueIn, valueOut);
4167 break;
4168 case ParamType::TEGLDEBUGPROCKHR:
4169 SetParamVal<ParamType::TEGLDEBUGPROCKHR>(valueIn, valueOut);
4170 break;
4171 case ParamType::TEGLDeviceEXT:
4172 SetParamVal<ParamType::TEGLDeviceEXT>(valueIn, valueOut);
4173 break;
4174 case ParamType::TEGLDisplay:
4175 SetParamVal<ParamType::TEGLDisplay>(valueIn, valueOut);
4176 break;
4177 case ParamType::TEGLGetBlobFuncANDROID:
4178 SetParamVal<ParamType::TEGLGetBlobFuncANDROID>(valueIn, valueOut);
4179 break;
4180 case ParamType::TEGLImage:
4181 SetParamVal<ParamType::TEGLImage>(valueIn, valueOut);
4182 break;
4183 case ParamType::TEGLImageKHR:
4184 SetParamVal<ParamType::TEGLImageKHR>(valueIn, valueOut);
4185 break;
4186 case ParamType::TEGLLabelKHR:
4187 SetParamVal<ParamType::TEGLLabelKHR>(valueIn, valueOut);
4188 break;
4189 case ParamType::TEGLNativeDisplayType:
4190 SetParamVal<ParamType::TEGLNativeDisplayType>(valueIn, valueOut);
4191 break;
4192 case ParamType::TEGLNativePixmapType:
4193 SetParamVal<ParamType::TEGLNativePixmapType>(valueIn, valueOut);
4194 break;
4195 case ParamType::TEGLNativeWindowType:
4196 SetParamVal<ParamType::TEGLNativeWindowType>(valueIn, valueOut);
4197 break;
4198 case ParamType::TEGLObjectKHR:
4199 SetParamVal<ParamType::TEGLObjectKHR>(valueIn, valueOut);
4200 break;
4201 case ParamType::TEGLSetBlobFuncANDROID:
4202 SetParamVal<ParamType::TEGLSetBlobFuncANDROID>(valueIn, valueOut);
4203 break;
4204 case ParamType::TEGLStreamKHR:
4205 SetParamVal<ParamType::TEGLStreamKHR>(valueIn, valueOut);
4206 break;
4207 case ParamType::TEGLSurface:
4208 SetParamVal<ParamType::TEGLSurface>(valueIn, valueOut);
4209 break;
4210 case ParamType::TEGLSync:
4211 SetParamVal<ParamType::TEGLSync>(valueIn, valueOut);
4212 break;
4213 case ParamType::TEGLSyncKHR:
4214 SetParamVal<ParamType::TEGLSyncKHR>(valueIn, valueOut);
4215 break;
4216 case ParamType::TEGLTime:
4217 SetParamVal<ParamType::TEGLTime>(valueIn, valueOut);
4218 break;
4219 case ParamType::TEGLTimeKHR:
4220 SetParamVal<ParamType::TEGLTimeKHR>(valueIn, valueOut);
4221 break;
4222 case ParamType::TEGLenum:
4223 SetParamVal<ParamType::TEGLenum>(valueIn, valueOut);
4224 break;
4225 case ParamType::TEGLint:
4226 SetParamVal<ParamType::TEGLint>(valueIn, valueOut);
4227 break;
4228 case ParamType::TEGLintConstPointer:
4229 SetParamVal<ParamType::TEGLintConstPointer>(valueIn, valueOut);
4230 break;
4231 case ParamType::TEGLintPointer:
4232 SetParamVal<ParamType::TEGLintPointer>(valueIn, valueOut);
4233 break;
4234 case ParamType::TEGLnsecsANDROID:
4235 SetParamVal<ParamType::TEGLnsecsANDROID>(valueIn, valueOut);
4236 break;
4237 case ParamType::TEGLnsecsANDROIDPointer:
4238 SetParamVal<ParamType::TEGLnsecsANDROIDPointer>(valueIn, valueOut);
4239 break;
4240 case ParamType::TEGLuint64KHR:
4241 SetParamVal<ParamType::TEGLuint64KHR>(valueIn, valueOut);
4242 break;
4243 case ParamType::TEGLuint64KHRPointer:
4244 SetParamVal<ParamType::TEGLuint64KHRPointer>(valueIn, valueOut);
4245 break;
4246 case ParamType::TEventInfo:
4247 SetParamVal<ParamType::TEventInfo>(valueIn, valueOut);
4248 break;
4249 case ParamType::TFenceNVID:
4250 SetParamVal<ParamType::TFenceNVID>(valueIn, valueOut);
4251 break;
4252 case ParamType::TFenceNVIDConstPointer:
4253 SetParamVal<ParamType::TFenceNVIDConstPointer>(valueIn, valueOut);
4254 break;
4255 case ParamType::TFenceNVIDPointer:
4256 SetParamVal<ParamType::TFenceNVIDPointer>(valueIn, valueOut);
4257 break;
4258 case ParamType::TFilterMode:
4259 SetParamVal<ParamType::TFilterMode>(valueIn, valueOut);
4260 break;
4261 case ParamType::TFramebufferID:
4262 SetParamVal<ParamType::TFramebufferID>(valueIn, valueOut);
4263 break;
4264 case ParamType::TFramebufferIDConstPointer:
4265 SetParamVal<ParamType::TFramebufferIDConstPointer>(valueIn, valueOut);
4266 break;
4267 case ParamType::TFramebufferIDPointer:
4268 SetParamVal<ParamType::TFramebufferIDPointer>(valueIn, valueOut);
4269 break;
4270 case ParamType::TGLDEBUGPROC:
4271 SetParamVal<ParamType::TGLDEBUGPROC>(valueIn, valueOut);
4272 break;
4273 case ParamType::TGLDEBUGPROCKHR:
4274 SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
4275 break;
4276 case ParamType::TGLGETBLOBPROCANGLE:
4277 SetParamVal<ParamType::TGLGETBLOBPROCANGLE>(valueIn, valueOut);
4278 break;
4279 case ParamType::TGLSETBLOBPROCANGLE:
4280 SetParamVal<ParamType::TGLSETBLOBPROCANGLE>(valueIn, valueOut);
4281 break;
4282 case ParamType::TGLbitfield:
4283 SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
4284 break;
4285 case ParamType::TGLboolean:
4286 SetParamVal<ParamType::TGLboolean>(valueIn, valueOut);
4287 break;
4288 case ParamType::TGLbooleanPointer:
4289 SetParamVal<ParamType::TGLbooleanPointer>(valueIn, valueOut);
4290 break;
4291 case ParamType::TGLcharConstPointer:
4292 SetParamVal<ParamType::TGLcharConstPointer>(valueIn, valueOut);
4293 break;
4294 case ParamType::TGLcharConstPointerPointer:
4295 SetParamVal<ParamType::TGLcharConstPointerPointer>(valueIn, valueOut);
4296 break;
4297 case ParamType::TGLcharPointer:
4298 SetParamVal<ParamType::TGLcharPointer>(valueIn, valueOut);
4299 break;
4300 case ParamType::TGLclampx:
4301 SetParamVal<ParamType::TGLclampx>(valueIn, valueOut);
4302 break;
4303 case ParamType::TGLeglClientBufferEXT:
4304 SetParamVal<ParamType::TGLeglClientBufferEXT>(valueIn, valueOut);
4305 break;
4306 case ParamType::TGLenum:
4307 SetParamVal<ParamType::TGLenum>(valueIn, valueOut);
4308 break;
4309 case ParamType::TGLenumConstPointer:
4310 SetParamVal<ParamType::TGLenumConstPointer>(valueIn, valueOut);
4311 break;
4312 case ParamType::TGLenumPointer:
4313 SetParamVal<ParamType::TGLenumPointer>(valueIn, valueOut);
4314 break;
4315 case ParamType::TGLfixed:
4316 SetParamVal<ParamType::TGLfixed>(valueIn, valueOut);
4317 break;
4318 case ParamType::TGLfixedConstPointer:
4319 SetParamVal<ParamType::TGLfixedConstPointer>(valueIn, valueOut);
4320 break;
4321 case ParamType::TGLfixedPointer:
4322 SetParamVal<ParamType::TGLfixedPointer>(valueIn, valueOut);
4323 break;
4324 case ParamType::TGLfloat:
4325 SetParamVal<ParamType::TGLfloat>(valueIn, valueOut);
4326 break;
4327 case ParamType::TGLfloatConstPointer:
4328 SetParamVal<ParamType::TGLfloatConstPointer>(valueIn, valueOut);
4329 break;
4330 case ParamType::TGLfloatPointer:
4331 SetParamVal<ParamType::TGLfloatPointer>(valueIn, valueOut);
4332 break;
4333 case ParamType::TGLint:
4334 SetParamVal<ParamType::TGLint>(valueIn, valueOut);
4335 break;
4336 case ParamType::TGLint64:
4337 SetParamVal<ParamType::TGLint64>(valueIn, valueOut);
4338 break;
4339 case ParamType::TGLint64Pointer:
4340 SetParamVal<ParamType::TGLint64Pointer>(valueIn, valueOut);
4341 break;
4342 case ParamType::TGLintConstPointer:
4343 SetParamVal<ParamType::TGLintConstPointer>(valueIn, valueOut);
4344 break;
4345 case ParamType::TGLintPointer:
4346 SetParamVal<ParamType::TGLintPointer>(valueIn, valueOut);
4347 break;
4348 case ParamType::TGLintptr:
4349 SetParamVal<ParamType::TGLintptr>(valueIn, valueOut);
4350 break;
4351 case ParamType::TGLshort:
4352 SetParamVal<ParamType::TGLshort>(valueIn, valueOut);
4353 break;
4354 case ParamType::TGLshortConstPointer:
4355 SetParamVal<ParamType::TGLshortConstPointer>(valueIn, valueOut);
4356 break;
4357 case ParamType::TGLsizei:
4358 SetParamVal<ParamType::TGLsizei>(valueIn, valueOut);
4359 break;
4360 case ParamType::TGLsizeiConstPointer:
4361 SetParamVal<ParamType::TGLsizeiConstPointer>(valueIn, valueOut);
4362 break;
4363 case ParamType::TGLsizeiPointer:
4364 SetParamVal<ParamType::TGLsizeiPointer>(valueIn, valueOut);
4365 break;
4366 case ParamType::TGLsizeiptr:
4367 SetParamVal<ParamType::TGLsizeiptr>(valueIn, valueOut);
4368 break;
4369 case ParamType::TGLsync:
4370 SetParamVal<ParamType::TGLsync>(valueIn, valueOut);
4371 break;
4372 case ParamType::TGLubyte:
4373 SetParamVal<ParamType::TGLubyte>(valueIn, valueOut);
4374 break;
4375 case ParamType::TGLubyteConstPointer:
4376 SetParamVal<ParamType::TGLubyteConstPointer>(valueIn, valueOut);
4377 break;
4378 case ParamType::TGLubytePointer:
4379 SetParamVal<ParamType::TGLubytePointer>(valueIn, valueOut);
4380 break;
4381 case ParamType::TGLuint:
4382 SetParamVal<ParamType::TGLuint>(valueIn, valueOut);
4383 break;
4384 case ParamType::TGLuint64:
4385 SetParamVal<ParamType::TGLuint64>(valueIn, valueOut);
4386 break;
4387 case ParamType::TGLuint64ConstPointer:
4388 SetParamVal<ParamType::TGLuint64ConstPointer>(valueIn, valueOut);
4389 break;
4390 case ParamType::TGLuint64Pointer:
4391 SetParamVal<ParamType::TGLuint64Pointer>(valueIn, valueOut);
4392 break;
4393 case ParamType::TGLuintConstPointer:
4394 SetParamVal<ParamType::TGLuintConstPointer>(valueIn, valueOut);
4395 break;
4396 case ParamType::TGLuintPointer:
4397 SetParamVal<ParamType::TGLuintPointer>(valueIn, valueOut);
4398 break;
4399 case ParamType::TGraphicsResetStatus:
4400 SetParamVal<ParamType::TGraphicsResetStatus>(valueIn, valueOut);
4401 break;
4402 case ParamType::THandleType:
4403 SetParamVal<ParamType::THandleType>(valueIn, valueOut);
4404 break;
4405 case ParamType::TImageID:
4406 SetParamVal<ParamType::TImageID>(valueIn, valueOut);
4407 break;
4408 case ParamType::TImageInfo:
4409 SetParamVal<ParamType::TImageInfo>(valueIn, valueOut);
4410 break;
4411 case ParamType::TKernelArgInfo:
4412 SetParamVal<ParamType::TKernelArgInfo>(valueIn, valueOut);
4413 break;
4414 case ParamType::TKernelExecInfo:
4415 SetParamVal<ParamType::TKernelExecInfo>(valueIn, valueOut);
4416 break;
4417 case ParamType::TKernelInfo:
4418 SetParamVal<ParamType::TKernelInfo>(valueIn, valueOut);
4419 break;
4420 case ParamType::TKernelSubGroupInfo:
4421 SetParamVal<ParamType::TKernelSubGroupInfo>(valueIn, valueOut);
4422 break;
4423 case ParamType::TKernelWorkGroupInfo:
4424 SetParamVal<ParamType::TKernelWorkGroupInfo>(valueIn, valueOut);
4425 break;
4426 case ParamType::TLightParameter:
4427 SetParamVal<ParamType::TLightParameter>(valueIn, valueOut);
4428 break;
4429 case ParamType::TLogicalOperation:
4430 SetParamVal<ParamType::TLogicalOperation>(valueIn, valueOut);
4431 break;
4432 case ParamType::TMapFlags:
4433 SetParamVal<ParamType::TMapFlags>(valueIn, valueOut);
4434 break;
4435 case ParamType::TMaterialParameter:
4436 SetParamVal<ParamType::TMaterialParameter>(valueIn, valueOut);
4437 break;
4438 case ParamType::TMatrixType:
4439 SetParamVal<ParamType::TMatrixType>(valueIn, valueOut);
4440 break;
4441 case ParamType::TMemFlags:
4442 SetParamVal<ParamType::TMemFlags>(valueIn, valueOut);
4443 break;
4444 case ParamType::TMemInfo:
4445 SetParamVal<ParamType::TMemInfo>(valueIn, valueOut);
4446 break;
4447 case ParamType::TMemMigrationFlags:
4448 SetParamVal<ParamType::TMemMigrationFlags>(valueIn, valueOut);
4449 break;
4450 case ParamType::TMemObjectType:
4451 SetParamVal<ParamType::TMemObjectType>(valueIn, valueOut);
4452 break;
4453 case ParamType::TMemoryObjectID:
4454 SetParamVal<ParamType::TMemoryObjectID>(valueIn, valueOut);
4455 break;
4456 case ParamType::TMemoryObjectIDConstPointer:
4457 SetParamVal<ParamType::TMemoryObjectIDConstPointer>(valueIn, valueOut);
4458 break;
4459 case ParamType::TMemoryObjectIDPointer:
4460 SetParamVal<ParamType::TMemoryObjectIDPointer>(valueIn, valueOut);
4461 break;
4462 case ParamType::TObjectType:
4463 SetParamVal<ParamType::TObjectType>(valueIn, valueOut);
4464 break;
4465 case ParamType::TPipeInfo:
4466 SetParamVal<ParamType::TPipeInfo>(valueIn, valueOut);
4467 break;
4468 case ParamType::TPlatformInfo:
4469 SetParamVal<ParamType::TPlatformInfo>(valueIn, valueOut);
4470 break;
4471 case ParamType::TPointParameter:
4472 SetParamVal<ParamType::TPointParameter>(valueIn, valueOut);
4473 break;
4474 case ParamType::TPolygonMode:
4475 SetParamVal<ParamType::TPolygonMode>(valueIn, valueOut);
4476 break;
4477 case ParamType::TPrimitiveMode:
4478 SetParamVal<ParamType::TPrimitiveMode>(valueIn, valueOut);
4479 break;
4480 case ParamType::TProfilingInfo:
4481 SetParamVal<ParamType::TProfilingInfo>(valueIn, valueOut);
4482 break;
4483 case ParamType::TProgramBuildInfo:
4484 SetParamVal<ParamType::TProgramBuildInfo>(valueIn, valueOut);
4485 break;
4486 case ParamType::TProgramInfo:
4487 SetParamVal<ParamType::TProgramInfo>(valueIn, valueOut);
4488 break;
4489 case ParamType::TProgramPipelineID:
4490 SetParamVal<ParamType::TProgramPipelineID>(valueIn, valueOut);
4491 break;
4492 case ParamType::TProgramPipelineIDConstPointer:
4493 SetParamVal<ParamType::TProgramPipelineIDConstPointer>(valueIn, valueOut);
4494 break;
4495 case ParamType::TProgramPipelineIDPointer:
4496 SetParamVal<ParamType::TProgramPipelineIDPointer>(valueIn, valueOut);
4497 break;
4498 case ParamType::TProvokingVertexConvention:
4499 SetParamVal<ParamType::TProvokingVertexConvention>(valueIn, valueOut);
4500 break;
4501 case ParamType::TQueryID:
4502 SetParamVal<ParamType::TQueryID>(valueIn, valueOut);
4503 break;
4504 case ParamType::TQueryIDConstPointer:
4505 SetParamVal<ParamType::TQueryIDConstPointer>(valueIn, valueOut);
4506 break;
4507 case ParamType::TQueryIDPointer:
4508 SetParamVal<ParamType::TQueryIDPointer>(valueIn, valueOut);
4509 break;
4510 case ParamType::TQueryType:
4511 SetParamVal<ParamType::TQueryType>(valueIn, valueOut);
4512 break;
4513 case ParamType::TRenderbufferID:
4514 SetParamVal<ParamType::TRenderbufferID>(valueIn, valueOut);
4515 break;
4516 case ParamType::TRenderbufferIDConstPointer:
4517 SetParamVal<ParamType::TRenderbufferIDConstPointer>(valueIn, valueOut);
4518 break;
4519 case ParamType::TRenderbufferIDPointer:
4520 SetParamVal<ParamType::TRenderbufferIDPointer>(valueIn, valueOut);
4521 break;
4522 case ParamType::TSVM_MemFlags:
4523 SetParamVal<ParamType::TSVM_MemFlags>(valueIn, valueOut);
4524 break;
4525 case ParamType::TSamplerID:
4526 SetParamVal<ParamType::TSamplerID>(valueIn, valueOut);
4527 break;
4528 case ParamType::TSamplerIDConstPointer:
4529 SetParamVal<ParamType::TSamplerIDConstPointer>(valueIn, valueOut);
4530 break;
4531 case ParamType::TSamplerIDPointer:
4532 SetParamVal<ParamType::TSamplerIDPointer>(valueIn, valueOut);
4533 break;
4534 case ParamType::TSamplerInfo:
4535 SetParamVal<ParamType::TSamplerInfo>(valueIn, valueOut);
4536 break;
4537 case ParamType::TSemaphoreID:
4538 SetParamVal<ParamType::TSemaphoreID>(valueIn, valueOut);
4539 break;
4540 case ParamType::TSemaphoreIDConstPointer:
4541 SetParamVal<ParamType::TSemaphoreIDConstPointer>(valueIn, valueOut);
4542 break;
4543 case ParamType::TSemaphoreIDPointer:
4544 SetParamVal<ParamType::TSemaphoreIDPointer>(valueIn, valueOut);
4545 break;
4546 case ParamType::TShaderProgramID:
4547 SetParamVal<ParamType::TShaderProgramID>(valueIn, valueOut);
4548 break;
4549 case ParamType::TShaderProgramIDConstPointer:
4550 SetParamVal<ParamType::TShaderProgramIDConstPointer>(valueIn, valueOut);
4551 break;
4552 case ParamType::TShaderProgramIDPointer:
4553 SetParamVal<ParamType::TShaderProgramIDPointer>(valueIn, valueOut);
4554 break;
4555 case ParamType::TShaderType:
4556 SetParamVal<ParamType::TShaderType>(valueIn, valueOut);
4557 break;
4558 case ParamType::TShadingModel:
4559 SetParamVal<ParamType::TShadingModel>(valueIn, valueOut);
4560 break;
4561 case ParamType::TSurfaceID:
4562 SetParamVal<ParamType::TSurfaceID>(valueIn, valueOut);
4563 break;
4564 case ParamType::TSyncID:
4565 SetParamVal<ParamType::TSyncID>(valueIn, valueOut);
4566 break;
4567 case ParamType::TTextureEnvParameter:
4568 SetParamVal<ParamType::TTextureEnvParameter>(valueIn, valueOut);
4569 break;
4570 case ParamType::TTextureEnvTarget:
4571 SetParamVal<ParamType::TTextureEnvTarget>(valueIn, valueOut);
4572 break;
4573 case ParamType::TTextureID:
4574 SetParamVal<ParamType::TTextureID>(valueIn, valueOut);
4575 break;
4576 case ParamType::TTextureIDConstPointer:
4577 SetParamVal<ParamType::TTextureIDConstPointer>(valueIn, valueOut);
4578 break;
4579 case ParamType::TTextureIDPointer:
4580 SetParamVal<ParamType::TTextureIDPointer>(valueIn, valueOut);
4581 break;
4582 case ParamType::TTextureTarget:
4583 SetParamVal<ParamType::TTextureTarget>(valueIn, valueOut);
4584 break;
4585 case ParamType::TTextureType:
4586 SetParamVal<ParamType::TTextureType>(valueIn, valueOut);
4587 break;
4588 case ParamType::TTimestamp:
4589 SetParamVal<ParamType::TTimestamp>(valueIn, valueOut);
4590 break;
4591 case ParamType::TTransformFeedbackID:
4592 SetParamVal<ParamType::TTransformFeedbackID>(valueIn, valueOut);
4593 break;
4594 case ParamType::TTransformFeedbackIDConstPointer:
4595 SetParamVal<ParamType::TTransformFeedbackIDConstPointer>(valueIn, valueOut);
4596 break;
4597 case ParamType::TTransformFeedbackIDPointer:
4598 SetParamVal<ParamType::TTransformFeedbackIDPointer>(valueIn, valueOut);
4599 break;
4600 case ParamType::TUniformBlockIndex:
4601 SetParamVal<ParamType::TUniformBlockIndex>(valueIn, valueOut);
4602 break;
4603 case ParamType::TUniformLocation:
4604 SetParamVal<ParamType::TUniformLocation>(valueIn, valueOut);
4605 break;
4606 case ParamType::TVertexArrayID:
4607 SetParamVal<ParamType::TVertexArrayID>(valueIn, valueOut);
4608 break;
4609 case ParamType::TVertexArrayIDConstPointer:
4610 SetParamVal<ParamType::TVertexArrayIDConstPointer>(valueIn, valueOut);
4611 break;
4612 case ParamType::TVertexArrayIDPointer:
4613 SetParamVal<ParamType::TVertexArrayIDPointer>(valueIn, valueOut);
4614 break;
4615 case ParamType::TVertexAttribType:
4616 SetParamVal<ParamType::TVertexAttribType>(valueIn, valueOut);
4617 break;
4618 case ParamType::TcharConstPointer:
4619 SetParamVal<ParamType::TcharConstPointer>(valueIn, valueOut);
4620 break;
4621 case ParamType::TcharConstPointerPointer:
4622 SetParamVal<ParamType::TcharConstPointerPointer>(valueIn, valueOut);
4623 break;
4624 case ParamType::TcharUnsignedConstPointerPointer:
4625 SetParamVal<ParamType::TcharUnsignedConstPointerPointer>(valueIn, valueOut);
4626 break;
4627 case ParamType::Tcl_bool:
4628 SetParamVal<ParamType::Tcl_bool>(valueIn, valueOut);
4629 break;
4630 case ParamType::Tcl_buffer_create_type:
4631 SetParamVal<ParamType::Tcl_buffer_create_type>(valueIn, valueOut);
4632 break;
4633 case ParamType::Tcl_callback_func_type:
4634 SetParamVal<ParamType::Tcl_callback_func_type>(valueIn, valueOut);
4635 break;
4636 case ParamType::Tcl_command_queue:
4637 SetParamVal<ParamType::Tcl_command_queue>(valueIn, valueOut);
4638 break;
4639 case ParamType::Tcl_command_queue_propertiesPointer:
4640 SetParamVal<ParamType::Tcl_command_queue_propertiesPointer>(valueIn, valueOut);
4641 break;
4642 case ParamType::Tcl_context:
4643 SetParamVal<ParamType::Tcl_context>(valueIn, valueOut);
4644 break;
4645 case ParamType::Tcl_context_destructor_func_type:
4646 SetParamVal<ParamType::Tcl_context_destructor_func_type>(valueIn, valueOut);
4647 break;
4648 case ParamType::Tcl_context_func_type:
4649 SetParamVal<ParamType::Tcl_context_func_type>(valueIn, valueOut);
4650 break;
4651 case ParamType::Tcl_context_propertiesConstPointer:
4652 SetParamVal<ParamType::Tcl_context_propertiesConstPointer>(valueIn, valueOut);
4653 break;
4654 case ParamType::Tcl_device_id:
4655 SetParamVal<ParamType::Tcl_device_id>(valueIn, valueOut);
4656 break;
4657 case ParamType::Tcl_device_idConstPointer:
4658 SetParamVal<ParamType::Tcl_device_idConstPointer>(valueIn, valueOut);
4659 break;
4660 case ParamType::Tcl_device_idPointer:
4661 SetParamVal<ParamType::Tcl_device_idPointer>(valueIn, valueOut);
4662 break;
4663 case ParamType::Tcl_device_partition_propertyConstPointer:
4664 SetParamVal<ParamType::Tcl_device_partition_propertyConstPointer>(valueIn, valueOut);
4665 break;
4666 case ParamType::Tcl_event:
4667 SetParamVal<ParamType::Tcl_event>(valueIn, valueOut);
4668 break;
4669 case ParamType::Tcl_eventConstPointer:
4670 SetParamVal<ParamType::Tcl_eventConstPointer>(valueIn, valueOut);
4671 break;
4672 case ParamType::Tcl_eventPointer:
4673 SetParamVal<ParamType::Tcl_eventPointer>(valueIn, valueOut);
4674 break;
4675 case ParamType::Tcl_image_descConstPointer:
4676 SetParamVal<ParamType::Tcl_image_descConstPointer>(valueIn, valueOut);
4677 break;
4678 case ParamType::Tcl_image_formatConstPointer:
4679 SetParamVal<ParamType::Tcl_image_formatConstPointer>(valueIn, valueOut);
4680 break;
4681 case ParamType::Tcl_image_formatPointer:
4682 SetParamVal<ParamType::Tcl_image_formatPointer>(valueIn, valueOut);
4683 break;
4684 case ParamType::Tcl_int:
4685 SetParamVal<ParamType::Tcl_int>(valueIn, valueOut);
4686 break;
4687 case ParamType::Tcl_intPointer:
4688 SetParamVal<ParamType::Tcl_intPointer>(valueIn, valueOut);
4689 break;
4690 case ParamType::Tcl_kernel:
4691 SetParamVal<ParamType::Tcl_kernel>(valueIn, valueOut);
4692 break;
4693 case ParamType::Tcl_kernelPointer:
4694 SetParamVal<ParamType::Tcl_kernelPointer>(valueIn, valueOut);
4695 break;
4696 case ParamType::Tcl_mem:
4697 SetParamVal<ParamType::Tcl_mem>(valueIn, valueOut);
4698 break;
4699 case ParamType::Tcl_memConstPointer:
4700 SetParamVal<ParamType::Tcl_memConstPointer>(valueIn, valueOut);
4701 break;
4702 case ParamType::Tcl_mem_destructor_func_type:
4703 SetParamVal<ParamType::Tcl_mem_destructor_func_type>(valueIn, valueOut);
4704 break;
4705 case ParamType::Tcl_mem_propertiesConstPointer:
4706 SetParamVal<ParamType::Tcl_mem_propertiesConstPointer>(valueIn, valueOut);
4707 break;
4708 case ParamType::Tcl_pipe_propertiesConstPointer:
4709 SetParamVal<ParamType::Tcl_pipe_propertiesConstPointer>(valueIn, valueOut);
4710 break;
4711 case ParamType::Tcl_platform_id:
4712 SetParamVal<ParamType::Tcl_platform_id>(valueIn, valueOut);
4713 break;
4714 case ParamType::Tcl_platform_idPointer:
4715 SetParamVal<ParamType::Tcl_platform_idPointer>(valueIn, valueOut);
4716 break;
4717 case ParamType::Tcl_program:
4718 SetParamVal<ParamType::Tcl_program>(valueIn, valueOut);
4719 break;
4720 case ParamType::Tcl_programConstPointer:
4721 SetParamVal<ParamType::Tcl_programConstPointer>(valueIn, valueOut);
4722 break;
4723 case ParamType::Tcl_program_func_type:
4724 SetParamVal<ParamType::Tcl_program_func_type>(valueIn, valueOut);
4725 break;
4726 case ParamType::Tcl_queue_propertiesConstPointer:
4727 SetParamVal<ParamType::Tcl_queue_propertiesConstPointer>(valueIn, valueOut);
4728 break;
4729 case ParamType::Tcl_sampler:
4730 SetParamVal<ParamType::Tcl_sampler>(valueIn, valueOut);
4731 break;
4732 case ParamType::Tcl_sampler_propertiesConstPointer:
4733 SetParamVal<ParamType::Tcl_sampler_propertiesConstPointer>(valueIn, valueOut);
4734 break;
4735 case ParamType::Tcl_svm_free_callback_func_type:
4736 SetParamVal<ParamType::Tcl_svm_free_callback_func_type>(valueIn, valueOut);
4737 break;
4738 case ParamType::Tcl_uint:
4739 SetParamVal<ParamType::Tcl_uint>(valueIn, valueOut);
4740 break;
4741 case ParamType::Tcl_uintPointer:
4742 SetParamVal<ParamType::Tcl_uintPointer>(valueIn, valueOut);
4743 break;
4744 case ParamType::Tcl_ulongPointer:
4745 SetParamVal<ParamType::Tcl_ulongPointer>(valueIn, valueOut);
4746 break;
4747 case ParamType::Tcl_void_func_type:
4748 SetParamVal<ParamType::Tcl_void_func_type>(valueIn, valueOut);
4749 break;
4750 case ParamType::Tegl_ConfigPointer:
4751 SetParamVal<ParamType::Tegl_ConfigPointer>(valueIn, valueOut);
4752 break;
4753 case ParamType::Tegl_DevicePointer:
4754 SetParamVal<ParamType::Tegl_DevicePointer>(valueIn, valueOut);
4755 break;
4756 case ParamType::Tegl_DisplayPointer:
4757 SetParamVal<ParamType::Tegl_DisplayPointer>(valueIn, valueOut);
4758 break;
4759 case ParamType::Tegl_StreamPointer:
4760 SetParamVal<ParamType::Tegl_StreamPointer>(valueIn, valueOut);
4761 break;
4762 case ParamType::Tegl_SyncID:
4763 SetParamVal<ParamType::Tegl_SyncID>(valueIn, valueOut);
4764 break;
4765 case ParamType::Tsize_t:
4766 SetParamVal<ParamType::Tsize_t>(valueIn, valueOut);
4767 break;
4768 case ParamType::Tsize_tConstPointer:
4769 SetParamVal<ParamType::Tsize_tConstPointer>(valueIn, valueOut);
4770 break;
4771 case ParamType::Tsize_tPointer:
4772 SetParamVal<ParamType::Tsize_tPointer>(valueIn, valueOut);
4773 break;
4774 case ParamType::TvoidConstPointer:
4775 SetParamVal<ParamType::TvoidConstPointer>(valueIn, valueOut);
4776 break;
4777 case ParamType::TvoidConstPointerPointer:
4778 SetParamVal<ParamType::TvoidConstPointerPointer>(valueIn, valueOut);
4779 break;
4780 case ParamType::TvoidPointer:
4781 SetParamVal<ParamType::TvoidPointer>(valueIn, valueOut);
4782 break;
4783 case ParamType::TvoidPointerPointer:
4784 SetParamVal<ParamType::TvoidPointerPointer>(valueIn, valueOut);
4785 break;
4786 }
4787 }
4788
4789 struct CallCapture;
4790 struct ParamCapture;
4791
4792 void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const ParamCapture ¶m);
4793 const char *ParamTypeToString(ParamType paramType);
4794
4795 enum class ResourceIDType
4796 {
4797 Buffer,
4798 Context,
4799 FenceNV,
4800 Framebuffer,
4801 Image,
4802 MemoryObject,
4803 ProgramPipeline,
4804 Query,
4805 Renderbuffer,
4806 Sampler,
4807 Semaphore,
4808 ShaderProgram,
4809 Surface,
4810 Sync,
4811 Texture,
4812 TransformFeedback,
4813 VertexArray,
4814 egl_Sync,
4815 EnumCount,
4816 InvalidEnum = EnumCount
4817 };
4818
4819 ResourceIDType GetResourceIDTypeFromParamType(ParamType paramType);
4820 const char *GetResourceIDTypeName(ResourceIDType resourceIDType);
4821
4822 template <typename ResourceType>
4823 struct GetResourceIDTypeFromType;
4824
4825 template <>
4826 struct GetResourceIDTypeFromType<gl::BufferID>
4827 {
4828 static constexpr ResourceIDType IDType = ResourceIDType::Buffer;
4829 };
4830
4831 template <>
4832 struct GetResourceIDTypeFromType<gl::ContextID>
4833 {
4834 static constexpr ResourceIDType IDType = ResourceIDType::Context;
4835 };
4836
4837 template <>
4838 struct GetResourceIDTypeFromType<gl::FenceNVID>
4839 {
4840 static constexpr ResourceIDType IDType = ResourceIDType::FenceNV;
4841 };
4842
4843 template <>
4844 struct GetResourceIDTypeFromType<gl::FramebufferID>
4845 {
4846 static constexpr ResourceIDType IDType = ResourceIDType::Framebuffer;
4847 };
4848
4849 template <>
4850 struct GetResourceIDTypeFromType<egl::ImageID>
4851 {
4852 static constexpr ResourceIDType IDType = ResourceIDType::Image;
4853 };
4854
4855 template <>
4856 struct GetResourceIDTypeFromType<gl::MemoryObjectID>
4857 {
4858 static constexpr ResourceIDType IDType = ResourceIDType::MemoryObject;
4859 };
4860
4861 template <>
4862 struct GetResourceIDTypeFromType<gl::ProgramPipelineID>
4863 {
4864 static constexpr ResourceIDType IDType = ResourceIDType::ProgramPipeline;
4865 };
4866
4867 template <>
4868 struct GetResourceIDTypeFromType<gl::QueryID>
4869 {
4870 static constexpr ResourceIDType IDType = ResourceIDType::Query;
4871 };
4872
4873 template <>
4874 struct GetResourceIDTypeFromType<gl::RenderbufferID>
4875 {
4876 static constexpr ResourceIDType IDType = ResourceIDType::Renderbuffer;
4877 };
4878
4879 template <>
4880 struct GetResourceIDTypeFromType<gl::SamplerID>
4881 {
4882 static constexpr ResourceIDType IDType = ResourceIDType::Sampler;
4883 };
4884
4885 template <>
4886 struct GetResourceIDTypeFromType<gl::SemaphoreID>
4887 {
4888 static constexpr ResourceIDType IDType = ResourceIDType::Semaphore;
4889 };
4890
4891 template <>
4892 struct GetResourceIDTypeFromType<gl::ShaderProgramID>
4893 {
4894 static constexpr ResourceIDType IDType = ResourceIDType::ShaderProgram;
4895 };
4896
4897 template <>
4898 struct GetResourceIDTypeFromType<egl::SurfaceID>
4899 {
4900 static constexpr ResourceIDType IDType = ResourceIDType::Surface;
4901 };
4902
4903 template <>
4904 struct GetResourceIDTypeFromType<gl::SyncID>
4905 {
4906 static constexpr ResourceIDType IDType = ResourceIDType::Sync;
4907 };
4908
4909 template <>
4910 struct GetResourceIDTypeFromType<gl::TextureID>
4911 {
4912 static constexpr ResourceIDType IDType = ResourceIDType::Texture;
4913 };
4914
4915 template <>
4916 struct GetResourceIDTypeFromType<gl::TransformFeedbackID>
4917 {
4918 static constexpr ResourceIDType IDType = ResourceIDType::TransformFeedback;
4919 };
4920
4921 template <>
4922 struct GetResourceIDTypeFromType<gl::VertexArrayID>
4923 {
4924 static constexpr ResourceIDType IDType = ResourceIDType::VertexArray;
4925 };
4926
4927 template <>
4928 struct GetResourceIDTypeFromType<egl::SyncID>
4929 {
4930 static constexpr ResourceIDType IDType = ResourceIDType::egl_Sync;
4931 };
4932
4933 } // namespace angle
4934
4935 #endif // COMMON_FRAME_CAPTURE_UTILS_AUTOGEN_H_
4936