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