1 // GENERATED FILE - DO NOT EDIT.
2 // Generated by gen_interpreter_utils.py using data from gl.xml and gl_angle_ext.xml.
3 //
4 // Copyright 2022 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 // trace_interpreter_autogen.cpp:
9 // Helper code for trace interpreter.
10
11 #include "angle_trace_gl.h"
12 #include "trace_fixture.h"
13 #include "trace_interpreter.h"
14
15 namespace angle
16 {
ParseCallCapture(const Token & nameToken,size_t numParamTokens,const Token * paramTokens,const TraceStringMap & strings)17 CallCapture ParseCallCapture(const Token &nameToken,
18 size_t numParamTokens,
19 const Token *paramTokens,
20 const TraceStringMap &strings)
21 {
22 if (strcmp(nameToken, "eglAcquireExternalContextANGLE") == 0)
23 {
24 ParamBuffer params =
25 ParseParameters<std::remove_pointer<PFNEGLACQUIREEXTERNALCONTEXTANGLEPROC>::type>(
26 paramTokens, strings);
27 return CallCapture(EntryPoint::EGLAcquireExternalContextANGLE, std::move(params));
28 }
29 if (strcmp(nameToken, "eglBindAPI") == 0)
30 {
31 ParamBuffer params =
32 ParseParameters<std::remove_pointer<PFNEGLBINDAPIPROC>::type>(paramTokens, strings);
33 return CallCapture(EntryPoint::EGLBindAPI, std::move(params));
34 }
35 if (strcmp(nameToken, "eglBindTexImage") == 0)
36 {
37 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLBINDTEXIMAGEPROC>::type>(
38 paramTokens, strings);
39 return CallCapture(EntryPoint::EGLBindTexImage, std::move(params));
40 }
41 if (strcmp(nameToken, "eglChooseConfig") == 0)
42 {
43 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCHOOSECONFIGPROC>::type>(
44 paramTokens, strings);
45 return CallCapture(EntryPoint::EGLChooseConfig, std::move(params));
46 }
47 if (strcmp(nameToken, "eglClientWaitSync") == 0)
48 {
49 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCLIENTWAITSYNCPROC>::type>(
50 paramTokens, strings);
51 return CallCapture(EntryPoint::EGLClientWaitSync, std::move(params));
52 }
53 if (strcmp(nameToken, "eglClientWaitSyncKHR") == 0)
54 {
55 ParamBuffer params =
56 ParseParameters<std::remove_pointer<PFNEGLCLIENTWAITSYNCKHRPROC>::type>(paramTokens,
57 strings);
58 return CallCapture(EntryPoint::EGLClientWaitSyncKHR, std::move(params));
59 }
60 if (strcmp(nameToken, "eglCopyBuffers") == 0)
61 {
62 ParamBuffer params =
63 ParseParameters<std::remove_pointer<PFNEGLCOPYBUFFERSPROC>::type>(paramTokens, strings);
64 return CallCapture(EntryPoint::EGLCopyBuffers, std::move(params));
65 }
66 if (strcmp(nameToken, "eglCopyMetalSharedEventANGLE") == 0)
67 {
68 ParamBuffer params =
69 ParseParameters<std::remove_pointer<PFNEGLCOPYMETALSHAREDEVENTANGLEPROC>::type>(
70 paramTokens, strings);
71 return CallCapture(EntryPoint::EGLCopyMetalSharedEventANGLE, std::move(params));
72 }
73 if (strcmp(nameToken, "eglCreateContext") == 0)
74 {
75 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATECONTEXTPROC>::type>(
76 paramTokens, strings);
77 return CallCapture(EntryPoint::EGLCreateContext, std::move(params));
78 }
79 if (strcmp(nameToken, "eglCreateDeviceANGLE") == 0)
80 {
81 ParamBuffer params =
82 ParseParameters<std::remove_pointer<PFNEGLCREATEDEVICEANGLEPROC>::type>(paramTokens,
83 strings);
84 return CallCapture(EntryPoint::EGLCreateDeviceANGLE, std::move(params));
85 }
86 if (strcmp(nameToken, "eglCreateImage") == 0)
87 {
88 ParamBuffer params =
89 ParseParameters<std::remove_pointer<PFNEGLCREATEIMAGEPROC>::type>(paramTokens, strings);
90 return CallCapture(EntryPoint::EGLCreateImage, std::move(params));
91 }
92 if (strcmp(nameToken, "eglCreateImageKHR") == 0)
93 {
94 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATEIMAGEKHRPROC>::type>(
95 paramTokens, strings);
96 return CallCapture(EntryPoint::EGLCreateImageKHR, std::move(params));
97 }
98 if (strcmp(nameToken, "eglCreateNativeClientBufferANDROID") == 0)
99 {
100 ParamBuffer params =
101 ParseParameters<std::remove_pointer<PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC>::type>(
102 paramTokens, strings);
103 return CallCapture(EntryPoint::EGLCreateNativeClientBufferANDROID, std::move(params));
104 }
105 if (strcmp(nameToken, "eglCreatePbufferFromClientBuffer") == 0)
106 {
107 ParamBuffer params =
108 ParseParameters<std::remove_pointer<PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC>::type>(
109 paramTokens, strings);
110 return CallCapture(EntryPoint::EGLCreatePbufferFromClientBuffer, std::move(params));
111 }
112 if (strcmp(nameToken, "eglCreatePbufferSurface") == 0)
113 {
114 ParamBuffer params =
115 ParseParameters<std::remove_pointer<PFNEGLCREATEPBUFFERSURFACEPROC>::type>(paramTokens,
116 strings);
117 return CallCapture(EntryPoint::EGLCreatePbufferSurface, std::move(params));
118 }
119 if (strcmp(nameToken, "eglCreatePixmapSurface") == 0)
120 {
121 ParamBuffer params =
122 ParseParameters<std::remove_pointer<PFNEGLCREATEPIXMAPSURFACEPROC>::type>(paramTokens,
123 strings);
124 return CallCapture(EntryPoint::EGLCreatePixmapSurface, std::move(params));
125 }
126 if (strcmp(nameToken, "eglCreatePlatformPixmapSurface") == 0)
127 {
128 ParamBuffer params =
129 ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC>::type>(
130 paramTokens, strings);
131 return CallCapture(EntryPoint::EGLCreatePlatformPixmapSurface, std::move(params));
132 }
133 if (strcmp(nameToken, "eglCreatePlatformPixmapSurfaceEXT") == 0)
134 {
135 ParamBuffer params =
136 ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC>::type>(
137 paramTokens, strings);
138 return CallCapture(EntryPoint::EGLCreatePlatformPixmapSurfaceEXT, std::move(params));
139 }
140 if (strcmp(nameToken, "eglCreatePlatformWindowSurface") == 0)
141 {
142 ParamBuffer params =
143 ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMWINDOWSURFACEPROC>::type>(
144 paramTokens, strings);
145 return CallCapture(EntryPoint::EGLCreatePlatformWindowSurface, std::move(params));
146 }
147 if (strcmp(nameToken, "eglCreatePlatformWindowSurfaceEXT") == 0)
148 {
149 ParamBuffer params =
150 ParseParameters<std::remove_pointer<PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC>::type>(
151 paramTokens, strings);
152 return CallCapture(EntryPoint::EGLCreatePlatformWindowSurfaceEXT, std::move(params));
153 }
154 if (strcmp(nameToken, "eglCreateStreamKHR") == 0)
155 {
156 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATESTREAMKHRPROC>::type>(
157 paramTokens, strings);
158 return CallCapture(EntryPoint::EGLCreateStreamKHR, std::move(params));
159 }
160 if (strcmp(nameToken, "eglCreateStreamProducerD3DTextureANGLE") == 0)
161 {
162 ParamBuffer params = ParseParameters<
163 std::remove_pointer<PFNEGLCREATESTREAMPRODUCERD3DTEXTUREANGLEPROC>::type>(paramTokens,
164 strings);
165 return CallCapture(EntryPoint::EGLCreateStreamProducerD3DTextureANGLE, std::move(params));
166 }
167 if (strcmp(nameToken, "eglCreateSync") == 0)
168 {
169 ParamBuffer params =
170 ParseParameters<std::remove_pointer<PFNEGLCREATESYNCPROC>::type>(paramTokens, strings);
171 return CallCapture(EntryPoint::EGLCreateSync, std::move(params));
172 }
173 if (strcmp(nameToken, "eglCreateSyncKHR") == 0)
174 {
175 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLCREATESYNCKHRPROC>::type>(
176 paramTokens, strings);
177 return CallCapture(EntryPoint::EGLCreateSyncKHR, std::move(params));
178 }
179 if (strcmp(nameToken, "eglCreateWindowSurface") == 0)
180 {
181 ParamBuffer params =
182 ParseParameters<std::remove_pointer<PFNEGLCREATEWINDOWSURFACEPROC>::type>(paramTokens,
183 strings);
184 return CallCapture(EntryPoint::EGLCreateWindowSurface, std::move(params));
185 }
186 if (strcmp(nameToken, "eglDebugMessageControlKHR") == 0)
187 {
188 ParamBuffer params =
189 ParseParameters<std::remove_pointer<PFNEGLDEBUGMESSAGECONTROLKHRPROC>::type>(
190 paramTokens, strings);
191 return CallCapture(EntryPoint::EGLDebugMessageControlKHR, std::move(params));
192 }
193 if (strcmp(nameToken, "eglDestroyContext") == 0)
194 {
195 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYCONTEXTPROC>::type>(
196 paramTokens, strings);
197 return CallCapture(EntryPoint::EGLDestroyContext, std::move(params));
198 }
199 if (strcmp(nameToken, "eglDestroyImage") == 0)
200 {
201 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYIMAGEPROC>::type>(
202 paramTokens, strings);
203 return CallCapture(EntryPoint::EGLDestroyImage, std::move(params));
204 }
205 if (strcmp(nameToken, "eglDestroyImageKHR") == 0)
206 {
207 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYIMAGEKHRPROC>::type>(
208 paramTokens, strings);
209 return CallCapture(EntryPoint::EGLDestroyImageKHR, std::move(params));
210 }
211 if (strcmp(nameToken, "eglDestroyStreamKHR") == 0)
212 {
213 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSTREAMKHRPROC>::type>(
214 paramTokens, strings);
215 return CallCapture(EntryPoint::EGLDestroyStreamKHR, std::move(params));
216 }
217 if (strcmp(nameToken, "eglDestroySurface") == 0)
218 {
219 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSURFACEPROC>::type>(
220 paramTokens, strings);
221 return CallCapture(EntryPoint::EGLDestroySurface, std::move(params));
222 }
223 if (strcmp(nameToken, "eglDestroySync") == 0)
224 {
225 ParamBuffer params =
226 ParseParameters<std::remove_pointer<PFNEGLDESTROYSYNCPROC>::type>(paramTokens, strings);
227 return CallCapture(EntryPoint::EGLDestroySync, std::move(params));
228 }
229 if (strcmp(nameToken, "eglDestroySyncKHR") == 0)
230 {
231 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLDESTROYSYNCKHRPROC>::type>(
232 paramTokens, strings);
233 return CallCapture(EntryPoint::EGLDestroySyncKHR, std::move(params));
234 }
235 if (strcmp(nameToken, "eglDupNativeFenceFDANDROID") == 0)
236 {
237 ParamBuffer params =
238 ParseParameters<std::remove_pointer<PFNEGLDUPNATIVEFENCEFDANDROIDPROC>::type>(
239 paramTokens, strings);
240 return CallCapture(EntryPoint::EGLDupNativeFenceFDANDROID, std::move(params));
241 }
242 if (strcmp(nameToken, "eglExportVkImageANGLE") == 0)
243 {
244 ParamBuffer params =
245 ParseParameters<std::remove_pointer<PFNEGLEXPORTVKIMAGEANGLEPROC>::type>(paramTokens,
246 strings);
247 return CallCapture(EntryPoint::EGLExportVkImageANGLE, std::move(params));
248 }
249 if (strcmp(nameToken, "eglForceGPUSwitchANGLE") == 0)
250 {
251 ParamBuffer params =
252 ParseParameters<std::remove_pointer<PFNEGLFORCEGPUSWITCHANGLEPROC>::type>(paramTokens,
253 strings);
254 return CallCapture(EntryPoint::EGLForceGPUSwitchANGLE, std::move(params));
255 }
256 if (strcmp(nameToken, "eglGetCompositorTimingANDROID") == 0)
257 {
258 ParamBuffer params =
259 ParseParameters<std::remove_pointer<PFNEGLGETCOMPOSITORTIMINGANDROIDPROC>::type>(
260 paramTokens, strings);
261 return CallCapture(EntryPoint::EGLGetCompositorTimingANDROID, std::move(params));
262 }
263 if (strcmp(nameToken, "eglGetCompositorTimingSupportedANDROID") == 0)
264 {
265 ParamBuffer params = ParseParameters<
266 std::remove_pointer<PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC>::type>(paramTokens,
267 strings);
268 return CallCapture(EntryPoint::EGLGetCompositorTimingSupportedANDROID, std::move(params));
269 }
270 if (strcmp(nameToken, "eglGetConfigAttrib") == 0)
271 {
272 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETCONFIGATTRIBPROC>::type>(
273 paramTokens, strings);
274 return CallCapture(EntryPoint::EGLGetConfigAttrib, std::move(params));
275 }
276 if (strcmp(nameToken, "eglGetConfigs") == 0)
277 {
278 ParamBuffer params =
279 ParseParameters<std::remove_pointer<PFNEGLGETCONFIGSPROC>::type>(paramTokens, strings);
280 return CallCapture(EntryPoint::EGLGetConfigs, std::move(params));
281 }
282 if (strcmp(nameToken, "eglGetCurrentContext") == 0)
283 {
284 ParamBuffer params =
285 ParseParameters<std::remove_pointer<PFNEGLGETCURRENTCONTEXTPROC>::type>(paramTokens,
286 strings);
287 return CallCapture(EntryPoint::EGLGetCurrentContext, std::move(params));
288 }
289 if (strcmp(nameToken, "eglGetCurrentDisplay") == 0)
290 {
291 ParamBuffer params =
292 ParseParameters<std::remove_pointer<PFNEGLGETCURRENTDISPLAYPROC>::type>(paramTokens,
293 strings);
294 return CallCapture(EntryPoint::EGLGetCurrentDisplay, std::move(params));
295 }
296 if (strcmp(nameToken, "eglGetCurrentSurface") == 0)
297 {
298 ParamBuffer params =
299 ParseParameters<std::remove_pointer<PFNEGLGETCURRENTSURFACEPROC>::type>(paramTokens,
300 strings);
301 return CallCapture(EntryPoint::EGLGetCurrentSurface, std::move(params));
302 }
303 if (strcmp(nameToken, "eglGetDisplay") == 0)
304 {
305 ParamBuffer params =
306 ParseParameters<std::remove_pointer<PFNEGLGETDISPLAYPROC>::type>(paramTokens, strings);
307 return CallCapture(EntryPoint::EGLGetDisplay, std::move(params));
308 }
309 if (strcmp(nameToken, "eglGetError") == 0)
310 {
311 ParamBuffer params =
312 ParseParameters<std::remove_pointer<PFNEGLGETERRORPROC>::type>(paramTokens, strings);
313 return CallCapture(EntryPoint::EGLGetError, std::move(params));
314 }
315 if (strcmp(nameToken, "eglGetFrameTimestampSupportedANDROID") == 0)
316 {
317 ParamBuffer params =
318 ParseParameters<std::remove_pointer<PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC>::type>(
319 paramTokens, strings);
320 return CallCapture(EntryPoint::EGLGetFrameTimestampSupportedANDROID, std::move(params));
321 }
322 if (strcmp(nameToken, "eglGetFrameTimestampsANDROID") == 0)
323 {
324 ParamBuffer params =
325 ParseParameters<std::remove_pointer<PFNEGLGETFRAMETIMESTAMPSANDROIDPROC>::type>(
326 paramTokens, strings);
327 return CallCapture(EntryPoint::EGLGetFrameTimestampsANDROID, std::move(params));
328 }
329 if (strcmp(nameToken, "eglGetMscRateANGLE") == 0)
330 {
331 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETMSCRATEANGLEPROC>::type>(
332 paramTokens, strings);
333 return CallCapture(EntryPoint::EGLGetMscRateANGLE, std::move(params));
334 }
335 if (strcmp(nameToken, "eglGetNativeClientBufferANDROID") == 0)
336 {
337 ParamBuffer params =
338 ParseParameters<std::remove_pointer<PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC>::type>(
339 paramTokens, strings);
340 return CallCapture(EntryPoint::EGLGetNativeClientBufferANDROID, std::move(params));
341 }
342 if (strcmp(nameToken, "eglGetNextFrameIdANDROID") == 0)
343 {
344 ParamBuffer params =
345 ParseParameters<std::remove_pointer<PFNEGLGETNEXTFRAMEIDANDROIDPROC>::type>(paramTokens,
346 strings);
347 return CallCapture(EntryPoint::EGLGetNextFrameIdANDROID, std::move(params));
348 }
349 if (strcmp(nameToken, "eglGetPlatformDisplay") == 0)
350 {
351 ParamBuffer params =
352 ParseParameters<std::remove_pointer<PFNEGLGETPLATFORMDISPLAYPROC>::type>(paramTokens,
353 strings);
354 return CallCapture(EntryPoint::EGLGetPlatformDisplay, std::move(params));
355 }
356 if (strcmp(nameToken, "eglGetPlatformDisplayEXT") == 0)
357 {
358 ParamBuffer params =
359 ParseParameters<std::remove_pointer<PFNEGLGETPLATFORMDISPLAYEXTPROC>::type>(paramTokens,
360 strings);
361 return CallCapture(EntryPoint::EGLGetPlatformDisplayEXT, std::move(params));
362 }
363 if (strcmp(nameToken, "eglGetProcAddress") == 0)
364 {
365 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETPROCADDRESSPROC>::type>(
366 paramTokens, strings);
367 return CallCapture(EntryPoint::EGLGetProcAddress, std::move(params));
368 }
369 if (strcmp(nameToken, "eglGetSyncAttrib") == 0)
370 {
371 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETSYNCATTRIBPROC>::type>(
372 paramTokens, strings);
373 return CallCapture(EntryPoint::EGLGetSyncAttrib, std::move(params));
374 }
375 if (strcmp(nameToken, "eglGetSyncAttribKHR") == 0)
376 {
377 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLGETSYNCATTRIBKHRPROC>::type>(
378 paramTokens, strings);
379 return CallCapture(EntryPoint::EGLGetSyncAttribKHR, std::move(params));
380 }
381 if (strcmp(nameToken, "eglGetSyncValuesCHROMIUM") == 0)
382 {
383 ParamBuffer params =
384 ParseParameters<std::remove_pointer<PFNEGLGETSYNCVALUESCHROMIUMPROC>::type>(paramTokens,
385 strings);
386 return CallCapture(EntryPoint::EGLGetSyncValuesCHROMIUM, std::move(params));
387 }
388 if (strcmp(nameToken, "eglHandleGPUSwitchANGLE") == 0)
389 {
390 ParamBuffer params =
391 ParseParameters<std::remove_pointer<PFNEGLHANDLEGPUSWITCHANGLEPROC>::type>(paramTokens,
392 strings);
393 return CallCapture(EntryPoint::EGLHandleGPUSwitchANGLE, std::move(params));
394 }
395 if (strcmp(nameToken, "eglInitialize") == 0)
396 {
397 ParamBuffer params =
398 ParseParameters<std::remove_pointer<PFNEGLINITIALIZEPROC>::type>(paramTokens, strings);
399 return CallCapture(EntryPoint::EGLInitialize, std::move(params));
400 }
401 if (strcmp(nameToken, "eglLabelObjectKHR") == 0)
402 {
403 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLLABELOBJECTKHRPROC>::type>(
404 paramTokens, strings);
405 return CallCapture(EntryPoint::EGLLabelObjectKHR, std::move(params));
406 }
407 if (strcmp(nameToken, "eglLockSurfaceKHR") == 0)
408 {
409 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLLOCKSURFACEKHRPROC>::type>(
410 paramTokens, strings);
411 return CallCapture(EntryPoint::EGLLockSurfaceKHR, std::move(params));
412 }
413 if (strcmp(nameToken, "eglLockVulkanQueueANGLE") == 0)
414 {
415 ParamBuffer params =
416 ParseParameters<std::remove_pointer<PFNEGLLOCKVULKANQUEUEANGLEPROC>::type>(paramTokens,
417 strings);
418 return CallCapture(EntryPoint::EGLLockVulkanQueueANGLE, std::move(params));
419 }
420 if (strcmp(nameToken, "eglMakeCurrent") == 0)
421 {
422 ParamBuffer params =
423 ParseParameters<std::remove_pointer<PFNEGLMAKECURRENTPROC>::type>(paramTokens, strings);
424 return CallCapture(EntryPoint::EGLMakeCurrent, std::move(params));
425 }
426 if (strcmp(nameToken, "eglPostSubBufferNV") == 0)
427 {
428 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLPOSTSUBBUFFERNVPROC>::type>(
429 paramTokens, strings);
430 return CallCapture(EntryPoint::EGLPostSubBufferNV, std::move(params));
431 }
432 if (strcmp(nameToken, "eglPrepareSwapBuffersANGLE") == 0)
433 {
434 ParamBuffer params =
435 ParseParameters<std::remove_pointer<PFNEGLPREPARESWAPBUFFERSANGLEPROC>::type>(
436 paramTokens, strings);
437 return CallCapture(EntryPoint::EGLPrepareSwapBuffersANGLE, std::move(params));
438 }
439 if (strcmp(nameToken, "eglPresentationTimeANDROID") == 0)
440 {
441 ParamBuffer params =
442 ParseParameters<std::remove_pointer<PFNEGLPRESENTATIONTIMEANDROIDPROC>::type>(
443 paramTokens, strings);
444 return CallCapture(EntryPoint::EGLPresentationTimeANDROID, std::move(params));
445 }
446 if (strcmp(nameToken, "eglProgramCacheGetAttribANGLE") == 0)
447 {
448 ParamBuffer params =
449 ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEGETATTRIBANGLEPROC>::type>(
450 paramTokens, strings);
451 return CallCapture(EntryPoint::EGLProgramCacheGetAttribANGLE, std::move(params));
452 }
453 if (strcmp(nameToken, "eglProgramCachePopulateANGLE") == 0)
454 {
455 ParamBuffer params =
456 ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEPOPULATEANGLEPROC>::type>(
457 paramTokens, strings);
458 return CallCapture(EntryPoint::EGLProgramCachePopulateANGLE, std::move(params));
459 }
460 if (strcmp(nameToken, "eglProgramCacheQueryANGLE") == 0)
461 {
462 ParamBuffer params =
463 ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHEQUERYANGLEPROC>::type>(
464 paramTokens, strings);
465 return CallCapture(EntryPoint::EGLProgramCacheQueryANGLE, std::move(params));
466 }
467 if (strcmp(nameToken, "eglProgramCacheResizeANGLE") == 0)
468 {
469 ParamBuffer params =
470 ParseParameters<std::remove_pointer<PFNEGLPROGRAMCACHERESIZEANGLEPROC>::type>(
471 paramTokens, strings);
472 return CallCapture(EntryPoint::EGLProgramCacheResizeANGLE, std::move(params));
473 }
474 if (strcmp(nameToken, "eglQueryAPI") == 0)
475 {
476 ParamBuffer params =
477 ParseParameters<std::remove_pointer<PFNEGLQUERYAPIPROC>::type>(paramTokens, strings);
478 return CallCapture(EntryPoint::EGLQueryAPI, std::move(params));
479 }
480 if (strcmp(nameToken, "eglQueryContext") == 0)
481 {
482 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYCONTEXTPROC>::type>(
483 paramTokens, strings);
484 return CallCapture(EntryPoint::EGLQueryContext, std::move(params));
485 }
486 if (strcmp(nameToken, "eglQueryDebugKHR") == 0)
487 {
488 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYDEBUGKHRPROC>::type>(
489 paramTokens, strings);
490 return CallCapture(EntryPoint::EGLQueryDebugKHR, std::move(params));
491 }
492 if (strcmp(nameToken, "eglQueryDeviceAttribEXT") == 0)
493 {
494 ParamBuffer params =
495 ParseParameters<std::remove_pointer<PFNEGLQUERYDEVICEATTRIBEXTPROC>::type>(paramTokens,
496 strings);
497 return CallCapture(EntryPoint::EGLQueryDeviceAttribEXT, std::move(params));
498 }
499 if (strcmp(nameToken, "eglQueryDeviceStringEXT") == 0)
500 {
501 ParamBuffer params =
502 ParseParameters<std::remove_pointer<PFNEGLQUERYDEVICESTRINGEXTPROC>::type>(paramTokens,
503 strings);
504 return CallCapture(EntryPoint::EGLQueryDeviceStringEXT, std::move(params));
505 }
506 if (strcmp(nameToken, "eglQueryDisplayAttribANGLE") == 0)
507 {
508 ParamBuffer params =
509 ParseParameters<std::remove_pointer<PFNEGLQUERYDISPLAYATTRIBANGLEPROC>::type>(
510 paramTokens, strings);
511 return CallCapture(EntryPoint::EGLQueryDisplayAttribANGLE, std::move(params));
512 }
513 if (strcmp(nameToken, "eglQueryDisplayAttribEXT") == 0)
514 {
515 ParamBuffer params =
516 ParseParameters<std::remove_pointer<PFNEGLQUERYDISPLAYATTRIBEXTPROC>::type>(paramTokens,
517 strings);
518 return CallCapture(EntryPoint::EGLQueryDisplayAttribEXT, std::move(params));
519 }
520 if (strcmp(nameToken, "eglQueryDmaBufFormatsEXT") == 0)
521 {
522 ParamBuffer params =
523 ParseParameters<std::remove_pointer<PFNEGLQUERYDMABUFFORMATSEXTPROC>::type>(paramTokens,
524 strings);
525 return CallCapture(EntryPoint::EGLQueryDmaBufFormatsEXT, std::move(params));
526 }
527 if (strcmp(nameToken, "eglQueryDmaBufModifiersEXT") == 0)
528 {
529 ParamBuffer params =
530 ParseParameters<std::remove_pointer<PFNEGLQUERYDMABUFMODIFIERSEXTPROC>::type>(
531 paramTokens, strings);
532 return CallCapture(EntryPoint::EGLQueryDmaBufModifiersEXT, std::move(params));
533 }
534 if (strcmp(nameToken, "eglQueryStreamKHR") == 0)
535 {
536 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYSTREAMKHRPROC>::type>(
537 paramTokens, strings);
538 return CallCapture(EntryPoint::EGLQueryStreamKHR, std::move(params));
539 }
540 if (strcmp(nameToken, "eglQueryStreamu64KHR") == 0)
541 {
542 ParamBuffer params =
543 ParseParameters<std::remove_pointer<PFNEGLQUERYSTREAMU64KHRPROC>::type>(paramTokens,
544 strings);
545 return CallCapture(EntryPoint::EGLQueryStreamu64KHR, std::move(params));
546 }
547 if (strcmp(nameToken, "eglQueryString") == 0)
548 {
549 ParamBuffer params =
550 ParseParameters<std::remove_pointer<PFNEGLQUERYSTRINGPROC>::type>(paramTokens, strings);
551 return CallCapture(EntryPoint::EGLQueryString, std::move(params));
552 }
553 if (strcmp(nameToken, "eglQueryStringiANGLE") == 0)
554 {
555 ParamBuffer params =
556 ParseParameters<std::remove_pointer<PFNEGLQUERYSTRINGIANGLEPROC>::type>(paramTokens,
557 strings);
558 return CallCapture(EntryPoint::EGLQueryStringiANGLE, std::move(params));
559 }
560 if (strcmp(nameToken, "eglQuerySupportedCompressionRatesEXT") == 0)
561 {
562 ParamBuffer params =
563 ParseParameters<std::remove_pointer<PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC>::type>(
564 paramTokens, strings);
565 return CallCapture(EntryPoint::EGLQuerySupportedCompressionRatesEXT, std::move(params));
566 }
567 if (strcmp(nameToken, "eglQuerySurface") == 0)
568 {
569 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACEPROC>::type>(
570 paramTokens, strings);
571 return CallCapture(EntryPoint::EGLQuerySurface, std::move(params));
572 }
573 if (strcmp(nameToken, "eglQuerySurface64KHR") == 0)
574 {
575 ParamBuffer params =
576 ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACE64KHRPROC>::type>(paramTokens,
577 strings);
578 return CallCapture(EntryPoint::EGLQuerySurface64KHR, std::move(params));
579 }
580 if (strcmp(nameToken, "eglQuerySurfacePointerANGLE") == 0)
581 {
582 ParamBuffer params =
583 ParseParameters<std::remove_pointer<PFNEGLQUERYSURFACEPOINTERANGLEPROC>::type>(
584 paramTokens, strings);
585 return CallCapture(EntryPoint::EGLQuerySurfacePointerANGLE, std::move(params));
586 }
587 if (strcmp(nameToken, "eglReacquireHighPowerGPUANGLE") == 0)
588 {
589 ParamBuffer params =
590 ParseParameters<std::remove_pointer<PFNEGLREACQUIREHIGHPOWERGPUANGLEPROC>::type>(
591 paramTokens, strings);
592 return CallCapture(EntryPoint::EGLReacquireHighPowerGPUANGLE, std::move(params));
593 }
594 if (strcmp(nameToken, "eglReleaseDeviceANGLE") == 0)
595 {
596 ParamBuffer params =
597 ParseParameters<std::remove_pointer<PFNEGLRELEASEDEVICEANGLEPROC>::type>(paramTokens,
598 strings);
599 return CallCapture(EntryPoint::EGLReleaseDeviceANGLE, std::move(params));
600 }
601 if (strcmp(nameToken, "eglReleaseExternalContextANGLE") == 0)
602 {
603 ParamBuffer params =
604 ParseParameters<std::remove_pointer<PFNEGLRELEASEEXTERNALCONTEXTANGLEPROC>::type>(
605 paramTokens, strings);
606 return CallCapture(EntryPoint::EGLReleaseExternalContextANGLE, std::move(params));
607 }
608 if (strcmp(nameToken, "eglReleaseHighPowerGPUANGLE") == 0)
609 {
610 ParamBuffer params =
611 ParseParameters<std::remove_pointer<PFNEGLRELEASEHIGHPOWERGPUANGLEPROC>::type>(
612 paramTokens, strings);
613 return CallCapture(EntryPoint::EGLReleaseHighPowerGPUANGLE, std::move(params));
614 }
615 if (strcmp(nameToken, "eglReleaseTexImage") == 0)
616 {
617 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLRELEASETEXIMAGEPROC>::type>(
618 paramTokens, strings);
619 return CallCapture(EntryPoint::EGLReleaseTexImage, std::move(params));
620 }
621 if (strcmp(nameToken, "eglReleaseThread") == 0)
622 {
623 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLRELEASETHREADPROC>::type>(
624 paramTokens, strings);
625 return CallCapture(EntryPoint::EGLReleaseThread, std::move(params));
626 }
627 if (strcmp(nameToken, "eglSetBlobCacheFuncsANDROID") == 0)
628 {
629 ParamBuffer params =
630 ParseParameters<std::remove_pointer<PFNEGLSETBLOBCACHEFUNCSANDROIDPROC>::type>(
631 paramTokens, strings);
632 return CallCapture(EntryPoint::EGLSetBlobCacheFuncsANDROID, std::move(params));
633 }
634 if (strcmp(nameToken, "eglSetDamageRegionKHR") == 0)
635 {
636 ParamBuffer params =
637 ParseParameters<std::remove_pointer<PFNEGLSETDAMAGEREGIONKHRPROC>::type>(paramTokens,
638 strings);
639 return CallCapture(EntryPoint::EGLSetDamageRegionKHR, std::move(params));
640 }
641 if (strcmp(nameToken, "eglSetValidationEnabledANGLE") == 0)
642 {
643 ParamBuffer params =
644 ParseParameters<std::remove_pointer<PFNEGLSETVALIDATIONENABLEDANGLEPROC>::type>(
645 paramTokens, strings);
646 return CallCapture(EntryPoint::EGLSetValidationEnabledANGLE, std::move(params));
647 }
648 if (strcmp(nameToken, "eglSignalSyncKHR") == 0)
649 {
650 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSIGNALSYNCKHRPROC>::type>(
651 paramTokens, strings);
652 return CallCapture(EntryPoint::EGLSignalSyncKHR, std::move(params));
653 }
654 if (strcmp(nameToken, "eglStreamAttribKHR") == 0)
655 {
656 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSTREAMATTRIBKHRPROC>::type>(
657 paramTokens, strings);
658 return CallCapture(EntryPoint::EGLStreamAttribKHR, std::move(params));
659 }
660 if (strcmp(nameToken, "eglStreamConsumerAcquireKHR") == 0)
661 {
662 ParamBuffer params =
663 ParseParameters<std::remove_pointer<PFNEGLSTREAMCONSUMERACQUIREKHRPROC>::type>(
664 paramTokens, strings);
665 return CallCapture(EntryPoint::EGLStreamConsumerAcquireKHR, std::move(params));
666 }
667 if (strcmp(nameToken, "eglStreamConsumerGLTextureExternalAttribsNV") == 0)
668 {
669 ParamBuffer params = ParseParameters<
670 std::remove_pointer<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC>::type>(
671 paramTokens, strings);
672 return CallCapture(EntryPoint::EGLStreamConsumerGLTextureExternalAttribsNV,
673 std::move(params));
674 }
675 if (strcmp(nameToken, "eglStreamConsumerGLTextureExternalKHR") == 0)
676 {
677 ParamBuffer params = ParseParameters<
678 std::remove_pointer<PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC>::type>(paramTokens,
679 strings);
680 return CallCapture(EntryPoint::EGLStreamConsumerGLTextureExternalKHR, std::move(params));
681 }
682 if (strcmp(nameToken, "eglStreamConsumerReleaseKHR") == 0)
683 {
684 ParamBuffer params =
685 ParseParameters<std::remove_pointer<PFNEGLSTREAMCONSUMERRELEASEKHRPROC>::type>(
686 paramTokens, strings);
687 return CallCapture(EntryPoint::EGLStreamConsumerReleaseKHR, std::move(params));
688 }
689 if (strcmp(nameToken, "eglStreamPostD3DTextureANGLE") == 0)
690 {
691 ParamBuffer params =
692 ParseParameters<std::remove_pointer<PFNEGLSTREAMPOSTD3DTEXTUREANGLEPROC>::type>(
693 paramTokens, strings);
694 return CallCapture(EntryPoint::EGLStreamPostD3DTextureANGLE, std::move(params));
695 }
696 if (strcmp(nameToken, "eglSurfaceAttrib") == 0)
697 {
698 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSURFACEATTRIBPROC>::type>(
699 paramTokens, strings);
700 return CallCapture(EntryPoint::EGLSurfaceAttrib, std::move(params));
701 }
702 if (strcmp(nameToken, "eglSwapBuffers") == 0)
703 {
704 ParamBuffer params =
705 ParseParameters<std::remove_pointer<PFNEGLSWAPBUFFERSPROC>::type>(paramTokens, strings);
706 return CallCapture(EntryPoint::EGLSwapBuffers, std::move(params));
707 }
708 if (strcmp(nameToken, "eglSwapBuffersWithDamageKHR") == 0)
709 {
710 ParamBuffer params =
711 ParseParameters<std::remove_pointer<PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC>::type>(
712 paramTokens, strings);
713 return CallCapture(EntryPoint::EGLSwapBuffersWithDamageKHR, std::move(params));
714 }
715 if (strcmp(nameToken, "eglSwapInterval") == 0)
716 {
717 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLSWAPINTERVALPROC>::type>(
718 paramTokens, strings);
719 return CallCapture(EntryPoint::EGLSwapInterval, std::move(params));
720 }
721 if (strcmp(nameToken, "eglTerminate") == 0)
722 {
723 ParamBuffer params =
724 ParseParameters<std::remove_pointer<PFNEGLTERMINATEPROC>::type>(paramTokens, strings);
725 return CallCapture(EntryPoint::EGLTerminate, std::move(params));
726 }
727 if (strcmp(nameToken, "eglUnlockSurfaceKHR") == 0)
728 {
729 ParamBuffer params = ParseParameters<std::remove_pointer<PFNEGLUNLOCKSURFACEKHRPROC>::type>(
730 paramTokens, strings);
731 return CallCapture(EntryPoint::EGLUnlockSurfaceKHR, std::move(params));
732 }
733 if (strcmp(nameToken, "eglUnlockVulkanQueueANGLE") == 0)
734 {
735 ParamBuffer params =
736 ParseParameters<std::remove_pointer<PFNEGLUNLOCKVULKANQUEUEANGLEPROC>::type>(
737 paramTokens, strings);
738 return CallCapture(EntryPoint::EGLUnlockVulkanQueueANGLE, std::move(params));
739 }
740 if (strcmp(nameToken, "eglWaitClient") == 0)
741 {
742 ParamBuffer params =
743 ParseParameters<std::remove_pointer<PFNEGLWAITCLIENTPROC>::type>(paramTokens, strings);
744 return CallCapture(EntryPoint::EGLWaitClient, std::move(params));
745 }
746 if (strcmp(nameToken, "eglWaitGL") == 0)
747 {
748 ParamBuffer params =
749 ParseParameters<std::remove_pointer<PFNEGLWAITGLPROC>::type>(paramTokens, strings);
750 return CallCapture(EntryPoint::EGLWaitGL, std::move(params));
751 }
752 if (strcmp(nameToken, "eglWaitNative") == 0)
753 {
754 ParamBuffer params =
755 ParseParameters<std::remove_pointer<PFNEGLWAITNATIVEPROC>::type>(paramTokens, strings);
756 return CallCapture(EntryPoint::EGLWaitNative, std::move(params));
757 }
758 if (strcmp(nameToken, "eglWaitSync") == 0)
759 {
760 ParamBuffer params =
761 ParseParameters<std::remove_pointer<PFNEGLWAITSYNCPROC>::type>(paramTokens, strings);
762 return CallCapture(EntryPoint::EGLWaitSync, std::move(params));
763 }
764 if (strcmp(nameToken, "eglWaitSyncKHR") == 0)
765 {
766 ParamBuffer params =
767 ParseParameters<std::remove_pointer<PFNEGLWAITSYNCKHRPROC>::type>(paramTokens, strings);
768 return CallCapture(EntryPoint::EGLWaitSyncKHR, std::move(params));
769 }
770 if (strcmp(nameToken, "eglWaitUntilWorkScheduledANGLE") == 0)
771 {
772 ParamBuffer params =
773 ParseParameters<std::remove_pointer<PFNEGLWAITUNTILWORKSCHEDULEDANGLEPROC>::type>(
774 paramTokens, strings);
775 return CallCapture(EntryPoint::EGLWaitUntilWorkScheduledANGLE, std::move(params));
776 }
777 if (strcmp(nameToken, "glAcquireTexturesANGLE") == 0)
778 {
779 ParamBuffer params =
780 ParseParameters<std::remove_pointer<PFNGLACQUIRETEXTURESANGLEPROC>::type>(paramTokens,
781 strings);
782 return CallCapture(EntryPoint::GLAcquireTexturesANGLE, std::move(params));
783 }
784 if (strcmp(nameToken, "glActiveShaderProgram") == 0)
785 {
786 ParamBuffer params =
787 ParseParameters<std::remove_pointer<PFNGLACTIVESHADERPROGRAMPROC>::type>(paramTokens,
788 strings);
789 return CallCapture(EntryPoint::GLActiveShaderProgram, std::move(params));
790 }
791 if (strcmp(nameToken, "glActiveShaderProgramEXT") == 0)
792 {
793 ParamBuffer params =
794 ParseParameters<std::remove_pointer<PFNGLACTIVESHADERPROGRAMEXTPROC>::type>(paramTokens,
795 strings);
796 return CallCapture(EntryPoint::GLActiveShaderProgramEXT, std::move(params));
797 }
798 if (strcmp(nameToken, "glActiveTexture") == 0)
799 {
800 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLACTIVETEXTUREPROC>::type>(
801 paramTokens, strings);
802 return CallCapture(EntryPoint::GLActiveTexture, std::move(params));
803 }
804 if (strcmp(nameToken, "glAlphaFunc") == 0)
805 {
806 ParamBuffer params =
807 ParseParameters<std::remove_pointer<PFNGLALPHAFUNCPROC>::type>(paramTokens, strings);
808 return CallCapture(EntryPoint::GLAlphaFunc, std::move(params));
809 }
810 if (strcmp(nameToken, "glAlphaFuncx") == 0)
811 {
812 ParamBuffer params =
813 ParseParameters<std::remove_pointer<PFNGLALPHAFUNCXPROC>::type>(paramTokens, strings);
814 return CallCapture(EntryPoint::GLAlphaFuncx, std::move(params));
815 }
816 if (strcmp(nameToken, "glAttachShader") == 0)
817 {
818 ParamBuffer params =
819 ParseParameters<std::remove_pointer<PFNGLATTACHSHADERPROC>::type>(paramTokens, strings);
820 return CallCapture(EntryPoint::GLAttachShader, std::move(params));
821 }
822 if (strcmp(nameToken, "glBeginPerfMonitorAMD") == 0)
823 {
824 ParamBuffer params =
825 ParseParameters<std::remove_pointer<PFNGLBEGINPERFMONITORAMDPROC>::type>(paramTokens,
826 strings);
827 return CallCapture(EntryPoint::GLBeginPerfMonitorAMD, std::move(params));
828 }
829 if (strcmp(nameToken, "glBeginPixelLocalStorageANGLE") == 0)
830 {
831 ParamBuffer params =
832 ParseParameters<std::remove_pointer<PFNGLBEGINPIXELLOCALSTORAGEANGLEPROC>::type>(
833 paramTokens, strings);
834 return CallCapture(EntryPoint::GLBeginPixelLocalStorageANGLE, std::move(params));
835 }
836 if (strcmp(nameToken, "glBeginQuery") == 0)
837 {
838 ParamBuffer params =
839 ParseParameters<std::remove_pointer<PFNGLBEGINQUERYPROC>::type>(paramTokens, strings);
840 return CallCapture(EntryPoint::GLBeginQuery, std::move(params));
841 }
842 if (strcmp(nameToken, "glBeginQueryEXT") == 0)
843 {
844 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBEGINQUERYEXTPROC>::type>(
845 paramTokens, strings);
846 return CallCapture(EntryPoint::GLBeginQueryEXT, std::move(params));
847 }
848 if (strcmp(nameToken, "glBeginTransformFeedback") == 0)
849 {
850 ParamBuffer params =
851 ParseParameters<std::remove_pointer<PFNGLBEGINTRANSFORMFEEDBACKPROC>::type>(paramTokens,
852 strings);
853 return CallCapture(EntryPoint::GLBeginTransformFeedback, std::move(params));
854 }
855 if (strcmp(nameToken, "glBindAttribLocation") == 0)
856 {
857 ParamBuffer params =
858 ParseParameters<std::remove_pointer<PFNGLBINDATTRIBLOCATIONPROC>::type>(paramTokens,
859 strings);
860 return CallCapture(EntryPoint::GLBindAttribLocation, std::move(params));
861 }
862 if (strcmp(nameToken, "glBindBuffer") == 0)
863 {
864 ParamBuffer params =
865 ParseParameters<std::remove_pointer<PFNGLBINDBUFFERPROC>::type>(paramTokens, strings);
866 return CallCapture(EntryPoint::GLBindBuffer, std::move(params));
867 }
868 if (strcmp(nameToken, "glBindBufferBase") == 0)
869 {
870 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDBUFFERBASEPROC>::type>(
871 paramTokens, strings);
872 return CallCapture(EntryPoint::GLBindBufferBase, std::move(params));
873 }
874 if (strcmp(nameToken, "glBindBufferRange") == 0)
875 {
876 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDBUFFERRANGEPROC>::type>(
877 paramTokens, strings);
878 return CallCapture(EntryPoint::GLBindBufferRange, std::move(params));
879 }
880 if (strcmp(nameToken, "glBindFragDataLocationEXT") == 0)
881 {
882 ParamBuffer params =
883 ParseParameters<std::remove_pointer<PFNGLBINDFRAGDATALOCATIONEXTPROC>::type>(
884 paramTokens, strings);
885 return CallCapture(EntryPoint::GLBindFragDataLocationEXT, std::move(params));
886 }
887 if (strcmp(nameToken, "glBindFragDataLocationIndexedEXT") == 0)
888 {
889 ParamBuffer params =
890 ParseParameters<std::remove_pointer<PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC>::type>(
891 paramTokens, strings);
892 return CallCapture(EntryPoint::GLBindFragDataLocationIndexedEXT, std::move(params));
893 }
894 if (strcmp(nameToken, "glBindFramebuffer") == 0)
895 {
896 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDFRAMEBUFFERPROC>::type>(
897 paramTokens, strings);
898 return CallCapture(EntryPoint::GLBindFramebuffer, std::move(params));
899 }
900 if (strcmp(nameToken, "glBindFramebufferOES") == 0)
901 {
902 ParamBuffer params =
903 ParseParameters<std::remove_pointer<PFNGLBINDFRAMEBUFFEROESPROC>::type>(paramTokens,
904 strings);
905 return CallCapture(EntryPoint::GLBindFramebufferOES, std::move(params));
906 }
907 if (strcmp(nameToken, "glBindImageTexture") == 0)
908 {
909 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDIMAGETEXTUREPROC>::type>(
910 paramTokens, strings);
911 return CallCapture(EntryPoint::GLBindImageTexture, std::move(params));
912 }
913 if (strcmp(nameToken, "glBindProgramPipeline") == 0)
914 {
915 ParamBuffer params =
916 ParseParameters<std::remove_pointer<PFNGLBINDPROGRAMPIPELINEPROC>::type>(paramTokens,
917 strings);
918 return CallCapture(EntryPoint::GLBindProgramPipeline, std::move(params));
919 }
920 if (strcmp(nameToken, "glBindProgramPipelineEXT") == 0)
921 {
922 ParamBuffer params =
923 ParseParameters<std::remove_pointer<PFNGLBINDPROGRAMPIPELINEEXTPROC>::type>(paramTokens,
924 strings);
925 return CallCapture(EntryPoint::GLBindProgramPipelineEXT, std::move(params));
926 }
927 if (strcmp(nameToken, "glBindRenderbuffer") == 0)
928 {
929 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDRENDERBUFFERPROC>::type>(
930 paramTokens, strings);
931 return CallCapture(EntryPoint::GLBindRenderbuffer, std::move(params));
932 }
933 if (strcmp(nameToken, "glBindRenderbufferOES") == 0)
934 {
935 ParamBuffer params =
936 ParseParameters<std::remove_pointer<PFNGLBINDRENDERBUFFEROESPROC>::type>(paramTokens,
937 strings);
938 return CallCapture(EntryPoint::GLBindRenderbufferOES, std::move(params));
939 }
940 if (strcmp(nameToken, "glBindSampler") == 0)
941 {
942 ParamBuffer params =
943 ParseParameters<std::remove_pointer<PFNGLBINDSAMPLERPROC>::type>(paramTokens, strings);
944 return CallCapture(EntryPoint::GLBindSampler, std::move(params));
945 }
946 if (strcmp(nameToken, "glBindTexture") == 0)
947 {
948 ParamBuffer params =
949 ParseParameters<std::remove_pointer<PFNGLBINDTEXTUREPROC>::type>(paramTokens, strings);
950 return CallCapture(EntryPoint::GLBindTexture, std::move(params));
951 }
952 if (strcmp(nameToken, "glBindTransformFeedback") == 0)
953 {
954 ParamBuffer params =
955 ParseParameters<std::remove_pointer<PFNGLBINDTRANSFORMFEEDBACKPROC>::type>(paramTokens,
956 strings);
957 return CallCapture(EntryPoint::GLBindTransformFeedback, std::move(params));
958 }
959 if (strcmp(nameToken, "glBindUniformLocationCHROMIUM") == 0)
960 {
961 ParamBuffer params =
962 ParseParameters<std::remove_pointer<PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC>::type>(
963 paramTokens, strings);
964 return CallCapture(EntryPoint::GLBindUniformLocationCHROMIUM, std::move(params));
965 }
966 if (strcmp(nameToken, "glBindVertexArray") == 0)
967 {
968 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDVERTEXARRAYPROC>::type>(
969 paramTokens, strings);
970 return CallCapture(EntryPoint::GLBindVertexArray, std::move(params));
971 }
972 if (strcmp(nameToken, "glBindVertexArrayOES") == 0)
973 {
974 ParamBuffer params =
975 ParseParameters<std::remove_pointer<PFNGLBINDVERTEXARRAYOESPROC>::type>(paramTokens,
976 strings);
977 return CallCapture(EntryPoint::GLBindVertexArrayOES, std::move(params));
978 }
979 if (strcmp(nameToken, "glBindVertexBuffer") == 0)
980 {
981 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBINDVERTEXBUFFERPROC>::type>(
982 paramTokens, strings);
983 return CallCapture(EntryPoint::GLBindVertexBuffer, std::move(params));
984 }
985 if (strcmp(nameToken, "glBlendBarrier") == 0)
986 {
987 ParamBuffer params =
988 ParseParameters<std::remove_pointer<PFNGLBLENDBARRIERPROC>::type>(paramTokens, strings);
989 return CallCapture(EntryPoint::GLBlendBarrier, std::move(params));
990 }
991 if (strcmp(nameToken, "glBlendBarrierKHR") == 0)
992 {
993 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDBARRIERKHRPROC>::type>(
994 paramTokens, strings);
995 return CallCapture(EntryPoint::GLBlendBarrierKHR, std::move(params));
996 }
997 if (strcmp(nameToken, "glBlendColor") == 0)
998 {
999 ParamBuffer params =
1000 ParseParameters<std::remove_pointer<PFNGLBLENDCOLORPROC>::type>(paramTokens, strings);
1001 return CallCapture(EntryPoint::GLBlendColor, std::move(params));
1002 }
1003 if (strcmp(nameToken, "glBlendEquation") == 0)
1004 {
1005 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONPROC>::type>(
1006 paramTokens, strings);
1007 return CallCapture(EntryPoint::GLBlendEquation, std::move(params));
1008 }
1009 if (strcmp(nameToken, "glBlendEquationOES") == 0)
1010 {
1011 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONOESPROC>::type>(
1012 paramTokens, strings);
1013 return CallCapture(EntryPoint::GLBlendEquationOES, std::move(params));
1014 }
1015 if (strcmp(nameToken, "glBlendEquationSeparate") == 0)
1016 {
1017 ParamBuffer params =
1018 ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEPROC>::type>(paramTokens,
1019 strings);
1020 return CallCapture(EntryPoint::GLBlendEquationSeparate, std::move(params));
1021 }
1022 if (strcmp(nameToken, "glBlendEquationSeparatei") == 0)
1023 {
1024 ParamBuffer params =
1025 ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIPROC>::type>(paramTokens,
1026 strings);
1027 return CallCapture(EntryPoint::GLBlendEquationSeparatei, std::move(params));
1028 }
1029 if (strcmp(nameToken, "glBlendEquationSeparateiEXT") == 0)
1030 {
1031 ParamBuffer params =
1032 ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIEXTPROC>::type>(
1033 paramTokens, strings);
1034 return CallCapture(EntryPoint::GLBlendEquationSeparateiEXT, std::move(params));
1035 }
1036 if (strcmp(nameToken, "glBlendEquationSeparateiOES") == 0)
1037 {
1038 ParamBuffer params =
1039 ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONSEPARATEIOESPROC>::type>(
1040 paramTokens, strings);
1041 return CallCapture(EntryPoint::GLBlendEquationSeparateiOES, std::move(params));
1042 }
1043 if (strcmp(nameToken, "glBlendEquationi") == 0)
1044 {
1045 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIPROC>::type>(
1046 paramTokens, strings);
1047 return CallCapture(EntryPoint::GLBlendEquationi, std::move(params));
1048 }
1049 if (strcmp(nameToken, "glBlendEquationiEXT") == 0)
1050 {
1051 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIEXTPROC>::type>(
1052 paramTokens, strings);
1053 return CallCapture(EntryPoint::GLBlendEquationiEXT, std::move(params));
1054 }
1055 if (strcmp(nameToken, "glBlendEquationiOES") == 0)
1056 {
1057 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDEQUATIONIOESPROC>::type>(
1058 paramTokens, strings);
1059 return CallCapture(EntryPoint::GLBlendEquationiOES, std::move(params));
1060 }
1061 if (strcmp(nameToken, "glBlendFunc") == 0)
1062 {
1063 ParamBuffer params =
1064 ParseParameters<std::remove_pointer<PFNGLBLENDFUNCPROC>::type>(paramTokens, strings);
1065 return CallCapture(EntryPoint::GLBlendFunc, std::move(params));
1066 }
1067 if (strcmp(nameToken, "glBlendFuncSeparate") == 0)
1068 {
1069 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEPROC>::type>(
1070 paramTokens, strings);
1071 return CallCapture(EntryPoint::GLBlendFuncSeparate, std::move(params));
1072 }
1073 if (strcmp(nameToken, "glBlendFuncSeparatei") == 0)
1074 {
1075 ParamBuffer params =
1076 ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIPROC>::type>(paramTokens,
1077 strings);
1078 return CallCapture(EntryPoint::GLBlendFuncSeparatei, std::move(params));
1079 }
1080 if (strcmp(nameToken, "glBlendFuncSeparateiEXT") == 0)
1081 {
1082 ParamBuffer params =
1083 ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIEXTPROC>::type>(paramTokens,
1084 strings);
1085 return CallCapture(EntryPoint::GLBlendFuncSeparateiEXT, std::move(params));
1086 }
1087 if (strcmp(nameToken, "glBlendFuncSeparateiOES") == 0)
1088 {
1089 ParamBuffer params =
1090 ParseParameters<std::remove_pointer<PFNGLBLENDFUNCSEPARATEIOESPROC>::type>(paramTokens,
1091 strings);
1092 return CallCapture(EntryPoint::GLBlendFuncSeparateiOES, std::move(params));
1093 }
1094 if (strcmp(nameToken, "glBlendFunci") == 0)
1095 {
1096 ParamBuffer params =
1097 ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIPROC>::type>(paramTokens, strings);
1098 return CallCapture(EntryPoint::GLBlendFunci, std::move(params));
1099 }
1100 if (strcmp(nameToken, "glBlendFunciEXT") == 0)
1101 {
1102 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIEXTPROC>::type>(
1103 paramTokens, strings);
1104 return CallCapture(EntryPoint::GLBlendFunciEXT, std::move(params));
1105 }
1106 if (strcmp(nameToken, "glBlendFunciOES") == 0)
1107 {
1108 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLENDFUNCIOESPROC>::type>(
1109 paramTokens, strings);
1110 return CallCapture(EntryPoint::GLBlendFunciOES, std::move(params));
1111 }
1112 if (strcmp(nameToken, "glBlitFramebuffer") == 0)
1113 {
1114 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERPROC>::type>(
1115 paramTokens, strings);
1116 return CallCapture(EntryPoint::GLBlitFramebuffer, std::move(params));
1117 }
1118 if (strcmp(nameToken, "glBlitFramebufferANGLE") == 0)
1119 {
1120 ParamBuffer params =
1121 ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERANGLEPROC>::type>(paramTokens,
1122 strings);
1123 return CallCapture(EntryPoint::GLBlitFramebufferANGLE, std::move(params));
1124 }
1125 if (strcmp(nameToken, "glBlitFramebufferNV") == 0)
1126 {
1127 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBLITFRAMEBUFFERNVPROC>::type>(
1128 paramTokens, strings);
1129 return CallCapture(EntryPoint::GLBlitFramebufferNV, std::move(params));
1130 }
1131 if (strcmp(nameToken, "glBlobCacheCallbacksANGLE") == 0)
1132 {
1133 ParamBuffer params =
1134 ParseParameters<std::remove_pointer<PFNGLBLOBCACHECALLBACKSANGLEPROC>::type>(
1135 paramTokens, strings);
1136 return CallCapture(EntryPoint::GLBlobCacheCallbacksANGLE, std::move(params));
1137 }
1138 if (strcmp(nameToken, "glBufferData") == 0)
1139 {
1140 ParamBuffer params =
1141 ParseParameters<std::remove_pointer<PFNGLBUFFERDATAPROC>::type>(paramTokens, strings);
1142 return CallCapture(EntryPoint::GLBufferData, std::move(params));
1143 }
1144 if (strcmp(nameToken, "glBufferStorageEXT") == 0)
1145 {
1146 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEEXTPROC>::type>(
1147 paramTokens, strings);
1148 return CallCapture(EntryPoint::GLBufferStorageEXT, std::move(params));
1149 }
1150 if (strcmp(nameToken, "glBufferStorageExternalEXT") == 0)
1151 {
1152 ParamBuffer params =
1153 ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEEXTERNALEXTPROC>::type>(
1154 paramTokens, strings);
1155 return CallCapture(EntryPoint::GLBufferStorageExternalEXT, std::move(params));
1156 }
1157 if (strcmp(nameToken, "glBufferStorageMemEXT") == 0)
1158 {
1159 ParamBuffer params =
1160 ParseParameters<std::remove_pointer<PFNGLBUFFERSTORAGEMEMEXTPROC>::type>(paramTokens,
1161 strings);
1162 return CallCapture(EntryPoint::GLBufferStorageMemEXT, std::move(params));
1163 }
1164 if (strcmp(nameToken, "glBufferSubData") == 0)
1165 {
1166 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLBUFFERSUBDATAPROC>::type>(
1167 paramTokens, strings);
1168 return CallCapture(EntryPoint::GLBufferSubData, std::move(params));
1169 }
1170 if (strcmp(nameToken, "glCheckFramebufferStatus") == 0)
1171 {
1172 ParamBuffer params =
1173 ParseParameters<std::remove_pointer<PFNGLCHECKFRAMEBUFFERSTATUSPROC>::type>(paramTokens,
1174 strings);
1175 return CallCapture(EntryPoint::GLCheckFramebufferStatus, std::move(params));
1176 }
1177 if (strcmp(nameToken, "glCheckFramebufferStatusOES") == 0)
1178 {
1179 ParamBuffer params =
1180 ParseParameters<std::remove_pointer<PFNGLCHECKFRAMEBUFFERSTATUSOESPROC>::type>(
1181 paramTokens, strings);
1182 return CallCapture(EntryPoint::GLCheckFramebufferStatusOES, std::move(params));
1183 }
1184 if (strcmp(nameToken, "glClear") == 0)
1185 {
1186 ParamBuffer params =
1187 ParseParameters<std::remove_pointer<PFNGLCLEARPROC>::type>(paramTokens, strings);
1188 return CallCapture(EntryPoint::GLClear, std::move(params));
1189 }
1190 if (strcmp(nameToken, "glClearBufferfi") == 0)
1191 {
1192 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERFIPROC>::type>(
1193 paramTokens, strings);
1194 return CallCapture(EntryPoint::GLClearBufferfi, std::move(params));
1195 }
1196 if (strcmp(nameToken, "glClearBufferfv") == 0)
1197 {
1198 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERFVPROC>::type>(
1199 paramTokens, strings);
1200 return CallCapture(EntryPoint::GLClearBufferfv, std::move(params));
1201 }
1202 if (strcmp(nameToken, "glClearBufferiv") == 0)
1203 {
1204 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERIVPROC>::type>(
1205 paramTokens, strings);
1206 return CallCapture(EntryPoint::GLClearBufferiv, std::move(params));
1207 }
1208 if (strcmp(nameToken, "glClearBufferuiv") == 0)
1209 {
1210 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARBUFFERUIVPROC>::type>(
1211 paramTokens, strings);
1212 return CallCapture(EntryPoint::GLClearBufferuiv, std::move(params));
1213 }
1214 if (strcmp(nameToken, "glClearColor") == 0)
1215 {
1216 ParamBuffer params =
1217 ParseParameters<std::remove_pointer<PFNGLCLEARCOLORPROC>::type>(paramTokens, strings);
1218 return CallCapture(EntryPoint::GLClearColor, std::move(params));
1219 }
1220 if (strcmp(nameToken, "glClearColorx") == 0)
1221 {
1222 ParamBuffer params =
1223 ParseParameters<std::remove_pointer<PFNGLCLEARCOLORXPROC>::type>(paramTokens, strings);
1224 return CallCapture(EntryPoint::GLClearColorx, std::move(params));
1225 }
1226 if (strcmp(nameToken, "glClearDepthf") == 0)
1227 {
1228 ParamBuffer params =
1229 ParseParameters<std::remove_pointer<PFNGLCLEARDEPTHFPROC>::type>(paramTokens, strings);
1230 return CallCapture(EntryPoint::GLClearDepthf, std::move(params));
1231 }
1232 if (strcmp(nameToken, "glClearDepthx") == 0)
1233 {
1234 ParamBuffer params =
1235 ParseParameters<std::remove_pointer<PFNGLCLEARDEPTHXPROC>::type>(paramTokens, strings);
1236 return CallCapture(EntryPoint::GLClearDepthx, std::move(params));
1237 }
1238 if (strcmp(nameToken, "glClearStencil") == 0)
1239 {
1240 ParamBuffer params =
1241 ParseParameters<std::remove_pointer<PFNGLCLEARSTENCILPROC>::type>(paramTokens, strings);
1242 return CallCapture(EntryPoint::GLClearStencil, std::move(params));
1243 }
1244 if (strcmp(nameToken, "glClearTexImageEXT") == 0)
1245 {
1246 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLEARTEXIMAGEEXTPROC>::type>(
1247 paramTokens, strings);
1248 return CallCapture(EntryPoint::GLClearTexImageEXT, std::move(params));
1249 }
1250 if (strcmp(nameToken, "glClearTexSubImageEXT") == 0)
1251 {
1252 ParamBuffer params =
1253 ParseParameters<std::remove_pointer<PFNGLCLEARTEXSUBIMAGEEXTPROC>::type>(paramTokens,
1254 strings);
1255 return CallCapture(EntryPoint::GLClearTexSubImageEXT, std::move(params));
1256 }
1257 if (strcmp(nameToken, "glClientActiveTexture") == 0)
1258 {
1259 ParamBuffer params =
1260 ParseParameters<std::remove_pointer<PFNGLCLIENTACTIVETEXTUREPROC>::type>(paramTokens,
1261 strings);
1262 return CallCapture(EntryPoint::GLClientActiveTexture, std::move(params));
1263 }
1264 if (strcmp(nameToken, "glClientWaitSync") == 0)
1265 {
1266 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLIENTWAITSYNCPROC>::type>(
1267 paramTokens, strings);
1268 return CallCapture(EntryPoint::GLClientWaitSync, std::move(params));
1269 }
1270 if (strcmp(nameToken, "glClipControlEXT") == 0)
1271 {
1272 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCLIPCONTROLEXTPROC>::type>(
1273 paramTokens, strings);
1274 return CallCapture(EntryPoint::GLClipControlEXT, std::move(params));
1275 }
1276 if (strcmp(nameToken, "glClipPlanef") == 0)
1277 {
1278 ParamBuffer params =
1279 ParseParameters<std::remove_pointer<PFNGLCLIPPLANEFPROC>::type>(paramTokens, strings);
1280 return CallCapture(EntryPoint::GLClipPlanef, std::move(params));
1281 }
1282 if (strcmp(nameToken, "glClipPlanex") == 0)
1283 {
1284 ParamBuffer params =
1285 ParseParameters<std::remove_pointer<PFNGLCLIPPLANEXPROC>::type>(paramTokens, strings);
1286 return CallCapture(EntryPoint::GLClipPlanex, std::move(params));
1287 }
1288 if (strcmp(nameToken, "glColor4f") == 0)
1289 {
1290 ParamBuffer params =
1291 ParseParameters<std::remove_pointer<PFNGLCOLOR4FPROC>::type>(paramTokens, strings);
1292 return CallCapture(EntryPoint::GLColor4f, std::move(params));
1293 }
1294 if (strcmp(nameToken, "glColor4ub") == 0)
1295 {
1296 ParamBuffer params =
1297 ParseParameters<std::remove_pointer<PFNGLCOLOR4UBPROC>::type>(paramTokens, strings);
1298 return CallCapture(EntryPoint::GLColor4ub, std::move(params));
1299 }
1300 if (strcmp(nameToken, "glColor4x") == 0)
1301 {
1302 ParamBuffer params =
1303 ParseParameters<std::remove_pointer<PFNGLCOLOR4XPROC>::type>(paramTokens, strings);
1304 return CallCapture(EntryPoint::GLColor4x, std::move(params));
1305 }
1306 if (strcmp(nameToken, "glColorMask") == 0)
1307 {
1308 ParamBuffer params =
1309 ParseParameters<std::remove_pointer<PFNGLCOLORMASKPROC>::type>(paramTokens, strings);
1310 return CallCapture(EntryPoint::GLColorMask, std::move(params));
1311 }
1312 if (strcmp(nameToken, "glColorMaski") == 0)
1313 {
1314 ParamBuffer params =
1315 ParseParameters<std::remove_pointer<PFNGLCOLORMASKIPROC>::type>(paramTokens, strings);
1316 return CallCapture(EntryPoint::GLColorMaski, std::move(params));
1317 }
1318 if (strcmp(nameToken, "glColorMaskiEXT") == 0)
1319 {
1320 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOLORMASKIEXTPROC>::type>(
1321 paramTokens, strings);
1322 return CallCapture(EntryPoint::GLColorMaskiEXT, std::move(params));
1323 }
1324 if (strcmp(nameToken, "glColorMaskiOES") == 0)
1325 {
1326 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOLORMASKIOESPROC>::type>(
1327 paramTokens, strings);
1328 return CallCapture(EntryPoint::GLColorMaskiOES, std::move(params));
1329 }
1330 if (strcmp(nameToken, "glColorPointer") == 0)
1331 {
1332 ParamBuffer params =
1333 ParseParameters<std::remove_pointer<PFNGLCOLORPOINTERPROC>::type>(paramTokens, strings);
1334 return CallCapture(EntryPoint::GLColorPointer, std::move(params));
1335 }
1336 if (strcmp(nameToken, "glCompileShader") == 0)
1337 {
1338 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOMPILESHADERPROC>::type>(
1339 paramTokens, strings);
1340 return CallCapture(EntryPoint::GLCompileShader, std::move(params));
1341 }
1342 if (strcmp(nameToken, "glCompressedCopyTextureCHROMIUM") == 0)
1343 {
1344 ParamBuffer params =
1345 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDCOPYTEXTURECHROMIUMPROC>::type>(
1346 paramTokens, strings);
1347 return CallCapture(EntryPoint::GLCompressedCopyTextureCHROMIUM, std::move(params));
1348 }
1349 if (strcmp(nameToken, "glCompressedTexImage2D") == 0)
1350 {
1351 ParamBuffer params =
1352 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE2DPROC>::type>(paramTokens,
1353 strings);
1354 return CallCapture(EntryPoint::GLCompressedTexImage2D, std::move(params));
1355 }
1356 if (strcmp(nameToken, "glCompressedTexImage2DRobustANGLE") == 0)
1357 {
1358 ParamBuffer params =
1359 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE2DROBUSTANGLEPROC>::type>(
1360 paramTokens, strings);
1361 return CallCapture(EntryPoint::GLCompressedTexImage2DRobustANGLE, std::move(params));
1362 }
1363 if (strcmp(nameToken, "glCompressedTexImage3D") == 0)
1364 {
1365 ParamBuffer params =
1366 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DPROC>::type>(paramTokens,
1367 strings);
1368 return CallCapture(EntryPoint::GLCompressedTexImage3D, std::move(params));
1369 }
1370 if (strcmp(nameToken, "glCompressedTexImage3DOES") == 0)
1371 {
1372 ParamBuffer params =
1373 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DOESPROC>::type>(
1374 paramTokens, strings);
1375 return CallCapture(EntryPoint::GLCompressedTexImage3DOES, std::move(params));
1376 }
1377 if (strcmp(nameToken, "glCompressedTexImage3DRobustANGLE") == 0)
1378 {
1379 ParamBuffer params =
1380 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXIMAGE3DROBUSTANGLEPROC>::type>(
1381 paramTokens, strings);
1382 return CallCapture(EntryPoint::GLCompressedTexImage3DRobustANGLE, std::move(params));
1383 }
1384 if (strcmp(nameToken, "glCompressedTexSubImage2D") == 0)
1385 {
1386 ParamBuffer params =
1387 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC>::type>(
1388 paramTokens, strings);
1389 return CallCapture(EntryPoint::GLCompressedTexSubImage2D, std::move(params));
1390 }
1391 if (strcmp(nameToken, "glCompressedTexSubImage2DRobustANGLE") == 0)
1392 {
1393 ParamBuffer params =
1394 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE2DROBUSTANGLEPROC>::type>(
1395 paramTokens, strings);
1396 return CallCapture(EntryPoint::GLCompressedTexSubImage2DRobustANGLE, std::move(params));
1397 }
1398 if (strcmp(nameToken, "glCompressedTexSubImage3D") == 0)
1399 {
1400 ParamBuffer params =
1401 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC>::type>(
1402 paramTokens, strings);
1403 return CallCapture(EntryPoint::GLCompressedTexSubImage3D, std::move(params));
1404 }
1405 if (strcmp(nameToken, "glCompressedTexSubImage3DOES") == 0)
1406 {
1407 ParamBuffer params =
1408 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC>::type>(
1409 paramTokens, strings);
1410 return CallCapture(EntryPoint::GLCompressedTexSubImage3DOES, std::move(params));
1411 }
1412 if (strcmp(nameToken, "glCompressedTexSubImage3DRobustANGLE") == 0)
1413 {
1414 ParamBuffer params =
1415 ParseParameters<std::remove_pointer<PFNGLCOMPRESSEDTEXSUBIMAGE3DROBUSTANGLEPROC>::type>(
1416 paramTokens, strings);
1417 return CallCapture(EntryPoint::GLCompressedTexSubImage3DRobustANGLE, std::move(params));
1418 }
1419 if (strcmp(nameToken, "glCopyBufferSubData") == 0)
1420 {
1421 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYBUFFERSUBDATAPROC>::type>(
1422 paramTokens, strings);
1423 return CallCapture(EntryPoint::GLCopyBufferSubData, std::move(params));
1424 }
1425 if (strcmp(nameToken, "glCopyImageSubData") == 0)
1426 {
1427 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAPROC>::type>(
1428 paramTokens, strings);
1429 return CallCapture(EntryPoint::GLCopyImageSubData, std::move(params));
1430 }
1431 if (strcmp(nameToken, "glCopyImageSubDataEXT") == 0)
1432 {
1433 ParamBuffer params =
1434 ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAEXTPROC>::type>(paramTokens,
1435 strings);
1436 return CallCapture(EntryPoint::GLCopyImageSubDataEXT, std::move(params));
1437 }
1438 if (strcmp(nameToken, "glCopyImageSubDataOES") == 0)
1439 {
1440 ParamBuffer params =
1441 ParseParameters<std::remove_pointer<PFNGLCOPYIMAGESUBDATAOESPROC>::type>(paramTokens,
1442 strings);
1443 return CallCapture(EntryPoint::GLCopyImageSubDataOES, std::move(params));
1444 }
1445 if (strcmp(nameToken, "glCopySubTexture3DANGLE") == 0)
1446 {
1447 ParamBuffer params =
1448 ParseParameters<std::remove_pointer<PFNGLCOPYSUBTEXTURE3DANGLEPROC>::type>(paramTokens,
1449 strings);
1450 return CallCapture(EntryPoint::GLCopySubTexture3DANGLE, std::move(params));
1451 }
1452 if (strcmp(nameToken, "glCopySubTextureCHROMIUM") == 0)
1453 {
1454 ParamBuffer params =
1455 ParseParameters<std::remove_pointer<PFNGLCOPYSUBTEXTURECHROMIUMPROC>::type>(paramTokens,
1456 strings);
1457 return CallCapture(EntryPoint::GLCopySubTextureCHROMIUM, std::move(params));
1458 }
1459 if (strcmp(nameToken, "glCopyTexImage2D") == 0)
1460 {
1461 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXIMAGE2DPROC>::type>(
1462 paramTokens, strings);
1463 return CallCapture(EntryPoint::GLCopyTexImage2D, std::move(params));
1464 }
1465 if (strcmp(nameToken, "glCopyTexSubImage2D") == 0)
1466 {
1467 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE2DPROC>::type>(
1468 paramTokens, strings);
1469 return CallCapture(EntryPoint::GLCopyTexSubImage2D, std::move(params));
1470 }
1471 if (strcmp(nameToken, "glCopyTexSubImage3D") == 0)
1472 {
1473 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE3DPROC>::type>(
1474 paramTokens, strings);
1475 return CallCapture(EntryPoint::GLCopyTexSubImage3D, std::move(params));
1476 }
1477 if (strcmp(nameToken, "glCopyTexSubImage3DOES") == 0)
1478 {
1479 ParamBuffer params =
1480 ParseParameters<std::remove_pointer<PFNGLCOPYTEXSUBIMAGE3DOESPROC>::type>(paramTokens,
1481 strings);
1482 return CallCapture(EntryPoint::GLCopyTexSubImage3DOES, std::move(params));
1483 }
1484 if (strcmp(nameToken, "glCopyTexture3DANGLE") == 0)
1485 {
1486 ParamBuffer params =
1487 ParseParameters<std::remove_pointer<PFNGLCOPYTEXTURE3DANGLEPROC>::type>(paramTokens,
1488 strings);
1489 return CallCapture(EntryPoint::GLCopyTexture3DANGLE, std::move(params));
1490 }
1491 if (strcmp(nameToken, "glCopyTextureCHROMIUM") == 0)
1492 {
1493 ParamBuffer params =
1494 ParseParameters<std::remove_pointer<PFNGLCOPYTEXTURECHROMIUMPROC>::type>(paramTokens,
1495 strings);
1496 return CallCapture(EntryPoint::GLCopyTextureCHROMIUM, std::move(params));
1497 }
1498 if (strcmp(nameToken, "glCoverageModulationCHROMIUM") == 0)
1499 {
1500 ParamBuffer params =
1501 ParseParameters<std::remove_pointer<PFNGLCOVERAGEMODULATIONCHROMIUMPROC>::type>(
1502 paramTokens, strings);
1503 return CallCapture(EntryPoint::GLCoverageModulationCHROMIUM, std::move(params));
1504 }
1505 if (strcmp(nameToken, "glCreateMemoryObjectsEXT") == 0)
1506 {
1507 ParamBuffer params =
1508 ParseParameters<std::remove_pointer<PFNGLCREATEMEMORYOBJECTSEXTPROC>::type>(paramTokens,
1509 strings);
1510 return CallCapture(EntryPoint::GLCreateMemoryObjectsEXT, std::move(params));
1511 }
1512 if (strcmp(nameToken, "glCreateProgram") == 0)
1513 {
1514 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLCREATEPROGRAMPROC>::type>(
1515 paramTokens, strings);
1516 return CallCapture(EntryPoint::GLCreateProgram, std::move(params));
1517 }
1518 if (strcmp(nameToken, "glCreateShader") == 0)
1519 {
1520 ParamBuffer params =
1521 ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROC>::type>(paramTokens, strings);
1522 return CallCapture(EntryPoint::GLCreateShader, std::move(params));
1523 }
1524 if (strcmp(nameToken, "glCreateShaderProgramv") == 0)
1525 {
1526 ParamBuffer params =
1527 ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROGRAMVPROC>::type>(paramTokens,
1528 strings);
1529 return CallCapture(EntryPoint::GLCreateShaderProgramv, std::move(params));
1530 }
1531 if (strcmp(nameToken, "glCreateShaderProgramvEXT") == 0)
1532 {
1533 ParamBuffer params =
1534 ParseParameters<std::remove_pointer<PFNGLCREATESHADERPROGRAMVEXTPROC>::type>(
1535 paramTokens, strings);
1536 return CallCapture(EntryPoint::GLCreateShaderProgramvEXT, std::move(params));
1537 }
1538 if (strcmp(nameToken, "glCullFace") == 0)
1539 {
1540 ParamBuffer params =
1541 ParseParameters<std::remove_pointer<PFNGLCULLFACEPROC>::type>(paramTokens, strings);
1542 return CallCapture(EntryPoint::GLCullFace, std::move(params));
1543 }
1544 if (strcmp(nameToken, "glCurrentPaletteMatrixOES") == 0)
1545 {
1546 ParamBuffer params =
1547 ParseParameters<std::remove_pointer<PFNGLCURRENTPALETTEMATRIXOESPROC>::type>(
1548 paramTokens, strings);
1549 return CallCapture(EntryPoint::GLCurrentPaletteMatrixOES, std::move(params));
1550 }
1551 if (strcmp(nameToken, "glDebugMessageCallback") == 0)
1552 {
1553 ParamBuffer params =
1554 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECALLBACKPROC>::type>(paramTokens,
1555 strings);
1556 return CallCapture(EntryPoint::GLDebugMessageCallback, std::move(params));
1557 }
1558 if (strcmp(nameToken, "glDebugMessageCallbackKHR") == 0)
1559 {
1560 ParamBuffer params =
1561 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECALLBACKKHRPROC>::type>(
1562 paramTokens, strings);
1563 return CallCapture(EntryPoint::GLDebugMessageCallbackKHR, std::move(params));
1564 }
1565 if (strcmp(nameToken, "glDebugMessageControl") == 0)
1566 {
1567 ParamBuffer params =
1568 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECONTROLPROC>::type>(paramTokens,
1569 strings);
1570 return CallCapture(EntryPoint::GLDebugMessageControl, std::move(params));
1571 }
1572 if (strcmp(nameToken, "glDebugMessageControlKHR") == 0)
1573 {
1574 ParamBuffer params =
1575 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGECONTROLKHRPROC>::type>(paramTokens,
1576 strings);
1577 return CallCapture(EntryPoint::GLDebugMessageControlKHR, std::move(params));
1578 }
1579 if (strcmp(nameToken, "glDebugMessageInsert") == 0)
1580 {
1581 ParamBuffer params =
1582 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGEINSERTPROC>::type>(paramTokens,
1583 strings);
1584 return CallCapture(EntryPoint::GLDebugMessageInsert, std::move(params));
1585 }
1586 if (strcmp(nameToken, "glDebugMessageInsertKHR") == 0)
1587 {
1588 ParamBuffer params =
1589 ParseParameters<std::remove_pointer<PFNGLDEBUGMESSAGEINSERTKHRPROC>::type>(paramTokens,
1590 strings);
1591 return CallCapture(EntryPoint::GLDebugMessageInsertKHR, std::move(params));
1592 }
1593 if (strcmp(nameToken, "glDeleteBuffers") == 0)
1594 {
1595 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEBUFFERSPROC>::type>(
1596 paramTokens, strings);
1597 return CallCapture(EntryPoint::GLDeleteBuffers, std::move(params));
1598 }
1599 if (strcmp(nameToken, "glDeleteFencesNV") == 0)
1600 {
1601 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEFENCESNVPROC>::type>(
1602 paramTokens, strings);
1603 return CallCapture(EntryPoint::GLDeleteFencesNV, std::move(params));
1604 }
1605 if (strcmp(nameToken, "glDeleteFramebuffers") == 0)
1606 {
1607 ParamBuffer params =
1608 ParseParameters<std::remove_pointer<PFNGLDELETEFRAMEBUFFERSPROC>::type>(paramTokens,
1609 strings);
1610 return CallCapture(EntryPoint::GLDeleteFramebuffers, std::move(params));
1611 }
1612 if (strcmp(nameToken, "glDeleteFramebuffersOES") == 0)
1613 {
1614 ParamBuffer params =
1615 ParseParameters<std::remove_pointer<PFNGLDELETEFRAMEBUFFERSOESPROC>::type>(paramTokens,
1616 strings);
1617 return CallCapture(EntryPoint::GLDeleteFramebuffersOES, std::move(params));
1618 }
1619 if (strcmp(nameToken, "glDeleteMemoryObjectsEXT") == 0)
1620 {
1621 ParamBuffer params =
1622 ParseParameters<std::remove_pointer<PFNGLDELETEMEMORYOBJECTSEXTPROC>::type>(paramTokens,
1623 strings);
1624 return CallCapture(EntryPoint::GLDeleteMemoryObjectsEXT, std::move(params));
1625 }
1626 if (strcmp(nameToken, "glDeletePerfMonitorsAMD") == 0)
1627 {
1628 ParamBuffer params =
1629 ParseParameters<std::remove_pointer<PFNGLDELETEPERFMONITORSAMDPROC>::type>(paramTokens,
1630 strings);
1631 return CallCapture(EntryPoint::GLDeletePerfMonitorsAMD, std::move(params));
1632 }
1633 if (strcmp(nameToken, "glDeleteProgram") == 0)
1634 {
1635 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPROC>::type>(
1636 paramTokens, strings);
1637 return CallCapture(EntryPoint::GLDeleteProgram, std::move(params));
1638 }
1639 if (strcmp(nameToken, "glDeleteProgramPipelines") == 0)
1640 {
1641 ParamBuffer params =
1642 ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPIPELINESPROC>::type>(paramTokens,
1643 strings);
1644 return CallCapture(EntryPoint::GLDeleteProgramPipelines, std::move(params));
1645 }
1646 if (strcmp(nameToken, "glDeleteProgramPipelinesEXT") == 0)
1647 {
1648 ParamBuffer params =
1649 ParseParameters<std::remove_pointer<PFNGLDELETEPROGRAMPIPELINESEXTPROC>::type>(
1650 paramTokens, strings);
1651 return CallCapture(EntryPoint::GLDeleteProgramPipelinesEXT, std::move(params));
1652 }
1653 if (strcmp(nameToken, "glDeleteQueries") == 0)
1654 {
1655 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEQUERIESPROC>::type>(
1656 paramTokens, strings);
1657 return CallCapture(EntryPoint::GLDeleteQueries, std::move(params));
1658 }
1659 if (strcmp(nameToken, "glDeleteQueriesEXT") == 0)
1660 {
1661 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETEQUERIESEXTPROC>::type>(
1662 paramTokens, strings);
1663 return CallCapture(EntryPoint::GLDeleteQueriesEXT, std::move(params));
1664 }
1665 if (strcmp(nameToken, "glDeleteRenderbuffers") == 0)
1666 {
1667 ParamBuffer params =
1668 ParseParameters<std::remove_pointer<PFNGLDELETERENDERBUFFERSPROC>::type>(paramTokens,
1669 strings);
1670 return CallCapture(EntryPoint::GLDeleteRenderbuffers, std::move(params));
1671 }
1672 if (strcmp(nameToken, "glDeleteRenderbuffersOES") == 0)
1673 {
1674 ParamBuffer params =
1675 ParseParameters<std::remove_pointer<PFNGLDELETERENDERBUFFERSOESPROC>::type>(paramTokens,
1676 strings);
1677 return CallCapture(EntryPoint::GLDeleteRenderbuffersOES, std::move(params));
1678 }
1679 if (strcmp(nameToken, "glDeleteSamplers") == 0)
1680 {
1681 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETESAMPLERSPROC>::type>(
1682 paramTokens, strings);
1683 return CallCapture(EntryPoint::GLDeleteSamplers, std::move(params));
1684 }
1685 if (strcmp(nameToken, "glDeleteSemaphoresEXT") == 0)
1686 {
1687 ParamBuffer params =
1688 ParseParameters<std::remove_pointer<PFNGLDELETESEMAPHORESEXTPROC>::type>(paramTokens,
1689 strings);
1690 return CallCapture(EntryPoint::GLDeleteSemaphoresEXT, std::move(params));
1691 }
1692 if (strcmp(nameToken, "glDeleteShader") == 0)
1693 {
1694 ParamBuffer params =
1695 ParseParameters<std::remove_pointer<PFNGLDELETESHADERPROC>::type>(paramTokens, strings);
1696 return CallCapture(EntryPoint::GLDeleteShader, std::move(params));
1697 }
1698 if (strcmp(nameToken, "glDeleteSync") == 0)
1699 {
1700 ParamBuffer params =
1701 ParseParameters<std::remove_pointer<PFNGLDELETESYNCPROC>::type>(paramTokens, strings);
1702 return CallCapture(EntryPoint::GLDeleteSync, std::move(params));
1703 }
1704 if (strcmp(nameToken, "glDeleteTextures") == 0)
1705 {
1706 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDELETETEXTURESPROC>::type>(
1707 paramTokens, strings);
1708 return CallCapture(EntryPoint::GLDeleteTextures, std::move(params));
1709 }
1710 if (strcmp(nameToken, "glDeleteTransformFeedbacks") == 0)
1711 {
1712 ParamBuffer params =
1713 ParseParameters<std::remove_pointer<PFNGLDELETETRANSFORMFEEDBACKSPROC>::type>(
1714 paramTokens, strings);
1715 return CallCapture(EntryPoint::GLDeleteTransformFeedbacks, std::move(params));
1716 }
1717 if (strcmp(nameToken, "glDeleteVertexArrays") == 0)
1718 {
1719 ParamBuffer params =
1720 ParseParameters<std::remove_pointer<PFNGLDELETEVERTEXARRAYSPROC>::type>(paramTokens,
1721 strings);
1722 return CallCapture(EntryPoint::GLDeleteVertexArrays, std::move(params));
1723 }
1724 if (strcmp(nameToken, "glDeleteVertexArraysOES") == 0)
1725 {
1726 ParamBuffer params =
1727 ParseParameters<std::remove_pointer<PFNGLDELETEVERTEXARRAYSOESPROC>::type>(paramTokens,
1728 strings);
1729 return CallCapture(EntryPoint::GLDeleteVertexArraysOES, std::move(params));
1730 }
1731 if (strcmp(nameToken, "glDepthFunc") == 0)
1732 {
1733 ParamBuffer params =
1734 ParseParameters<std::remove_pointer<PFNGLDEPTHFUNCPROC>::type>(paramTokens, strings);
1735 return CallCapture(EntryPoint::GLDepthFunc, std::move(params));
1736 }
1737 if (strcmp(nameToken, "glDepthMask") == 0)
1738 {
1739 ParamBuffer params =
1740 ParseParameters<std::remove_pointer<PFNGLDEPTHMASKPROC>::type>(paramTokens, strings);
1741 return CallCapture(EntryPoint::GLDepthMask, std::move(params));
1742 }
1743 if (strcmp(nameToken, "glDepthRangef") == 0)
1744 {
1745 ParamBuffer params =
1746 ParseParameters<std::remove_pointer<PFNGLDEPTHRANGEFPROC>::type>(paramTokens, strings);
1747 return CallCapture(EntryPoint::GLDepthRangef, std::move(params));
1748 }
1749 if (strcmp(nameToken, "glDepthRangex") == 0)
1750 {
1751 ParamBuffer params =
1752 ParseParameters<std::remove_pointer<PFNGLDEPTHRANGEXPROC>::type>(paramTokens, strings);
1753 return CallCapture(EntryPoint::GLDepthRangex, std::move(params));
1754 }
1755 if (strcmp(nameToken, "glDetachShader") == 0)
1756 {
1757 ParamBuffer params =
1758 ParseParameters<std::remove_pointer<PFNGLDETACHSHADERPROC>::type>(paramTokens, strings);
1759 return CallCapture(EntryPoint::GLDetachShader, std::move(params));
1760 }
1761 if (strcmp(nameToken, "glDisable") == 0)
1762 {
1763 ParamBuffer params =
1764 ParseParameters<std::remove_pointer<PFNGLDISABLEPROC>::type>(paramTokens, strings);
1765 return CallCapture(EntryPoint::GLDisable, std::move(params));
1766 }
1767 if (strcmp(nameToken, "glDisableClientState") == 0)
1768 {
1769 ParamBuffer params =
1770 ParseParameters<std::remove_pointer<PFNGLDISABLECLIENTSTATEPROC>::type>(paramTokens,
1771 strings);
1772 return CallCapture(EntryPoint::GLDisableClientState, std::move(params));
1773 }
1774 if (strcmp(nameToken, "glDisableExtensionANGLE") == 0)
1775 {
1776 ParamBuffer params =
1777 ParseParameters<std::remove_pointer<PFNGLDISABLEEXTENSIONANGLEPROC>::type>(paramTokens,
1778 strings);
1779 return CallCapture(EntryPoint::GLDisableExtensionANGLE, std::move(params));
1780 }
1781 if (strcmp(nameToken, "glDisableVertexAttribArray") == 0)
1782 {
1783 ParamBuffer params =
1784 ParseParameters<std::remove_pointer<PFNGLDISABLEVERTEXATTRIBARRAYPROC>::type>(
1785 paramTokens, strings);
1786 return CallCapture(EntryPoint::GLDisableVertexAttribArray, std::move(params));
1787 }
1788 if (strcmp(nameToken, "glDisablei") == 0)
1789 {
1790 ParamBuffer params =
1791 ParseParameters<std::remove_pointer<PFNGLDISABLEIPROC>::type>(paramTokens, strings);
1792 return CallCapture(EntryPoint::GLDisablei, std::move(params));
1793 }
1794 if (strcmp(nameToken, "glDisableiEXT") == 0)
1795 {
1796 ParamBuffer params =
1797 ParseParameters<std::remove_pointer<PFNGLDISABLEIEXTPROC>::type>(paramTokens, strings);
1798 return CallCapture(EntryPoint::GLDisableiEXT, std::move(params));
1799 }
1800 if (strcmp(nameToken, "glDisableiOES") == 0)
1801 {
1802 ParamBuffer params =
1803 ParseParameters<std::remove_pointer<PFNGLDISABLEIOESPROC>::type>(paramTokens, strings);
1804 return CallCapture(EntryPoint::GLDisableiOES, std::move(params));
1805 }
1806 if (strcmp(nameToken, "glDiscardFramebufferEXT") == 0)
1807 {
1808 ParamBuffer params =
1809 ParseParameters<std::remove_pointer<PFNGLDISCARDFRAMEBUFFEREXTPROC>::type>(paramTokens,
1810 strings);
1811 return CallCapture(EntryPoint::GLDiscardFramebufferEXT, std::move(params));
1812 }
1813 if (strcmp(nameToken, "glDispatchCompute") == 0)
1814 {
1815 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDISPATCHCOMPUTEPROC>::type>(
1816 paramTokens, strings);
1817 return CallCapture(EntryPoint::GLDispatchCompute, std::move(params));
1818 }
1819 if (strcmp(nameToken, "glDispatchComputeIndirect") == 0)
1820 {
1821 ParamBuffer params =
1822 ParseParameters<std::remove_pointer<PFNGLDISPATCHCOMPUTEINDIRECTPROC>::type>(
1823 paramTokens, strings);
1824 return CallCapture(EntryPoint::GLDispatchComputeIndirect, std::move(params));
1825 }
1826 if (strcmp(nameToken, "glDrawArrays") == 0)
1827 {
1828 ParamBuffer params =
1829 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSPROC>::type>(paramTokens, strings);
1830 return CallCapture(EntryPoint::GLDrawArrays, std::move(params));
1831 }
1832 if (strcmp(nameToken, "glDrawArraysIndirect") == 0)
1833 {
1834 ParamBuffer params =
1835 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINDIRECTPROC>::type>(paramTokens,
1836 strings);
1837 return CallCapture(EntryPoint::GLDrawArraysIndirect, std::move(params));
1838 }
1839 if (strcmp(nameToken, "glDrawArraysInstanced") == 0)
1840 {
1841 ParamBuffer params =
1842 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDPROC>::type>(paramTokens,
1843 strings);
1844 return CallCapture(EntryPoint::GLDrawArraysInstanced, std::move(params));
1845 }
1846 if (strcmp(nameToken, "glDrawArraysInstancedANGLE") == 0)
1847 {
1848 ParamBuffer params =
1849 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDANGLEPROC>::type>(
1850 paramTokens, strings);
1851 return CallCapture(EntryPoint::GLDrawArraysInstancedANGLE, std::move(params));
1852 }
1853 if (strcmp(nameToken, "glDrawArraysInstancedBaseInstanceANGLE") == 0)
1854 {
1855 ParamBuffer params = ParseParameters<
1856 std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC>::type>(paramTokens,
1857 strings);
1858 return CallCapture(EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE, std::move(params));
1859 }
1860 if (strcmp(nameToken, "glDrawArraysInstancedBaseInstanceEXT") == 0)
1861 {
1862 ParamBuffer params =
1863 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC>::type>(
1864 paramTokens, strings);
1865 return CallCapture(EntryPoint::GLDrawArraysInstancedBaseInstanceEXT, std::move(params));
1866 }
1867 if (strcmp(nameToken, "glDrawArraysInstancedEXT") == 0)
1868 {
1869 ParamBuffer params =
1870 ParseParameters<std::remove_pointer<PFNGLDRAWARRAYSINSTANCEDEXTPROC>::type>(paramTokens,
1871 strings);
1872 return CallCapture(EntryPoint::GLDrawArraysInstancedEXT, std::move(params));
1873 }
1874 if (strcmp(nameToken, "glDrawBuffers") == 0)
1875 {
1876 ParamBuffer params =
1877 ParseParameters<std::remove_pointer<PFNGLDRAWBUFFERSPROC>::type>(paramTokens, strings);
1878 return CallCapture(EntryPoint::GLDrawBuffers, std::move(params));
1879 }
1880 if (strcmp(nameToken, "glDrawBuffersEXT") == 0)
1881 {
1882 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDRAWBUFFERSEXTPROC>::type>(
1883 paramTokens, strings);
1884 return CallCapture(EntryPoint::GLDrawBuffersEXT, std::move(params));
1885 }
1886 if (strcmp(nameToken, "glDrawElements") == 0)
1887 {
1888 ParamBuffer params =
1889 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSPROC>::type>(paramTokens, strings);
1890 return CallCapture(EntryPoint::GLDrawElements, std::move(params));
1891 }
1892 if (strcmp(nameToken, "glDrawElementsBaseVertex") == 0)
1893 {
1894 ParamBuffer params =
1895 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXPROC>::type>(paramTokens,
1896 strings);
1897 return CallCapture(EntryPoint::GLDrawElementsBaseVertex, std::move(params));
1898 }
1899 if (strcmp(nameToken, "glDrawElementsBaseVertexEXT") == 0)
1900 {
1901 ParamBuffer params =
1902 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXEXTPROC>::type>(
1903 paramTokens, strings);
1904 return CallCapture(EntryPoint::GLDrawElementsBaseVertexEXT, std::move(params));
1905 }
1906 if (strcmp(nameToken, "glDrawElementsBaseVertexOES") == 0)
1907 {
1908 ParamBuffer params =
1909 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSBASEVERTEXOESPROC>::type>(
1910 paramTokens, strings);
1911 return CallCapture(EntryPoint::GLDrawElementsBaseVertexOES, std::move(params));
1912 }
1913 if (strcmp(nameToken, "glDrawElementsIndirect") == 0)
1914 {
1915 ParamBuffer params =
1916 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINDIRECTPROC>::type>(paramTokens,
1917 strings);
1918 return CallCapture(EntryPoint::GLDrawElementsIndirect, std::move(params));
1919 }
1920 if (strcmp(nameToken, "glDrawElementsInstanced") == 0)
1921 {
1922 ParamBuffer params =
1923 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDPROC>::type>(paramTokens,
1924 strings);
1925 return CallCapture(EntryPoint::GLDrawElementsInstanced, std::move(params));
1926 }
1927 if (strcmp(nameToken, "glDrawElementsInstancedANGLE") == 0)
1928 {
1929 ParamBuffer params =
1930 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDANGLEPROC>::type>(
1931 paramTokens, strings);
1932 return CallCapture(EntryPoint::GLDrawElementsInstancedANGLE, std::move(params));
1933 }
1934 if (strcmp(nameToken, "glDrawElementsInstancedBaseInstanceEXT") == 0)
1935 {
1936 ParamBuffer params = ParseParameters<
1937 std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC>::type>(paramTokens,
1938 strings);
1939 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseInstanceEXT, std::move(params));
1940 }
1941 if (strcmp(nameToken, "glDrawElementsInstancedBaseVertex") == 0)
1942 {
1943 ParamBuffer params =
1944 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC>::type>(
1945 paramTokens, strings);
1946 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertex, std::move(params));
1947 }
1948 if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexBaseInstanceANGLE") == 0)
1949 {
1950 ParamBuffer params = ParseParameters<
1951 std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC>::type>(
1952 paramTokens, strings);
1953 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE,
1954 std::move(params));
1955 }
1956 if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexBaseInstanceEXT") == 0)
1957 {
1958 ParamBuffer params = ParseParameters<
1959 std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC>::type>(
1960 paramTokens, strings);
1961 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT,
1962 std::move(params));
1963 }
1964 if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexEXT") == 0)
1965 {
1966 ParamBuffer params =
1967 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC>::type>(
1968 paramTokens, strings);
1969 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexEXT, std::move(params));
1970 }
1971 if (strcmp(nameToken, "glDrawElementsInstancedBaseVertexOES") == 0)
1972 {
1973 ParamBuffer params =
1974 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXOESPROC>::type>(
1975 paramTokens, strings);
1976 return CallCapture(EntryPoint::GLDrawElementsInstancedBaseVertexOES, std::move(params));
1977 }
1978 if (strcmp(nameToken, "glDrawElementsInstancedEXT") == 0)
1979 {
1980 ParamBuffer params =
1981 ParseParameters<std::remove_pointer<PFNGLDRAWELEMENTSINSTANCEDEXTPROC>::type>(
1982 paramTokens, strings);
1983 return CallCapture(EntryPoint::GLDrawElementsInstancedEXT, std::move(params));
1984 }
1985 if (strcmp(nameToken, "glDrawRangeElements") == 0)
1986 {
1987 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSPROC>::type>(
1988 paramTokens, strings);
1989 return CallCapture(EntryPoint::GLDrawRangeElements, std::move(params));
1990 }
1991 if (strcmp(nameToken, "glDrawRangeElementsBaseVertex") == 0)
1992 {
1993 ParamBuffer params =
1994 ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC>::type>(
1995 paramTokens, strings);
1996 return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertex, std::move(params));
1997 }
1998 if (strcmp(nameToken, "glDrawRangeElementsBaseVertexEXT") == 0)
1999 {
2000 ParamBuffer params =
2001 ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC>::type>(
2002 paramTokens, strings);
2003 return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertexEXT, std::move(params));
2004 }
2005 if (strcmp(nameToken, "glDrawRangeElementsBaseVertexOES") == 0)
2006 {
2007 ParamBuffer params =
2008 ParseParameters<std::remove_pointer<PFNGLDRAWRANGEELEMENTSBASEVERTEXOESPROC>::type>(
2009 paramTokens, strings);
2010 return CallCapture(EntryPoint::GLDrawRangeElementsBaseVertexOES, std::move(params));
2011 }
2012 if (strcmp(nameToken, "glDrawTexfOES") == 0)
2013 {
2014 ParamBuffer params =
2015 ParseParameters<std::remove_pointer<PFNGLDRAWTEXFOESPROC>::type>(paramTokens, strings);
2016 return CallCapture(EntryPoint::GLDrawTexfOES, std::move(params));
2017 }
2018 if (strcmp(nameToken, "glDrawTexfvOES") == 0)
2019 {
2020 ParamBuffer params =
2021 ParseParameters<std::remove_pointer<PFNGLDRAWTEXFVOESPROC>::type>(paramTokens, strings);
2022 return CallCapture(EntryPoint::GLDrawTexfvOES, std::move(params));
2023 }
2024 if (strcmp(nameToken, "glDrawTexiOES") == 0)
2025 {
2026 ParamBuffer params =
2027 ParseParameters<std::remove_pointer<PFNGLDRAWTEXIOESPROC>::type>(paramTokens, strings);
2028 return CallCapture(EntryPoint::GLDrawTexiOES, std::move(params));
2029 }
2030 if (strcmp(nameToken, "glDrawTexivOES") == 0)
2031 {
2032 ParamBuffer params =
2033 ParseParameters<std::remove_pointer<PFNGLDRAWTEXIVOESPROC>::type>(paramTokens, strings);
2034 return CallCapture(EntryPoint::GLDrawTexivOES, std::move(params));
2035 }
2036 if (strcmp(nameToken, "glDrawTexsOES") == 0)
2037 {
2038 ParamBuffer params =
2039 ParseParameters<std::remove_pointer<PFNGLDRAWTEXSOESPROC>::type>(paramTokens, strings);
2040 return CallCapture(EntryPoint::GLDrawTexsOES, std::move(params));
2041 }
2042 if (strcmp(nameToken, "glDrawTexsvOES") == 0)
2043 {
2044 ParamBuffer params =
2045 ParseParameters<std::remove_pointer<PFNGLDRAWTEXSVOESPROC>::type>(paramTokens, strings);
2046 return CallCapture(EntryPoint::GLDrawTexsvOES, std::move(params));
2047 }
2048 if (strcmp(nameToken, "glDrawTexxOES") == 0)
2049 {
2050 ParamBuffer params =
2051 ParseParameters<std::remove_pointer<PFNGLDRAWTEXXOESPROC>::type>(paramTokens, strings);
2052 return CallCapture(EntryPoint::GLDrawTexxOES, std::move(params));
2053 }
2054 if (strcmp(nameToken, "glDrawTexxvOES") == 0)
2055 {
2056 ParamBuffer params =
2057 ParseParameters<std::remove_pointer<PFNGLDRAWTEXXVOESPROC>::type>(paramTokens, strings);
2058 return CallCapture(EntryPoint::GLDrawTexxvOES, std::move(params));
2059 }
2060 if (strcmp(nameToken, "glEGLImageTargetRenderbufferStorageOES") == 0)
2061 {
2062 ParamBuffer params = ParseParameters<
2063 std::remove_pointer<PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC>::type>(paramTokens,
2064 strings);
2065 return CallCapture(EntryPoint::GLEGLImageTargetRenderbufferStorageOES, std::move(params));
2066 }
2067 if (strcmp(nameToken, "glEGLImageTargetTexStorageEXT") == 0)
2068 {
2069 ParamBuffer params =
2070 ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC>::type>(
2071 paramTokens, strings);
2072 return CallCapture(EntryPoint::GLEGLImageTargetTexStorageEXT, std::move(params));
2073 }
2074 if (strcmp(nameToken, "glEGLImageTargetTexture2DOES") == 0)
2075 {
2076 ParamBuffer params =
2077 ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXTURE2DOESPROC>::type>(
2078 paramTokens, strings);
2079 return CallCapture(EntryPoint::GLEGLImageTargetTexture2DOES, std::move(params));
2080 }
2081 if (strcmp(nameToken, "glEGLImageTargetTextureStorageEXT") == 0)
2082 {
2083 ParamBuffer params =
2084 ParseParameters<std::remove_pointer<PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC>::type>(
2085 paramTokens, strings);
2086 return CallCapture(EntryPoint::GLEGLImageTargetTextureStorageEXT, std::move(params));
2087 }
2088 if (strcmp(nameToken, "glEnable") == 0)
2089 {
2090 ParamBuffer params =
2091 ParseParameters<std::remove_pointer<PFNGLENABLEPROC>::type>(paramTokens, strings);
2092 return CallCapture(EntryPoint::GLEnable, std::move(params));
2093 }
2094 if (strcmp(nameToken, "glEnableClientState") == 0)
2095 {
2096 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENABLECLIENTSTATEPROC>::type>(
2097 paramTokens, strings);
2098 return CallCapture(EntryPoint::GLEnableClientState, std::move(params));
2099 }
2100 if (strcmp(nameToken, "glEnableVertexAttribArray") == 0)
2101 {
2102 ParamBuffer params =
2103 ParseParameters<std::remove_pointer<PFNGLENABLEVERTEXATTRIBARRAYPROC>::type>(
2104 paramTokens, strings);
2105 return CallCapture(EntryPoint::GLEnableVertexAttribArray, std::move(params));
2106 }
2107 if (strcmp(nameToken, "glEnablei") == 0)
2108 {
2109 ParamBuffer params =
2110 ParseParameters<std::remove_pointer<PFNGLENABLEIPROC>::type>(paramTokens, strings);
2111 return CallCapture(EntryPoint::GLEnablei, std::move(params));
2112 }
2113 if (strcmp(nameToken, "glEnableiEXT") == 0)
2114 {
2115 ParamBuffer params =
2116 ParseParameters<std::remove_pointer<PFNGLENABLEIEXTPROC>::type>(paramTokens, strings);
2117 return CallCapture(EntryPoint::GLEnableiEXT, std::move(params));
2118 }
2119 if (strcmp(nameToken, "glEnableiOES") == 0)
2120 {
2121 ParamBuffer params =
2122 ParseParameters<std::remove_pointer<PFNGLENABLEIOESPROC>::type>(paramTokens, strings);
2123 return CallCapture(EntryPoint::GLEnableiOES, std::move(params));
2124 }
2125 if (strcmp(nameToken, "glEndPerfMonitorAMD") == 0)
2126 {
2127 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENDPERFMONITORAMDPROC>::type>(
2128 paramTokens, strings);
2129 return CallCapture(EntryPoint::GLEndPerfMonitorAMD, std::move(params));
2130 }
2131 if (strcmp(nameToken, "glEndPixelLocalStorageANGLE") == 0)
2132 {
2133 ParamBuffer params =
2134 ParseParameters<std::remove_pointer<PFNGLENDPIXELLOCALSTORAGEANGLEPROC>::type>(
2135 paramTokens, strings);
2136 return CallCapture(EntryPoint::GLEndPixelLocalStorageANGLE, std::move(params));
2137 }
2138 if (strcmp(nameToken, "glEndQuery") == 0)
2139 {
2140 ParamBuffer params =
2141 ParseParameters<std::remove_pointer<PFNGLENDQUERYPROC>::type>(paramTokens, strings);
2142 return CallCapture(EntryPoint::GLEndQuery, std::move(params));
2143 }
2144 if (strcmp(nameToken, "glEndQueryEXT") == 0)
2145 {
2146 ParamBuffer params =
2147 ParseParameters<std::remove_pointer<PFNGLENDQUERYEXTPROC>::type>(paramTokens, strings);
2148 return CallCapture(EntryPoint::GLEndQueryEXT, std::move(params));
2149 }
2150 if (strcmp(nameToken, "glEndTilingQCOM") == 0)
2151 {
2152 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLENDTILINGQCOMPROC>::type>(
2153 paramTokens, strings);
2154 return CallCapture(EntryPoint::GLEndTilingQCOM, std::move(params));
2155 }
2156 if (strcmp(nameToken, "glEndTransformFeedback") == 0)
2157 {
2158 ParamBuffer params =
2159 ParseParameters<std::remove_pointer<PFNGLENDTRANSFORMFEEDBACKPROC>::type>(paramTokens,
2160 strings);
2161 return CallCapture(EntryPoint::GLEndTransformFeedback, std::move(params));
2162 }
2163 if (strcmp(nameToken, "glFenceSync") == 0)
2164 {
2165 ParamBuffer params =
2166 ParseParameters<std::remove_pointer<PFNGLFENCESYNCPROC>::type>(paramTokens, strings);
2167 return CallCapture(EntryPoint::GLFenceSync, std::move(params));
2168 }
2169 if (strcmp(nameToken, "glFinish") == 0)
2170 {
2171 ParamBuffer params =
2172 ParseParameters<std::remove_pointer<PFNGLFINISHPROC>::type>(paramTokens, strings);
2173 return CallCapture(EntryPoint::GLFinish, std::move(params));
2174 }
2175 if (strcmp(nameToken, "glFinishFenceNV") == 0)
2176 {
2177 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLFINISHFENCENVPROC>::type>(
2178 paramTokens, strings);
2179 return CallCapture(EntryPoint::GLFinishFenceNV, std::move(params));
2180 }
2181 if (strcmp(nameToken, "glFlush") == 0)
2182 {
2183 ParamBuffer params =
2184 ParseParameters<std::remove_pointer<PFNGLFLUSHPROC>::type>(paramTokens, strings);
2185 return CallCapture(EntryPoint::GLFlush, std::move(params));
2186 }
2187 if (strcmp(nameToken, "glFlushMappedBufferRange") == 0)
2188 {
2189 ParamBuffer params =
2190 ParseParameters<std::remove_pointer<PFNGLFLUSHMAPPEDBUFFERRANGEPROC>::type>(paramTokens,
2191 strings);
2192 return CallCapture(EntryPoint::GLFlushMappedBufferRange, std::move(params));
2193 }
2194 if (strcmp(nameToken, "glFlushMappedBufferRangeEXT") == 0)
2195 {
2196 ParamBuffer params =
2197 ParseParameters<std::remove_pointer<PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC>::type>(
2198 paramTokens, strings);
2199 return CallCapture(EntryPoint::GLFlushMappedBufferRangeEXT, std::move(params));
2200 }
2201 if (strcmp(nameToken, "glFogf") == 0)
2202 {
2203 ParamBuffer params =
2204 ParseParameters<std::remove_pointer<PFNGLFOGFPROC>::type>(paramTokens, strings);
2205 return CallCapture(EntryPoint::GLFogf, std::move(params));
2206 }
2207 if (strcmp(nameToken, "glFogfv") == 0)
2208 {
2209 ParamBuffer params =
2210 ParseParameters<std::remove_pointer<PFNGLFOGFVPROC>::type>(paramTokens, strings);
2211 return CallCapture(EntryPoint::GLFogfv, std::move(params));
2212 }
2213 if (strcmp(nameToken, "glFogx") == 0)
2214 {
2215 ParamBuffer params =
2216 ParseParameters<std::remove_pointer<PFNGLFOGXPROC>::type>(paramTokens, strings);
2217 return CallCapture(EntryPoint::GLFogx, std::move(params));
2218 }
2219 if (strcmp(nameToken, "glFogxv") == 0)
2220 {
2221 ParamBuffer params =
2222 ParseParameters<std::remove_pointer<PFNGLFOGXVPROC>::type>(paramTokens, strings);
2223 return CallCapture(EntryPoint::GLFogxv, std::move(params));
2224 }
2225 if (strcmp(nameToken, "glFramebufferFetchBarrierEXT") == 0)
2226 {
2227 ParamBuffer params =
2228 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC>::type>(
2229 paramTokens, strings);
2230 return CallCapture(EntryPoint::GLFramebufferFetchBarrierEXT, std::move(params));
2231 }
2232 if (strcmp(nameToken, "glFramebufferFoveationConfigQCOM") == 0)
2233 {
2234 ParamBuffer params =
2235 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC>::type>(
2236 paramTokens, strings);
2237 return CallCapture(EntryPoint::GLFramebufferFoveationConfigQCOM, std::move(params));
2238 }
2239 if (strcmp(nameToken, "glFramebufferFoveationParametersQCOM") == 0)
2240 {
2241 ParamBuffer params =
2242 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC>::type>(
2243 paramTokens, strings);
2244 return CallCapture(EntryPoint::GLFramebufferFoveationParametersQCOM, std::move(params));
2245 }
2246 if (strcmp(nameToken, "glFramebufferMemorylessPixelLocalStorageANGLE") == 0)
2247 {
2248 ParamBuffer params = ParseParameters<
2249 std::remove_pointer<PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC>::type>(
2250 paramTokens, strings);
2251 return CallCapture(EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE,
2252 std::move(params));
2253 }
2254 if (strcmp(nameToken, "glFramebufferParameteri") == 0)
2255 {
2256 ParamBuffer params =
2257 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIPROC>::type>(paramTokens,
2258 strings);
2259 return CallCapture(EntryPoint::GLFramebufferParameteri, std::move(params));
2260 }
2261 if (strcmp(nameToken, "glFramebufferParameteriMESA") == 0)
2262 {
2263 ParamBuffer params =
2264 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIMESAPROC>::type>(
2265 paramTokens, strings);
2266 return CallCapture(EntryPoint::GLFramebufferParameteriMESA, std::move(params));
2267 }
2268 if (strcmp(nameToken, "glFramebufferPixelLocalClearValuefvANGLE") == 0)
2269 {
2270 ParamBuffer params = ParseParameters<
2271 std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC>::type>(paramTokens,
2272 strings);
2273 return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE, std::move(params));
2274 }
2275 if (strcmp(nameToken, "glFramebufferPixelLocalClearValueivANGLE") == 0)
2276 {
2277 ParamBuffer params = ParseParameters<
2278 std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC>::type>(paramTokens,
2279 strings);
2280 return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueivANGLE, std::move(params));
2281 }
2282 if (strcmp(nameToken, "glFramebufferPixelLocalClearValueuivANGLE") == 0)
2283 {
2284 ParamBuffer params = ParseParameters<
2285 std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC>::type>(
2286 paramTokens, strings);
2287 return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE,
2288 std::move(params));
2289 }
2290 if (strcmp(nameToken, "glFramebufferPixelLocalStorageInterruptANGLE") == 0)
2291 {
2292 ParamBuffer params = ParseParameters<
2293 std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGEINTERRUPTANGLEPROC>::type>(
2294 paramTokens, strings);
2295 return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE,
2296 std::move(params));
2297 }
2298 if (strcmp(nameToken, "glFramebufferPixelLocalStorageRestoreANGLE") == 0)
2299 {
2300 ParamBuffer params = ParseParameters<
2301 std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGERESTOREANGLEPROC>::type>(
2302 paramTokens, strings);
2303 return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE,
2304 std::move(params));
2305 }
2306 if (strcmp(nameToken, "glFramebufferRenderbuffer") == 0)
2307 {
2308 ParamBuffer params =
2309 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFERPROC>::type>(
2310 paramTokens, strings);
2311 return CallCapture(EntryPoint::GLFramebufferRenderbuffer, std::move(params));
2312 }
2313 if (strcmp(nameToken, "glFramebufferRenderbufferOES") == 0)
2314 {
2315 ParamBuffer params =
2316 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFEROESPROC>::type>(
2317 paramTokens, strings);
2318 return CallCapture(EntryPoint::GLFramebufferRenderbufferOES, std::move(params));
2319 }
2320 if (strcmp(nameToken, "glFramebufferTexture") == 0)
2321 {
2322 ParamBuffer params =
2323 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPROC>::type>(paramTokens,
2324 strings);
2325 return CallCapture(EntryPoint::GLFramebufferTexture, std::move(params));
2326 }
2327 if (strcmp(nameToken, "glFramebufferTexture2D") == 0)
2328 {
2329 ParamBuffer params =
2330 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DPROC>::type>(paramTokens,
2331 strings);
2332 return CallCapture(EntryPoint::GLFramebufferTexture2D, std::move(params));
2333 }
2334 if (strcmp(nameToken, "glFramebufferTexture2DMultisampleEXT") == 0)
2335 {
2336 ParamBuffer params =
2337 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC>::type>(
2338 paramTokens, strings);
2339 return CallCapture(EntryPoint::GLFramebufferTexture2DMultisampleEXT, std::move(params));
2340 }
2341 if (strcmp(nameToken, "glFramebufferTexture2DOES") == 0)
2342 {
2343 ParamBuffer params =
2344 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DOESPROC>::type>(
2345 paramTokens, strings);
2346 return CallCapture(EntryPoint::GLFramebufferTexture2DOES, std::move(params));
2347 }
2348 if (strcmp(nameToken, "glFramebufferTexture3DOES") == 0)
2349 {
2350 ParamBuffer params =
2351 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE3DOESPROC>::type>(
2352 paramTokens, strings);
2353 return CallCapture(EntryPoint::GLFramebufferTexture3DOES, std::move(params));
2354 }
2355 if (strcmp(nameToken, "glFramebufferTextureEXT") == 0)
2356 {
2357 ParamBuffer params =
2358 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREEXTPROC>::type>(paramTokens,
2359 strings);
2360 return CallCapture(EntryPoint::GLFramebufferTextureEXT, std::move(params));
2361 }
2362 if (strcmp(nameToken, "glFramebufferTextureLayer") == 0)
2363 {
2364 ParamBuffer params =
2365 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURELAYERPROC>::type>(
2366 paramTokens, strings);
2367 return CallCapture(EntryPoint::GLFramebufferTextureLayer, std::move(params));
2368 }
2369 if (strcmp(nameToken, "glFramebufferTextureMultiviewOVR") == 0)
2370 {
2371 ParamBuffer params =
2372 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC>::type>(
2373 paramTokens, strings);
2374 return CallCapture(EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(params));
2375 }
2376 if (strcmp(nameToken, "glFramebufferTextureOES") == 0)
2377 {
2378 ParamBuffer params =
2379 ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREOESPROC>::type>(paramTokens,
2380 strings);
2381 return CallCapture(EntryPoint::GLFramebufferTextureOES, std::move(params));
2382 }
2383 if (strcmp(nameToken, "glFramebufferTexturePixelLocalStorageANGLE") == 0)
2384 {
2385 ParamBuffer params = ParseParameters<
2386 std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC>::type>(
2387 paramTokens, strings);
2388 return CallCapture(EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE,
2389 std::move(params));
2390 }
2391 if (strcmp(nameToken, "glFrontFace") == 0)
2392 {
2393 ParamBuffer params =
2394 ParseParameters<std::remove_pointer<PFNGLFRONTFACEPROC>::type>(paramTokens, strings);
2395 return CallCapture(EntryPoint::GLFrontFace, std::move(params));
2396 }
2397 if (strcmp(nameToken, "glFrustumf") == 0)
2398 {
2399 ParamBuffer params =
2400 ParseParameters<std::remove_pointer<PFNGLFRUSTUMFPROC>::type>(paramTokens, strings);
2401 return CallCapture(EntryPoint::GLFrustumf, std::move(params));
2402 }
2403 if (strcmp(nameToken, "glFrustumx") == 0)
2404 {
2405 ParamBuffer params =
2406 ParseParameters<std::remove_pointer<PFNGLFRUSTUMXPROC>::type>(paramTokens, strings);
2407 return CallCapture(EntryPoint::GLFrustumx, std::move(params));
2408 }
2409 if (strcmp(nameToken, "glGenBuffers") == 0)
2410 {
2411 ParamBuffer params =
2412 ParseParameters<std::remove_pointer<PFNGLGENBUFFERSPROC>::type>(paramTokens, strings);
2413 return CallCapture(EntryPoint::GLGenBuffers, std::move(params));
2414 }
2415 if (strcmp(nameToken, "glGenFencesNV") == 0)
2416 {
2417 ParamBuffer params =
2418 ParseParameters<std::remove_pointer<PFNGLGENFENCESNVPROC>::type>(paramTokens, strings);
2419 return CallCapture(EntryPoint::GLGenFencesNV, std::move(params));
2420 }
2421 if (strcmp(nameToken, "glGenFramebuffers") == 0)
2422 {
2423 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSPROC>::type>(
2424 paramTokens, strings);
2425 return CallCapture(EntryPoint::GLGenFramebuffers, std::move(params));
2426 }
2427 if (strcmp(nameToken, "glGenFramebuffersOES") == 0)
2428 {
2429 ParamBuffer params =
2430 ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSOESPROC>::type>(paramTokens,
2431 strings);
2432 return CallCapture(EntryPoint::GLGenFramebuffersOES, std::move(params));
2433 }
2434 if (strcmp(nameToken, "glGenPerfMonitorsAMD") == 0)
2435 {
2436 ParamBuffer params =
2437 ParseParameters<std::remove_pointer<PFNGLGENPERFMONITORSAMDPROC>::type>(paramTokens,
2438 strings);
2439 return CallCapture(EntryPoint::GLGenPerfMonitorsAMD, std::move(params));
2440 }
2441 if (strcmp(nameToken, "glGenProgramPipelines") == 0)
2442 {
2443 ParamBuffer params =
2444 ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESPROC>::type>(paramTokens,
2445 strings);
2446 return CallCapture(EntryPoint::GLGenProgramPipelines, std::move(params));
2447 }
2448 if (strcmp(nameToken, "glGenProgramPipelinesEXT") == 0)
2449 {
2450 ParamBuffer params =
2451 ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESEXTPROC>::type>(paramTokens,
2452 strings);
2453 return CallCapture(EntryPoint::GLGenProgramPipelinesEXT, std::move(params));
2454 }
2455 if (strcmp(nameToken, "glGenQueries") == 0)
2456 {
2457 ParamBuffer params =
2458 ParseParameters<std::remove_pointer<PFNGLGENQUERIESPROC>::type>(paramTokens, strings);
2459 return CallCapture(EntryPoint::GLGenQueries, std::move(params));
2460 }
2461 if (strcmp(nameToken, "glGenQueriesEXT") == 0)
2462 {
2463 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENQUERIESEXTPROC>::type>(
2464 paramTokens, strings);
2465 return CallCapture(EntryPoint::GLGenQueriesEXT, std::move(params));
2466 }
2467 if (strcmp(nameToken, "glGenRenderbuffers") == 0)
2468 {
2469 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSPROC>::type>(
2470 paramTokens, strings);
2471 return CallCapture(EntryPoint::GLGenRenderbuffers, std::move(params));
2472 }
2473 if (strcmp(nameToken, "glGenRenderbuffersOES") == 0)
2474 {
2475 ParamBuffer params =
2476 ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSOESPROC>::type>(paramTokens,
2477 strings);
2478 return CallCapture(EntryPoint::GLGenRenderbuffersOES, std::move(params));
2479 }
2480 if (strcmp(nameToken, "glGenSamplers") == 0)
2481 {
2482 ParamBuffer params =
2483 ParseParameters<std::remove_pointer<PFNGLGENSAMPLERSPROC>::type>(paramTokens, strings);
2484 return CallCapture(EntryPoint::GLGenSamplers, std::move(params));
2485 }
2486 if (strcmp(nameToken, "glGenSemaphoresEXT") == 0)
2487 {
2488 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENSEMAPHORESEXTPROC>::type>(
2489 paramTokens, strings);
2490 return CallCapture(EntryPoint::GLGenSemaphoresEXT, std::move(params));
2491 }
2492 if (strcmp(nameToken, "glGenTextures") == 0)
2493 {
2494 ParamBuffer params =
2495 ParseParameters<std::remove_pointer<PFNGLGENTEXTURESPROC>::type>(paramTokens, strings);
2496 return CallCapture(EntryPoint::GLGenTextures, std::move(params));
2497 }
2498 if (strcmp(nameToken, "glGenTransformFeedbacks") == 0)
2499 {
2500 ParamBuffer params =
2501 ParseParameters<std::remove_pointer<PFNGLGENTRANSFORMFEEDBACKSPROC>::type>(paramTokens,
2502 strings);
2503 return CallCapture(EntryPoint::GLGenTransformFeedbacks, std::move(params));
2504 }
2505 if (strcmp(nameToken, "glGenVertexArrays") == 0)
2506 {
2507 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSPROC>::type>(
2508 paramTokens, strings);
2509 return CallCapture(EntryPoint::GLGenVertexArrays, std::move(params));
2510 }
2511 if (strcmp(nameToken, "glGenVertexArraysOES") == 0)
2512 {
2513 ParamBuffer params =
2514 ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSOESPROC>::type>(paramTokens,
2515 strings);
2516 return CallCapture(EntryPoint::GLGenVertexArraysOES, std::move(params));
2517 }
2518 if (strcmp(nameToken, "glGenerateMipmap") == 0)
2519 {
2520 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPPROC>::type>(
2521 paramTokens, strings);
2522 return CallCapture(EntryPoint::GLGenerateMipmap, std::move(params));
2523 }
2524 if (strcmp(nameToken, "glGenerateMipmapOES") == 0)
2525 {
2526 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPOESPROC>::type>(
2527 paramTokens, strings);
2528 return CallCapture(EntryPoint::GLGenerateMipmapOES, std::move(params));
2529 }
2530 if (strcmp(nameToken, "glGetActiveAttrib") == 0)
2531 {
2532 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEATTRIBPROC>::type>(
2533 paramTokens, strings);
2534 return CallCapture(EntryPoint::GLGetActiveAttrib, std::move(params));
2535 }
2536 if (strcmp(nameToken, "glGetActiveUniform") == 0)
2537 {
2538 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMPROC>::type>(
2539 paramTokens, strings);
2540 return CallCapture(EntryPoint::GLGetActiveUniform, std::move(params));
2541 }
2542 if (strcmp(nameToken, "glGetActiveUniformBlockName") == 0)
2543 {
2544 ParamBuffer params =
2545 ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC>::type>(
2546 paramTokens, strings);
2547 return CallCapture(EntryPoint::GLGetActiveUniformBlockName, std::move(params));
2548 }
2549 if (strcmp(nameToken, "glGetActiveUniformBlockiv") == 0)
2550 {
2551 ParamBuffer params =
2552 ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVPROC>::type>(
2553 paramTokens, strings);
2554 return CallCapture(EntryPoint::GLGetActiveUniformBlockiv, std::move(params));
2555 }
2556 if (strcmp(nameToken, "glGetActiveUniformBlockivRobustANGLE") == 0)
2557 {
2558 ParamBuffer params =
2559 ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVROBUSTANGLEPROC>::type>(
2560 paramTokens, strings);
2561 return CallCapture(EntryPoint::GLGetActiveUniformBlockivRobustANGLE, std::move(params));
2562 }
2563 if (strcmp(nameToken, "glGetActiveUniformsiv") == 0)
2564 {
2565 ParamBuffer params =
2566 ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMSIVPROC>::type>(paramTokens,
2567 strings);
2568 return CallCapture(EntryPoint::GLGetActiveUniformsiv, std::move(params));
2569 }
2570 if (strcmp(nameToken, "glGetAttachedShaders") == 0)
2571 {
2572 ParamBuffer params =
2573 ParseParameters<std::remove_pointer<PFNGLGETATTACHEDSHADERSPROC>::type>(paramTokens,
2574 strings);
2575 return CallCapture(EntryPoint::GLGetAttachedShaders, std::move(params));
2576 }
2577 if (strcmp(nameToken, "glGetAttribLocation") == 0)
2578 {
2579 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETATTRIBLOCATIONPROC>::type>(
2580 paramTokens, strings);
2581 return CallCapture(EntryPoint::GLGetAttribLocation, std::move(params));
2582 }
2583 if (strcmp(nameToken, "glGetBooleani_v") == 0)
2584 {
2585 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VPROC>::type>(
2586 paramTokens, strings);
2587 return CallCapture(EntryPoint::GLGetBooleani_v, std::move(params));
2588 }
2589 if (strcmp(nameToken, "glGetBooleani_vRobustANGLE") == 0)
2590 {
2591 ParamBuffer params =
2592 ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VROBUSTANGLEPROC>::type>(
2593 paramTokens, strings);
2594 return CallCapture(EntryPoint::GLGetBooleani_vRobustANGLE, std::move(params));
2595 }
2596 if (strcmp(nameToken, "glGetBooleanv") == 0)
2597 {
2598 ParamBuffer params =
2599 ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVPROC>::type>(paramTokens, strings);
2600 return CallCapture(EntryPoint::GLGetBooleanv, std::move(params));
2601 }
2602 if (strcmp(nameToken, "glGetBooleanvRobustANGLE") == 0)
2603 {
2604 ParamBuffer params =
2605 ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVROBUSTANGLEPROC>::type>(paramTokens,
2606 strings);
2607 return CallCapture(EntryPoint::GLGetBooleanvRobustANGLE, std::move(params));
2608 }
2609 if (strcmp(nameToken, "glGetBufferParameteri64v") == 0)
2610 {
2611 ParamBuffer params =
2612 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VPROC>::type>(paramTokens,
2613 strings);
2614 return CallCapture(EntryPoint::GLGetBufferParameteri64v, std::move(params));
2615 }
2616 if (strcmp(nameToken, "glGetBufferParameteri64vRobustANGLE") == 0)
2617 {
2618 ParamBuffer params =
2619 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VROBUSTANGLEPROC>::type>(
2620 paramTokens, strings);
2621 return CallCapture(EntryPoint::GLGetBufferParameteri64vRobustANGLE, std::move(params));
2622 }
2623 if (strcmp(nameToken, "glGetBufferParameteriv") == 0)
2624 {
2625 ParamBuffer params =
2626 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVPROC>::type>(paramTokens,
2627 strings);
2628 return CallCapture(EntryPoint::GLGetBufferParameteriv, std::move(params));
2629 }
2630 if (strcmp(nameToken, "glGetBufferParameterivRobustANGLE") == 0)
2631 {
2632 ParamBuffer params =
2633 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(
2634 paramTokens, strings);
2635 return CallCapture(EntryPoint::GLGetBufferParameterivRobustANGLE, std::move(params));
2636 }
2637 if (strcmp(nameToken, "glGetBufferPointerv") == 0)
2638 {
2639 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVPROC>::type>(
2640 paramTokens, strings);
2641 return CallCapture(EntryPoint::GLGetBufferPointerv, std::move(params));
2642 }
2643 if (strcmp(nameToken, "glGetBufferPointervOES") == 0)
2644 {
2645 ParamBuffer params =
2646 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVOESPROC>::type>(paramTokens,
2647 strings);
2648 return CallCapture(EntryPoint::GLGetBufferPointervOES, std::move(params));
2649 }
2650 if (strcmp(nameToken, "glGetBufferPointervRobustANGLE") == 0)
2651 {
2652 ParamBuffer params =
2653 ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVROBUSTANGLEPROC>::type>(
2654 paramTokens, strings);
2655 return CallCapture(EntryPoint::GLGetBufferPointervRobustANGLE, std::move(params));
2656 }
2657 if (strcmp(nameToken, "glGetClipPlanef") == 0)
2658 {
2659 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEFPROC>::type>(
2660 paramTokens, strings);
2661 return CallCapture(EntryPoint::GLGetClipPlanef, std::move(params));
2662 }
2663 if (strcmp(nameToken, "glGetClipPlanex") == 0)
2664 {
2665 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEXPROC>::type>(
2666 paramTokens, strings);
2667 return CallCapture(EntryPoint::GLGetClipPlanex, std::move(params));
2668 }
2669 if (strcmp(nameToken, "glGetCompressedTexImageANGLE") == 0)
2670 {
2671 ParamBuffer params =
2672 ParseParameters<std::remove_pointer<PFNGLGETCOMPRESSEDTEXIMAGEANGLEPROC>::type>(
2673 paramTokens, strings);
2674 return CallCapture(EntryPoint::GLGetCompressedTexImageANGLE, std::move(params));
2675 }
2676 if (strcmp(nameToken, "glGetDebugMessageLog") == 0)
2677 {
2678 ParamBuffer params =
2679 ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGPROC>::type>(paramTokens,
2680 strings);
2681 return CallCapture(EntryPoint::GLGetDebugMessageLog, std::move(params));
2682 }
2683 if (strcmp(nameToken, "glGetDebugMessageLogKHR") == 0)
2684 {
2685 ParamBuffer params =
2686 ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGKHRPROC>::type>(paramTokens,
2687 strings);
2688 return CallCapture(EntryPoint::GLGetDebugMessageLogKHR, std::move(params));
2689 }
2690 if (strcmp(nameToken, "glGetError") == 0)
2691 {
2692 ParamBuffer params =
2693 ParseParameters<std::remove_pointer<PFNGLGETERRORPROC>::type>(paramTokens, strings);
2694 return CallCapture(EntryPoint::GLGetError, std::move(params));
2695 }
2696 if (strcmp(nameToken, "glGetFenceivNV") == 0)
2697 {
2698 ParamBuffer params =
2699 ParseParameters<std::remove_pointer<PFNGLGETFENCEIVNVPROC>::type>(paramTokens, strings);
2700 return CallCapture(EntryPoint::GLGetFenceivNV, std::move(params));
2701 }
2702 if (strcmp(nameToken, "glGetFixedv") == 0)
2703 {
2704 ParamBuffer params =
2705 ParseParameters<std::remove_pointer<PFNGLGETFIXEDVPROC>::type>(paramTokens, strings);
2706 return CallCapture(EntryPoint::GLGetFixedv, std::move(params));
2707 }
2708 if (strcmp(nameToken, "glGetFloatv") == 0)
2709 {
2710 ParamBuffer params =
2711 ParseParameters<std::remove_pointer<PFNGLGETFLOATVPROC>::type>(paramTokens, strings);
2712 return CallCapture(EntryPoint::GLGetFloatv, std::move(params));
2713 }
2714 if (strcmp(nameToken, "glGetFloatvRobustANGLE") == 0)
2715 {
2716 ParamBuffer params =
2717 ParseParameters<std::remove_pointer<PFNGLGETFLOATVROBUSTANGLEPROC>::type>(paramTokens,
2718 strings);
2719 return CallCapture(EntryPoint::GLGetFloatvRobustANGLE, std::move(params));
2720 }
2721 if (strcmp(nameToken, "glGetFragDataIndexEXT") == 0)
2722 {
2723 ParamBuffer params =
2724 ParseParameters<std::remove_pointer<PFNGLGETFRAGDATAINDEXEXTPROC>::type>(paramTokens,
2725 strings);
2726 return CallCapture(EntryPoint::GLGetFragDataIndexEXT, std::move(params));
2727 }
2728 if (strcmp(nameToken, "glGetFragDataLocation") == 0)
2729 {
2730 ParamBuffer params =
2731 ParseParameters<std::remove_pointer<PFNGLGETFRAGDATALOCATIONPROC>::type>(paramTokens,
2732 strings);
2733 return CallCapture(EntryPoint::GLGetFragDataLocation, std::move(params));
2734 }
2735 if (strcmp(nameToken, "glGetFramebufferAttachmentParameteriv") == 0)
2736 {
2737 ParamBuffer params = ParseParameters<
2738 std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC>::type>(paramTokens,
2739 strings);
2740 return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameteriv, std::move(params));
2741 }
2742 if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivOES") == 0)
2743 {
2744 ParamBuffer params = ParseParameters<
2745 std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC>::type>(paramTokens,
2746 strings);
2747 return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivOES, std::move(params));
2748 }
2749 if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivRobustANGLE") == 0)
2750 {
2751 ParamBuffer params = ParseParameters<
2752 std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVROBUSTANGLEPROC>::type>(
2753 paramTokens, strings);
2754 return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
2755 std::move(params));
2756 }
2757 if (strcmp(nameToken, "glGetFramebufferParameteriv") == 0)
2758 {
2759 ParamBuffer params =
2760 ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVPROC>::type>(
2761 paramTokens, strings);
2762 return CallCapture(EntryPoint::GLGetFramebufferParameteriv, std::move(params));
2763 }
2764 if (strcmp(nameToken, "glGetFramebufferParameterivMESA") == 0)
2765 {
2766 ParamBuffer params =
2767 ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC>::type>(
2768 paramTokens, strings);
2769 return CallCapture(EntryPoint::GLGetFramebufferParameterivMESA, std::move(params));
2770 }
2771 if (strcmp(nameToken, "glGetFramebufferParameterivRobustANGLE") == 0)
2772 {
2773 ParamBuffer params = ParseParameters<
2774 std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
2775 strings);
2776 return CallCapture(EntryPoint::GLGetFramebufferParameterivRobustANGLE, std::move(params));
2777 }
2778 if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvANGLE") == 0)
2779 {
2780 ParamBuffer params = ParseParameters<
2781 std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC>::type>(
2782 paramTokens, strings);
2783 return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
2784 std::move(params));
2785 }
2786 if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvRobustANGLE") == 0)
2787 {
2788 ParamBuffer params = ParseParameters<std::remove_pointer<
2789 PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVROBUSTANGLEPROC>::type>(paramTokens,
2790 strings);
2791 return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
2792 std::move(params));
2793 }
2794 if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivANGLE") == 0)
2795 {
2796 ParamBuffer params = ParseParameters<
2797 std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC>::type>(
2798 paramTokens, strings);
2799 return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
2800 std::move(params));
2801 }
2802 if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivRobustANGLE") == 0)
2803 {
2804 ParamBuffer params = ParseParameters<std::remove_pointer<
2805 PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
2806 strings);
2807 return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
2808 std::move(params));
2809 }
2810 if (strcmp(nameToken, "glGetGraphicsResetStatus") == 0)
2811 {
2812 ParamBuffer params =
2813 ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSPROC>::type>(paramTokens,
2814 strings);
2815 return CallCapture(EntryPoint::GLGetGraphicsResetStatus, std::move(params));
2816 }
2817 if (strcmp(nameToken, "glGetGraphicsResetStatusEXT") == 0)
2818 {
2819 ParamBuffer params =
2820 ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>::type>(
2821 paramTokens, strings);
2822 return CallCapture(EntryPoint::GLGetGraphicsResetStatusEXT, std::move(params));
2823 }
2824 if (strcmp(nameToken, "glGetGraphicsResetStatusKHR") == 0)
2825 {
2826 ParamBuffer params =
2827 ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSKHRPROC>::type>(
2828 paramTokens, strings);
2829 return CallCapture(EntryPoint::GLGetGraphicsResetStatusKHR, std::move(params));
2830 }
2831 if (strcmp(nameToken, "glGetInteger64i_v") == 0)
2832 {
2833 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VPROC>::type>(
2834 paramTokens, strings);
2835 return CallCapture(EntryPoint::GLGetInteger64i_v, std::move(params));
2836 }
2837 if (strcmp(nameToken, "glGetInteger64i_vRobustANGLE") == 0)
2838 {
2839 ParamBuffer params =
2840 ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VROBUSTANGLEPROC>::type>(
2841 paramTokens, strings);
2842 return CallCapture(EntryPoint::GLGetInteger64i_vRobustANGLE, std::move(params));
2843 }
2844 if (strcmp(nameToken, "glGetInteger64v") == 0)
2845 {
2846 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VPROC>::type>(
2847 paramTokens, strings);
2848 return CallCapture(EntryPoint::GLGetInteger64v, std::move(params));
2849 }
2850 if (strcmp(nameToken, "glGetInteger64vEXT") == 0)
2851 {
2852 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VEXTPROC>::type>(
2853 paramTokens, strings);
2854 return CallCapture(EntryPoint::GLGetInteger64vEXT, std::move(params));
2855 }
2856 if (strcmp(nameToken, "glGetInteger64vRobustANGLE") == 0)
2857 {
2858 ParamBuffer params =
2859 ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VROBUSTANGLEPROC>::type>(
2860 paramTokens, strings);
2861 return CallCapture(EntryPoint::GLGetInteger64vRobustANGLE, std::move(params));
2862 }
2863 if (strcmp(nameToken, "glGetIntegeri_v") == 0)
2864 {
2865 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VPROC>::type>(
2866 paramTokens, strings);
2867 return CallCapture(EntryPoint::GLGetIntegeri_v, std::move(params));
2868 }
2869 if (strcmp(nameToken, "glGetIntegeri_vRobustANGLE") == 0)
2870 {
2871 ParamBuffer params =
2872 ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VROBUSTANGLEPROC>::type>(
2873 paramTokens, strings);
2874 return CallCapture(EntryPoint::GLGetIntegeri_vRobustANGLE, std::move(params));
2875 }
2876 if (strcmp(nameToken, "glGetIntegerv") == 0)
2877 {
2878 ParamBuffer params =
2879 ParseParameters<std::remove_pointer<PFNGLGETINTEGERVPROC>::type>(paramTokens, strings);
2880 return CallCapture(EntryPoint::GLGetIntegerv, std::move(params));
2881 }
2882 if (strcmp(nameToken, "glGetIntegervRobustANGLE") == 0)
2883 {
2884 ParamBuffer params =
2885 ParseParameters<std::remove_pointer<PFNGLGETINTEGERVROBUSTANGLEPROC>::type>(paramTokens,
2886 strings);
2887 return CallCapture(EntryPoint::GLGetIntegervRobustANGLE, std::move(params));
2888 }
2889 if (strcmp(nameToken, "glGetInternalformativ") == 0)
2890 {
2891 ParamBuffer params =
2892 ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVPROC>::type>(paramTokens,
2893 strings);
2894 return CallCapture(EntryPoint::GLGetInternalformativ, std::move(params));
2895 }
2896 if (strcmp(nameToken, "glGetInternalformativRobustANGLE") == 0)
2897 {
2898 ParamBuffer params =
2899 ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVROBUSTANGLEPROC>::type>(
2900 paramTokens, strings);
2901 return CallCapture(EntryPoint::GLGetInternalformativRobustANGLE, std::move(params));
2902 }
2903 if (strcmp(nameToken, "glGetLightfv") == 0)
2904 {
2905 ParamBuffer params =
2906 ParseParameters<std::remove_pointer<PFNGLGETLIGHTFVPROC>::type>(paramTokens, strings);
2907 return CallCapture(EntryPoint::GLGetLightfv, std::move(params));
2908 }
2909 if (strcmp(nameToken, "glGetLightxv") == 0)
2910 {
2911 ParamBuffer params =
2912 ParseParameters<std::remove_pointer<PFNGLGETLIGHTXVPROC>::type>(paramTokens, strings);
2913 return CallCapture(EntryPoint::GLGetLightxv, std::move(params));
2914 }
2915 if (strcmp(nameToken, "glGetMaterialfv") == 0)
2916 {
2917 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALFVPROC>::type>(
2918 paramTokens, strings);
2919 return CallCapture(EntryPoint::GLGetMaterialfv, std::move(params));
2920 }
2921 if (strcmp(nameToken, "glGetMaterialxv") == 0)
2922 {
2923 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALXVPROC>::type>(
2924 paramTokens, strings);
2925 return CallCapture(EntryPoint::GLGetMaterialxv, std::move(params));
2926 }
2927 if (strcmp(nameToken, "glGetMemoryObjectParameterivEXT") == 0)
2928 {
2929 ParamBuffer params =
2930 ParseParameters<std::remove_pointer<PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
2931 paramTokens, strings);
2932 return CallCapture(EntryPoint::GLGetMemoryObjectParameterivEXT, std::move(params));
2933 }
2934 if (strcmp(nameToken, "glGetMultisamplefv") == 0)
2935 {
2936 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVPROC>::type>(
2937 paramTokens, strings);
2938 return CallCapture(EntryPoint::GLGetMultisamplefv, std::move(params));
2939 }
2940 if (strcmp(nameToken, "glGetMultisamplefvANGLE") == 0)
2941 {
2942 ParamBuffer params =
2943 ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVANGLEPROC>::type>(paramTokens,
2944 strings);
2945 return CallCapture(EntryPoint::GLGetMultisamplefvANGLE, std::move(params));
2946 }
2947 if (strcmp(nameToken, "glGetMultisamplefvRobustANGLE") == 0)
2948 {
2949 ParamBuffer params =
2950 ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVROBUSTANGLEPROC>::type>(
2951 paramTokens, strings);
2952 return CallCapture(EntryPoint::GLGetMultisamplefvRobustANGLE, std::move(params));
2953 }
2954 if (strcmp(nameToken, "glGetObjectLabel") == 0)
2955 {
2956 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELPROC>::type>(
2957 paramTokens, strings);
2958 return CallCapture(EntryPoint::GLGetObjectLabel, std::move(params));
2959 }
2960 if (strcmp(nameToken, "glGetObjectLabelEXT") == 0)
2961 {
2962 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELEXTPROC>::type>(
2963 paramTokens, strings);
2964 return CallCapture(EntryPoint::GLGetObjectLabelEXT, std::move(params));
2965 }
2966 if (strcmp(nameToken, "glGetObjectLabelKHR") == 0)
2967 {
2968 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELKHRPROC>::type>(
2969 paramTokens, strings);
2970 return CallCapture(EntryPoint::GLGetObjectLabelKHR, std::move(params));
2971 }
2972 if (strcmp(nameToken, "glGetObjectPtrLabel") == 0)
2973 {
2974 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELPROC>::type>(
2975 paramTokens, strings);
2976 return CallCapture(EntryPoint::GLGetObjectPtrLabel, std::move(params));
2977 }
2978 if (strcmp(nameToken, "glGetObjectPtrLabelKHR") == 0)
2979 {
2980 ParamBuffer params =
2981 ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELKHRPROC>::type>(paramTokens,
2982 strings);
2983 return CallCapture(EntryPoint::GLGetObjectPtrLabelKHR, std::move(params));
2984 }
2985 if (strcmp(nameToken, "glGetPerfMonitorCounterDataAMD") == 0)
2986 {
2987 ParamBuffer params =
2988 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERDATAAMDPROC>::type>(
2989 paramTokens, strings);
2990 return CallCapture(EntryPoint::GLGetPerfMonitorCounterDataAMD, std::move(params));
2991 }
2992 if (strcmp(nameToken, "glGetPerfMonitorCounterInfoAMD") == 0)
2993 {
2994 ParamBuffer params =
2995 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERINFOAMDPROC>::type>(
2996 paramTokens, strings);
2997 return CallCapture(EntryPoint::GLGetPerfMonitorCounterInfoAMD, std::move(params));
2998 }
2999 if (strcmp(nameToken, "glGetPerfMonitorCounterStringAMD") == 0)
3000 {
3001 ParamBuffer params =
3002 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC>::type>(
3003 paramTokens, strings);
3004 return CallCapture(EntryPoint::GLGetPerfMonitorCounterStringAMD, std::move(params));
3005 }
3006 if (strcmp(nameToken, "glGetPerfMonitorCountersAMD") == 0)
3007 {
3008 ParamBuffer params =
3009 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSAMDPROC>::type>(
3010 paramTokens, strings);
3011 return CallCapture(EntryPoint::GLGetPerfMonitorCountersAMD, std::move(params));
3012 }
3013 if (strcmp(nameToken, "glGetPerfMonitorGroupStringAMD") == 0)
3014 {
3015 ParamBuffer params =
3016 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSTRINGAMDPROC>::type>(
3017 paramTokens, strings);
3018 return CallCapture(EntryPoint::GLGetPerfMonitorGroupStringAMD, std::move(params));
3019 }
3020 if (strcmp(nameToken, "glGetPerfMonitorGroupsAMD") == 0)
3021 {
3022 ParamBuffer params =
3023 ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSAMDPROC>::type>(
3024 paramTokens, strings);
3025 return CallCapture(EntryPoint::GLGetPerfMonitorGroupsAMD, std::move(params));
3026 }
3027 if (strcmp(nameToken, "glGetPointerv") == 0)
3028 {
3029 ParamBuffer params =
3030 ParseParameters<std::remove_pointer<PFNGLGETPOINTERVPROC>::type>(paramTokens, strings);
3031 return CallCapture(EntryPoint::GLGetPointerv, std::move(params));
3032 }
3033 if (strcmp(nameToken, "glGetPointervANGLE") == 0)
3034 {
3035 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPOINTERVANGLEPROC>::type>(
3036 paramTokens, strings);
3037 return CallCapture(EntryPoint::GLGetPointervANGLE, std::move(params));
3038 }
3039 if (strcmp(nameToken, "glGetPointervKHR") == 0)
3040 {
3041 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPOINTERVKHRPROC>::type>(
3042 paramTokens, strings);
3043 return CallCapture(EntryPoint::GLGetPointervKHR, std::move(params));
3044 }
3045 if (strcmp(nameToken, "glGetPointervRobustANGLERobustANGLE") == 0)
3046 {
3047 ParamBuffer params =
3048 ParseParameters<std::remove_pointer<PFNGLGETPOINTERVROBUSTANGLEROBUSTANGLEPROC>::type>(
3049 paramTokens, strings);
3050 return CallCapture(EntryPoint::GLGetPointervRobustANGLERobustANGLE, std::move(params));
3051 }
3052 if (strcmp(nameToken, "glGetProgramBinary") == 0)
3053 {
3054 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYPROC>::type>(
3055 paramTokens, strings);
3056 return CallCapture(EntryPoint::GLGetProgramBinary, std::move(params));
3057 }
3058 if (strcmp(nameToken, "glGetProgramBinaryOES") == 0)
3059 {
3060 ParamBuffer params =
3061 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYOESPROC>::type>(paramTokens,
3062 strings);
3063 return CallCapture(EntryPoint::GLGetProgramBinaryOES, std::move(params));
3064 }
3065 if (strcmp(nameToken, "glGetProgramInfoLog") == 0)
3066 {
3067 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINFOLOGPROC>::type>(
3068 paramTokens, strings);
3069 return CallCapture(EntryPoint::GLGetProgramInfoLog, std::move(params));
3070 }
3071 if (strcmp(nameToken, "glGetProgramInterfaceiv") == 0)
3072 {
3073 ParamBuffer params =
3074 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVPROC>::type>(paramTokens,
3075 strings);
3076 return CallCapture(EntryPoint::GLGetProgramInterfaceiv, std::move(params));
3077 }
3078 if (strcmp(nameToken, "glGetProgramInterfaceivRobustANGLE") == 0)
3079 {
3080 ParamBuffer params =
3081 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVROBUSTANGLEPROC>::type>(
3082 paramTokens, strings);
3083 return CallCapture(EntryPoint::GLGetProgramInterfaceivRobustANGLE, std::move(params));
3084 }
3085 if (strcmp(nameToken, "glGetProgramPipelineInfoLog") == 0)
3086 {
3087 ParamBuffer params =
3088 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGPROC>::type>(
3089 paramTokens, strings);
3090 return CallCapture(EntryPoint::GLGetProgramPipelineInfoLog, std::move(params));
3091 }
3092 if (strcmp(nameToken, "glGetProgramPipelineInfoLogEXT") == 0)
3093 {
3094 ParamBuffer params =
3095 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC>::type>(
3096 paramTokens, strings);
3097 return CallCapture(EntryPoint::GLGetProgramPipelineInfoLogEXT, std::move(params));
3098 }
3099 if (strcmp(nameToken, "glGetProgramPipelineiv") == 0)
3100 {
3101 ParamBuffer params =
3102 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVPROC>::type>(paramTokens,
3103 strings);
3104 return CallCapture(EntryPoint::GLGetProgramPipelineiv, std::move(params));
3105 }
3106 if (strcmp(nameToken, "glGetProgramPipelineivEXT") == 0)
3107 {
3108 ParamBuffer params =
3109 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVEXTPROC>::type>(
3110 paramTokens, strings);
3111 return CallCapture(EntryPoint::GLGetProgramPipelineivEXT, std::move(params));
3112 }
3113 if (strcmp(nameToken, "glGetProgramResourceIndex") == 0)
3114 {
3115 ParamBuffer params =
3116 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEINDEXPROC>::type>(
3117 paramTokens, strings);
3118 return CallCapture(EntryPoint::GLGetProgramResourceIndex, std::move(params));
3119 }
3120 if (strcmp(nameToken, "glGetProgramResourceLocation") == 0)
3121 {
3122 ParamBuffer params =
3123 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONPROC>::type>(
3124 paramTokens, strings);
3125 return CallCapture(EntryPoint::GLGetProgramResourceLocation, std::move(params));
3126 }
3127 if (strcmp(nameToken, "glGetProgramResourceLocationIndexEXT") == 0)
3128 {
3129 ParamBuffer params =
3130 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC>::type>(
3131 paramTokens, strings);
3132 return CallCapture(EntryPoint::GLGetProgramResourceLocationIndexEXT, std::move(params));
3133 }
3134 if (strcmp(nameToken, "glGetProgramResourceName") == 0)
3135 {
3136 ParamBuffer params =
3137 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCENAMEPROC>::type>(paramTokens,
3138 strings);
3139 return CallCapture(EntryPoint::GLGetProgramResourceName, std::move(params));
3140 }
3141 if (strcmp(nameToken, "glGetProgramResourceiv") == 0)
3142 {
3143 ParamBuffer params =
3144 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEIVPROC>::type>(paramTokens,
3145 strings);
3146 return CallCapture(EntryPoint::GLGetProgramResourceiv, std::move(params));
3147 }
3148 if (strcmp(nameToken, "glGetProgramiv") == 0)
3149 {
3150 ParamBuffer params =
3151 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVPROC>::type>(paramTokens, strings);
3152 return CallCapture(EntryPoint::GLGetProgramiv, std::move(params));
3153 }
3154 if (strcmp(nameToken, "glGetProgramivRobustANGLE") == 0)
3155 {
3156 ParamBuffer params =
3157 ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVROBUSTANGLEPROC>::type>(
3158 paramTokens, strings);
3159 return CallCapture(EntryPoint::GLGetProgramivRobustANGLE, std::move(params));
3160 }
3161 if (strcmp(nameToken, "glGetQueryObjecti64vEXT") == 0)
3162 {
3163 ParamBuffer params =
3164 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VEXTPROC>::type>(paramTokens,
3165 strings);
3166 return CallCapture(EntryPoint::GLGetQueryObjecti64vEXT, std::move(params));
3167 }
3168 if (strcmp(nameToken, "glGetQueryObjecti64vRobustANGLE") == 0)
3169 {
3170 ParamBuffer params =
3171 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VROBUSTANGLEPROC>::type>(
3172 paramTokens, strings);
3173 return CallCapture(EntryPoint::GLGetQueryObjecti64vRobustANGLE, std::move(params));
3174 }
3175 if (strcmp(nameToken, "glGetQueryObjectivEXT") == 0)
3176 {
3177 ParamBuffer params =
3178 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVEXTPROC>::type>(paramTokens,
3179 strings);
3180 return CallCapture(EntryPoint::GLGetQueryObjectivEXT, std::move(params));
3181 }
3182 if (strcmp(nameToken, "glGetQueryObjectivRobustANGLE") == 0)
3183 {
3184 ParamBuffer params =
3185 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVROBUSTANGLEPROC>::type>(
3186 paramTokens, strings);
3187 return CallCapture(EntryPoint::GLGetQueryObjectivRobustANGLE, std::move(params));
3188 }
3189 if (strcmp(nameToken, "glGetQueryObjectui64vEXT") == 0)
3190 {
3191 ParamBuffer params =
3192 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VEXTPROC>::type>(paramTokens,
3193 strings);
3194 return CallCapture(EntryPoint::GLGetQueryObjectui64vEXT, std::move(params));
3195 }
3196 if (strcmp(nameToken, "glGetQueryObjectui64vRobustANGLE") == 0)
3197 {
3198 ParamBuffer params =
3199 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VROBUSTANGLEPROC>::type>(
3200 paramTokens, strings);
3201 return CallCapture(EntryPoint::GLGetQueryObjectui64vRobustANGLE, std::move(params));
3202 }
3203 if (strcmp(nameToken, "glGetQueryObjectuiv") == 0)
3204 {
3205 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVPROC>::type>(
3206 paramTokens, strings);
3207 return CallCapture(EntryPoint::GLGetQueryObjectuiv, std::move(params));
3208 }
3209 if (strcmp(nameToken, "glGetQueryObjectuivEXT") == 0)
3210 {
3211 ParamBuffer params =
3212 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVEXTPROC>::type>(paramTokens,
3213 strings);
3214 return CallCapture(EntryPoint::GLGetQueryObjectuivEXT, std::move(params));
3215 }
3216 if (strcmp(nameToken, "glGetQueryObjectuivRobustANGLE") == 0)
3217 {
3218 ParamBuffer params =
3219 ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVROBUSTANGLEPROC>::type>(
3220 paramTokens, strings);
3221 return CallCapture(EntryPoint::GLGetQueryObjectuivRobustANGLE, std::move(params));
3222 }
3223 if (strcmp(nameToken, "glGetQueryiv") == 0)
3224 {
3225 ParamBuffer params =
3226 ParseParameters<std::remove_pointer<PFNGLGETQUERYIVPROC>::type>(paramTokens, strings);
3227 return CallCapture(EntryPoint::GLGetQueryiv, std::move(params));
3228 }
3229 if (strcmp(nameToken, "glGetQueryivEXT") == 0)
3230 {
3231 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYIVEXTPROC>::type>(
3232 paramTokens, strings);
3233 return CallCapture(EntryPoint::GLGetQueryivEXT, std::move(params));
3234 }
3235 if (strcmp(nameToken, "glGetQueryivRobustANGLE") == 0)
3236 {
3237 ParamBuffer params =
3238 ParseParameters<std::remove_pointer<PFNGLGETQUERYIVROBUSTANGLEPROC>::type>(paramTokens,
3239 strings);
3240 return CallCapture(EntryPoint::GLGetQueryivRobustANGLE, std::move(params));
3241 }
3242 if (strcmp(nameToken, "glGetRenderbufferImageANGLE") == 0)
3243 {
3244 ParamBuffer params =
3245 ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERIMAGEANGLEPROC>::type>(
3246 paramTokens, strings);
3247 return CallCapture(EntryPoint::GLGetRenderbufferImageANGLE, std::move(params));
3248 }
3249 if (strcmp(nameToken, "glGetRenderbufferParameteriv") == 0)
3250 {
3251 ParamBuffer params =
3252 ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVPROC>::type>(
3253 paramTokens, strings);
3254 return CallCapture(EntryPoint::GLGetRenderbufferParameteriv, std::move(params));
3255 }
3256 if (strcmp(nameToken, "glGetRenderbufferParameterivOES") == 0)
3257 {
3258 ParamBuffer params =
3259 ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVOESPROC>::type>(
3260 paramTokens, strings);
3261 return CallCapture(EntryPoint::GLGetRenderbufferParameterivOES, std::move(params));
3262 }
3263 if (strcmp(nameToken, "glGetRenderbufferParameterivRobustANGLE") == 0)
3264 {
3265 ParamBuffer params = ParseParameters<
3266 std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
3267 strings);
3268 return CallCapture(EntryPoint::GLGetRenderbufferParameterivRobustANGLE, std::move(params));
3269 }
3270 if (strcmp(nameToken, "glGetSamplerParameterIiv") == 0)
3271 {
3272 ParamBuffer params =
3273 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
3274 strings);
3275 return CallCapture(EntryPoint::GLGetSamplerParameterIiv, std::move(params));
3276 }
3277 if (strcmp(nameToken, "glGetSamplerParameterIivEXT") == 0)
3278 {
3279 ParamBuffer params =
3280 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVEXTPROC>::type>(
3281 paramTokens, strings);
3282 return CallCapture(EntryPoint::GLGetSamplerParameterIivEXT, std::move(params));
3283 }
3284 if (strcmp(nameToken, "glGetSamplerParameterIivOES") == 0)
3285 {
3286 ParamBuffer params =
3287 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVOESPROC>::type>(
3288 paramTokens, strings);
3289 return CallCapture(EntryPoint::GLGetSamplerParameterIivOES, std::move(params));
3290 }
3291 if (strcmp(nameToken, "glGetSamplerParameterIivRobustANGLE") == 0)
3292 {
3293 ParamBuffer params =
3294 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
3295 paramTokens, strings);
3296 return CallCapture(EntryPoint::GLGetSamplerParameterIivRobustANGLE, std::move(params));
3297 }
3298 if (strcmp(nameToken, "glGetSamplerParameterIuiv") == 0)
3299 {
3300 ParamBuffer params =
3301 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVPROC>::type>(
3302 paramTokens, strings);
3303 return CallCapture(EntryPoint::GLGetSamplerParameterIuiv, std::move(params));
3304 }
3305 if (strcmp(nameToken, "glGetSamplerParameterIuivEXT") == 0)
3306 {
3307 ParamBuffer params =
3308 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVEXTPROC>::type>(
3309 paramTokens, strings);
3310 return CallCapture(EntryPoint::GLGetSamplerParameterIuivEXT, std::move(params));
3311 }
3312 if (strcmp(nameToken, "glGetSamplerParameterIuivOES") == 0)
3313 {
3314 ParamBuffer params =
3315 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVOESPROC>::type>(
3316 paramTokens, strings);
3317 return CallCapture(EntryPoint::GLGetSamplerParameterIuivOES, std::move(params));
3318 }
3319 if (strcmp(nameToken, "glGetSamplerParameterIuivRobustANGLE") == 0)
3320 {
3321 ParamBuffer params =
3322 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
3323 paramTokens, strings);
3324 return CallCapture(EntryPoint::GLGetSamplerParameterIuivRobustANGLE, std::move(params));
3325 }
3326 if (strcmp(nameToken, "glGetSamplerParameterfv") == 0)
3327 {
3328 ParamBuffer params =
3329 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVPROC>::type>(paramTokens,
3330 strings);
3331 return CallCapture(EntryPoint::GLGetSamplerParameterfv, std::move(params));
3332 }
3333 if (strcmp(nameToken, "glGetSamplerParameterfvRobustANGLE") == 0)
3334 {
3335 ParamBuffer params =
3336 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
3337 paramTokens, strings);
3338 return CallCapture(EntryPoint::GLGetSamplerParameterfvRobustANGLE, std::move(params));
3339 }
3340 if (strcmp(nameToken, "glGetSamplerParameteriv") == 0)
3341 {
3342 ParamBuffer params =
3343 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVPROC>::type>(paramTokens,
3344 strings);
3345 return CallCapture(EntryPoint::GLGetSamplerParameteriv, std::move(params));
3346 }
3347 if (strcmp(nameToken, "glGetSamplerParameterivRobustANGLE") == 0)
3348 {
3349 ParamBuffer params =
3350 ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
3351 paramTokens, strings);
3352 return CallCapture(EntryPoint::GLGetSamplerParameterivRobustANGLE, std::move(params));
3353 }
3354 if (strcmp(nameToken, "glGetSemaphoreParameterui64vEXT") == 0)
3355 {
3356 ParamBuffer params =
3357 ParseParameters<std::remove_pointer<PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
3358 paramTokens, strings);
3359 return CallCapture(EntryPoint::GLGetSemaphoreParameterui64vEXT, std::move(params));
3360 }
3361 if (strcmp(nameToken, "glGetShaderInfoLog") == 0)
3362 {
3363 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERINFOLOGPROC>::type>(
3364 paramTokens, strings);
3365 return CallCapture(EntryPoint::GLGetShaderInfoLog, std::move(params));
3366 }
3367 if (strcmp(nameToken, "glGetShaderPrecisionFormat") == 0)
3368 {
3369 ParamBuffer params =
3370 ParseParameters<std::remove_pointer<PFNGLGETSHADERPRECISIONFORMATPROC>::type>(
3371 paramTokens, strings);
3372 return CallCapture(EntryPoint::GLGetShaderPrecisionFormat, std::move(params));
3373 }
3374 if (strcmp(nameToken, "glGetShaderSource") == 0)
3375 {
3376 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERSOURCEPROC>::type>(
3377 paramTokens, strings);
3378 return CallCapture(EntryPoint::GLGetShaderSource, std::move(params));
3379 }
3380 if (strcmp(nameToken, "glGetShaderiv") == 0)
3381 {
3382 ParamBuffer params =
3383 ParseParameters<std::remove_pointer<PFNGLGETSHADERIVPROC>::type>(paramTokens, strings);
3384 return CallCapture(EntryPoint::GLGetShaderiv, std::move(params));
3385 }
3386 if (strcmp(nameToken, "glGetShaderivRobustANGLE") == 0)
3387 {
3388 ParamBuffer params =
3389 ParseParameters<std::remove_pointer<PFNGLGETSHADERIVROBUSTANGLEPROC>::type>(paramTokens,
3390 strings);
3391 return CallCapture(EntryPoint::GLGetShaderivRobustANGLE, std::move(params));
3392 }
3393 if (strcmp(nameToken, "glGetString") == 0)
3394 {
3395 ParamBuffer params =
3396 ParseParameters<std::remove_pointer<PFNGLGETSTRINGPROC>::type>(paramTokens, strings);
3397 return CallCapture(EntryPoint::GLGetString, std::move(params));
3398 }
3399 if (strcmp(nameToken, "glGetStringi") == 0)
3400 {
3401 ParamBuffer params =
3402 ParseParameters<std::remove_pointer<PFNGLGETSTRINGIPROC>::type>(paramTokens, strings);
3403 return CallCapture(EntryPoint::GLGetStringi, std::move(params));
3404 }
3405 if (strcmp(nameToken, "glGetSynciv") == 0)
3406 {
3407 ParamBuffer params =
3408 ParseParameters<std::remove_pointer<PFNGLGETSYNCIVPROC>::type>(paramTokens, strings);
3409 return CallCapture(EntryPoint::GLGetSynciv, std::move(params));
3410 }
3411 if (strcmp(nameToken, "glGetTexEnvfv") == 0)
3412 {
3413 ParamBuffer params =
3414 ParseParameters<std::remove_pointer<PFNGLGETTEXENVFVPROC>::type>(paramTokens, strings);
3415 return CallCapture(EntryPoint::GLGetTexEnvfv, std::move(params));
3416 }
3417 if (strcmp(nameToken, "glGetTexEnviv") == 0)
3418 {
3419 ParamBuffer params =
3420 ParseParameters<std::remove_pointer<PFNGLGETTEXENVIVPROC>::type>(paramTokens, strings);
3421 return CallCapture(EntryPoint::GLGetTexEnviv, std::move(params));
3422 }
3423 if (strcmp(nameToken, "glGetTexEnvxv") == 0)
3424 {
3425 ParamBuffer params =
3426 ParseParameters<std::remove_pointer<PFNGLGETTEXENVXVPROC>::type>(paramTokens, strings);
3427 return CallCapture(EntryPoint::GLGetTexEnvxv, std::move(params));
3428 }
3429 if (strcmp(nameToken, "glGetTexGenfvOES") == 0)
3430 {
3431 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENFVOESPROC>::type>(
3432 paramTokens, strings);
3433 return CallCapture(EntryPoint::GLGetTexGenfvOES, std::move(params));
3434 }
3435 if (strcmp(nameToken, "glGetTexGenivOES") == 0)
3436 {
3437 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENIVOESPROC>::type>(
3438 paramTokens, strings);
3439 return CallCapture(EntryPoint::GLGetTexGenivOES, std::move(params));
3440 }
3441 if (strcmp(nameToken, "glGetTexGenxvOES") == 0)
3442 {
3443 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENXVOESPROC>::type>(
3444 paramTokens, strings);
3445 return CallCapture(EntryPoint::GLGetTexGenxvOES, std::move(params));
3446 }
3447 if (strcmp(nameToken, "glGetTexImageANGLE") == 0)
3448 {
3449 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXIMAGEANGLEPROC>::type>(
3450 paramTokens, strings);
3451 return CallCapture(EntryPoint::GLGetTexImageANGLE, std::move(params));
3452 }
3453 if (strcmp(nameToken, "glGetTexLevelParameterfv") == 0)
3454 {
3455 ParamBuffer params =
3456 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVPROC>::type>(paramTokens,
3457 strings);
3458 return CallCapture(EntryPoint::GLGetTexLevelParameterfv, std::move(params));
3459 }
3460 if (strcmp(nameToken, "glGetTexLevelParameterfvANGLE") == 0)
3461 {
3462 ParamBuffer params =
3463 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVANGLEPROC>::type>(
3464 paramTokens, strings);
3465 return CallCapture(EntryPoint::GLGetTexLevelParameterfvANGLE, std::move(params));
3466 }
3467 if (strcmp(nameToken, "glGetTexLevelParameterfvRobustANGLE") == 0)
3468 {
3469 ParamBuffer params =
3470 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVROBUSTANGLEPROC>::type>(
3471 paramTokens, strings);
3472 return CallCapture(EntryPoint::GLGetTexLevelParameterfvRobustANGLE, std::move(params));
3473 }
3474 if (strcmp(nameToken, "glGetTexLevelParameteriv") == 0)
3475 {
3476 ParamBuffer params =
3477 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVPROC>::type>(paramTokens,
3478 strings);
3479 return CallCapture(EntryPoint::GLGetTexLevelParameteriv, std::move(params));
3480 }
3481 if (strcmp(nameToken, "glGetTexLevelParameterivANGLE") == 0)
3482 {
3483 ParamBuffer params =
3484 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVANGLEPROC>::type>(
3485 paramTokens, strings);
3486 return CallCapture(EntryPoint::GLGetTexLevelParameterivANGLE, std::move(params));
3487 }
3488 if (strcmp(nameToken, "glGetTexLevelParameterivRobustANGLE") == 0)
3489 {
3490 ParamBuffer params =
3491 ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVROBUSTANGLEPROC>::type>(
3492 paramTokens, strings);
3493 return CallCapture(EntryPoint::GLGetTexLevelParameterivRobustANGLE, std::move(params));
3494 }
3495 if (strcmp(nameToken, "glGetTexParameterIiv") == 0)
3496 {
3497 ParamBuffer params =
3498 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVPROC>::type>(paramTokens,
3499 strings);
3500 return CallCapture(EntryPoint::GLGetTexParameterIiv, std::move(params));
3501 }
3502 if (strcmp(nameToken, "glGetTexParameterIivEXT") == 0)
3503 {
3504 ParamBuffer params =
3505 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
3506 strings);
3507 return CallCapture(EntryPoint::GLGetTexParameterIivEXT, std::move(params));
3508 }
3509 if (strcmp(nameToken, "glGetTexParameterIivOES") == 0)
3510 {
3511 ParamBuffer params =
3512 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVOESPROC>::type>(paramTokens,
3513 strings);
3514 return CallCapture(EntryPoint::GLGetTexParameterIivOES, std::move(params));
3515 }
3516 if (strcmp(nameToken, "glGetTexParameterIivRobustANGLE") == 0)
3517 {
3518 ParamBuffer params =
3519 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
3520 paramTokens, strings);
3521 return CallCapture(EntryPoint::GLGetTexParameterIivRobustANGLE, std::move(params));
3522 }
3523 if (strcmp(nameToken, "glGetTexParameterIuiv") == 0)
3524 {
3525 ParamBuffer params =
3526 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVPROC>::type>(paramTokens,
3527 strings);
3528 return CallCapture(EntryPoint::GLGetTexParameterIuiv, std::move(params));
3529 }
3530 if (strcmp(nameToken, "glGetTexParameterIuivEXT") == 0)
3531 {
3532 ParamBuffer params =
3533 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
3534 strings);
3535 return CallCapture(EntryPoint::GLGetTexParameterIuivEXT, std::move(params));
3536 }
3537 if (strcmp(nameToken, "glGetTexParameterIuivOES") == 0)
3538 {
3539 ParamBuffer params =
3540 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
3541 strings);
3542 return CallCapture(EntryPoint::GLGetTexParameterIuivOES, std::move(params));
3543 }
3544 if (strcmp(nameToken, "glGetTexParameterIuivRobustANGLE") == 0)
3545 {
3546 ParamBuffer params =
3547 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
3548 paramTokens, strings);
3549 return CallCapture(EntryPoint::GLGetTexParameterIuivRobustANGLE, std::move(params));
3550 }
3551 if (strcmp(nameToken, "glGetTexParameterfv") == 0)
3552 {
3553 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVPROC>::type>(
3554 paramTokens, strings);
3555 return CallCapture(EntryPoint::GLGetTexParameterfv, std::move(params));
3556 }
3557 if (strcmp(nameToken, "glGetTexParameterfvRobustANGLE") == 0)
3558 {
3559 ParamBuffer params =
3560 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVROBUSTANGLEPROC>::type>(
3561 paramTokens, strings);
3562 return CallCapture(EntryPoint::GLGetTexParameterfvRobustANGLE, std::move(params));
3563 }
3564 if (strcmp(nameToken, "glGetTexParameteriv") == 0)
3565 {
3566 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVPROC>::type>(
3567 paramTokens, strings);
3568 return CallCapture(EntryPoint::GLGetTexParameteriv, std::move(params));
3569 }
3570 if (strcmp(nameToken, "glGetTexParameterivRobustANGLE") == 0)
3571 {
3572 ParamBuffer params =
3573 ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVROBUSTANGLEPROC>::type>(
3574 paramTokens, strings);
3575 return CallCapture(EntryPoint::GLGetTexParameterivRobustANGLE, std::move(params));
3576 }
3577 if (strcmp(nameToken, "glGetTexParameterxv") == 0)
3578 {
3579 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERXVPROC>::type>(
3580 paramTokens, strings);
3581 return CallCapture(EntryPoint::GLGetTexParameterxv, std::move(params));
3582 }
3583 if (strcmp(nameToken, "glGetTransformFeedbackVarying") == 0)
3584 {
3585 ParamBuffer params =
3586 ParseParameters<std::remove_pointer<PFNGLGETTRANSFORMFEEDBACKVARYINGPROC>::type>(
3587 paramTokens, strings);
3588 return CallCapture(EntryPoint::GLGetTransformFeedbackVarying, std::move(params));
3589 }
3590 if (strcmp(nameToken, "glGetTranslatedShaderSourceANGLE") == 0)
3591 {
3592 ParamBuffer params =
3593 ParseParameters<std::remove_pointer<PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC>::type>(
3594 paramTokens, strings);
3595 return CallCapture(EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(params));
3596 }
3597 if (strcmp(nameToken, "glGetUniformBlockIndex") == 0)
3598 {
3599 ParamBuffer params =
3600 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMBLOCKINDEXPROC>::type>(paramTokens,
3601 strings);
3602 return CallCapture(EntryPoint::GLGetUniformBlockIndex, std::move(params));
3603 }
3604 if (strcmp(nameToken, "glGetUniformIndices") == 0)
3605 {
3606 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMINDICESPROC>::type>(
3607 paramTokens, strings);
3608 return CallCapture(EntryPoint::GLGetUniformIndices, std::move(params));
3609 }
3610 if (strcmp(nameToken, "glGetUniformLocation") == 0)
3611 {
3612 ParamBuffer params =
3613 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMLOCATIONPROC>::type>(paramTokens,
3614 strings);
3615 return CallCapture(EntryPoint::GLGetUniformLocation, std::move(params));
3616 }
3617 if (strcmp(nameToken, "glGetUniformfv") == 0)
3618 {
3619 ParamBuffer params =
3620 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVPROC>::type>(paramTokens, strings);
3621 return CallCapture(EntryPoint::GLGetUniformfv, std::move(params));
3622 }
3623 if (strcmp(nameToken, "glGetUniformfvRobustANGLE") == 0)
3624 {
3625 ParamBuffer params =
3626 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVROBUSTANGLEPROC>::type>(
3627 paramTokens, strings);
3628 return CallCapture(EntryPoint::GLGetUniformfvRobustANGLE, std::move(params));
3629 }
3630 if (strcmp(nameToken, "glGetUniformiv") == 0)
3631 {
3632 ParamBuffer params =
3633 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVPROC>::type>(paramTokens, strings);
3634 return CallCapture(EntryPoint::GLGetUniformiv, std::move(params));
3635 }
3636 if (strcmp(nameToken, "glGetUniformivRobustANGLE") == 0)
3637 {
3638 ParamBuffer params =
3639 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVROBUSTANGLEPROC>::type>(
3640 paramTokens, strings);
3641 return CallCapture(EntryPoint::GLGetUniformivRobustANGLE, std::move(params));
3642 }
3643 if (strcmp(nameToken, "glGetUniformuiv") == 0)
3644 {
3645 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVPROC>::type>(
3646 paramTokens, strings);
3647 return CallCapture(EntryPoint::GLGetUniformuiv, std::move(params));
3648 }
3649 if (strcmp(nameToken, "glGetUniformuivRobustANGLE") == 0)
3650 {
3651 ParamBuffer params =
3652 ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVROBUSTANGLEPROC>::type>(
3653 paramTokens, strings);
3654 return CallCapture(EntryPoint::GLGetUniformuivRobustANGLE, std::move(params));
3655 }
3656 if (strcmp(nameToken, "glGetUnsignedBytei_vEXT") == 0)
3657 {
3658 ParamBuffer params =
3659 ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEI_VEXTPROC>::type>(paramTokens,
3660 strings);
3661 return CallCapture(EntryPoint::GLGetUnsignedBytei_vEXT, std::move(params));
3662 }
3663 if (strcmp(nameToken, "glGetUnsignedBytevEXT") == 0)
3664 {
3665 ParamBuffer params =
3666 ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEVEXTPROC>::type>(paramTokens,
3667 strings);
3668 return CallCapture(EntryPoint::GLGetUnsignedBytevEXT, std::move(params));
3669 }
3670 if (strcmp(nameToken, "glGetVertexAttribIiv") == 0)
3671 {
3672 ParamBuffer params =
3673 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVPROC>::type>(paramTokens,
3674 strings);
3675 return CallCapture(EntryPoint::GLGetVertexAttribIiv, std::move(params));
3676 }
3677 if (strcmp(nameToken, "glGetVertexAttribIivRobustANGLE") == 0)
3678 {
3679 ParamBuffer params =
3680 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVROBUSTANGLEPROC>::type>(
3681 paramTokens, strings);
3682 return CallCapture(EntryPoint::GLGetVertexAttribIivRobustANGLE, std::move(params));
3683 }
3684 if (strcmp(nameToken, "glGetVertexAttribIuiv") == 0)
3685 {
3686 ParamBuffer params =
3687 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVPROC>::type>(paramTokens,
3688 strings);
3689 return CallCapture(EntryPoint::GLGetVertexAttribIuiv, std::move(params));
3690 }
3691 if (strcmp(nameToken, "glGetVertexAttribIuivRobustANGLE") == 0)
3692 {
3693 ParamBuffer params =
3694 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVROBUSTANGLEPROC>::type>(
3695 paramTokens, strings);
3696 return CallCapture(EntryPoint::GLGetVertexAttribIuivRobustANGLE, std::move(params));
3697 }
3698 if (strcmp(nameToken, "glGetVertexAttribPointerv") == 0)
3699 {
3700 ParamBuffer params =
3701 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVPROC>::type>(
3702 paramTokens, strings);
3703 return CallCapture(EntryPoint::GLGetVertexAttribPointerv, std::move(params));
3704 }
3705 if (strcmp(nameToken, "glGetVertexAttribPointervRobustANGLE") == 0)
3706 {
3707 ParamBuffer params =
3708 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVROBUSTANGLEPROC>::type>(
3709 paramTokens, strings);
3710 return CallCapture(EntryPoint::GLGetVertexAttribPointervRobustANGLE, std::move(params));
3711 }
3712 if (strcmp(nameToken, "glGetVertexAttribfv") == 0)
3713 {
3714 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVPROC>::type>(
3715 paramTokens, strings);
3716 return CallCapture(EntryPoint::GLGetVertexAttribfv, std::move(params));
3717 }
3718 if (strcmp(nameToken, "glGetVertexAttribfvRobustANGLE") == 0)
3719 {
3720 ParamBuffer params =
3721 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVROBUSTANGLEPROC>::type>(
3722 paramTokens, strings);
3723 return CallCapture(EntryPoint::GLGetVertexAttribfvRobustANGLE, std::move(params));
3724 }
3725 if (strcmp(nameToken, "glGetVertexAttribiv") == 0)
3726 {
3727 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVPROC>::type>(
3728 paramTokens, strings);
3729 return CallCapture(EntryPoint::GLGetVertexAttribiv, std::move(params));
3730 }
3731 if (strcmp(nameToken, "glGetVertexAttribivRobustANGLE") == 0)
3732 {
3733 ParamBuffer params =
3734 ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVROBUSTANGLEPROC>::type>(
3735 paramTokens, strings);
3736 return CallCapture(EntryPoint::GLGetVertexAttribivRobustANGLE, std::move(params));
3737 }
3738 if (strcmp(nameToken, "glGetnUniformfv") == 0)
3739 {
3740 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVPROC>::type>(
3741 paramTokens, strings);
3742 return CallCapture(EntryPoint::GLGetnUniformfv, std::move(params));
3743 }
3744 if (strcmp(nameToken, "glGetnUniformfvEXT") == 0)
3745 {
3746 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVEXTPROC>::type>(
3747 paramTokens, strings);
3748 return CallCapture(EntryPoint::GLGetnUniformfvEXT, std::move(params));
3749 }
3750 if (strcmp(nameToken, "glGetnUniformfvKHR") == 0)
3751 {
3752 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVKHRPROC>::type>(
3753 paramTokens, strings);
3754 return CallCapture(EntryPoint::GLGetnUniformfvKHR, std::move(params));
3755 }
3756 if (strcmp(nameToken, "glGetnUniformfvRobustANGLE") == 0)
3757 {
3758 ParamBuffer params =
3759 ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVROBUSTANGLEPROC>::type>(
3760 paramTokens, strings);
3761 return CallCapture(EntryPoint::GLGetnUniformfvRobustANGLE, std::move(params));
3762 }
3763 if (strcmp(nameToken, "glGetnUniformiv") == 0)
3764 {
3765 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVPROC>::type>(
3766 paramTokens, strings);
3767 return CallCapture(EntryPoint::GLGetnUniformiv, std::move(params));
3768 }
3769 if (strcmp(nameToken, "glGetnUniformivEXT") == 0)
3770 {
3771 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVEXTPROC>::type>(
3772 paramTokens, strings);
3773 return CallCapture(EntryPoint::GLGetnUniformivEXT, std::move(params));
3774 }
3775 if (strcmp(nameToken, "glGetnUniformivKHR") == 0)
3776 {
3777 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVKHRPROC>::type>(
3778 paramTokens, strings);
3779 return CallCapture(EntryPoint::GLGetnUniformivKHR, std::move(params));
3780 }
3781 if (strcmp(nameToken, "glGetnUniformivRobustANGLE") == 0)
3782 {
3783 ParamBuffer params =
3784 ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVROBUSTANGLEPROC>::type>(
3785 paramTokens, strings);
3786 return CallCapture(EntryPoint::GLGetnUniformivRobustANGLE, std::move(params));
3787 }
3788 if (strcmp(nameToken, "glGetnUniformuiv") == 0)
3789 {
3790 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVPROC>::type>(
3791 paramTokens, strings);
3792 return CallCapture(EntryPoint::GLGetnUniformuiv, std::move(params));
3793 }
3794 if (strcmp(nameToken, "glGetnUniformuivKHR") == 0)
3795 {
3796 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVKHRPROC>::type>(
3797 paramTokens, strings);
3798 return CallCapture(EntryPoint::GLGetnUniformuivKHR, std::move(params));
3799 }
3800 if (strcmp(nameToken, "glGetnUniformuivRobustANGLE") == 0)
3801 {
3802 ParamBuffer params =
3803 ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVROBUSTANGLEPROC>::type>(
3804 paramTokens, strings);
3805 return CallCapture(EntryPoint::GLGetnUniformuivRobustANGLE, std::move(params));
3806 }
3807 if (strcmp(nameToken, "glHint") == 0)
3808 {
3809 ParamBuffer params =
3810 ParseParameters<std::remove_pointer<PFNGLHINTPROC>::type>(paramTokens, strings);
3811 return CallCapture(EntryPoint::GLHint, std::move(params));
3812 }
3813 if (strcmp(nameToken, "glImportMemoryFdEXT") == 0)
3814 {
3815 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYFDEXTPROC>::type>(
3816 paramTokens, strings);
3817 return CallCapture(EntryPoint::GLImportMemoryFdEXT, std::move(params));
3818 }
3819 if (strcmp(nameToken, "glImportMemoryZirconHandleANGLE") == 0)
3820 {
3821 ParamBuffer params =
3822 ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYZIRCONHANDLEANGLEPROC>::type>(
3823 paramTokens, strings);
3824 return CallCapture(EntryPoint::GLImportMemoryZirconHandleANGLE, std::move(params));
3825 }
3826 if (strcmp(nameToken, "glImportSemaphoreFdEXT") == 0)
3827 {
3828 ParamBuffer params =
3829 ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREFDEXTPROC>::type>(paramTokens,
3830 strings);
3831 return CallCapture(EntryPoint::GLImportSemaphoreFdEXT, std::move(params));
3832 }
3833 if (strcmp(nameToken, "glImportSemaphoreZirconHandleANGLE") == 0)
3834 {
3835 ParamBuffer params =
3836 ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREZIRCONHANDLEANGLEPROC>::type>(
3837 paramTokens, strings);
3838 return CallCapture(EntryPoint::GLImportSemaphoreZirconHandleANGLE, std::move(params));
3839 }
3840 if (strcmp(nameToken, "glInsertEventMarkerEXT") == 0)
3841 {
3842 ParamBuffer params =
3843 ParseParameters<std::remove_pointer<PFNGLINSERTEVENTMARKEREXTPROC>::type>(paramTokens,
3844 strings);
3845 return CallCapture(EntryPoint::GLInsertEventMarkerEXT, std::move(params));
3846 }
3847 if (strcmp(nameToken, "glInvalidateFramebuffer") == 0)
3848 {
3849 ParamBuffer params =
3850 ParseParameters<std::remove_pointer<PFNGLINVALIDATEFRAMEBUFFERPROC>::type>(paramTokens,
3851 strings);
3852 return CallCapture(EntryPoint::GLInvalidateFramebuffer, std::move(params));
3853 }
3854 if (strcmp(nameToken, "glInvalidateSubFramebuffer") == 0)
3855 {
3856 ParamBuffer params =
3857 ParseParameters<std::remove_pointer<PFNGLINVALIDATESUBFRAMEBUFFERPROC>::type>(
3858 paramTokens, strings);
3859 return CallCapture(EntryPoint::GLInvalidateSubFramebuffer, std::move(params));
3860 }
3861 if (strcmp(nameToken, "glInvalidateTextureANGLE") == 0)
3862 {
3863 ParamBuffer params =
3864 ParseParameters<std::remove_pointer<PFNGLINVALIDATETEXTUREANGLEPROC>::type>(paramTokens,
3865 strings);
3866 return CallCapture(EntryPoint::GLInvalidateTextureANGLE, std::move(params));
3867 }
3868 if (strcmp(nameToken, "glIsBuffer") == 0)
3869 {
3870 ParamBuffer params =
3871 ParseParameters<std::remove_pointer<PFNGLISBUFFERPROC>::type>(paramTokens, strings);
3872 return CallCapture(EntryPoint::GLIsBuffer, std::move(params));
3873 }
3874 if (strcmp(nameToken, "glIsEnabled") == 0)
3875 {
3876 ParamBuffer params =
3877 ParseParameters<std::remove_pointer<PFNGLISENABLEDPROC>::type>(paramTokens, strings);
3878 return CallCapture(EntryPoint::GLIsEnabled, std::move(params));
3879 }
3880 if (strcmp(nameToken, "glIsEnabledi") == 0)
3881 {
3882 ParamBuffer params =
3883 ParseParameters<std::remove_pointer<PFNGLISENABLEDIPROC>::type>(paramTokens, strings);
3884 return CallCapture(EntryPoint::GLIsEnabledi, std::move(params));
3885 }
3886 if (strcmp(nameToken, "glIsEnablediEXT") == 0)
3887 {
3888 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIEXTPROC>::type>(
3889 paramTokens, strings);
3890 return CallCapture(EntryPoint::GLIsEnablediEXT, std::move(params));
3891 }
3892 if (strcmp(nameToken, "glIsEnablediOES") == 0)
3893 {
3894 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIOESPROC>::type>(
3895 paramTokens, strings);
3896 return CallCapture(EntryPoint::GLIsEnablediOES, std::move(params));
3897 }
3898 if (strcmp(nameToken, "glIsFenceNV") == 0)
3899 {
3900 ParamBuffer params =
3901 ParseParameters<std::remove_pointer<PFNGLISFENCENVPROC>::type>(paramTokens, strings);
3902 return CallCapture(EntryPoint::GLIsFenceNV, std::move(params));
3903 }
3904 if (strcmp(nameToken, "glIsFramebuffer") == 0)
3905 {
3906 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFERPROC>::type>(
3907 paramTokens, strings);
3908 return CallCapture(EntryPoint::GLIsFramebuffer, std::move(params));
3909 }
3910 if (strcmp(nameToken, "glIsFramebufferOES") == 0)
3911 {
3912 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFEROESPROC>::type>(
3913 paramTokens, strings);
3914 return CallCapture(EntryPoint::GLIsFramebufferOES, std::move(params));
3915 }
3916 if (strcmp(nameToken, "glIsMemoryObjectEXT") == 0)
3917 {
3918 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISMEMORYOBJECTEXTPROC>::type>(
3919 paramTokens, strings);
3920 return CallCapture(EntryPoint::GLIsMemoryObjectEXT, std::move(params));
3921 }
3922 if (strcmp(nameToken, "glIsProgram") == 0)
3923 {
3924 ParamBuffer params =
3925 ParseParameters<std::remove_pointer<PFNGLISPROGRAMPROC>::type>(paramTokens, strings);
3926 return CallCapture(EntryPoint::GLIsProgram, std::move(params));
3927 }
3928 if (strcmp(nameToken, "glIsProgramPipeline") == 0)
3929 {
3930 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEPROC>::type>(
3931 paramTokens, strings);
3932 return CallCapture(EntryPoint::GLIsProgramPipeline, std::move(params));
3933 }
3934 if (strcmp(nameToken, "glIsProgramPipelineEXT") == 0)
3935 {
3936 ParamBuffer params =
3937 ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEEXTPROC>::type>(paramTokens,
3938 strings);
3939 return CallCapture(EntryPoint::GLIsProgramPipelineEXT, std::move(params));
3940 }
3941 if (strcmp(nameToken, "glIsQuery") == 0)
3942 {
3943 ParamBuffer params =
3944 ParseParameters<std::remove_pointer<PFNGLISQUERYPROC>::type>(paramTokens, strings);
3945 return CallCapture(EntryPoint::GLIsQuery, std::move(params));
3946 }
3947 if (strcmp(nameToken, "glIsQueryEXT") == 0)
3948 {
3949 ParamBuffer params =
3950 ParseParameters<std::remove_pointer<PFNGLISQUERYEXTPROC>::type>(paramTokens, strings);
3951 return CallCapture(EntryPoint::GLIsQueryEXT, std::move(params));
3952 }
3953 if (strcmp(nameToken, "glIsRenderbuffer") == 0)
3954 {
3955 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFERPROC>::type>(
3956 paramTokens, strings);
3957 return CallCapture(EntryPoint::GLIsRenderbuffer, std::move(params));
3958 }
3959 if (strcmp(nameToken, "glIsRenderbufferOES") == 0)
3960 {
3961 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFEROESPROC>::type>(
3962 paramTokens, strings);
3963 return CallCapture(EntryPoint::GLIsRenderbufferOES, std::move(params));
3964 }
3965 if (strcmp(nameToken, "glIsSampler") == 0)
3966 {
3967 ParamBuffer params =
3968 ParseParameters<std::remove_pointer<PFNGLISSAMPLERPROC>::type>(paramTokens, strings);
3969 return CallCapture(EntryPoint::GLIsSampler, std::move(params));
3970 }
3971 if (strcmp(nameToken, "glIsSemaphoreEXT") == 0)
3972 {
3973 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISSEMAPHOREEXTPROC>::type>(
3974 paramTokens, strings);
3975 return CallCapture(EntryPoint::GLIsSemaphoreEXT, std::move(params));
3976 }
3977 if (strcmp(nameToken, "glIsShader") == 0)
3978 {
3979 ParamBuffer params =
3980 ParseParameters<std::remove_pointer<PFNGLISSHADERPROC>::type>(paramTokens, strings);
3981 return CallCapture(EntryPoint::GLIsShader, std::move(params));
3982 }
3983 if (strcmp(nameToken, "glIsSync") == 0)
3984 {
3985 ParamBuffer params =
3986 ParseParameters<std::remove_pointer<PFNGLISSYNCPROC>::type>(paramTokens, strings);
3987 return CallCapture(EntryPoint::GLIsSync, std::move(params));
3988 }
3989 if (strcmp(nameToken, "glIsTexture") == 0)
3990 {
3991 ParamBuffer params =
3992 ParseParameters<std::remove_pointer<PFNGLISTEXTUREPROC>::type>(paramTokens, strings);
3993 return CallCapture(EntryPoint::GLIsTexture, std::move(params));
3994 }
3995 if (strcmp(nameToken, "glIsTransformFeedback") == 0)
3996 {
3997 ParamBuffer params =
3998 ParseParameters<std::remove_pointer<PFNGLISTRANSFORMFEEDBACKPROC>::type>(paramTokens,
3999 strings);
4000 return CallCapture(EntryPoint::GLIsTransformFeedback, std::move(params));
4001 }
4002 if (strcmp(nameToken, "glIsVertexArray") == 0)
4003 {
4004 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYPROC>::type>(
4005 paramTokens, strings);
4006 return CallCapture(EntryPoint::GLIsVertexArray, std::move(params));
4007 }
4008 if (strcmp(nameToken, "glIsVertexArrayOES") == 0)
4009 {
4010 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYOESPROC>::type>(
4011 paramTokens, strings);
4012 return CallCapture(EntryPoint::GLIsVertexArrayOES, std::move(params));
4013 }
4014 if (strcmp(nameToken, "glLabelObjectEXT") == 0)
4015 {
4016 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLLABELOBJECTEXTPROC>::type>(
4017 paramTokens, strings);
4018 return CallCapture(EntryPoint::GLLabelObjectEXT, std::move(params));
4019 }
4020 if (strcmp(nameToken, "glLightModelf") == 0)
4021 {
4022 ParamBuffer params =
4023 ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFPROC>::type>(paramTokens, strings);
4024 return CallCapture(EntryPoint::GLLightModelf, std::move(params));
4025 }
4026 if (strcmp(nameToken, "glLightModelfv") == 0)
4027 {
4028 ParamBuffer params =
4029 ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFVPROC>::type>(paramTokens, strings);
4030 return CallCapture(EntryPoint::GLLightModelfv, std::move(params));
4031 }
4032 if (strcmp(nameToken, "glLightModelx") == 0)
4033 {
4034 ParamBuffer params =
4035 ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXPROC>::type>(paramTokens, strings);
4036 return CallCapture(EntryPoint::GLLightModelx, std::move(params));
4037 }
4038 if (strcmp(nameToken, "glLightModelxv") == 0)
4039 {
4040 ParamBuffer params =
4041 ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXVPROC>::type>(paramTokens, strings);
4042 return CallCapture(EntryPoint::GLLightModelxv, std::move(params));
4043 }
4044 if (strcmp(nameToken, "glLightf") == 0)
4045 {
4046 ParamBuffer params =
4047 ParseParameters<std::remove_pointer<PFNGLLIGHTFPROC>::type>(paramTokens, strings);
4048 return CallCapture(EntryPoint::GLLightf, std::move(params));
4049 }
4050 if (strcmp(nameToken, "glLightfv") == 0)
4051 {
4052 ParamBuffer params =
4053 ParseParameters<std::remove_pointer<PFNGLLIGHTFVPROC>::type>(paramTokens, strings);
4054 return CallCapture(EntryPoint::GLLightfv, std::move(params));
4055 }
4056 if (strcmp(nameToken, "glLightx") == 0)
4057 {
4058 ParamBuffer params =
4059 ParseParameters<std::remove_pointer<PFNGLLIGHTXPROC>::type>(paramTokens, strings);
4060 return CallCapture(EntryPoint::GLLightx, std::move(params));
4061 }
4062 if (strcmp(nameToken, "glLightxv") == 0)
4063 {
4064 ParamBuffer params =
4065 ParseParameters<std::remove_pointer<PFNGLLIGHTXVPROC>::type>(paramTokens, strings);
4066 return CallCapture(EntryPoint::GLLightxv, std::move(params));
4067 }
4068 if (strcmp(nameToken, "glLineWidth") == 0)
4069 {
4070 ParamBuffer params =
4071 ParseParameters<std::remove_pointer<PFNGLLINEWIDTHPROC>::type>(paramTokens, strings);
4072 return CallCapture(EntryPoint::GLLineWidth, std::move(params));
4073 }
4074 if (strcmp(nameToken, "glLineWidthx") == 0)
4075 {
4076 ParamBuffer params =
4077 ParseParameters<std::remove_pointer<PFNGLLINEWIDTHXPROC>::type>(paramTokens, strings);
4078 return CallCapture(EntryPoint::GLLineWidthx, std::move(params));
4079 }
4080 if (strcmp(nameToken, "glLinkProgram") == 0)
4081 {
4082 ParamBuffer params =
4083 ParseParameters<std::remove_pointer<PFNGLLINKPROGRAMPROC>::type>(paramTokens, strings);
4084 return CallCapture(EntryPoint::GLLinkProgram, std::move(params));
4085 }
4086 if (strcmp(nameToken, "glLoadIdentity") == 0)
4087 {
4088 ParamBuffer params =
4089 ParseParameters<std::remove_pointer<PFNGLLOADIDENTITYPROC>::type>(paramTokens, strings);
4090 return CallCapture(EntryPoint::GLLoadIdentity, std::move(params));
4091 }
4092 if (strcmp(nameToken, "glLoadMatrixf") == 0)
4093 {
4094 ParamBuffer params =
4095 ParseParameters<std::remove_pointer<PFNGLLOADMATRIXFPROC>::type>(paramTokens, strings);
4096 return CallCapture(EntryPoint::GLLoadMatrixf, std::move(params));
4097 }
4098 if (strcmp(nameToken, "glLoadMatrixx") == 0)
4099 {
4100 ParamBuffer params =
4101 ParseParameters<std::remove_pointer<PFNGLLOADMATRIXXPROC>::type>(paramTokens, strings);
4102 return CallCapture(EntryPoint::GLLoadMatrixx, std::move(params));
4103 }
4104 if (strcmp(nameToken, "glLoadPaletteFromModelViewMatrixOES") == 0)
4105 {
4106 ParamBuffer params =
4107 ParseParameters<std::remove_pointer<PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC>::type>(
4108 paramTokens, strings);
4109 return CallCapture(EntryPoint::GLLoadPaletteFromModelViewMatrixOES, std::move(params));
4110 }
4111 if (strcmp(nameToken, "glLogicOp") == 0)
4112 {
4113 ParamBuffer params =
4114 ParseParameters<std::remove_pointer<PFNGLLOGICOPPROC>::type>(paramTokens, strings);
4115 return CallCapture(EntryPoint::GLLogicOp, std::move(params));
4116 }
4117 if (strcmp(nameToken, "glLogicOpANGLE") == 0)
4118 {
4119 ParamBuffer params =
4120 ParseParameters<std::remove_pointer<PFNGLLOGICOPANGLEPROC>::type>(paramTokens, strings);
4121 return CallCapture(EntryPoint::GLLogicOpANGLE, std::move(params));
4122 }
4123 if (strcmp(nameToken, "glLoseContextCHROMIUM") == 0)
4124 {
4125 ParamBuffer params =
4126 ParseParameters<std::remove_pointer<PFNGLLOSECONTEXTCHROMIUMPROC>::type>(paramTokens,
4127 strings);
4128 return CallCapture(EntryPoint::GLLoseContextCHROMIUM, std::move(params));
4129 }
4130 if (strcmp(nameToken, "glMapBufferOES") == 0)
4131 {
4132 ParamBuffer params =
4133 ParseParameters<std::remove_pointer<PFNGLMAPBUFFEROESPROC>::type>(paramTokens, strings);
4134 return CallCapture(EntryPoint::GLMapBufferOES, std::move(params));
4135 }
4136 if (strcmp(nameToken, "glMapBufferRange") == 0)
4137 {
4138 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEPROC>::type>(
4139 paramTokens, strings);
4140 return CallCapture(EntryPoint::GLMapBufferRange, std::move(params));
4141 }
4142 if (strcmp(nameToken, "glMapBufferRangeEXT") == 0)
4143 {
4144 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEEXTPROC>::type>(
4145 paramTokens, strings);
4146 return CallCapture(EntryPoint::GLMapBufferRangeEXT, std::move(params));
4147 }
4148 if (strcmp(nameToken, "glMaterialf") == 0)
4149 {
4150 ParamBuffer params =
4151 ParseParameters<std::remove_pointer<PFNGLMATERIALFPROC>::type>(paramTokens, strings);
4152 return CallCapture(EntryPoint::GLMaterialf, std::move(params));
4153 }
4154 if (strcmp(nameToken, "glMaterialfv") == 0)
4155 {
4156 ParamBuffer params =
4157 ParseParameters<std::remove_pointer<PFNGLMATERIALFVPROC>::type>(paramTokens, strings);
4158 return CallCapture(EntryPoint::GLMaterialfv, std::move(params));
4159 }
4160 if (strcmp(nameToken, "glMaterialx") == 0)
4161 {
4162 ParamBuffer params =
4163 ParseParameters<std::remove_pointer<PFNGLMATERIALXPROC>::type>(paramTokens, strings);
4164 return CallCapture(EntryPoint::GLMaterialx, std::move(params));
4165 }
4166 if (strcmp(nameToken, "glMaterialxv") == 0)
4167 {
4168 ParamBuffer params =
4169 ParseParameters<std::remove_pointer<PFNGLMATERIALXVPROC>::type>(paramTokens, strings);
4170 return CallCapture(EntryPoint::GLMaterialxv, std::move(params));
4171 }
4172 if (strcmp(nameToken, "glMatrixIndexPointerOES") == 0)
4173 {
4174 ParamBuffer params =
4175 ParseParameters<std::remove_pointer<PFNGLMATRIXINDEXPOINTEROESPROC>::type>(paramTokens,
4176 strings);
4177 return CallCapture(EntryPoint::GLMatrixIndexPointerOES, std::move(params));
4178 }
4179 if (strcmp(nameToken, "glMatrixMode") == 0)
4180 {
4181 ParamBuffer params =
4182 ParseParameters<std::remove_pointer<PFNGLMATRIXMODEPROC>::type>(paramTokens, strings);
4183 return CallCapture(EntryPoint::GLMatrixMode, std::move(params));
4184 }
4185 if (strcmp(nameToken, "glMaxShaderCompilerThreadsKHR") == 0)
4186 {
4187 ParamBuffer params =
4188 ParseParameters<std::remove_pointer<PFNGLMAXSHADERCOMPILERTHREADSKHRPROC>::type>(
4189 paramTokens, strings);
4190 return CallCapture(EntryPoint::GLMaxShaderCompilerThreadsKHR, std::move(params));
4191 }
4192 if (strcmp(nameToken, "glMemoryBarrier") == 0)
4193 {
4194 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERPROC>::type>(
4195 paramTokens, strings);
4196 return CallCapture(EntryPoint::GLMemoryBarrier, std::move(params));
4197 }
4198 if (strcmp(nameToken, "glMemoryBarrierByRegion") == 0)
4199 {
4200 ParamBuffer params =
4201 ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERBYREGIONPROC>::type>(paramTokens,
4202 strings);
4203 return CallCapture(EntryPoint::GLMemoryBarrierByRegion, std::move(params));
4204 }
4205 if (strcmp(nameToken, "glMemoryObjectParameterivEXT") == 0)
4206 {
4207 ParamBuffer params =
4208 ParseParameters<std::remove_pointer<PFNGLMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
4209 paramTokens, strings);
4210 return CallCapture(EntryPoint::GLMemoryObjectParameterivEXT, std::move(params));
4211 }
4212 if (strcmp(nameToken, "glMinSampleShading") == 0)
4213 {
4214 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGPROC>::type>(
4215 paramTokens, strings);
4216 return CallCapture(EntryPoint::GLMinSampleShading, std::move(params));
4217 }
4218 if (strcmp(nameToken, "glMinSampleShadingOES") == 0)
4219 {
4220 ParamBuffer params =
4221 ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGOESPROC>::type>(paramTokens,
4222 strings);
4223 return CallCapture(EntryPoint::GLMinSampleShadingOES, std::move(params));
4224 }
4225 if (strcmp(nameToken, "glMultMatrixf") == 0)
4226 {
4227 ParamBuffer params =
4228 ParseParameters<std::remove_pointer<PFNGLMULTMATRIXFPROC>::type>(paramTokens, strings);
4229 return CallCapture(EntryPoint::GLMultMatrixf, std::move(params));
4230 }
4231 if (strcmp(nameToken, "glMultMatrixx") == 0)
4232 {
4233 ParamBuffer params =
4234 ParseParameters<std::remove_pointer<PFNGLMULTMATRIXXPROC>::type>(paramTokens, strings);
4235 return CallCapture(EntryPoint::GLMultMatrixx, std::move(params));
4236 }
4237 if (strcmp(nameToken, "glMultiDrawArraysANGLE") == 0)
4238 {
4239 ParamBuffer params =
4240 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSANGLEPROC>::type>(paramTokens,
4241 strings);
4242 return CallCapture(EntryPoint::GLMultiDrawArraysANGLE, std::move(params));
4243 }
4244 if (strcmp(nameToken, "glMultiDrawArraysIndirectEXT") == 0)
4245 {
4246 ParamBuffer params =
4247 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC>::type>(
4248 paramTokens, strings);
4249 return CallCapture(EntryPoint::GLMultiDrawArraysIndirectEXT, std::move(params));
4250 }
4251 if (strcmp(nameToken, "glMultiDrawArraysInstancedANGLE") == 0)
4252 {
4253 ParamBuffer params =
4254 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDANGLEPROC>::type>(
4255 paramTokens, strings);
4256 return CallCapture(EntryPoint::GLMultiDrawArraysInstancedANGLE, std::move(params));
4257 }
4258 if (strcmp(nameToken, "glMultiDrawArraysInstancedBaseInstanceANGLE") == 0)
4259 {
4260 ParamBuffer params = ParseParameters<
4261 std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC>::type>(
4262 paramTokens, strings);
4263 return CallCapture(EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
4264 std::move(params));
4265 }
4266 if (strcmp(nameToken, "glMultiDrawElementsANGLE") == 0)
4267 {
4268 ParamBuffer params =
4269 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSANGLEPROC>::type>(paramTokens,
4270 strings);
4271 return CallCapture(EntryPoint::GLMultiDrawElementsANGLE, std::move(params));
4272 }
4273 if (strcmp(nameToken, "glMultiDrawElementsBaseVertexEXT") == 0)
4274 {
4275 ParamBuffer params =
4276 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC>::type>(
4277 paramTokens, strings);
4278 return CallCapture(EntryPoint::GLMultiDrawElementsBaseVertexEXT, std::move(params));
4279 }
4280 if (strcmp(nameToken, "glMultiDrawElementsIndirectEXT") == 0)
4281 {
4282 ParamBuffer params =
4283 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC>::type>(
4284 paramTokens, strings);
4285 return CallCapture(EntryPoint::GLMultiDrawElementsIndirectEXT, std::move(params));
4286 }
4287 if (strcmp(nameToken, "glMultiDrawElementsInstancedANGLE") == 0)
4288 {
4289 ParamBuffer params =
4290 ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINSTANCEDANGLEPROC>::type>(
4291 paramTokens, strings);
4292 return CallCapture(EntryPoint::GLMultiDrawElementsInstancedANGLE, std::move(params));
4293 }
4294 if (strcmp(nameToken, "glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE") == 0)
4295 {
4296 ParamBuffer params = ParseParameters<std::remove_pointer<
4297 PFNGLMULTIDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC>::type>(paramTokens,
4298 strings);
4299 return CallCapture(EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
4300 std::move(params));
4301 }
4302 if (strcmp(nameToken, "glMultiTexCoord4f") == 0)
4303 {
4304 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4FPROC>::type>(
4305 paramTokens, strings);
4306 return CallCapture(EntryPoint::GLMultiTexCoord4f, std::move(params));
4307 }
4308 if (strcmp(nameToken, "glMultiTexCoord4x") == 0)
4309 {
4310 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4XPROC>::type>(
4311 paramTokens, strings);
4312 return CallCapture(EntryPoint::GLMultiTexCoord4x, std::move(params));
4313 }
4314 if (strcmp(nameToken, "glNamedBufferStorageExternalEXT") == 0)
4315 {
4316 ParamBuffer params =
4317 ParseParameters<std::remove_pointer<PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC>::type>(
4318 paramTokens, strings);
4319 return CallCapture(EntryPoint::GLNamedBufferStorageExternalEXT, std::move(params));
4320 }
4321 if (strcmp(nameToken, "glNormal3f") == 0)
4322 {
4323 ParamBuffer params =
4324 ParseParameters<std::remove_pointer<PFNGLNORMAL3FPROC>::type>(paramTokens, strings);
4325 return CallCapture(EntryPoint::GLNormal3f, std::move(params));
4326 }
4327 if (strcmp(nameToken, "glNormal3x") == 0)
4328 {
4329 ParamBuffer params =
4330 ParseParameters<std::remove_pointer<PFNGLNORMAL3XPROC>::type>(paramTokens, strings);
4331 return CallCapture(EntryPoint::GLNormal3x, std::move(params));
4332 }
4333 if (strcmp(nameToken, "glNormalPointer") == 0)
4334 {
4335 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLNORMALPOINTERPROC>::type>(
4336 paramTokens, strings);
4337 return CallCapture(EntryPoint::GLNormalPointer, std::move(params));
4338 }
4339 if (strcmp(nameToken, "glObjectLabel") == 0)
4340 {
4341 ParamBuffer params =
4342 ParseParameters<std::remove_pointer<PFNGLOBJECTLABELPROC>::type>(paramTokens, strings);
4343 return CallCapture(EntryPoint::GLObjectLabel, std::move(params));
4344 }
4345 if (strcmp(nameToken, "glObjectLabelKHR") == 0)
4346 {
4347 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTLABELKHRPROC>::type>(
4348 paramTokens, strings);
4349 return CallCapture(EntryPoint::GLObjectLabelKHR, std::move(params));
4350 }
4351 if (strcmp(nameToken, "glObjectPtrLabel") == 0)
4352 {
4353 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELPROC>::type>(
4354 paramTokens, strings);
4355 return CallCapture(EntryPoint::GLObjectPtrLabel, std::move(params));
4356 }
4357 if (strcmp(nameToken, "glObjectPtrLabelKHR") == 0)
4358 {
4359 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELKHRPROC>::type>(
4360 paramTokens, strings);
4361 return CallCapture(EntryPoint::GLObjectPtrLabelKHR, std::move(params));
4362 }
4363 if (strcmp(nameToken, "glOrthof") == 0)
4364 {
4365 ParamBuffer params =
4366 ParseParameters<std::remove_pointer<PFNGLORTHOFPROC>::type>(paramTokens, strings);
4367 return CallCapture(EntryPoint::GLOrthof, std::move(params));
4368 }
4369 if (strcmp(nameToken, "glOrthox") == 0)
4370 {
4371 ParamBuffer params =
4372 ParseParameters<std::remove_pointer<PFNGLORTHOXPROC>::type>(paramTokens, strings);
4373 return CallCapture(EntryPoint::GLOrthox, std::move(params));
4374 }
4375 if (strcmp(nameToken, "glPatchParameteri") == 0)
4376 {
4377 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIPROC>::type>(
4378 paramTokens, strings);
4379 return CallCapture(EntryPoint::GLPatchParameteri, std::move(params));
4380 }
4381 if (strcmp(nameToken, "glPatchParameteriEXT") == 0)
4382 {
4383 ParamBuffer params =
4384 ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIEXTPROC>::type>(paramTokens,
4385 strings);
4386 return CallCapture(EntryPoint::GLPatchParameteriEXT, std::move(params));
4387 }
4388 if (strcmp(nameToken, "glPatchParameteriOES") == 0)
4389 {
4390 ParamBuffer params =
4391 ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIOESPROC>::type>(paramTokens,
4392 strings);
4393 return CallCapture(EntryPoint::GLPatchParameteriOES, std::move(params));
4394 }
4395 if (strcmp(nameToken, "glPauseTransformFeedback") == 0)
4396 {
4397 ParamBuffer params =
4398 ParseParameters<std::remove_pointer<PFNGLPAUSETRANSFORMFEEDBACKPROC>::type>(paramTokens,
4399 strings);
4400 return CallCapture(EntryPoint::GLPauseTransformFeedback, std::move(params));
4401 }
4402 if (strcmp(nameToken, "glPixelLocalStorageBarrierANGLE") == 0)
4403 {
4404 ParamBuffer params =
4405 ParseParameters<std::remove_pointer<PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC>::type>(
4406 paramTokens, strings);
4407 return CallCapture(EntryPoint::GLPixelLocalStorageBarrierANGLE, std::move(params));
4408 }
4409 if (strcmp(nameToken, "glPixelStorei") == 0)
4410 {
4411 ParamBuffer params =
4412 ParseParameters<std::remove_pointer<PFNGLPIXELSTOREIPROC>::type>(paramTokens, strings);
4413 return CallCapture(EntryPoint::GLPixelStorei, std::move(params));
4414 }
4415 if (strcmp(nameToken, "glPointParameterf") == 0)
4416 {
4417 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFPROC>::type>(
4418 paramTokens, strings);
4419 return CallCapture(EntryPoint::GLPointParameterf, std::move(params));
4420 }
4421 if (strcmp(nameToken, "glPointParameterfv") == 0)
4422 {
4423 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFVPROC>::type>(
4424 paramTokens, strings);
4425 return CallCapture(EntryPoint::GLPointParameterfv, std::move(params));
4426 }
4427 if (strcmp(nameToken, "glPointParameterx") == 0)
4428 {
4429 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXPROC>::type>(
4430 paramTokens, strings);
4431 return CallCapture(EntryPoint::GLPointParameterx, std::move(params));
4432 }
4433 if (strcmp(nameToken, "glPointParameterxv") == 0)
4434 {
4435 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXVPROC>::type>(
4436 paramTokens, strings);
4437 return CallCapture(EntryPoint::GLPointParameterxv, std::move(params));
4438 }
4439 if (strcmp(nameToken, "glPointSize") == 0)
4440 {
4441 ParamBuffer params =
4442 ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPROC>::type>(paramTokens, strings);
4443 return CallCapture(EntryPoint::GLPointSize, std::move(params));
4444 }
4445 if (strcmp(nameToken, "glPointSizePointerOES") == 0)
4446 {
4447 ParamBuffer params =
4448 ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPOINTEROESPROC>::type>(paramTokens,
4449 strings);
4450 return CallCapture(EntryPoint::GLPointSizePointerOES, std::move(params));
4451 }
4452 if (strcmp(nameToken, "glPointSizex") == 0)
4453 {
4454 ParamBuffer params =
4455 ParseParameters<std::remove_pointer<PFNGLPOINTSIZEXPROC>::type>(paramTokens, strings);
4456 return CallCapture(EntryPoint::GLPointSizex, std::move(params));
4457 }
4458 if (strcmp(nameToken, "glPolygonModeANGLE") == 0)
4459 {
4460 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODEANGLEPROC>::type>(
4461 paramTokens, strings);
4462 return CallCapture(EntryPoint::GLPolygonModeANGLE, std::move(params));
4463 }
4464 if (strcmp(nameToken, "glPolygonModeNV") == 0)
4465 {
4466 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODENVPROC>::type>(
4467 paramTokens, strings);
4468 return CallCapture(EntryPoint::GLPolygonModeNV, std::move(params));
4469 }
4470 if (strcmp(nameToken, "glPolygonOffset") == 0)
4471 {
4472 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETPROC>::type>(
4473 paramTokens, strings);
4474 return CallCapture(EntryPoint::GLPolygonOffset, std::move(params));
4475 }
4476 if (strcmp(nameToken, "glPolygonOffsetClampEXT") == 0)
4477 {
4478 ParamBuffer params =
4479 ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETCLAMPEXTPROC>::type>(paramTokens,
4480 strings);
4481 return CallCapture(EntryPoint::GLPolygonOffsetClampEXT, std::move(params));
4482 }
4483 if (strcmp(nameToken, "glPolygonOffsetx") == 0)
4484 {
4485 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETXPROC>::type>(
4486 paramTokens, strings);
4487 return CallCapture(EntryPoint::GLPolygonOffsetx, std::move(params));
4488 }
4489 if (strcmp(nameToken, "glPopDebugGroup") == 0)
4490 {
4491 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPPROC>::type>(
4492 paramTokens, strings);
4493 return CallCapture(EntryPoint::GLPopDebugGroup, std::move(params));
4494 }
4495 if (strcmp(nameToken, "glPopDebugGroupKHR") == 0)
4496 {
4497 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPKHRPROC>::type>(
4498 paramTokens, strings);
4499 return CallCapture(EntryPoint::GLPopDebugGroupKHR, std::move(params));
4500 }
4501 if (strcmp(nameToken, "glPopGroupMarkerEXT") == 0)
4502 {
4503 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPGROUPMARKEREXTPROC>::type>(
4504 paramTokens, strings);
4505 return CallCapture(EntryPoint::GLPopGroupMarkerEXT, std::move(params));
4506 }
4507 if (strcmp(nameToken, "glPopMatrix") == 0)
4508 {
4509 ParamBuffer params =
4510 ParseParameters<std::remove_pointer<PFNGLPOPMATRIXPROC>::type>(paramTokens, strings);
4511 return CallCapture(EntryPoint::GLPopMatrix, std::move(params));
4512 }
4513 if (strcmp(nameToken, "glPrimitiveBoundingBox") == 0)
4514 {
4515 ParamBuffer params =
4516 ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXPROC>::type>(paramTokens,
4517 strings);
4518 return CallCapture(EntryPoint::GLPrimitiveBoundingBox, std::move(params));
4519 }
4520 if (strcmp(nameToken, "glPrimitiveBoundingBoxEXT") == 0)
4521 {
4522 ParamBuffer params =
4523 ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXEXTPROC>::type>(
4524 paramTokens, strings);
4525 return CallCapture(EntryPoint::GLPrimitiveBoundingBoxEXT, std::move(params));
4526 }
4527 if (strcmp(nameToken, "glPrimitiveBoundingBoxOES") == 0)
4528 {
4529 ParamBuffer params =
4530 ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXOESPROC>::type>(
4531 paramTokens, strings);
4532 return CallCapture(EntryPoint::GLPrimitiveBoundingBoxOES, std::move(params));
4533 }
4534 if (strcmp(nameToken, "glProgramBinary") == 0)
4535 {
4536 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYPROC>::type>(
4537 paramTokens, strings);
4538 return CallCapture(EntryPoint::GLProgramBinary, std::move(params));
4539 }
4540 if (strcmp(nameToken, "glProgramBinaryOES") == 0)
4541 {
4542 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYOESPROC>::type>(
4543 paramTokens, strings);
4544 return CallCapture(EntryPoint::GLProgramBinaryOES, std::move(params));
4545 }
4546 if (strcmp(nameToken, "glProgramParameteri") == 0)
4547 {
4548 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIPROC>::type>(
4549 paramTokens, strings);
4550 return CallCapture(EntryPoint::GLProgramParameteri, std::move(params));
4551 }
4552 if (strcmp(nameToken, "glProgramParameteriEXT") == 0)
4553 {
4554 ParamBuffer params =
4555 ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIEXTPROC>::type>(paramTokens,
4556 strings);
4557 return CallCapture(EntryPoint::GLProgramParameteriEXT, std::move(params));
4558 }
4559 if (strcmp(nameToken, "glProgramUniform1f") == 0)
4560 {
4561 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FPROC>::type>(
4562 paramTokens, strings);
4563 return CallCapture(EntryPoint::GLProgramUniform1f, std::move(params));
4564 }
4565 if (strcmp(nameToken, "glProgramUniform1fEXT") == 0)
4566 {
4567 ParamBuffer params =
4568 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FEXTPROC>::type>(paramTokens,
4569 strings);
4570 return CallCapture(EntryPoint::GLProgramUniform1fEXT, std::move(params));
4571 }
4572 if (strcmp(nameToken, "glProgramUniform1fv") == 0)
4573 {
4574 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVPROC>::type>(
4575 paramTokens, strings);
4576 return CallCapture(EntryPoint::GLProgramUniform1fv, std::move(params));
4577 }
4578 if (strcmp(nameToken, "glProgramUniform1fvEXT") == 0)
4579 {
4580 ParamBuffer params =
4581 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVEXTPROC>::type>(paramTokens,
4582 strings);
4583 return CallCapture(EntryPoint::GLProgramUniform1fvEXT, std::move(params));
4584 }
4585 if (strcmp(nameToken, "glProgramUniform1i") == 0)
4586 {
4587 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IPROC>::type>(
4588 paramTokens, strings);
4589 return CallCapture(EntryPoint::GLProgramUniform1i, std::move(params));
4590 }
4591 if (strcmp(nameToken, "glProgramUniform1iEXT") == 0)
4592 {
4593 ParamBuffer params =
4594 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IEXTPROC>::type>(paramTokens,
4595 strings);
4596 return CallCapture(EntryPoint::GLProgramUniform1iEXT, std::move(params));
4597 }
4598 if (strcmp(nameToken, "glProgramUniform1iv") == 0)
4599 {
4600 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVPROC>::type>(
4601 paramTokens, strings);
4602 return CallCapture(EntryPoint::GLProgramUniform1iv, std::move(params));
4603 }
4604 if (strcmp(nameToken, "glProgramUniform1ivEXT") == 0)
4605 {
4606 ParamBuffer params =
4607 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVEXTPROC>::type>(paramTokens,
4608 strings);
4609 return CallCapture(EntryPoint::GLProgramUniform1ivEXT, std::move(params));
4610 }
4611 if (strcmp(nameToken, "glProgramUniform1ui") == 0)
4612 {
4613 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIPROC>::type>(
4614 paramTokens, strings);
4615 return CallCapture(EntryPoint::GLProgramUniform1ui, std::move(params));
4616 }
4617 if (strcmp(nameToken, "glProgramUniform1uiEXT") == 0)
4618 {
4619 ParamBuffer params =
4620 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIEXTPROC>::type>(paramTokens,
4621 strings);
4622 return CallCapture(EntryPoint::GLProgramUniform1uiEXT, std::move(params));
4623 }
4624 if (strcmp(nameToken, "glProgramUniform1uiv") == 0)
4625 {
4626 ParamBuffer params =
4627 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVPROC>::type>(paramTokens,
4628 strings);
4629 return CallCapture(EntryPoint::GLProgramUniform1uiv, std::move(params));
4630 }
4631 if (strcmp(nameToken, "glProgramUniform1uivEXT") == 0)
4632 {
4633 ParamBuffer params =
4634 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVEXTPROC>::type>(paramTokens,
4635 strings);
4636 return CallCapture(EntryPoint::GLProgramUniform1uivEXT, std::move(params));
4637 }
4638 if (strcmp(nameToken, "glProgramUniform2f") == 0)
4639 {
4640 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FPROC>::type>(
4641 paramTokens, strings);
4642 return CallCapture(EntryPoint::GLProgramUniform2f, std::move(params));
4643 }
4644 if (strcmp(nameToken, "glProgramUniform2fEXT") == 0)
4645 {
4646 ParamBuffer params =
4647 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FEXTPROC>::type>(paramTokens,
4648 strings);
4649 return CallCapture(EntryPoint::GLProgramUniform2fEXT, std::move(params));
4650 }
4651 if (strcmp(nameToken, "glProgramUniform2fv") == 0)
4652 {
4653 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVPROC>::type>(
4654 paramTokens, strings);
4655 return CallCapture(EntryPoint::GLProgramUniform2fv, std::move(params));
4656 }
4657 if (strcmp(nameToken, "glProgramUniform2fvEXT") == 0)
4658 {
4659 ParamBuffer params =
4660 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVEXTPROC>::type>(paramTokens,
4661 strings);
4662 return CallCapture(EntryPoint::GLProgramUniform2fvEXT, std::move(params));
4663 }
4664 if (strcmp(nameToken, "glProgramUniform2i") == 0)
4665 {
4666 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IPROC>::type>(
4667 paramTokens, strings);
4668 return CallCapture(EntryPoint::GLProgramUniform2i, std::move(params));
4669 }
4670 if (strcmp(nameToken, "glProgramUniform2iEXT") == 0)
4671 {
4672 ParamBuffer params =
4673 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IEXTPROC>::type>(paramTokens,
4674 strings);
4675 return CallCapture(EntryPoint::GLProgramUniform2iEXT, std::move(params));
4676 }
4677 if (strcmp(nameToken, "glProgramUniform2iv") == 0)
4678 {
4679 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVPROC>::type>(
4680 paramTokens, strings);
4681 return CallCapture(EntryPoint::GLProgramUniform2iv, std::move(params));
4682 }
4683 if (strcmp(nameToken, "glProgramUniform2ivEXT") == 0)
4684 {
4685 ParamBuffer params =
4686 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVEXTPROC>::type>(paramTokens,
4687 strings);
4688 return CallCapture(EntryPoint::GLProgramUniform2ivEXT, std::move(params));
4689 }
4690 if (strcmp(nameToken, "glProgramUniform2ui") == 0)
4691 {
4692 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIPROC>::type>(
4693 paramTokens, strings);
4694 return CallCapture(EntryPoint::GLProgramUniform2ui, std::move(params));
4695 }
4696 if (strcmp(nameToken, "glProgramUniform2uiEXT") == 0)
4697 {
4698 ParamBuffer params =
4699 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIEXTPROC>::type>(paramTokens,
4700 strings);
4701 return CallCapture(EntryPoint::GLProgramUniform2uiEXT, std::move(params));
4702 }
4703 if (strcmp(nameToken, "glProgramUniform2uiv") == 0)
4704 {
4705 ParamBuffer params =
4706 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVPROC>::type>(paramTokens,
4707 strings);
4708 return CallCapture(EntryPoint::GLProgramUniform2uiv, std::move(params));
4709 }
4710 if (strcmp(nameToken, "glProgramUniform2uivEXT") == 0)
4711 {
4712 ParamBuffer params =
4713 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVEXTPROC>::type>(paramTokens,
4714 strings);
4715 return CallCapture(EntryPoint::GLProgramUniform2uivEXT, std::move(params));
4716 }
4717 if (strcmp(nameToken, "glProgramUniform3f") == 0)
4718 {
4719 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FPROC>::type>(
4720 paramTokens, strings);
4721 return CallCapture(EntryPoint::GLProgramUniform3f, std::move(params));
4722 }
4723 if (strcmp(nameToken, "glProgramUniform3fEXT") == 0)
4724 {
4725 ParamBuffer params =
4726 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FEXTPROC>::type>(paramTokens,
4727 strings);
4728 return CallCapture(EntryPoint::GLProgramUniform3fEXT, std::move(params));
4729 }
4730 if (strcmp(nameToken, "glProgramUniform3fv") == 0)
4731 {
4732 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVPROC>::type>(
4733 paramTokens, strings);
4734 return CallCapture(EntryPoint::GLProgramUniform3fv, std::move(params));
4735 }
4736 if (strcmp(nameToken, "glProgramUniform3fvEXT") == 0)
4737 {
4738 ParamBuffer params =
4739 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVEXTPROC>::type>(paramTokens,
4740 strings);
4741 return CallCapture(EntryPoint::GLProgramUniform3fvEXT, std::move(params));
4742 }
4743 if (strcmp(nameToken, "glProgramUniform3i") == 0)
4744 {
4745 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IPROC>::type>(
4746 paramTokens, strings);
4747 return CallCapture(EntryPoint::GLProgramUniform3i, std::move(params));
4748 }
4749 if (strcmp(nameToken, "glProgramUniform3iEXT") == 0)
4750 {
4751 ParamBuffer params =
4752 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IEXTPROC>::type>(paramTokens,
4753 strings);
4754 return CallCapture(EntryPoint::GLProgramUniform3iEXT, std::move(params));
4755 }
4756 if (strcmp(nameToken, "glProgramUniform3iv") == 0)
4757 {
4758 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVPROC>::type>(
4759 paramTokens, strings);
4760 return CallCapture(EntryPoint::GLProgramUniform3iv, std::move(params));
4761 }
4762 if (strcmp(nameToken, "glProgramUniform3ivEXT") == 0)
4763 {
4764 ParamBuffer params =
4765 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVEXTPROC>::type>(paramTokens,
4766 strings);
4767 return CallCapture(EntryPoint::GLProgramUniform3ivEXT, std::move(params));
4768 }
4769 if (strcmp(nameToken, "glProgramUniform3ui") == 0)
4770 {
4771 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIPROC>::type>(
4772 paramTokens, strings);
4773 return CallCapture(EntryPoint::GLProgramUniform3ui, std::move(params));
4774 }
4775 if (strcmp(nameToken, "glProgramUniform3uiEXT") == 0)
4776 {
4777 ParamBuffer params =
4778 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIEXTPROC>::type>(paramTokens,
4779 strings);
4780 return CallCapture(EntryPoint::GLProgramUniform3uiEXT, std::move(params));
4781 }
4782 if (strcmp(nameToken, "glProgramUniform3uiv") == 0)
4783 {
4784 ParamBuffer params =
4785 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVPROC>::type>(paramTokens,
4786 strings);
4787 return CallCapture(EntryPoint::GLProgramUniform3uiv, std::move(params));
4788 }
4789 if (strcmp(nameToken, "glProgramUniform3uivEXT") == 0)
4790 {
4791 ParamBuffer params =
4792 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVEXTPROC>::type>(paramTokens,
4793 strings);
4794 return CallCapture(EntryPoint::GLProgramUniform3uivEXT, std::move(params));
4795 }
4796 if (strcmp(nameToken, "glProgramUniform4f") == 0)
4797 {
4798 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FPROC>::type>(
4799 paramTokens, strings);
4800 return CallCapture(EntryPoint::GLProgramUniform4f, std::move(params));
4801 }
4802 if (strcmp(nameToken, "glProgramUniform4fEXT") == 0)
4803 {
4804 ParamBuffer params =
4805 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FEXTPROC>::type>(paramTokens,
4806 strings);
4807 return CallCapture(EntryPoint::GLProgramUniform4fEXT, std::move(params));
4808 }
4809 if (strcmp(nameToken, "glProgramUniform4fv") == 0)
4810 {
4811 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVPROC>::type>(
4812 paramTokens, strings);
4813 return CallCapture(EntryPoint::GLProgramUniform4fv, std::move(params));
4814 }
4815 if (strcmp(nameToken, "glProgramUniform4fvEXT") == 0)
4816 {
4817 ParamBuffer params =
4818 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVEXTPROC>::type>(paramTokens,
4819 strings);
4820 return CallCapture(EntryPoint::GLProgramUniform4fvEXT, std::move(params));
4821 }
4822 if (strcmp(nameToken, "glProgramUniform4i") == 0)
4823 {
4824 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IPROC>::type>(
4825 paramTokens, strings);
4826 return CallCapture(EntryPoint::GLProgramUniform4i, std::move(params));
4827 }
4828 if (strcmp(nameToken, "glProgramUniform4iEXT") == 0)
4829 {
4830 ParamBuffer params =
4831 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IEXTPROC>::type>(paramTokens,
4832 strings);
4833 return CallCapture(EntryPoint::GLProgramUniform4iEXT, std::move(params));
4834 }
4835 if (strcmp(nameToken, "glProgramUniform4iv") == 0)
4836 {
4837 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVPROC>::type>(
4838 paramTokens, strings);
4839 return CallCapture(EntryPoint::GLProgramUniform4iv, std::move(params));
4840 }
4841 if (strcmp(nameToken, "glProgramUniform4ivEXT") == 0)
4842 {
4843 ParamBuffer params =
4844 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVEXTPROC>::type>(paramTokens,
4845 strings);
4846 return CallCapture(EntryPoint::GLProgramUniform4ivEXT, std::move(params));
4847 }
4848 if (strcmp(nameToken, "glProgramUniform4ui") == 0)
4849 {
4850 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIPROC>::type>(
4851 paramTokens, strings);
4852 return CallCapture(EntryPoint::GLProgramUniform4ui, std::move(params));
4853 }
4854 if (strcmp(nameToken, "glProgramUniform4uiEXT") == 0)
4855 {
4856 ParamBuffer params =
4857 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIEXTPROC>::type>(paramTokens,
4858 strings);
4859 return CallCapture(EntryPoint::GLProgramUniform4uiEXT, std::move(params));
4860 }
4861 if (strcmp(nameToken, "glProgramUniform4uiv") == 0)
4862 {
4863 ParamBuffer params =
4864 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVPROC>::type>(paramTokens,
4865 strings);
4866 return CallCapture(EntryPoint::GLProgramUniform4uiv, std::move(params));
4867 }
4868 if (strcmp(nameToken, "glProgramUniform4uivEXT") == 0)
4869 {
4870 ParamBuffer params =
4871 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVEXTPROC>::type>(paramTokens,
4872 strings);
4873 return CallCapture(EntryPoint::GLProgramUniform4uivEXT, std::move(params));
4874 }
4875 if (strcmp(nameToken, "glProgramUniformMatrix2fv") == 0)
4876 {
4877 ParamBuffer params =
4878 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVPROC>::type>(
4879 paramTokens, strings);
4880 return CallCapture(EntryPoint::GLProgramUniformMatrix2fv, std::move(params));
4881 }
4882 if (strcmp(nameToken, "glProgramUniformMatrix2fvEXT") == 0)
4883 {
4884 ParamBuffer params =
4885 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC>::type>(
4886 paramTokens, strings);
4887 return CallCapture(EntryPoint::GLProgramUniformMatrix2fvEXT, std::move(params));
4888 }
4889 if (strcmp(nameToken, "glProgramUniformMatrix2x3fv") == 0)
4890 {
4891 ParamBuffer params =
4892 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC>::type>(
4893 paramTokens, strings);
4894 return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fv, std::move(params));
4895 }
4896 if (strcmp(nameToken, "glProgramUniformMatrix2x3fvEXT") == 0)
4897 {
4898 ParamBuffer params =
4899 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC>::type>(
4900 paramTokens, strings);
4901 return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fvEXT, std::move(params));
4902 }
4903 if (strcmp(nameToken, "glProgramUniformMatrix2x4fv") == 0)
4904 {
4905 ParamBuffer params =
4906 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC>::type>(
4907 paramTokens, strings);
4908 return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fv, std::move(params));
4909 }
4910 if (strcmp(nameToken, "glProgramUniformMatrix2x4fvEXT") == 0)
4911 {
4912 ParamBuffer params =
4913 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC>::type>(
4914 paramTokens, strings);
4915 return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fvEXT, std::move(params));
4916 }
4917 if (strcmp(nameToken, "glProgramUniformMatrix3fv") == 0)
4918 {
4919 ParamBuffer params =
4920 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVPROC>::type>(
4921 paramTokens, strings);
4922 return CallCapture(EntryPoint::GLProgramUniformMatrix3fv, std::move(params));
4923 }
4924 if (strcmp(nameToken, "glProgramUniformMatrix3fvEXT") == 0)
4925 {
4926 ParamBuffer params =
4927 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC>::type>(
4928 paramTokens, strings);
4929 return CallCapture(EntryPoint::GLProgramUniformMatrix3fvEXT, std::move(params));
4930 }
4931 if (strcmp(nameToken, "glProgramUniformMatrix3x2fv") == 0)
4932 {
4933 ParamBuffer params =
4934 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC>::type>(
4935 paramTokens, strings);
4936 return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fv, std::move(params));
4937 }
4938 if (strcmp(nameToken, "glProgramUniformMatrix3x2fvEXT") == 0)
4939 {
4940 ParamBuffer params =
4941 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC>::type>(
4942 paramTokens, strings);
4943 return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fvEXT, std::move(params));
4944 }
4945 if (strcmp(nameToken, "glProgramUniformMatrix3x4fv") == 0)
4946 {
4947 ParamBuffer params =
4948 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC>::type>(
4949 paramTokens, strings);
4950 return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fv, std::move(params));
4951 }
4952 if (strcmp(nameToken, "glProgramUniformMatrix3x4fvEXT") == 0)
4953 {
4954 ParamBuffer params =
4955 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC>::type>(
4956 paramTokens, strings);
4957 return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fvEXT, std::move(params));
4958 }
4959 if (strcmp(nameToken, "glProgramUniformMatrix4fv") == 0)
4960 {
4961 ParamBuffer params =
4962 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVPROC>::type>(
4963 paramTokens, strings);
4964 return CallCapture(EntryPoint::GLProgramUniformMatrix4fv, std::move(params));
4965 }
4966 if (strcmp(nameToken, "glProgramUniformMatrix4fvEXT") == 0)
4967 {
4968 ParamBuffer params =
4969 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC>::type>(
4970 paramTokens, strings);
4971 return CallCapture(EntryPoint::GLProgramUniformMatrix4fvEXT, std::move(params));
4972 }
4973 if (strcmp(nameToken, "glProgramUniformMatrix4x2fv") == 0)
4974 {
4975 ParamBuffer params =
4976 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC>::type>(
4977 paramTokens, strings);
4978 return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fv, std::move(params));
4979 }
4980 if (strcmp(nameToken, "glProgramUniformMatrix4x2fvEXT") == 0)
4981 {
4982 ParamBuffer params =
4983 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC>::type>(
4984 paramTokens, strings);
4985 return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fvEXT, std::move(params));
4986 }
4987 if (strcmp(nameToken, "glProgramUniformMatrix4x3fv") == 0)
4988 {
4989 ParamBuffer params =
4990 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC>::type>(
4991 paramTokens, strings);
4992 return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fv, std::move(params));
4993 }
4994 if (strcmp(nameToken, "glProgramUniformMatrix4x3fvEXT") == 0)
4995 {
4996 ParamBuffer params =
4997 ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC>::type>(
4998 paramTokens, strings);
4999 return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fvEXT, std::move(params));
5000 }
5001 if (strcmp(nameToken, "glProvokingVertexANGLE") == 0)
5002 {
5003 ParamBuffer params =
5004 ParseParameters<std::remove_pointer<PFNGLPROVOKINGVERTEXANGLEPROC>::type>(paramTokens,
5005 strings);
5006 return CallCapture(EntryPoint::GLProvokingVertexANGLE, std::move(params));
5007 }
5008 if (strcmp(nameToken, "glPushDebugGroup") == 0)
5009 {
5010 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPPROC>::type>(
5011 paramTokens, strings);
5012 return CallCapture(EntryPoint::GLPushDebugGroup, std::move(params));
5013 }
5014 if (strcmp(nameToken, "glPushDebugGroupKHR") == 0)
5015 {
5016 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPKHRPROC>::type>(
5017 paramTokens, strings);
5018 return CallCapture(EntryPoint::GLPushDebugGroupKHR, std::move(params));
5019 }
5020 if (strcmp(nameToken, "glPushGroupMarkerEXT") == 0)
5021 {
5022 ParamBuffer params =
5023 ParseParameters<std::remove_pointer<PFNGLPUSHGROUPMARKEREXTPROC>::type>(paramTokens,
5024 strings);
5025 return CallCapture(EntryPoint::GLPushGroupMarkerEXT, std::move(params));
5026 }
5027 if (strcmp(nameToken, "glPushMatrix") == 0)
5028 {
5029 ParamBuffer params =
5030 ParseParameters<std::remove_pointer<PFNGLPUSHMATRIXPROC>::type>(paramTokens, strings);
5031 return CallCapture(EntryPoint::GLPushMatrix, std::move(params));
5032 }
5033 if (strcmp(nameToken, "glQueryCounterEXT") == 0)
5034 {
5035 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYCOUNTEREXTPROC>::type>(
5036 paramTokens, strings);
5037 return CallCapture(EntryPoint::GLQueryCounterEXT, std::move(params));
5038 }
5039 if (strcmp(nameToken, "glQueryMatrixxOES") == 0)
5040 {
5041 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYMATRIXXOESPROC>::type>(
5042 paramTokens, strings);
5043 return CallCapture(EntryPoint::GLQueryMatrixxOES, std::move(params));
5044 }
5045 if (strcmp(nameToken, "glReadBuffer") == 0)
5046 {
5047 ParamBuffer params =
5048 ParseParameters<std::remove_pointer<PFNGLREADBUFFERPROC>::type>(paramTokens, strings);
5049 return CallCapture(EntryPoint::GLReadBuffer, std::move(params));
5050 }
5051 if (strcmp(nameToken, "glReadPixels") == 0)
5052 {
5053 ParamBuffer params =
5054 ParseParameters<std::remove_pointer<PFNGLREADPIXELSPROC>::type>(paramTokens, strings);
5055 return CallCapture(EntryPoint::GLReadPixels, std::move(params));
5056 }
5057 if (strcmp(nameToken, "glReadPixelsRobustANGLE") == 0)
5058 {
5059 ParamBuffer params =
5060 ParseParameters<std::remove_pointer<PFNGLREADPIXELSROBUSTANGLEPROC>::type>(paramTokens,
5061 strings);
5062 return CallCapture(EntryPoint::GLReadPixelsRobustANGLE, std::move(params));
5063 }
5064 if (strcmp(nameToken, "glReadnPixels") == 0)
5065 {
5066 ParamBuffer params =
5067 ParseParameters<std::remove_pointer<PFNGLREADNPIXELSPROC>::type>(paramTokens, strings);
5068 return CallCapture(EntryPoint::GLReadnPixels, std::move(params));
5069 }
5070 if (strcmp(nameToken, "glReadnPixelsEXT") == 0)
5071 {
5072 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLREADNPIXELSEXTPROC>::type>(
5073 paramTokens, strings);
5074 return CallCapture(EntryPoint::GLReadnPixelsEXT, std::move(params));
5075 }
5076 if (strcmp(nameToken, "glReadnPixelsKHR") == 0)
5077 {
5078 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLREADNPIXELSKHRPROC>::type>(
5079 paramTokens, strings);
5080 return CallCapture(EntryPoint::GLReadnPixelsKHR, std::move(params));
5081 }
5082 if (strcmp(nameToken, "glReadnPixelsRobustANGLE") == 0)
5083 {
5084 ParamBuffer params =
5085 ParseParameters<std::remove_pointer<PFNGLREADNPIXELSROBUSTANGLEPROC>::type>(paramTokens,
5086 strings);
5087 return CallCapture(EntryPoint::GLReadnPixelsRobustANGLE, std::move(params));
5088 }
5089 if (strcmp(nameToken, "glReleaseShaderCompiler") == 0)
5090 {
5091 ParamBuffer params =
5092 ParseParameters<std::remove_pointer<PFNGLRELEASESHADERCOMPILERPROC>::type>(paramTokens,
5093 strings);
5094 return CallCapture(EntryPoint::GLReleaseShaderCompiler, std::move(params));
5095 }
5096 if (strcmp(nameToken, "glReleaseTexturesANGLE") == 0)
5097 {
5098 ParamBuffer params =
5099 ParseParameters<std::remove_pointer<PFNGLRELEASETEXTURESANGLEPROC>::type>(paramTokens,
5100 strings);
5101 return CallCapture(EntryPoint::GLReleaseTexturesANGLE, std::move(params));
5102 }
5103 if (strcmp(nameToken, "glRenderbufferStorage") == 0)
5104 {
5105 ParamBuffer params =
5106 ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEPROC>::type>(paramTokens,
5107 strings);
5108 return CallCapture(EntryPoint::GLRenderbufferStorage, std::move(params));
5109 }
5110 if (strcmp(nameToken, "glRenderbufferStorageMultisample") == 0)
5111 {
5112 ParamBuffer params =
5113 ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC>::type>(
5114 paramTokens, strings);
5115 return CallCapture(EntryPoint::GLRenderbufferStorageMultisample, std::move(params));
5116 }
5117 if (strcmp(nameToken, "glRenderbufferStorageMultisampleANGLE") == 0)
5118 {
5119 ParamBuffer params = ParseParameters<
5120 std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC>::type>(paramTokens,
5121 strings);
5122 return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleANGLE, std::move(params));
5123 }
5124 if (strcmp(nameToken, "glRenderbufferStorageMultisampleEXT") == 0)
5125 {
5126 ParamBuffer params =
5127 ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC>::type>(
5128 paramTokens, strings);
5129 return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleEXT, std::move(params));
5130 }
5131 if (strcmp(nameToken, "glRenderbufferStorageOES") == 0)
5132 {
5133 ParamBuffer params =
5134 ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEOESPROC>::type>(paramTokens,
5135 strings);
5136 return CallCapture(EntryPoint::GLRenderbufferStorageOES, std::move(params));
5137 }
5138 if (strcmp(nameToken, "glRequestExtensionANGLE") == 0)
5139 {
5140 ParamBuffer params =
5141 ParseParameters<std::remove_pointer<PFNGLREQUESTEXTENSIONANGLEPROC>::type>(paramTokens,
5142 strings);
5143 return CallCapture(EntryPoint::GLRequestExtensionANGLE, std::move(params));
5144 }
5145 if (strcmp(nameToken, "glResumeTransformFeedback") == 0)
5146 {
5147 ParamBuffer params =
5148 ParseParameters<std::remove_pointer<PFNGLRESUMETRANSFORMFEEDBACKPROC>::type>(
5149 paramTokens, strings);
5150 return CallCapture(EntryPoint::GLResumeTransformFeedback, std::move(params));
5151 }
5152 if (strcmp(nameToken, "glRotatef") == 0)
5153 {
5154 ParamBuffer params =
5155 ParseParameters<std::remove_pointer<PFNGLROTATEFPROC>::type>(paramTokens, strings);
5156 return CallCapture(EntryPoint::GLRotatef, std::move(params));
5157 }
5158 if (strcmp(nameToken, "glRotatex") == 0)
5159 {
5160 ParamBuffer params =
5161 ParseParameters<std::remove_pointer<PFNGLROTATEXPROC>::type>(paramTokens, strings);
5162 return CallCapture(EntryPoint::GLRotatex, std::move(params));
5163 }
5164 if (strcmp(nameToken, "glSampleCoverage") == 0)
5165 {
5166 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEPROC>::type>(
5167 paramTokens, strings);
5168 return CallCapture(EntryPoint::GLSampleCoverage, std::move(params));
5169 }
5170 if (strcmp(nameToken, "glSampleCoveragex") == 0)
5171 {
5172 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEXPROC>::type>(
5173 paramTokens, strings);
5174 return CallCapture(EntryPoint::GLSampleCoveragex, std::move(params));
5175 }
5176 if (strcmp(nameToken, "glSampleMaski") == 0)
5177 {
5178 ParamBuffer params =
5179 ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIPROC>::type>(paramTokens, strings);
5180 return CallCapture(EntryPoint::GLSampleMaski, std::move(params));
5181 }
5182 if (strcmp(nameToken, "glSampleMaskiANGLE") == 0)
5183 {
5184 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIANGLEPROC>::type>(
5185 paramTokens, strings);
5186 return CallCapture(EntryPoint::GLSampleMaskiANGLE, std::move(params));
5187 }
5188 if (strcmp(nameToken, "glSamplerParameterIiv") == 0)
5189 {
5190 ParamBuffer params =
5191 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
5192 strings);
5193 return CallCapture(EntryPoint::GLSamplerParameterIiv, std::move(params));
5194 }
5195 if (strcmp(nameToken, "glSamplerParameterIivEXT") == 0)
5196 {
5197 ParamBuffer params =
5198 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVEXTPROC>::type>(paramTokens,
5199 strings);
5200 return CallCapture(EntryPoint::GLSamplerParameterIivEXT, std::move(params));
5201 }
5202 if (strcmp(nameToken, "glSamplerParameterIivOES") == 0)
5203 {
5204 ParamBuffer params =
5205 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVOESPROC>::type>(paramTokens,
5206 strings);
5207 return CallCapture(EntryPoint::GLSamplerParameterIivOES, std::move(params));
5208 }
5209 if (strcmp(nameToken, "glSamplerParameterIivRobustANGLE") == 0)
5210 {
5211 ParamBuffer params =
5212 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
5213 paramTokens, strings);
5214 return CallCapture(EntryPoint::GLSamplerParameterIivRobustANGLE, std::move(params));
5215 }
5216 if (strcmp(nameToken, "glSamplerParameterIuiv") == 0)
5217 {
5218 ParamBuffer params =
5219 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVPROC>::type>(paramTokens,
5220 strings);
5221 return CallCapture(EntryPoint::GLSamplerParameterIuiv, std::move(params));
5222 }
5223 if (strcmp(nameToken, "glSamplerParameterIuivEXT") == 0)
5224 {
5225 ParamBuffer params =
5226 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVEXTPROC>::type>(
5227 paramTokens, strings);
5228 return CallCapture(EntryPoint::GLSamplerParameterIuivEXT, std::move(params));
5229 }
5230 if (strcmp(nameToken, "glSamplerParameterIuivOES") == 0)
5231 {
5232 ParamBuffer params =
5233 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVOESPROC>::type>(
5234 paramTokens, strings);
5235 return CallCapture(EntryPoint::GLSamplerParameterIuivOES, std::move(params));
5236 }
5237 if (strcmp(nameToken, "glSamplerParameterIuivRobustANGLE") == 0)
5238 {
5239 ParamBuffer params =
5240 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
5241 paramTokens, strings);
5242 return CallCapture(EntryPoint::GLSamplerParameterIuivRobustANGLE, std::move(params));
5243 }
5244 if (strcmp(nameToken, "glSamplerParameterf") == 0)
5245 {
5246 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFPROC>::type>(
5247 paramTokens, strings);
5248 return CallCapture(EntryPoint::GLSamplerParameterf, std::move(params));
5249 }
5250 if (strcmp(nameToken, "glSamplerParameterfv") == 0)
5251 {
5252 ParamBuffer params =
5253 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVPROC>::type>(paramTokens,
5254 strings);
5255 return CallCapture(EntryPoint::GLSamplerParameterfv, std::move(params));
5256 }
5257 if (strcmp(nameToken, "glSamplerParameterfvRobustANGLE") == 0)
5258 {
5259 ParamBuffer params =
5260 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
5261 paramTokens, strings);
5262 return CallCapture(EntryPoint::GLSamplerParameterfvRobustANGLE, std::move(params));
5263 }
5264 if (strcmp(nameToken, "glSamplerParameteri") == 0)
5265 {
5266 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIPROC>::type>(
5267 paramTokens, strings);
5268 return CallCapture(EntryPoint::GLSamplerParameteri, std::move(params));
5269 }
5270 if (strcmp(nameToken, "glSamplerParameteriv") == 0)
5271 {
5272 ParamBuffer params =
5273 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVPROC>::type>(paramTokens,
5274 strings);
5275 return CallCapture(EntryPoint::GLSamplerParameteriv, std::move(params));
5276 }
5277 if (strcmp(nameToken, "glSamplerParameterivRobustANGLE") == 0)
5278 {
5279 ParamBuffer params =
5280 ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
5281 paramTokens, strings);
5282 return CallCapture(EntryPoint::GLSamplerParameterivRobustANGLE, std::move(params));
5283 }
5284 if (strcmp(nameToken, "glScalef") == 0)
5285 {
5286 ParamBuffer params =
5287 ParseParameters<std::remove_pointer<PFNGLSCALEFPROC>::type>(paramTokens, strings);
5288 return CallCapture(EntryPoint::GLScalef, std::move(params));
5289 }
5290 if (strcmp(nameToken, "glScalex") == 0)
5291 {
5292 ParamBuffer params =
5293 ParseParameters<std::remove_pointer<PFNGLSCALEXPROC>::type>(paramTokens, strings);
5294 return CallCapture(EntryPoint::GLScalex, std::move(params));
5295 }
5296 if (strcmp(nameToken, "glScissor") == 0)
5297 {
5298 ParamBuffer params =
5299 ParseParameters<std::remove_pointer<PFNGLSCISSORPROC>::type>(paramTokens, strings);
5300 return CallCapture(EntryPoint::GLScissor, std::move(params));
5301 }
5302 if (strcmp(nameToken, "glSelectPerfMonitorCountersAMD") == 0)
5303 {
5304 ParamBuffer params =
5305 ParseParameters<std::remove_pointer<PFNGLSELECTPERFMONITORCOUNTERSAMDPROC>::type>(
5306 paramTokens, strings);
5307 return CallCapture(EntryPoint::GLSelectPerfMonitorCountersAMD, std::move(params));
5308 }
5309 if (strcmp(nameToken, "glSemaphoreParameterui64vEXT") == 0)
5310 {
5311 ParamBuffer params =
5312 ParseParameters<std::remove_pointer<PFNGLSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
5313 paramTokens, strings);
5314 return CallCapture(EntryPoint::GLSemaphoreParameterui64vEXT, std::move(params));
5315 }
5316 if (strcmp(nameToken, "glSetFenceNV") == 0)
5317 {
5318 ParamBuffer params =
5319 ParseParameters<std::remove_pointer<PFNGLSETFENCENVPROC>::type>(paramTokens, strings);
5320 return CallCapture(EntryPoint::GLSetFenceNV, std::move(params));
5321 }
5322 if (strcmp(nameToken, "glShadeModel") == 0)
5323 {
5324 ParamBuffer params =
5325 ParseParameters<std::remove_pointer<PFNGLSHADEMODELPROC>::type>(paramTokens, strings);
5326 return CallCapture(EntryPoint::GLShadeModel, std::move(params));
5327 }
5328 if (strcmp(nameToken, "glShaderBinary") == 0)
5329 {
5330 ParamBuffer params =
5331 ParseParameters<std::remove_pointer<PFNGLSHADERBINARYPROC>::type>(paramTokens, strings);
5332 return CallCapture(EntryPoint::GLShaderBinary, std::move(params));
5333 }
5334 if (strcmp(nameToken, "glShaderSource") == 0)
5335 {
5336 ParamBuffer params =
5337 ParseParameters<std::remove_pointer<PFNGLSHADERSOURCEPROC>::type>(paramTokens, strings);
5338 return CallCapture(EntryPoint::GLShaderSource, std::move(params));
5339 }
5340 if (strcmp(nameToken, "glShadingRateQCOM") == 0)
5341 {
5342 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSHADINGRATEQCOMPROC>::type>(
5343 paramTokens, strings);
5344 return CallCapture(EntryPoint::GLShadingRateQCOM, std::move(params));
5345 }
5346 if (strcmp(nameToken, "glSignalSemaphoreEXT") == 0)
5347 {
5348 ParamBuffer params =
5349 ParseParameters<std::remove_pointer<PFNGLSIGNALSEMAPHOREEXTPROC>::type>(paramTokens,
5350 strings);
5351 return CallCapture(EntryPoint::GLSignalSemaphoreEXT, std::move(params));
5352 }
5353 if (strcmp(nameToken, "glStartTilingQCOM") == 0)
5354 {
5355 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSTARTTILINGQCOMPROC>::type>(
5356 paramTokens, strings);
5357 return CallCapture(EntryPoint::GLStartTilingQCOM, std::move(params));
5358 }
5359 if (strcmp(nameToken, "glStencilFunc") == 0)
5360 {
5361 ParamBuffer params =
5362 ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCPROC>::type>(paramTokens, strings);
5363 return CallCapture(EntryPoint::GLStencilFunc, std::move(params));
5364 }
5365 if (strcmp(nameToken, "glStencilFuncSeparate") == 0)
5366 {
5367 ParamBuffer params =
5368 ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCSEPARATEPROC>::type>(paramTokens,
5369 strings);
5370 return CallCapture(EntryPoint::GLStencilFuncSeparate, std::move(params));
5371 }
5372 if (strcmp(nameToken, "glStencilMask") == 0)
5373 {
5374 ParamBuffer params =
5375 ParseParameters<std::remove_pointer<PFNGLSTENCILMASKPROC>::type>(paramTokens, strings);
5376 return CallCapture(EntryPoint::GLStencilMask, std::move(params));
5377 }
5378 if (strcmp(nameToken, "glStencilMaskSeparate") == 0)
5379 {
5380 ParamBuffer params =
5381 ParseParameters<std::remove_pointer<PFNGLSTENCILMASKSEPARATEPROC>::type>(paramTokens,
5382 strings);
5383 return CallCapture(EntryPoint::GLStencilMaskSeparate, std::move(params));
5384 }
5385 if (strcmp(nameToken, "glStencilOp") == 0)
5386 {
5387 ParamBuffer params =
5388 ParseParameters<std::remove_pointer<PFNGLSTENCILOPPROC>::type>(paramTokens, strings);
5389 return CallCapture(EntryPoint::GLStencilOp, std::move(params));
5390 }
5391 if (strcmp(nameToken, "glStencilOpSeparate") == 0)
5392 {
5393 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSTENCILOPSEPARATEPROC>::type>(
5394 paramTokens, strings);
5395 return CallCapture(EntryPoint::GLStencilOpSeparate, std::move(params));
5396 }
5397 if (strcmp(nameToken, "glTestFenceNV") == 0)
5398 {
5399 ParamBuffer params =
5400 ParseParameters<std::remove_pointer<PFNGLTESTFENCENVPROC>::type>(paramTokens, strings);
5401 return CallCapture(EntryPoint::GLTestFenceNV, std::move(params));
5402 }
5403 if (strcmp(nameToken, "glTexBuffer") == 0)
5404 {
5405 ParamBuffer params =
5406 ParseParameters<std::remove_pointer<PFNGLTEXBUFFERPROC>::type>(paramTokens, strings);
5407 return CallCapture(EntryPoint::GLTexBuffer, std::move(params));
5408 }
5409 if (strcmp(nameToken, "glTexBufferEXT") == 0)
5410 {
5411 ParamBuffer params =
5412 ParseParameters<std::remove_pointer<PFNGLTEXBUFFEREXTPROC>::type>(paramTokens, strings);
5413 return CallCapture(EntryPoint::GLTexBufferEXT, std::move(params));
5414 }
5415 if (strcmp(nameToken, "glTexBufferOES") == 0)
5416 {
5417 ParamBuffer params =
5418 ParseParameters<std::remove_pointer<PFNGLTEXBUFFEROESPROC>::type>(paramTokens, strings);
5419 return CallCapture(EntryPoint::GLTexBufferOES, std::move(params));
5420 }
5421 if (strcmp(nameToken, "glTexBufferRange") == 0)
5422 {
5423 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEPROC>::type>(
5424 paramTokens, strings);
5425 return CallCapture(EntryPoint::GLTexBufferRange, std::move(params));
5426 }
5427 if (strcmp(nameToken, "glTexBufferRangeEXT") == 0)
5428 {
5429 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEEXTPROC>::type>(
5430 paramTokens, strings);
5431 return CallCapture(EntryPoint::GLTexBufferRangeEXT, std::move(params));
5432 }
5433 if (strcmp(nameToken, "glTexBufferRangeOES") == 0)
5434 {
5435 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEOESPROC>::type>(
5436 paramTokens, strings);
5437 return CallCapture(EntryPoint::GLTexBufferRangeOES, std::move(params));
5438 }
5439 if (strcmp(nameToken, "glTexCoordPointer") == 0)
5440 {
5441 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXCOORDPOINTERPROC>::type>(
5442 paramTokens, strings);
5443 return CallCapture(EntryPoint::GLTexCoordPointer, std::move(params));
5444 }
5445 if (strcmp(nameToken, "glTexEnvf") == 0)
5446 {
5447 ParamBuffer params =
5448 ParseParameters<std::remove_pointer<PFNGLTEXENVFPROC>::type>(paramTokens, strings);
5449 return CallCapture(EntryPoint::GLTexEnvf, std::move(params));
5450 }
5451 if (strcmp(nameToken, "glTexEnvfv") == 0)
5452 {
5453 ParamBuffer params =
5454 ParseParameters<std::remove_pointer<PFNGLTEXENVFVPROC>::type>(paramTokens, strings);
5455 return CallCapture(EntryPoint::GLTexEnvfv, std::move(params));
5456 }
5457 if (strcmp(nameToken, "glTexEnvi") == 0)
5458 {
5459 ParamBuffer params =
5460 ParseParameters<std::remove_pointer<PFNGLTEXENVIPROC>::type>(paramTokens, strings);
5461 return CallCapture(EntryPoint::GLTexEnvi, std::move(params));
5462 }
5463 if (strcmp(nameToken, "glTexEnviv") == 0)
5464 {
5465 ParamBuffer params =
5466 ParseParameters<std::remove_pointer<PFNGLTEXENVIVPROC>::type>(paramTokens, strings);
5467 return CallCapture(EntryPoint::GLTexEnviv, std::move(params));
5468 }
5469 if (strcmp(nameToken, "glTexEnvx") == 0)
5470 {
5471 ParamBuffer params =
5472 ParseParameters<std::remove_pointer<PFNGLTEXENVXPROC>::type>(paramTokens, strings);
5473 return CallCapture(EntryPoint::GLTexEnvx, std::move(params));
5474 }
5475 if (strcmp(nameToken, "glTexEnvxv") == 0)
5476 {
5477 ParamBuffer params =
5478 ParseParameters<std::remove_pointer<PFNGLTEXENVXVPROC>::type>(paramTokens, strings);
5479 return CallCapture(EntryPoint::GLTexEnvxv, std::move(params));
5480 }
5481 if (strcmp(nameToken, "glTexGenfOES") == 0)
5482 {
5483 ParamBuffer params =
5484 ParseParameters<std::remove_pointer<PFNGLTEXGENFOESPROC>::type>(paramTokens, strings);
5485 return CallCapture(EntryPoint::GLTexGenfOES, std::move(params));
5486 }
5487 if (strcmp(nameToken, "glTexGenfvOES") == 0)
5488 {
5489 ParamBuffer params =
5490 ParseParameters<std::remove_pointer<PFNGLTEXGENFVOESPROC>::type>(paramTokens, strings);
5491 return CallCapture(EntryPoint::GLTexGenfvOES, std::move(params));
5492 }
5493 if (strcmp(nameToken, "glTexGeniOES") == 0)
5494 {
5495 ParamBuffer params =
5496 ParseParameters<std::remove_pointer<PFNGLTEXGENIOESPROC>::type>(paramTokens, strings);
5497 return CallCapture(EntryPoint::GLTexGeniOES, std::move(params));
5498 }
5499 if (strcmp(nameToken, "glTexGenivOES") == 0)
5500 {
5501 ParamBuffer params =
5502 ParseParameters<std::remove_pointer<PFNGLTEXGENIVOESPROC>::type>(paramTokens, strings);
5503 return CallCapture(EntryPoint::GLTexGenivOES, std::move(params));
5504 }
5505 if (strcmp(nameToken, "glTexGenxOES") == 0)
5506 {
5507 ParamBuffer params =
5508 ParseParameters<std::remove_pointer<PFNGLTEXGENXOESPROC>::type>(paramTokens, strings);
5509 return CallCapture(EntryPoint::GLTexGenxOES, std::move(params));
5510 }
5511 if (strcmp(nameToken, "glTexGenxvOES") == 0)
5512 {
5513 ParamBuffer params =
5514 ParseParameters<std::remove_pointer<PFNGLTEXGENXVOESPROC>::type>(paramTokens, strings);
5515 return CallCapture(EntryPoint::GLTexGenxvOES, std::move(params));
5516 }
5517 if (strcmp(nameToken, "glTexImage2D") == 0)
5518 {
5519 ParamBuffer params =
5520 ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DPROC>::type>(paramTokens, strings);
5521 return CallCapture(EntryPoint::GLTexImage2D, std::move(params));
5522 }
5523 if (strcmp(nameToken, "glTexImage2DExternalANGLE") == 0)
5524 {
5525 ParamBuffer params =
5526 ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DEXTERNALANGLEPROC>::type>(
5527 paramTokens, strings);
5528 return CallCapture(EntryPoint::GLTexImage2DExternalANGLE, std::move(params));
5529 }
5530 if (strcmp(nameToken, "glTexImage2DRobustANGLE") == 0)
5531 {
5532 ParamBuffer params =
5533 ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DROBUSTANGLEPROC>::type>(paramTokens,
5534 strings);
5535 return CallCapture(EntryPoint::GLTexImage2DRobustANGLE, std::move(params));
5536 }
5537 if (strcmp(nameToken, "glTexImage3D") == 0)
5538 {
5539 ParamBuffer params =
5540 ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DPROC>::type>(paramTokens, strings);
5541 return CallCapture(EntryPoint::GLTexImage3D, std::move(params));
5542 }
5543 if (strcmp(nameToken, "glTexImage3DOES") == 0)
5544 {
5545 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DOESPROC>::type>(
5546 paramTokens, strings);
5547 return CallCapture(EntryPoint::GLTexImage3DOES, std::move(params));
5548 }
5549 if (strcmp(nameToken, "glTexImage3DRobustANGLE") == 0)
5550 {
5551 ParamBuffer params =
5552 ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DROBUSTANGLEPROC>::type>(paramTokens,
5553 strings);
5554 return CallCapture(EntryPoint::GLTexImage3DRobustANGLE, std::move(params));
5555 }
5556 if (strcmp(nameToken, "glTexParameterIiv") == 0)
5557 {
5558 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVPROC>::type>(
5559 paramTokens, strings);
5560 return CallCapture(EntryPoint::GLTexParameterIiv, std::move(params));
5561 }
5562 if (strcmp(nameToken, "glTexParameterIivEXT") == 0)
5563 {
5564 ParamBuffer params =
5565 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
5566 strings);
5567 return CallCapture(EntryPoint::GLTexParameterIivEXT, std::move(params));
5568 }
5569 if (strcmp(nameToken, "glTexParameterIivOES") == 0)
5570 {
5571 ParamBuffer params =
5572 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVOESPROC>::type>(paramTokens,
5573 strings);
5574 return CallCapture(EntryPoint::GLTexParameterIivOES, std::move(params));
5575 }
5576 if (strcmp(nameToken, "glTexParameterIivRobustANGLE") == 0)
5577 {
5578 ParamBuffer params =
5579 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
5580 paramTokens, strings);
5581 return CallCapture(EntryPoint::GLTexParameterIivRobustANGLE, std::move(params));
5582 }
5583 if (strcmp(nameToken, "glTexParameterIuiv") == 0)
5584 {
5585 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVPROC>::type>(
5586 paramTokens, strings);
5587 return CallCapture(EntryPoint::GLTexParameterIuiv, std::move(params));
5588 }
5589 if (strcmp(nameToken, "glTexParameterIuivEXT") == 0)
5590 {
5591 ParamBuffer params =
5592 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
5593 strings);
5594 return CallCapture(EntryPoint::GLTexParameterIuivEXT, std::move(params));
5595 }
5596 if (strcmp(nameToken, "glTexParameterIuivOES") == 0)
5597 {
5598 ParamBuffer params =
5599 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
5600 strings);
5601 return CallCapture(EntryPoint::GLTexParameterIuivOES, std::move(params));
5602 }
5603 if (strcmp(nameToken, "glTexParameterIuivRobustANGLE") == 0)
5604 {
5605 ParamBuffer params =
5606 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
5607 paramTokens, strings);
5608 return CallCapture(EntryPoint::GLTexParameterIuivRobustANGLE, std::move(params));
5609 }
5610 if (strcmp(nameToken, "glTexParameterf") == 0)
5611 {
5612 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFPROC>::type>(
5613 paramTokens, strings);
5614 return CallCapture(EntryPoint::GLTexParameterf, std::move(params));
5615 }
5616 if (strcmp(nameToken, "glTexParameterfv") == 0)
5617 {
5618 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVPROC>::type>(
5619 paramTokens, strings);
5620 return CallCapture(EntryPoint::GLTexParameterfv, std::move(params));
5621 }
5622 if (strcmp(nameToken, "glTexParameterfvRobustANGLE") == 0)
5623 {
5624 ParamBuffer params =
5625 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVROBUSTANGLEPROC>::type>(
5626 paramTokens, strings);
5627 return CallCapture(EntryPoint::GLTexParameterfvRobustANGLE, std::move(params));
5628 }
5629 if (strcmp(nameToken, "glTexParameteri") == 0)
5630 {
5631 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIPROC>::type>(
5632 paramTokens, strings);
5633 return CallCapture(EntryPoint::GLTexParameteri, std::move(params));
5634 }
5635 if (strcmp(nameToken, "glTexParameteriv") == 0)
5636 {
5637 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVPROC>::type>(
5638 paramTokens, strings);
5639 return CallCapture(EntryPoint::GLTexParameteriv, std::move(params));
5640 }
5641 if (strcmp(nameToken, "glTexParameterivRobustANGLE") == 0)
5642 {
5643 ParamBuffer params =
5644 ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVROBUSTANGLEPROC>::type>(
5645 paramTokens, strings);
5646 return CallCapture(EntryPoint::GLTexParameterivRobustANGLE, std::move(params));
5647 }
5648 if (strcmp(nameToken, "glTexParameterx") == 0)
5649 {
5650 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXPROC>::type>(
5651 paramTokens, strings);
5652 return CallCapture(EntryPoint::GLTexParameterx, std::move(params));
5653 }
5654 if (strcmp(nameToken, "glTexParameterxv") == 0)
5655 {
5656 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXVPROC>::type>(
5657 paramTokens, strings);
5658 return CallCapture(EntryPoint::GLTexParameterxv, std::move(params));
5659 }
5660 if (strcmp(nameToken, "glTexStorage1DEXT") == 0)
5661 {
5662 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE1DEXTPROC>::type>(
5663 paramTokens, strings);
5664 return CallCapture(EntryPoint::GLTexStorage1DEXT, std::move(params));
5665 }
5666 if (strcmp(nameToken, "glTexStorage2D") == 0)
5667 {
5668 ParamBuffer params =
5669 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DPROC>::type>(paramTokens, strings);
5670 return CallCapture(EntryPoint::GLTexStorage2D, std::move(params));
5671 }
5672 if (strcmp(nameToken, "glTexStorage2DEXT") == 0)
5673 {
5674 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DEXTPROC>::type>(
5675 paramTokens, strings);
5676 return CallCapture(EntryPoint::GLTexStorage2DEXT, std::move(params));
5677 }
5678 if (strcmp(nameToken, "glTexStorage2DMultisample") == 0)
5679 {
5680 ParamBuffer params =
5681 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEPROC>::type>(
5682 paramTokens, strings);
5683 return CallCapture(EntryPoint::GLTexStorage2DMultisample, std::move(params));
5684 }
5685 if (strcmp(nameToken, "glTexStorage2DMultisampleANGLE") == 0)
5686 {
5687 ParamBuffer params =
5688 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC>::type>(
5689 paramTokens, strings);
5690 return CallCapture(EntryPoint::GLTexStorage2DMultisampleANGLE, std::move(params));
5691 }
5692 if (strcmp(nameToken, "glTexStorage3D") == 0)
5693 {
5694 ParamBuffer params =
5695 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DPROC>::type>(paramTokens, strings);
5696 return CallCapture(EntryPoint::GLTexStorage3D, std::move(params));
5697 }
5698 if (strcmp(nameToken, "glTexStorage3DEXT") == 0)
5699 {
5700 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DEXTPROC>::type>(
5701 paramTokens, strings);
5702 return CallCapture(EntryPoint::GLTexStorage3DEXT, std::move(params));
5703 }
5704 if (strcmp(nameToken, "glTexStorage3DMultisample") == 0)
5705 {
5706 ParamBuffer params =
5707 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEPROC>::type>(
5708 paramTokens, strings);
5709 return CallCapture(EntryPoint::GLTexStorage3DMultisample, std::move(params));
5710 }
5711 if (strcmp(nameToken, "glTexStorage3DMultisampleOES") == 0)
5712 {
5713 ParamBuffer params =
5714 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC>::type>(
5715 paramTokens, strings);
5716 return CallCapture(EntryPoint::GLTexStorage3DMultisampleOES, std::move(params));
5717 }
5718 if (strcmp(nameToken, "glTexStorageAttribs2DEXT") == 0)
5719 {
5720 ParamBuffer params =
5721 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEATTRIBS2DEXTPROC>::type>(paramTokens,
5722 strings);
5723 return CallCapture(EntryPoint::GLTexStorageAttribs2DEXT, std::move(params));
5724 }
5725 if (strcmp(nameToken, "glTexStorageAttribs3DEXT") == 0)
5726 {
5727 ParamBuffer params =
5728 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEATTRIBS3DEXTPROC>::type>(paramTokens,
5729 strings);
5730 return CallCapture(EntryPoint::GLTexStorageAttribs3DEXT, std::move(params));
5731 }
5732 if (strcmp(nameToken, "glTexStorageMem2DEXT") == 0)
5733 {
5734 ParamBuffer params =
5735 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DEXTPROC>::type>(paramTokens,
5736 strings);
5737 return CallCapture(EntryPoint::GLTexStorageMem2DEXT, std::move(params));
5738 }
5739 if (strcmp(nameToken, "glTexStorageMem2DMultisampleEXT") == 0)
5740 {
5741 ParamBuffer params =
5742 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC>::type>(
5743 paramTokens, strings);
5744 return CallCapture(EntryPoint::GLTexStorageMem2DMultisampleEXT, std::move(params));
5745 }
5746 if (strcmp(nameToken, "glTexStorageMem3DEXT") == 0)
5747 {
5748 ParamBuffer params =
5749 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DEXTPROC>::type>(paramTokens,
5750 strings);
5751 return CallCapture(EntryPoint::GLTexStorageMem3DEXT, std::move(params));
5752 }
5753 if (strcmp(nameToken, "glTexStorageMem3DMultisampleEXT") == 0)
5754 {
5755 ParamBuffer params =
5756 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC>::type>(
5757 paramTokens, strings);
5758 return CallCapture(EntryPoint::GLTexStorageMem3DMultisampleEXT, std::move(params));
5759 }
5760 if (strcmp(nameToken, "glTexStorageMemFlags2DANGLE") == 0)
5761 {
5762 ParamBuffer params =
5763 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DANGLEPROC>::type>(
5764 paramTokens, strings);
5765 return CallCapture(EntryPoint::GLTexStorageMemFlags2DANGLE, std::move(params));
5766 }
5767 if (strcmp(nameToken, "glTexStorageMemFlags2DMultisampleANGLE") == 0)
5768 {
5769 ParamBuffer params = ParseParameters<
5770 std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DMULTISAMPLEANGLEPROC>::type>(paramTokens,
5771 strings);
5772 return CallCapture(EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, std::move(params));
5773 }
5774 if (strcmp(nameToken, "glTexStorageMemFlags3DANGLE") == 0)
5775 {
5776 ParamBuffer params =
5777 ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DANGLEPROC>::type>(
5778 paramTokens, strings);
5779 return CallCapture(EntryPoint::GLTexStorageMemFlags3DANGLE, std::move(params));
5780 }
5781 if (strcmp(nameToken, "glTexStorageMemFlags3DMultisampleANGLE") == 0)
5782 {
5783 ParamBuffer params = ParseParameters<
5784 std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DMULTISAMPLEANGLEPROC>::type>(paramTokens,
5785 strings);
5786 return CallCapture(EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, std::move(params));
5787 }
5788 if (strcmp(nameToken, "glTexSubImage2D") == 0)
5789 {
5790 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DPROC>::type>(
5791 paramTokens, strings);
5792 return CallCapture(EntryPoint::GLTexSubImage2D, std::move(params));
5793 }
5794 if (strcmp(nameToken, "glTexSubImage2DRobustANGLE") == 0)
5795 {
5796 ParamBuffer params =
5797 ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DROBUSTANGLEPROC>::type>(
5798 paramTokens, strings);
5799 return CallCapture(EntryPoint::GLTexSubImage2DRobustANGLE, std::move(params));
5800 }
5801 if (strcmp(nameToken, "glTexSubImage3D") == 0)
5802 {
5803 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DPROC>::type>(
5804 paramTokens, strings);
5805 return CallCapture(EntryPoint::GLTexSubImage3D, std::move(params));
5806 }
5807 if (strcmp(nameToken, "glTexSubImage3DOES") == 0)
5808 {
5809 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DOESPROC>::type>(
5810 paramTokens, strings);
5811 return CallCapture(EntryPoint::GLTexSubImage3DOES, std::move(params));
5812 }
5813 if (strcmp(nameToken, "glTexSubImage3DRobustANGLE") == 0)
5814 {
5815 ParamBuffer params =
5816 ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DROBUSTANGLEPROC>::type>(
5817 paramTokens, strings);
5818 return CallCapture(EntryPoint::GLTexSubImage3DRobustANGLE, std::move(params));
5819 }
5820 if (strcmp(nameToken, "glTextureFoveationParametersQCOM") == 0)
5821 {
5822 ParamBuffer params =
5823 ParseParameters<std::remove_pointer<PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC>::type>(
5824 paramTokens, strings);
5825 return CallCapture(EntryPoint::GLTextureFoveationParametersQCOM, std::move(params));
5826 }
5827 if (strcmp(nameToken, "glTransformFeedbackVaryings") == 0)
5828 {
5829 ParamBuffer params =
5830 ParseParameters<std::remove_pointer<PFNGLTRANSFORMFEEDBACKVARYINGSPROC>::type>(
5831 paramTokens, strings);
5832 return CallCapture(EntryPoint::GLTransformFeedbackVaryings, std::move(params));
5833 }
5834 if (strcmp(nameToken, "glTranslatef") == 0)
5835 {
5836 ParamBuffer params =
5837 ParseParameters<std::remove_pointer<PFNGLTRANSLATEFPROC>::type>(paramTokens, strings);
5838 return CallCapture(EntryPoint::GLTranslatef, std::move(params));
5839 }
5840 if (strcmp(nameToken, "glTranslatex") == 0)
5841 {
5842 ParamBuffer params =
5843 ParseParameters<std::remove_pointer<PFNGLTRANSLATEXPROC>::type>(paramTokens, strings);
5844 return CallCapture(EntryPoint::GLTranslatex, std::move(params));
5845 }
5846 if (strcmp(nameToken, "glUniform1f") == 0)
5847 {
5848 ParamBuffer params =
5849 ParseParameters<std::remove_pointer<PFNGLUNIFORM1FPROC>::type>(paramTokens, strings);
5850 return CallCapture(EntryPoint::GLUniform1f, std::move(params));
5851 }
5852 if (strcmp(nameToken, "glUniform1fv") == 0)
5853 {
5854 ParamBuffer params =
5855 ParseParameters<std::remove_pointer<PFNGLUNIFORM1FVPROC>::type>(paramTokens, strings);
5856 return CallCapture(EntryPoint::GLUniform1fv, std::move(params));
5857 }
5858 if (strcmp(nameToken, "glUniform1i") == 0)
5859 {
5860 ParamBuffer params =
5861 ParseParameters<std::remove_pointer<PFNGLUNIFORM1IPROC>::type>(paramTokens, strings);
5862 return CallCapture(EntryPoint::GLUniform1i, std::move(params));
5863 }
5864 if (strcmp(nameToken, "glUniform1iv") == 0)
5865 {
5866 ParamBuffer params =
5867 ParseParameters<std::remove_pointer<PFNGLUNIFORM1IVPROC>::type>(paramTokens, strings);
5868 return CallCapture(EntryPoint::GLUniform1iv, std::move(params));
5869 }
5870 if (strcmp(nameToken, "glUniform1ui") == 0)
5871 {
5872 ParamBuffer params =
5873 ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIPROC>::type>(paramTokens, strings);
5874 return CallCapture(EntryPoint::GLUniform1ui, std::move(params));
5875 }
5876 if (strcmp(nameToken, "glUniform1uiv") == 0)
5877 {
5878 ParamBuffer params =
5879 ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIVPROC>::type>(paramTokens, strings);
5880 return CallCapture(EntryPoint::GLUniform1uiv, std::move(params));
5881 }
5882 if (strcmp(nameToken, "glUniform2f") == 0)
5883 {
5884 ParamBuffer params =
5885 ParseParameters<std::remove_pointer<PFNGLUNIFORM2FPROC>::type>(paramTokens, strings);
5886 return CallCapture(EntryPoint::GLUniform2f, std::move(params));
5887 }
5888 if (strcmp(nameToken, "glUniform2fv") == 0)
5889 {
5890 ParamBuffer params =
5891 ParseParameters<std::remove_pointer<PFNGLUNIFORM2FVPROC>::type>(paramTokens, strings);
5892 return CallCapture(EntryPoint::GLUniform2fv, std::move(params));
5893 }
5894 if (strcmp(nameToken, "glUniform2i") == 0)
5895 {
5896 ParamBuffer params =
5897 ParseParameters<std::remove_pointer<PFNGLUNIFORM2IPROC>::type>(paramTokens, strings);
5898 return CallCapture(EntryPoint::GLUniform2i, std::move(params));
5899 }
5900 if (strcmp(nameToken, "glUniform2iv") == 0)
5901 {
5902 ParamBuffer params =
5903 ParseParameters<std::remove_pointer<PFNGLUNIFORM2IVPROC>::type>(paramTokens, strings);
5904 return CallCapture(EntryPoint::GLUniform2iv, std::move(params));
5905 }
5906 if (strcmp(nameToken, "glUniform2ui") == 0)
5907 {
5908 ParamBuffer params =
5909 ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIPROC>::type>(paramTokens, strings);
5910 return CallCapture(EntryPoint::GLUniform2ui, std::move(params));
5911 }
5912 if (strcmp(nameToken, "glUniform2uiv") == 0)
5913 {
5914 ParamBuffer params =
5915 ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIVPROC>::type>(paramTokens, strings);
5916 return CallCapture(EntryPoint::GLUniform2uiv, std::move(params));
5917 }
5918 if (strcmp(nameToken, "glUniform3f") == 0)
5919 {
5920 ParamBuffer params =
5921 ParseParameters<std::remove_pointer<PFNGLUNIFORM3FPROC>::type>(paramTokens, strings);
5922 return CallCapture(EntryPoint::GLUniform3f, std::move(params));
5923 }
5924 if (strcmp(nameToken, "glUniform3fv") == 0)
5925 {
5926 ParamBuffer params =
5927 ParseParameters<std::remove_pointer<PFNGLUNIFORM3FVPROC>::type>(paramTokens, strings);
5928 return CallCapture(EntryPoint::GLUniform3fv, std::move(params));
5929 }
5930 if (strcmp(nameToken, "glUniform3i") == 0)
5931 {
5932 ParamBuffer params =
5933 ParseParameters<std::remove_pointer<PFNGLUNIFORM3IPROC>::type>(paramTokens, strings);
5934 return CallCapture(EntryPoint::GLUniform3i, std::move(params));
5935 }
5936 if (strcmp(nameToken, "glUniform3iv") == 0)
5937 {
5938 ParamBuffer params =
5939 ParseParameters<std::remove_pointer<PFNGLUNIFORM3IVPROC>::type>(paramTokens, strings);
5940 return CallCapture(EntryPoint::GLUniform3iv, std::move(params));
5941 }
5942 if (strcmp(nameToken, "glUniform3ui") == 0)
5943 {
5944 ParamBuffer params =
5945 ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIPROC>::type>(paramTokens, strings);
5946 return CallCapture(EntryPoint::GLUniform3ui, std::move(params));
5947 }
5948 if (strcmp(nameToken, "glUniform3uiv") == 0)
5949 {
5950 ParamBuffer params =
5951 ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIVPROC>::type>(paramTokens, strings);
5952 return CallCapture(EntryPoint::GLUniform3uiv, std::move(params));
5953 }
5954 if (strcmp(nameToken, "glUniform4f") == 0)
5955 {
5956 ParamBuffer params =
5957 ParseParameters<std::remove_pointer<PFNGLUNIFORM4FPROC>::type>(paramTokens, strings);
5958 return CallCapture(EntryPoint::GLUniform4f, std::move(params));
5959 }
5960 if (strcmp(nameToken, "glUniform4fv") == 0)
5961 {
5962 ParamBuffer params =
5963 ParseParameters<std::remove_pointer<PFNGLUNIFORM4FVPROC>::type>(paramTokens, strings);
5964 return CallCapture(EntryPoint::GLUniform4fv, std::move(params));
5965 }
5966 if (strcmp(nameToken, "glUniform4i") == 0)
5967 {
5968 ParamBuffer params =
5969 ParseParameters<std::remove_pointer<PFNGLUNIFORM4IPROC>::type>(paramTokens, strings);
5970 return CallCapture(EntryPoint::GLUniform4i, std::move(params));
5971 }
5972 if (strcmp(nameToken, "glUniform4iv") == 0)
5973 {
5974 ParamBuffer params =
5975 ParseParameters<std::remove_pointer<PFNGLUNIFORM4IVPROC>::type>(paramTokens, strings);
5976 return CallCapture(EntryPoint::GLUniform4iv, std::move(params));
5977 }
5978 if (strcmp(nameToken, "glUniform4ui") == 0)
5979 {
5980 ParamBuffer params =
5981 ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIPROC>::type>(paramTokens, strings);
5982 return CallCapture(EntryPoint::GLUniform4ui, std::move(params));
5983 }
5984 if (strcmp(nameToken, "glUniform4uiv") == 0)
5985 {
5986 ParamBuffer params =
5987 ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIVPROC>::type>(paramTokens, strings);
5988 return CallCapture(EntryPoint::GLUniform4uiv, std::move(params));
5989 }
5990 if (strcmp(nameToken, "glUniformBlockBinding") == 0)
5991 {
5992 ParamBuffer params =
5993 ParseParameters<std::remove_pointer<PFNGLUNIFORMBLOCKBINDINGPROC>::type>(paramTokens,
5994 strings);
5995 return CallCapture(EntryPoint::GLUniformBlockBinding, std::move(params));
5996 }
5997 if (strcmp(nameToken, "glUniformMatrix2fv") == 0)
5998 {
5999 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2FVPROC>::type>(
6000 paramTokens, strings);
6001 return CallCapture(EntryPoint::GLUniformMatrix2fv, std::move(params));
6002 }
6003 if (strcmp(nameToken, "glUniformMatrix2x3fv") == 0)
6004 {
6005 ParamBuffer params =
6006 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X3FVPROC>::type>(paramTokens,
6007 strings);
6008 return CallCapture(EntryPoint::GLUniformMatrix2x3fv, std::move(params));
6009 }
6010 if (strcmp(nameToken, "glUniformMatrix2x4fv") == 0)
6011 {
6012 ParamBuffer params =
6013 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X4FVPROC>::type>(paramTokens,
6014 strings);
6015 return CallCapture(EntryPoint::GLUniformMatrix2x4fv, std::move(params));
6016 }
6017 if (strcmp(nameToken, "glUniformMatrix3fv") == 0)
6018 {
6019 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3FVPROC>::type>(
6020 paramTokens, strings);
6021 return CallCapture(EntryPoint::GLUniformMatrix3fv, std::move(params));
6022 }
6023 if (strcmp(nameToken, "glUniformMatrix3x2fv") == 0)
6024 {
6025 ParamBuffer params =
6026 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X2FVPROC>::type>(paramTokens,
6027 strings);
6028 return CallCapture(EntryPoint::GLUniformMatrix3x2fv, std::move(params));
6029 }
6030 if (strcmp(nameToken, "glUniformMatrix3x4fv") == 0)
6031 {
6032 ParamBuffer params =
6033 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X4FVPROC>::type>(paramTokens,
6034 strings);
6035 return CallCapture(EntryPoint::GLUniformMatrix3x4fv, std::move(params));
6036 }
6037 if (strcmp(nameToken, "glUniformMatrix4fv") == 0)
6038 {
6039 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4FVPROC>::type>(
6040 paramTokens, strings);
6041 return CallCapture(EntryPoint::GLUniformMatrix4fv, std::move(params));
6042 }
6043 if (strcmp(nameToken, "glUniformMatrix4x2fv") == 0)
6044 {
6045 ParamBuffer params =
6046 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X2FVPROC>::type>(paramTokens,
6047 strings);
6048 return CallCapture(EntryPoint::GLUniformMatrix4x2fv, std::move(params));
6049 }
6050 if (strcmp(nameToken, "glUniformMatrix4x3fv") == 0)
6051 {
6052 ParamBuffer params =
6053 ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X3FVPROC>::type>(paramTokens,
6054 strings);
6055 return CallCapture(EntryPoint::GLUniformMatrix4x3fv, std::move(params));
6056 }
6057 if (strcmp(nameToken, "glUnmapBuffer") == 0)
6058 {
6059 ParamBuffer params =
6060 ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFERPROC>::type>(paramTokens, strings);
6061 return CallCapture(EntryPoint::GLUnmapBuffer, std::move(params));
6062 }
6063 if (strcmp(nameToken, "glUnmapBufferOES") == 0)
6064 {
6065 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFEROESPROC>::type>(
6066 paramTokens, strings);
6067 return CallCapture(EntryPoint::GLUnmapBufferOES, std::move(params));
6068 }
6069 if (strcmp(nameToken, "glUseProgram") == 0)
6070 {
6071 ParamBuffer params =
6072 ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMPROC>::type>(paramTokens, strings);
6073 return CallCapture(EntryPoint::GLUseProgram, std::move(params));
6074 }
6075 if (strcmp(nameToken, "glUseProgramStages") == 0)
6076 {
6077 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESPROC>::type>(
6078 paramTokens, strings);
6079 return CallCapture(EntryPoint::GLUseProgramStages, std::move(params));
6080 }
6081 if (strcmp(nameToken, "glUseProgramStagesEXT") == 0)
6082 {
6083 ParamBuffer params =
6084 ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESEXTPROC>::type>(paramTokens,
6085 strings);
6086 return CallCapture(EntryPoint::GLUseProgramStagesEXT, std::move(params));
6087 }
6088 if (strcmp(nameToken, "glValidateProgram") == 0)
6089 {
6090 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPROC>::type>(
6091 paramTokens, strings);
6092 return CallCapture(EntryPoint::GLValidateProgram, std::move(params));
6093 }
6094 if (strcmp(nameToken, "glValidateProgramPipeline") == 0)
6095 {
6096 ParamBuffer params =
6097 ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEPROC>::type>(
6098 paramTokens, strings);
6099 return CallCapture(EntryPoint::GLValidateProgramPipeline, std::move(params));
6100 }
6101 if (strcmp(nameToken, "glValidateProgramPipelineEXT") == 0)
6102 {
6103 ParamBuffer params =
6104 ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEEXTPROC>::type>(
6105 paramTokens, strings);
6106 return CallCapture(EntryPoint::GLValidateProgramPipelineEXT, std::move(params));
6107 }
6108 if (strcmp(nameToken, "glVertexAttrib1f") == 0)
6109 {
6110 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FPROC>::type>(
6111 paramTokens, strings);
6112 return CallCapture(EntryPoint::GLVertexAttrib1f, std::move(params));
6113 }
6114 if (strcmp(nameToken, "glVertexAttrib1fv") == 0)
6115 {
6116 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FVPROC>::type>(
6117 paramTokens, strings);
6118 return CallCapture(EntryPoint::GLVertexAttrib1fv, std::move(params));
6119 }
6120 if (strcmp(nameToken, "glVertexAttrib2f") == 0)
6121 {
6122 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FPROC>::type>(
6123 paramTokens, strings);
6124 return CallCapture(EntryPoint::GLVertexAttrib2f, std::move(params));
6125 }
6126 if (strcmp(nameToken, "glVertexAttrib2fv") == 0)
6127 {
6128 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FVPROC>::type>(
6129 paramTokens, strings);
6130 return CallCapture(EntryPoint::GLVertexAttrib2fv, std::move(params));
6131 }
6132 if (strcmp(nameToken, "glVertexAttrib3f") == 0)
6133 {
6134 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FPROC>::type>(
6135 paramTokens, strings);
6136 return CallCapture(EntryPoint::GLVertexAttrib3f, std::move(params));
6137 }
6138 if (strcmp(nameToken, "glVertexAttrib3fv") == 0)
6139 {
6140 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FVPROC>::type>(
6141 paramTokens, strings);
6142 return CallCapture(EntryPoint::GLVertexAttrib3fv, std::move(params));
6143 }
6144 if (strcmp(nameToken, "glVertexAttrib4f") == 0)
6145 {
6146 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FPROC>::type>(
6147 paramTokens, strings);
6148 return CallCapture(EntryPoint::GLVertexAttrib4f, std::move(params));
6149 }
6150 if (strcmp(nameToken, "glVertexAttrib4fv") == 0)
6151 {
6152 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FVPROC>::type>(
6153 paramTokens, strings);
6154 return CallCapture(EntryPoint::GLVertexAttrib4fv, std::move(params));
6155 }
6156 if (strcmp(nameToken, "glVertexAttribBinding") == 0)
6157 {
6158 ParamBuffer params =
6159 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBBINDINGPROC>::type>(paramTokens,
6160 strings);
6161 return CallCapture(EntryPoint::GLVertexAttribBinding, std::move(params));
6162 }
6163 if (strcmp(nameToken, "glVertexAttribDivisor") == 0)
6164 {
6165 ParamBuffer params =
6166 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORPROC>::type>(paramTokens,
6167 strings);
6168 return CallCapture(EntryPoint::GLVertexAttribDivisor, std::move(params));
6169 }
6170 if (strcmp(nameToken, "glVertexAttribDivisorANGLE") == 0)
6171 {
6172 ParamBuffer params =
6173 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORANGLEPROC>::type>(
6174 paramTokens, strings);
6175 return CallCapture(EntryPoint::GLVertexAttribDivisorANGLE, std::move(params));
6176 }
6177 if (strcmp(nameToken, "glVertexAttribDivisorEXT") == 0)
6178 {
6179 ParamBuffer params =
6180 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISOREXTPROC>::type>(paramTokens,
6181 strings);
6182 return CallCapture(EntryPoint::GLVertexAttribDivisorEXT, std::move(params));
6183 }
6184 if (strcmp(nameToken, "glVertexAttribFormat") == 0)
6185 {
6186 ParamBuffer params =
6187 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBFORMATPROC>::type>(paramTokens,
6188 strings);
6189 return CallCapture(EntryPoint::GLVertexAttribFormat, std::move(params));
6190 }
6191 if (strcmp(nameToken, "glVertexAttribI4i") == 0)
6192 {
6193 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IPROC>::type>(
6194 paramTokens, strings);
6195 return CallCapture(EntryPoint::GLVertexAttribI4i, std::move(params));
6196 }
6197 if (strcmp(nameToken, "glVertexAttribI4iv") == 0)
6198 {
6199 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IVPROC>::type>(
6200 paramTokens, strings);
6201 return CallCapture(EntryPoint::GLVertexAttribI4iv, std::move(params));
6202 }
6203 if (strcmp(nameToken, "glVertexAttribI4ui") == 0)
6204 {
6205 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIPROC>::type>(
6206 paramTokens, strings);
6207 return CallCapture(EntryPoint::GLVertexAttribI4ui, std::move(params));
6208 }
6209 if (strcmp(nameToken, "glVertexAttribI4uiv") == 0)
6210 {
6211 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIVPROC>::type>(
6212 paramTokens, strings);
6213 return CallCapture(EntryPoint::GLVertexAttribI4uiv, std::move(params));
6214 }
6215 if (strcmp(nameToken, "glVertexAttribIFormat") == 0)
6216 {
6217 ParamBuffer params =
6218 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIFORMATPROC>::type>(paramTokens,
6219 strings);
6220 return CallCapture(EntryPoint::GLVertexAttribIFormat, std::move(params));
6221 }
6222 if (strcmp(nameToken, "glVertexAttribIPointer") == 0)
6223 {
6224 ParamBuffer params =
6225 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIPOINTERPROC>::type>(paramTokens,
6226 strings);
6227 return CallCapture(EntryPoint::GLVertexAttribIPointer, std::move(params));
6228 }
6229 if (strcmp(nameToken, "glVertexAttribPointer") == 0)
6230 {
6231 ParamBuffer params =
6232 ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBPOINTERPROC>::type>(paramTokens,
6233 strings);
6234 return CallCapture(EntryPoint::GLVertexAttribPointer, std::move(params));
6235 }
6236 if (strcmp(nameToken, "glVertexBindingDivisor") == 0)
6237 {
6238 ParamBuffer params =
6239 ParseParameters<std::remove_pointer<PFNGLVERTEXBINDINGDIVISORPROC>::type>(paramTokens,
6240 strings);
6241 return CallCapture(EntryPoint::GLVertexBindingDivisor, std::move(params));
6242 }
6243 if (strcmp(nameToken, "glVertexPointer") == 0)
6244 {
6245 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXPOINTERPROC>::type>(
6246 paramTokens, strings);
6247 return CallCapture(EntryPoint::GLVertexPointer, std::move(params));
6248 }
6249 if (strcmp(nameToken, "glViewport") == 0)
6250 {
6251 ParamBuffer params =
6252 ParseParameters<std::remove_pointer<PFNGLVIEWPORTPROC>::type>(paramTokens, strings);
6253 return CallCapture(EntryPoint::GLViewport, std::move(params));
6254 }
6255 if (strcmp(nameToken, "glWaitSemaphoreEXT") == 0)
6256 {
6257 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWAITSEMAPHOREEXTPROC>::type>(
6258 paramTokens, strings);
6259 return CallCapture(EntryPoint::GLWaitSemaphoreEXT, std::move(params));
6260 }
6261 if (strcmp(nameToken, "glWaitSync") == 0)
6262 {
6263 ParamBuffer params =
6264 ParseParameters<std::remove_pointer<PFNGLWAITSYNCPROC>::type>(paramTokens, strings);
6265 return CallCapture(EntryPoint::GLWaitSync, std::move(params));
6266 }
6267 if (strcmp(nameToken, "glWeightPointerOES") == 0)
6268 {
6269 ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWEIGHTPOINTEROESPROC>::type>(
6270 paramTokens, strings);
6271 return CallCapture(EntryPoint::GLWeightPointerOES, std::move(params));
6272 }
6273 if (strcmp(nameToken, "CreateContext") == 0)
6274 {
6275 ParamBuffer params = ParseParameters<decltype(CreateContext)>(paramTokens, strings);
6276 return CallCapture("CreateContext", std::move(params));
6277 }
6278 if (strcmp(nameToken, "CreateEGLImage") == 0)
6279 {
6280 ParamBuffer params = ParseParameters<decltype(CreateEGLImage)>(paramTokens, strings);
6281 return CallCapture("CreateEGLImage", std::move(params));
6282 }
6283 if (strcmp(nameToken, "CreateEGLImageKHR") == 0)
6284 {
6285 ParamBuffer params = ParseParameters<decltype(CreateEGLImageKHR)>(paramTokens, strings);
6286 return CallCapture("CreateEGLImageKHR", std::move(params));
6287 }
6288 if (strcmp(nameToken, "CreateEGLSync") == 0)
6289 {
6290 ParamBuffer params = ParseParameters<decltype(CreateEGLSync)>(paramTokens, strings);
6291 return CallCapture("CreateEGLSync", std::move(params));
6292 }
6293 if (strcmp(nameToken, "CreateEGLSyncKHR") == 0)
6294 {
6295 ParamBuffer params = ParseParameters<decltype(CreateEGLSyncKHR)>(paramTokens, strings);
6296 return CallCapture("CreateEGLSyncKHR", std::move(params));
6297 }
6298 if (strcmp(nameToken, "CreateNativeClientBufferANDROID") == 0)
6299 {
6300 ParamBuffer params =
6301 ParseParameters<decltype(CreateNativeClientBufferANDROID)>(paramTokens, strings);
6302 return CallCapture("CreateNativeClientBufferANDROID", std::move(params));
6303 }
6304 if (strcmp(nameToken, "CreatePbufferSurface") == 0)
6305 {
6306 ParamBuffer params = ParseParameters<decltype(CreatePbufferSurface)>(paramTokens, strings);
6307 return CallCapture("CreatePbufferSurface", std::move(params));
6308 }
6309 if (strcmp(nameToken, "CreateProgram") == 0)
6310 {
6311 ParamBuffer params = ParseParameters<decltype(CreateProgram)>(paramTokens, strings);
6312 return CallCapture("CreateProgram", std::move(params));
6313 }
6314 if (strcmp(nameToken, "CreateShader") == 0)
6315 {
6316 ParamBuffer params = ParseParameters<decltype(CreateShader)>(paramTokens, strings);
6317 return CallCapture("CreateShader", std::move(params));
6318 }
6319 if (strcmp(nameToken, "CreateShaderProgramv") == 0)
6320 {
6321 ParamBuffer params = ParseParameters<decltype(CreateShaderProgramv)>(paramTokens, strings);
6322 return CallCapture("CreateShaderProgramv", std::move(params));
6323 }
6324 if (strcmp(nameToken, "DeleteUniformLocations") == 0)
6325 {
6326 ParamBuffer params =
6327 ParseParameters<decltype(DeleteUniformLocations)>(paramTokens, strings);
6328 return CallCapture("DeleteUniformLocations", std::move(params));
6329 }
6330 if (strcmp(nameToken, "DestroyEGLImage") == 0)
6331 {
6332 ParamBuffer params = ParseParameters<decltype(DestroyEGLImage)>(paramTokens, strings);
6333 return CallCapture("DestroyEGLImage", std::move(params));
6334 }
6335 if (strcmp(nameToken, "DestroyEGLImageKHR") == 0)
6336 {
6337 ParamBuffer params = ParseParameters<decltype(DestroyEGLImageKHR)>(paramTokens, strings);
6338 return CallCapture("DestroyEGLImageKHR", std::move(params));
6339 }
6340 if (strcmp(nameToken, "FenceSync") == 0)
6341 {
6342 ParamBuffer params = ParseParameters<decltype(FenceSync)>(paramTokens, strings);
6343 return CallCapture("FenceSync", std::move(params));
6344 }
6345 if (strcmp(nameToken, "FenceSync2") == 0)
6346 {
6347 ParamBuffer params = ParseParameters<decltype(FenceSync2)>(paramTokens, strings);
6348 return CallCapture("FenceSync2", std::move(params));
6349 }
6350 if (strcmp(nameToken, "InitializeReplay") == 0)
6351 {
6352 ParamBuffer params = ParseParameters<decltype(InitializeReplay)>(paramTokens, strings);
6353 return CallCapture("InitializeReplay", std::move(params));
6354 }
6355 if (strcmp(nameToken, "InitializeReplay2") == 0)
6356 {
6357 ParamBuffer params = ParseParameters<decltype(InitializeReplay2)>(paramTokens, strings);
6358 return CallCapture("InitializeReplay2", std::move(params));
6359 }
6360 if (strcmp(nameToken, "InitializeReplay3") == 0)
6361 {
6362 ParamBuffer params = ParseParameters<decltype(InitializeReplay3)>(paramTokens, strings);
6363 return CallCapture("InitializeReplay3", std::move(params));
6364 }
6365 if (strcmp(nameToken, "InitializeReplay4") == 0)
6366 {
6367 ParamBuffer params = ParseParameters<decltype(InitializeReplay4)>(paramTokens, strings);
6368 return CallCapture("InitializeReplay4", std::move(params));
6369 }
6370 if (strcmp(nameToken, "MapBufferOES") == 0)
6371 {
6372 ParamBuffer params = ParseParameters<decltype(MapBufferOES)>(paramTokens, strings);
6373 return CallCapture("MapBufferOES", std::move(params));
6374 }
6375 if (strcmp(nameToken, "MapBufferRange") == 0)
6376 {
6377 ParamBuffer params = ParseParameters<decltype(MapBufferRange)>(paramTokens, strings);
6378 return CallCapture("MapBufferRange", std::move(params));
6379 }
6380 if (strcmp(nameToken, "MapBufferRangeEXT") == 0)
6381 {
6382 ParamBuffer params = ParseParameters<decltype(MapBufferRangeEXT)>(paramTokens, strings);
6383 return CallCapture("MapBufferRangeEXT", std::move(params));
6384 }
6385 if (strcmp(nameToken, "SetBufferID") == 0)
6386 {
6387 ParamBuffer params = ParseParameters<decltype(SetBufferID)>(paramTokens, strings);
6388 return CallCapture("SetBufferID", std::move(params));
6389 }
6390 if (strcmp(nameToken, "SetCurrentContextID") == 0)
6391 {
6392 ParamBuffer params = ParseParameters<decltype(SetCurrentContextID)>(paramTokens, strings);
6393 return CallCapture("SetCurrentContextID", std::move(params));
6394 }
6395 if (strcmp(nameToken, "SetFramebufferID") == 0)
6396 {
6397 ParamBuffer params = ParseParameters<decltype(SetFramebufferID)>(paramTokens, strings);
6398 return CallCapture("SetFramebufferID", std::move(params));
6399 }
6400 if (strcmp(nameToken, "SetFramebufferID2") == 0)
6401 {
6402 ParamBuffer params = ParseParameters<decltype(SetFramebufferID2)>(paramTokens, strings);
6403 return CallCapture("SetFramebufferID2", std::move(params));
6404 }
6405 if (strcmp(nameToken, "SetRenderbufferID") == 0)
6406 {
6407 ParamBuffer params = ParseParameters<decltype(SetRenderbufferID)>(paramTokens, strings);
6408 return CallCapture("SetRenderbufferID", std::move(params));
6409 }
6410 if (strcmp(nameToken, "SetTextureID") == 0)
6411 {
6412 ParamBuffer params = ParseParameters<decltype(SetTextureID)>(paramTokens, strings);
6413 return CallCapture("SetTextureID", std::move(params));
6414 }
6415 if (strcmp(nameToken, "UniformBlockBinding") == 0)
6416 {
6417 ParamBuffer params = ParseParameters<decltype(UniformBlockBinding)>(paramTokens, strings);
6418 return CallCapture("UniformBlockBinding", std::move(params));
6419 }
6420 if (strcmp(nameToken, "UpdateBufferID") == 0)
6421 {
6422 ParamBuffer params = ParseParameters<decltype(UpdateBufferID)>(paramTokens, strings);
6423 return CallCapture("UpdateBufferID", std::move(params));
6424 }
6425 if (strcmp(nameToken, "UpdateClientArrayPointer") == 0)
6426 {
6427 ParamBuffer params =
6428 ParseParameters<decltype(UpdateClientArrayPointer)>(paramTokens, strings);
6429 return CallCapture("UpdateClientArrayPointer", std::move(params));
6430 }
6431 if (strcmp(nameToken, "UpdateClientBufferData") == 0)
6432 {
6433 ParamBuffer params =
6434 ParseParameters<decltype(UpdateClientBufferData)>(paramTokens, strings);
6435 return CallCapture("UpdateClientBufferData", std::move(params));
6436 }
6437 if (strcmp(nameToken, "UpdateClientBufferDataWithOffset") == 0)
6438 {
6439 ParamBuffer params =
6440 ParseParameters<decltype(UpdateClientBufferDataWithOffset)>(paramTokens, strings);
6441 return CallCapture("UpdateClientBufferDataWithOffset", std::move(params));
6442 }
6443 if (strcmp(nameToken, "UpdateCurrentProgram") == 0)
6444 {
6445 ParamBuffer params = ParseParameters<decltype(UpdateCurrentProgram)>(paramTokens, strings);
6446 return CallCapture("UpdateCurrentProgram", std::move(params));
6447 }
6448 if (strcmp(nameToken, "UpdateFenceNVID") == 0)
6449 {
6450 ParamBuffer params = ParseParameters<decltype(UpdateFenceNVID)>(paramTokens, strings);
6451 return CallCapture("UpdateFenceNVID", std::move(params));
6452 }
6453 if (strcmp(nameToken, "UpdateFramebufferID") == 0)
6454 {
6455 ParamBuffer params = ParseParameters<decltype(UpdateFramebufferID)>(paramTokens, strings);
6456 return CallCapture("UpdateFramebufferID", std::move(params));
6457 }
6458 if (strcmp(nameToken, "UpdateFramebufferID2") == 0)
6459 {
6460 ParamBuffer params = ParseParameters<decltype(UpdateFramebufferID2)>(paramTokens, strings);
6461 return CallCapture("UpdateFramebufferID2", std::move(params));
6462 }
6463 if (strcmp(nameToken, "UpdateMemoryObjectID") == 0)
6464 {
6465 ParamBuffer params = ParseParameters<decltype(UpdateMemoryObjectID)>(paramTokens, strings);
6466 return CallCapture("UpdateMemoryObjectID", std::move(params));
6467 }
6468 if (strcmp(nameToken, "UpdateProgramPipelineID") == 0)
6469 {
6470 ParamBuffer params =
6471 ParseParameters<decltype(UpdateProgramPipelineID)>(paramTokens, strings);
6472 return CallCapture("UpdateProgramPipelineID", std::move(params));
6473 }
6474 if (strcmp(nameToken, "UpdateQueryID") == 0)
6475 {
6476 ParamBuffer params = ParseParameters<decltype(UpdateQueryID)>(paramTokens, strings);
6477 return CallCapture("UpdateQueryID", std::move(params));
6478 }
6479 if (strcmp(nameToken, "UpdateRenderbufferID") == 0)
6480 {
6481 ParamBuffer params = ParseParameters<decltype(UpdateRenderbufferID)>(paramTokens, strings);
6482 return CallCapture("UpdateRenderbufferID", std::move(params));
6483 }
6484 if (strcmp(nameToken, "UpdateResourceIDBuffer") == 0)
6485 {
6486 ParamBuffer params =
6487 ParseParameters<decltype(UpdateResourceIDBuffer)>(paramTokens, strings);
6488 return CallCapture("UpdateResourceIDBuffer", std::move(params));
6489 }
6490 if (strcmp(nameToken, "UpdateSamplerID") == 0)
6491 {
6492 ParamBuffer params = ParseParameters<decltype(UpdateSamplerID)>(paramTokens, strings);
6493 return CallCapture("UpdateSamplerID", std::move(params));
6494 }
6495 if (strcmp(nameToken, "UpdateSemaphoreID") == 0)
6496 {
6497 ParamBuffer params = ParseParameters<decltype(UpdateSemaphoreID)>(paramTokens, strings);
6498 return CallCapture("UpdateSemaphoreID", std::move(params));
6499 }
6500 if (strcmp(nameToken, "UpdateShaderProgramID") == 0)
6501 {
6502 ParamBuffer params = ParseParameters<decltype(UpdateShaderProgramID)>(paramTokens, strings);
6503 return CallCapture("UpdateShaderProgramID", std::move(params));
6504 }
6505 if (strcmp(nameToken, "UpdateTextureID") == 0)
6506 {
6507 ParamBuffer params = ParseParameters<decltype(UpdateTextureID)>(paramTokens, strings);
6508 return CallCapture("UpdateTextureID", std::move(params));
6509 }
6510 if (strcmp(nameToken, "UpdateTransformFeedbackID") == 0)
6511 {
6512 ParamBuffer params =
6513 ParseParameters<decltype(UpdateTransformFeedbackID)>(paramTokens, strings);
6514 return CallCapture("UpdateTransformFeedbackID", std::move(params));
6515 }
6516 if (strcmp(nameToken, "UpdateUniformBlockIndex") == 0)
6517 {
6518 ParamBuffer params =
6519 ParseParameters<decltype(UpdateUniformBlockIndex)>(paramTokens, strings);
6520 return CallCapture("UpdateUniformBlockIndex", std::move(params));
6521 }
6522 if (strcmp(nameToken, "UpdateUniformLocation") == 0)
6523 {
6524 ParamBuffer params = ParseParameters<decltype(UpdateUniformLocation)>(paramTokens, strings);
6525 return CallCapture("UpdateUniformLocation", std::move(params));
6526 }
6527 if (strcmp(nameToken, "UpdateVertexArrayID") == 0)
6528 {
6529 ParamBuffer params = ParseParameters<decltype(UpdateVertexArrayID)>(paramTokens, strings);
6530 return CallCapture("UpdateVertexArrayID", std::move(params));
6531 }
6532 if (strcmp(nameToken, "ValidateSerializedState") == 0)
6533 {
6534 ParamBuffer params =
6535 ParseParameters<decltype(ValidateSerializedState)>(paramTokens, strings);
6536 return CallCapture("ValidateSerializedState", std::move(params));
6537 }
6538
6539 if (numParamTokens > 0)
6540 {
6541 printf("Expected zero parameter tokens for %s\n", nameToken);
6542 UNREACHABLE();
6543 }
6544 return CallCapture(nameToken, ParamBuffer());
6545 }
6546
6547 template <typename Fn, EnableIfNArgs<Fn, 1> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6548 void DispatchCallCapture(Fn *fn, const Captures &cap)
6549 {
6550 (*fn)(Arg<Fn, 0>(cap));
6551 }
6552
6553 template <typename Fn, EnableIfNArgs<Fn, 2> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6554 void DispatchCallCapture(Fn *fn, const Captures &cap)
6555 {
6556 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap));
6557 }
6558
6559 template <typename Fn, EnableIfNArgs<Fn, 3> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6560 void DispatchCallCapture(Fn *fn, const Captures &cap)
6561 {
6562 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap));
6563 }
6564
6565 template <typename Fn, EnableIfNArgs<Fn, 4> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6566 void DispatchCallCapture(Fn *fn, const Captures &cap)
6567 {
6568 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap));
6569 }
6570
6571 template <typename Fn, EnableIfNArgs<Fn, 5> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6572 void DispatchCallCapture(Fn *fn, const Captures &cap)
6573 {
6574 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap));
6575 }
6576
6577 template <typename Fn, EnableIfNArgs<Fn, 8> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6578 void DispatchCallCapture(Fn *fn, const Captures &cap)
6579 {
6580 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6581 Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap));
6582 }
6583
6584 template <typename Fn, EnableIfNArgs<Fn, 16> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6585 void DispatchCallCapture(Fn *fn, const Captures &cap)
6586 {
6587 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6588 Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6589 Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6590 Arg<Fn, 15>(cap));
6591 }
6592
6593 template <typename Fn, EnableIfNArgs<Fn, 20> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6594 void DispatchCallCapture(Fn *fn, const Captures &cap)
6595 {
6596 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6597 Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6598 Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6599 Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap));
6600 }
6601
6602 template <typename Fn, EnableIfNArgs<Fn, 22> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6603 void DispatchCallCapture(Fn *fn, const Captures &cap)
6604 {
6605 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6606 Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6607 Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6608 Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
6609 Arg<Fn, 20>(cap), Arg<Fn, 21>(cap));
6610 }
6611
6612 template <typename Fn, EnableIfNArgs<Fn, 23> = 0>
DispatchCallCapture(Fn * fn,const Captures & cap)6613 void DispatchCallCapture(Fn *fn, const Captures &cap)
6614 {
6615 (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6616 Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6617 Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6618 Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
6619 Arg<Fn, 20>(cap), Arg<Fn, 21>(cap), Arg<Fn, 22>(cap));
6620 }
6621
ReplayCustomFunctionCall(const CallCapture & call,const TraceFunctionMap & customFunctions)6622 void ReplayCustomFunctionCall(const CallCapture &call, const TraceFunctionMap &customFunctions)
6623 {
6624 ASSERT(call.entryPoint == EntryPoint::Invalid);
6625 const Captures &captures = call.params.getParamCaptures();
6626
6627 if (call.customFunctionName == "CreateContext")
6628 {
6629 DispatchCallCapture(CreateContext, captures);
6630 return;
6631 }
6632 if (call.customFunctionName == "CreateEGLImage")
6633 {
6634 DispatchCallCapture(CreateEGLImage, captures);
6635 return;
6636 }
6637 if (call.customFunctionName == "CreateEGLImageKHR")
6638 {
6639 DispatchCallCapture(CreateEGLImageKHR, captures);
6640 return;
6641 }
6642 if (call.customFunctionName == "CreateEGLSync")
6643 {
6644 DispatchCallCapture(CreateEGLSync, captures);
6645 return;
6646 }
6647 if (call.customFunctionName == "CreateEGLSyncKHR")
6648 {
6649 DispatchCallCapture(CreateEGLSyncKHR, captures);
6650 return;
6651 }
6652 if (call.customFunctionName == "CreateNativeClientBufferANDROID")
6653 {
6654 DispatchCallCapture(CreateNativeClientBufferANDROID, captures);
6655 return;
6656 }
6657 if (call.customFunctionName == "CreatePbufferSurface")
6658 {
6659 DispatchCallCapture(CreatePbufferSurface, captures);
6660 return;
6661 }
6662 if (call.customFunctionName == "CreateProgram")
6663 {
6664 DispatchCallCapture(CreateProgram, captures);
6665 return;
6666 }
6667 if (call.customFunctionName == "CreateShader")
6668 {
6669 DispatchCallCapture(CreateShader, captures);
6670 return;
6671 }
6672 if (call.customFunctionName == "CreateShaderProgramv")
6673 {
6674 DispatchCallCapture(CreateShaderProgramv, captures);
6675 return;
6676 }
6677 if (call.customFunctionName == "DeleteUniformLocations")
6678 {
6679 DispatchCallCapture(DeleteUniformLocations, captures);
6680 return;
6681 }
6682 if (call.customFunctionName == "DestroyEGLImage")
6683 {
6684 DispatchCallCapture(DestroyEGLImage, captures);
6685 return;
6686 }
6687 if (call.customFunctionName == "DestroyEGLImageKHR")
6688 {
6689 DispatchCallCapture(DestroyEGLImageKHR, captures);
6690 return;
6691 }
6692 if (call.customFunctionName == "FenceSync")
6693 {
6694 DispatchCallCapture(FenceSync, captures);
6695 return;
6696 }
6697 if (call.customFunctionName == "FenceSync2")
6698 {
6699 DispatchCallCapture(FenceSync2, captures);
6700 return;
6701 }
6702 if (call.customFunctionName == "InitializeReplay")
6703 {
6704 DispatchCallCapture(InitializeReplay, captures);
6705 return;
6706 }
6707 if (call.customFunctionName == "InitializeReplay2")
6708 {
6709 DispatchCallCapture(InitializeReplay2, captures);
6710 return;
6711 }
6712 if (call.customFunctionName == "InitializeReplay3")
6713 {
6714 DispatchCallCapture(InitializeReplay3, captures);
6715 return;
6716 }
6717 if (call.customFunctionName == "InitializeReplay4")
6718 {
6719 DispatchCallCapture(InitializeReplay4, captures);
6720 return;
6721 }
6722 if (call.customFunctionName == "MapBufferOES")
6723 {
6724 DispatchCallCapture(MapBufferOES, captures);
6725 return;
6726 }
6727 if (call.customFunctionName == "MapBufferRange")
6728 {
6729 DispatchCallCapture(MapBufferRange, captures);
6730 return;
6731 }
6732 if (call.customFunctionName == "MapBufferRangeEXT")
6733 {
6734 DispatchCallCapture(MapBufferRangeEXT, captures);
6735 return;
6736 }
6737 if (call.customFunctionName == "SetBufferID")
6738 {
6739 DispatchCallCapture(SetBufferID, captures);
6740 return;
6741 }
6742 if (call.customFunctionName == "SetCurrentContextID")
6743 {
6744 DispatchCallCapture(SetCurrentContextID, captures);
6745 return;
6746 }
6747 if (call.customFunctionName == "SetFramebufferID")
6748 {
6749 DispatchCallCapture(SetFramebufferID, captures);
6750 return;
6751 }
6752 if (call.customFunctionName == "SetFramebufferID2")
6753 {
6754 DispatchCallCapture(SetFramebufferID2, captures);
6755 return;
6756 }
6757 if (call.customFunctionName == "SetRenderbufferID")
6758 {
6759 DispatchCallCapture(SetRenderbufferID, captures);
6760 return;
6761 }
6762 if (call.customFunctionName == "SetTextureID")
6763 {
6764 DispatchCallCapture(SetTextureID, captures);
6765 return;
6766 }
6767 if (call.customFunctionName == "UniformBlockBinding")
6768 {
6769 DispatchCallCapture(UniformBlockBinding, captures);
6770 return;
6771 }
6772 if (call.customFunctionName == "UpdateBufferID")
6773 {
6774 DispatchCallCapture(UpdateBufferID, captures);
6775 return;
6776 }
6777 if (call.customFunctionName == "UpdateClientArrayPointer")
6778 {
6779 DispatchCallCapture(UpdateClientArrayPointer, captures);
6780 return;
6781 }
6782 if (call.customFunctionName == "UpdateClientBufferData")
6783 {
6784 DispatchCallCapture(UpdateClientBufferData, captures);
6785 return;
6786 }
6787 if (call.customFunctionName == "UpdateClientBufferDataWithOffset")
6788 {
6789 DispatchCallCapture(UpdateClientBufferDataWithOffset, captures);
6790 return;
6791 }
6792 if (call.customFunctionName == "UpdateCurrentProgram")
6793 {
6794 DispatchCallCapture(UpdateCurrentProgram, captures);
6795 return;
6796 }
6797 if (call.customFunctionName == "UpdateFenceNVID")
6798 {
6799 DispatchCallCapture(UpdateFenceNVID, captures);
6800 return;
6801 }
6802 if (call.customFunctionName == "UpdateFramebufferID")
6803 {
6804 DispatchCallCapture(UpdateFramebufferID, captures);
6805 return;
6806 }
6807 if (call.customFunctionName == "UpdateFramebufferID2")
6808 {
6809 DispatchCallCapture(UpdateFramebufferID2, captures);
6810 return;
6811 }
6812 if (call.customFunctionName == "UpdateMemoryObjectID")
6813 {
6814 DispatchCallCapture(UpdateMemoryObjectID, captures);
6815 return;
6816 }
6817 if (call.customFunctionName == "UpdateProgramPipelineID")
6818 {
6819 DispatchCallCapture(UpdateProgramPipelineID, captures);
6820 return;
6821 }
6822 if (call.customFunctionName == "UpdateQueryID")
6823 {
6824 DispatchCallCapture(UpdateQueryID, captures);
6825 return;
6826 }
6827 if (call.customFunctionName == "UpdateRenderbufferID")
6828 {
6829 DispatchCallCapture(UpdateRenderbufferID, captures);
6830 return;
6831 }
6832 if (call.customFunctionName == "UpdateResourceIDBuffer")
6833 {
6834 DispatchCallCapture(UpdateResourceIDBuffer, captures);
6835 return;
6836 }
6837 if (call.customFunctionName == "UpdateSamplerID")
6838 {
6839 DispatchCallCapture(UpdateSamplerID, captures);
6840 return;
6841 }
6842 if (call.customFunctionName == "UpdateSemaphoreID")
6843 {
6844 DispatchCallCapture(UpdateSemaphoreID, captures);
6845 return;
6846 }
6847 if (call.customFunctionName == "UpdateShaderProgramID")
6848 {
6849 DispatchCallCapture(UpdateShaderProgramID, captures);
6850 return;
6851 }
6852 if (call.customFunctionName == "UpdateTextureID")
6853 {
6854 DispatchCallCapture(UpdateTextureID, captures);
6855 return;
6856 }
6857 if (call.customFunctionName == "UpdateTransformFeedbackID")
6858 {
6859 DispatchCallCapture(UpdateTransformFeedbackID, captures);
6860 return;
6861 }
6862 if (call.customFunctionName == "UpdateUniformBlockIndex")
6863 {
6864 DispatchCallCapture(UpdateUniformBlockIndex, captures);
6865 return;
6866 }
6867 if (call.customFunctionName == "UpdateUniformLocation")
6868 {
6869 DispatchCallCapture(UpdateUniformLocation, captures);
6870 return;
6871 }
6872 if (call.customFunctionName == "UpdateVertexArrayID")
6873 {
6874 DispatchCallCapture(UpdateVertexArrayID, captures);
6875 return;
6876 }
6877 if (call.customFunctionName == "ValidateSerializedState")
6878 {
6879 DispatchCallCapture(ValidateSerializedState, captures);
6880 return;
6881 }
6882
6883 auto iter = customFunctions.find(call.customFunctionName);
6884 if (iter == customFunctions.end())
6885 {
6886 printf("Unknown custom function: %s\n", call.customFunctionName.c_str());
6887 UNREACHABLE();
6888 }
6889 else
6890 {
6891 ASSERT(call.params.empty());
6892 const TraceFunction &customFunc = iter->second;
6893 for (const CallCapture &customCall : customFunc)
6894 {
6895 ReplayTraceFunctionCall(customCall, customFunctions);
6896 }
6897 }
6898 }
6899 } // namespace angle
6900