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