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