CoCalc -- trace_interpreter

GitHub Repository: PojavLauncherTeam/angle
Path: blob/main/util/capture/trace_interpreter_autogen.cpp
⁶⁰⁶² views
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
{
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, "glFramebufferFoveationConfigQCOM") == 0)
2180
    {
2181
        ParamBuffer params =
2182
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC>::type>(
2183
                paramTokens, strings);
2184
        return CallCapture(EntryPoint::GLFramebufferFoveationConfigQCOM, std::move(params));
2185
    }
2186
    if (strcmp(nameToken, "glFramebufferFoveationParametersQCOM") == 0)
2187
    {
2188
        ParamBuffer params =
2189
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC>::type>(
2190
                paramTokens, strings);
2191
        return CallCapture(EntryPoint::GLFramebufferFoveationParametersQCOM, std::move(params));
2192
    }
2193
    if (strcmp(nameToken, "glFramebufferMemorylessPixelLocalStorageANGLE") == 0)
2194
    {
2195
        ParamBuffer params = ParseParameters<
2196
            std::remove_pointer<PFNGLFRAMEBUFFERMEMORYLESSPIXELLOCALSTORAGEANGLEPROC>::type>(
2197
            paramTokens, strings);
2198
        return CallCapture(EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE,
2199
                           std::move(params));
2200
    }
2201
    if (strcmp(nameToken, "glFramebufferParameteri") == 0)
2202
    {
2203
        ParamBuffer params =
2204
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIPROC>::type>(paramTokens,
2205
                                                                                       strings);
2206
        return CallCapture(EntryPoint::GLFramebufferParameteri, std::move(params));
2207
    }
2208
    if (strcmp(nameToken, "glFramebufferParameteriMESA") == 0)
2209
    {
2210
        ParamBuffer params =
2211
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERPARAMETERIMESAPROC>::type>(
2212
                paramTokens, strings);
2213
        return CallCapture(EntryPoint::GLFramebufferParameteriMESA, std::move(params));
2214
    }
2215
    if (strcmp(nameToken, "glFramebufferPixelLocalClearValuefvANGLE") == 0)
2216
    {
2217
        ParamBuffer params = ParseParameters<
2218
            std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEFVANGLEPROC>::type>(paramTokens,
2219
                                                                                        strings);
2220
        return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValuefvANGLE, std::move(params));
2221
    }
2222
    if (strcmp(nameToken, "glFramebufferPixelLocalClearValueivANGLE") == 0)
2223
    {
2224
        ParamBuffer params = ParseParameters<
2225
            std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEIVANGLEPROC>::type>(paramTokens,
2226
                                                                                        strings);
2227
        return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueivANGLE, std::move(params));
2228
    }
2229
    if (strcmp(nameToken, "glFramebufferPixelLocalClearValueuivANGLE") == 0)
2230
    {
2231
        ParamBuffer params = ParseParameters<
2232
            std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALCLEARVALUEUIVANGLEPROC>::type>(
2233
            paramTokens, strings);
2234
        return CallCapture(EntryPoint::GLFramebufferPixelLocalClearValueuivANGLE,
2235
                           std::move(params));
2236
    }
2237
    if (strcmp(nameToken, "glFramebufferPixelLocalStorageInterruptANGLE") == 0)
2238
    {
2239
        ParamBuffer params = ParseParameters<
2240
            std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGEINTERRUPTANGLEPROC>::type>(
2241
            paramTokens, strings);
2242
        return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageInterruptANGLE,
2243
                           std::move(params));
2244
    }
2245
    if (strcmp(nameToken, "glFramebufferPixelLocalStorageRestoreANGLE") == 0)
2246
    {
2247
        ParamBuffer params = ParseParameters<
2248
            std::remove_pointer<PFNGLFRAMEBUFFERPIXELLOCALSTORAGERESTOREANGLEPROC>::type>(
2249
            paramTokens, strings);
2250
        return CallCapture(EntryPoint::GLFramebufferPixelLocalStorageRestoreANGLE,
2251
                           std::move(params));
2252
    }
2253
    if (strcmp(nameToken, "glFramebufferRenderbuffer") == 0)
2254
    {
2255
        ParamBuffer params =
2256
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFERPROC>::type>(
2257
                paramTokens, strings);
2258
        return CallCapture(EntryPoint::GLFramebufferRenderbuffer, std::move(params));
2259
    }
2260
    if (strcmp(nameToken, "glFramebufferRenderbufferOES") == 0)
2261
    {
2262
        ParamBuffer params =
2263
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERRENDERBUFFEROESPROC>::type>(
2264
                paramTokens, strings);
2265
        return CallCapture(EntryPoint::GLFramebufferRenderbufferOES, std::move(params));
2266
    }
2267
    if (strcmp(nameToken, "glFramebufferTexture") == 0)
2268
    {
2269
        ParamBuffer params =
2270
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPROC>::type>(paramTokens,
2271
                                                                                    strings);
2272
        return CallCapture(EntryPoint::GLFramebufferTexture, std::move(params));
2273
    }
2274
    if (strcmp(nameToken, "glFramebufferTexture2D") == 0)
2275
    {
2276
        ParamBuffer params =
2277
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DPROC>::type>(paramTokens,
2278
                                                                                      strings);
2279
        return CallCapture(EntryPoint::GLFramebufferTexture2D, std::move(params));
2280
    }
2281
    if (strcmp(nameToken, "glFramebufferTexture2DMultisampleEXT") == 0)
2282
    {
2283
        ParamBuffer params =
2284
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC>::type>(
2285
                paramTokens, strings);
2286
        return CallCapture(EntryPoint::GLFramebufferTexture2DMultisampleEXT, std::move(params));
2287
    }
2288
    if (strcmp(nameToken, "glFramebufferTexture2DOES") == 0)
2289
    {
2290
        ParamBuffer params =
2291
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE2DOESPROC>::type>(
2292
                paramTokens, strings);
2293
        return CallCapture(EntryPoint::GLFramebufferTexture2DOES, std::move(params));
2294
    }
2295
    if (strcmp(nameToken, "glFramebufferTexture3DOES") == 0)
2296
    {
2297
        ParamBuffer params =
2298
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURE3DOESPROC>::type>(
2299
                paramTokens, strings);
2300
        return CallCapture(EntryPoint::GLFramebufferTexture3DOES, std::move(params));
2301
    }
2302
    if (strcmp(nameToken, "glFramebufferTextureEXT") == 0)
2303
    {
2304
        ParamBuffer params =
2305
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREEXTPROC>::type>(paramTokens,
2306
                                                                                       strings);
2307
        return CallCapture(EntryPoint::GLFramebufferTextureEXT, std::move(params));
2308
    }
2309
    if (strcmp(nameToken, "glFramebufferTextureLayer") == 0)
2310
    {
2311
        ParamBuffer params =
2312
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTURELAYERPROC>::type>(
2313
                paramTokens, strings);
2314
        return CallCapture(EntryPoint::GLFramebufferTextureLayer, std::move(params));
2315
    }
2316
    if (strcmp(nameToken, "glFramebufferTextureMultiviewOVR") == 0)
2317
    {
2318
        ParamBuffer params =
2319
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC>::type>(
2320
                paramTokens, strings);
2321
        return CallCapture(EntryPoint::GLFramebufferTextureMultiviewOVR, std::move(params));
2322
    }
2323
    if (strcmp(nameToken, "glFramebufferTextureOES") == 0)
2324
    {
2325
        ParamBuffer params =
2326
            ParseParameters<std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREOESPROC>::type>(paramTokens,
2327
                                                                                       strings);
2328
        return CallCapture(EntryPoint::GLFramebufferTextureOES, std::move(params));
2329
    }
2330
    if (strcmp(nameToken, "glFramebufferTexturePixelLocalStorageANGLE") == 0)
2331
    {
2332
        ParamBuffer params = ParseParameters<
2333
            std::remove_pointer<PFNGLFRAMEBUFFERTEXTUREPIXELLOCALSTORAGEANGLEPROC>::type>(
2334
            paramTokens, strings);
2335
        return CallCapture(EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE,
2336
                           std::move(params));
2337
    }
2338
    if (strcmp(nameToken, "glFrontFace") == 0)
2339
    {
2340
        ParamBuffer params =
2341
            ParseParameters<std::remove_pointer<PFNGLFRONTFACEPROC>::type>(paramTokens, strings);
2342
        return CallCapture(EntryPoint::GLFrontFace, std::move(params));
2343
    }
2344
    if (strcmp(nameToken, "glFrustumf") == 0)
2345
    {
2346
        ParamBuffer params =
2347
            ParseParameters<std::remove_pointer<PFNGLFRUSTUMFPROC>::type>(paramTokens, strings);
2348
        return CallCapture(EntryPoint::GLFrustumf, std::move(params));
2349
    }
2350
    if (strcmp(nameToken, "glFrustumx") == 0)
2351
    {
2352
        ParamBuffer params =
2353
            ParseParameters<std::remove_pointer<PFNGLFRUSTUMXPROC>::type>(paramTokens, strings);
2354
        return CallCapture(EntryPoint::GLFrustumx, std::move(params));
2355
    }
2356
    if (strcmp(nameToken, "glGenBuffers") == 0)
2357
    {
2358
        ParamBuffer params =
2359
            ParseParameters<std::remove_pointer<PFNGLGENBUFFERSPROC>::type>(paramTokens, strings);
2360
        return CallCapture(EntryPoint::GLGenBuffers, std::move(params));
2361
    }
2362
    if (strcmp(nameToken, "glGenFencesNV") == 0)
2363
    {
2364
        ParamBuffer params =
2365
            ParseParameters<std::remove_pointer<PFNGLGENFENCESNVPROC>::type>(paramTokens, strings);
2366
        return CallCapture(EntryPoint::GLGenFencesNV, std::move(params));
2367
    }
2368
    if (strcmp(nameToken, "glGenFramebuffers") == 0)
2369
    {
2370
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSPROC>::type>(
2371
            paramTokens, strings);
2372
        return CallCapture(EntryPoint::GLGenFramebuffers, std::move(params));
2373
    }
2374
    if (strcmp(nameToken, "glGenFramebuffersOES") == 0)
2375
    {
2376
        ParamBuffer params =
2377
            ParseParameters<std::remove_pointer<PFNGLGENFRAMEBUFFERSOESPROC>::type>(paramTokens,
2378
                                                                                    strings);
2379
        return CallCapture(EntryPoint::GLGenFramebuffersOES, std::move(params));
2380
    }
2381
    if (strcmp(nameToken, "glGenPerfMonitorsAMD") == 0)
2382
    {
2383
        ParamBuffer params =
2384
            ParseParameters<std::remove_pointer<PFNGLGENPERFMONITORSAMDPROC>::type>(paramTokens,
2385
                                                                                    strings);
2386
        return CallCapture(EntryPoint::GLGenPerfMonitorsAMD, std::move(params));
2387
    }
2388
    if (strcmp(nameToken, "glGenProgramPipelines") == 0)
2389
    {
2390
        ParamBuffer params =
2391
            ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESPROC>::type>(paramTokens,
2392
                                                                                     strings);
2393
        return CallCapture(EntryPoint::GLGenProgramPipelines, std::move(params));
2394
    }
2395
    if (strcmp(nameToken, "glGenProgramPipelinesEXT") == 0)
2396
    {
2397
        ParamBuffer params =
2398
            ParseParameters<std::remove_pointer<PFNGLGENPROGRAMPIPELINESEXTPROC>::type>(paramTokens,
2399
                                                                                        strings);
2400
        return CallCapture(EntryPoint::GLGenProgramPipelinesEXT, std::move(params));
2401
    }
2402
    if (strcmp(nameToken, "glGenQueries") == 0)
2403
    {
2404
        ParamBuffer params =
2405
            ParseParameters<std::remove_pointer<PFNGLGENQUERIESPROC>::type>(paramTokens, strings);
2406
        return CallCapture(EntryPoint::GLGenQueries, std::move(params));
2407
    }
2408
    if (strcmp(nameToken, "glGenQueriesEXT") == 0)
2409
    {
2410
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENQUERIESEXTPROC>::type>(
2411
            paramTokens, strings);
2412
        return CallCapture(EntryPoint::GLGenQueriesEXT, std::move(params));
2413
    }
2414
    if (strcmp(nameToken, "glGenRenderbuffers") == 0)
2415
    {
2416
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSPROC>::type>(
2417
            paramTokens, strings);
2418
        return CallCapture(EntryPoint::GLGenRenderbuffers, std::move(params));
2419
    }
2420
    if (strcmp(nameToken, "glGenRenderbuffersOES") == 0)
2421
    {
2422
        ParamBuffer params =
2423
            ParseParameters<std::remove_pointer<PFNGLGENRENDERBUFFERSOESPROC>::type>(paramTokens,
2424
                                                                                     strings);
2425
        return CallCapture(EntryPoint::GLGenRenderbuffersOES, std::move(params));
2426
    }
2427
    if (strcmp(nameToken, "glGenSamplers") == 0)
2428
    {
2429
        ParamBuffer params =
2430
            ParseParameters<std::remove_pointer<PFNGLGENSAMPLERSPROC>::type>(paramTokens, strings);
2431
        return CallCapture(EntryPoint::GLGenSamplers, std::move(params));
2432
    }
2433
    if (strcmp(nameToken, "glGenSemaphoresEXT") == 0)
2434
    {
2435
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENSEMAPHORESEXTPROC>::type>(
2436
            paramTokens, strings);
2437
        return CallCapture(EntryPoint::GLGenSemaphoresEXT, std::move(params));
2438
    }
2439
    if (strcmp(nameToken, "glGenTextures") == 0)
2440
    {
2441
        ParamBuffer params =
2442
            ParseParameters<std::remove_pointer<PFNGLGENTEXTURESPROC>::type>(paramTokens, strings);
2443
        return CallCapture(EntryPoint::GLGenTextures, std::move(params));
2444
    }
2445
    if (strcmp(nameToken, "glGenTransformFeedbacks") == 0)
2446
    {
2447
        ParamBuffer params =
2448
            ParseParameters<std::remove_pointer<PFNGLGENTRANSFORMFEEDBACKSPROC>::type>(paramTokens,
2449
                                                                                       strings);
2450
        return CallCapture(EntryPoint::GLGenTransformFeedbacks, std::move(params));
2451
    }
2452
    if (strcmp(nameToken, "glGenVertexArrays") == 0)
2453
    {
2454
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSPROC>::type>(
2455
            paramTokens, strings);
2456
        return CallCapture(EntryPoint::GLGenVertexArrays, std::move(params));
2457
    }
2458
    if (strcmp(nameToken, "glGenVertexArraysOES") == 0)
2459
    {
2460
        ParamBuffer params =
2461
            ParseParameters<std::remove_pointer<PFNGLGENVERTEXARRAYSOESPROC>::type>(paramTokens,
2462
                                                                                    strings);
2463
        return CallCapture(EntryPoint::GLGenVertexArraysOES, std::move(params));
2464
    }
2465
    if (strcmp(nameToken, "glGenerateMipmap") == 0)
2466
    {
2467
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPPROC>::type>(
2468
            paramTokens, strings);
2469
        return CallCapture(EntryPoint::GLGenerateMipmap, std::move(params));
2470
    }
2471
    if (strcmp(nameToken, "glGenerateMipmapOES") == 0)
2472
    {
2473
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGENERATEMIPMAPOESPROC>::type>(
2474
            paramTokens, strings);
2475
        return CallCapture(EntryPoint::GLGenerateMipmapOES, std::move(params));
2476
    }
2477
    if (strcmp(nameToken, "glGetActiveAttrib") == 0)
2478
    {
2479
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEATTRIBPROC>::type>(
2480
            paramTokens, strings);
2481
        return CallCapture(EntryPoint::GLGetActiveAttrib, std::move(params));
2482
    }
2483
    if (strcmp(nameToken, "glGetActiveUniform") == 0)
2484
    {
2485
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMPROC>::type>(
2486
            paramTokens, strings);
2487
        return CallCapture(EntryPoint::GLGetActiveUniform, std::move(params));
2488
    }
2489
    if (strcmp(nameToken, "glGetActiveUniformBlockName") == 0)
2490
    {
2491
        ParamBuffer params =
2492
            ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC>::type>(
2493
                paramTokens, strings);
2494
        return CallCapture(EntryPoint::GLGetActiveUniformBlockName, std::move(params));
2495
    }
2496
    if (strcmp(nameToken, "glGetActiveUniformBlockiv") == 0)
2497
    {
2498
        ParamBuffer params =
2499
            ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVPROC>::type>(
2500
                paramTokens, strings);
2501
        return CallCapture(EntryPoint::GLGetActiveUniformBlockiv, std::move(params));
2502
    }
2503
    if (strcmp(nameToken, "glGetActiveUniformBlockivRobustANGLE") == 0)
2504
    {
2505
        ParamBuffer params =
2506
            ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMBLOCKIVROBUSTANGLEPROC>::type>(
2507
                paramTokens, strings);
2508
        return CallCapture(EntryPoint::GLGetActiveUniformBlockivRobustANGLE, std::move(params));
2509
    }
2510
    if (strcmp(nameToken, "glGetActiveUniformsiv") == 0)
2511
    {
2512
        ParamBuffer params =
2513
            ParseParameters<std::remove_pointer<PFNGLGETACTIVEUNIFORMSIVPROC>::type>(paramTokens,
2514
                                                                                     strings);
2515
        return CallCapture(EntryPoint::GLGetActiveUniformsiv, std::move(params));
2516
    }
2517
    if (strcmp(nameToken, "glGetAttachedShaders") == 0)
2518
    {
2519
        ParamBuffer params =
2520
            ParseParameters<std::remove_pointer<PFNGLGETATTACHEDSHADERSPROC>::type>(paramTokens,
2521
                                                                                    strings);
2522
        return CallCapture(EntryPoint::GLGetAttachedShaders, std::move(params));
2523
    }
2524
    if (strcmp(nameToken, "glGetAttribLocation") == 0)
2525
    {
2526
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETATTRIBLOCATIONPROC>::type>(
2527
            paramTokens, strings);
2528
        return CallCapture(EntryPoint::GLGetAttribLocation, std::move(params));
2529
    }
2530
    if (strcmp(nameToken, "glGetBooleani_v") == 0)
2531
    {
2532
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VPROC>::type>(
2533
            paramTokens, strings);
2534
        return CallCapture(EntryPoint::GLGetBooleani_v, std::move(params));
2535
    }
2536
    if (strcmp(nameToken, "glGetBooleani_vRobustANGLE") == 0)
2537
    {
2538
        ParamBuffer params =
2539
            ParseParameters<std::remove_pointer<PFNGLGETBOOLEANI_VROBUSTANGLEPROC>::type>(
2540
                paramTokens, strings);
2541
        return CallCapture(EntryPoint::GLGetBooleani_vRobustANGLE, std::move(params));
2542
    }
2543
    if (strcmp(nameToken, "glGetBooleanv") == 0)
2544
    {
2545
        ParamBuffer params =
2546
            ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVPROC>::type>(paramTokens, strings);
2547
        return CallCapture(EntryPoint::GLGetBooleanv, std::move(params));
2548
    }
2549
    if (strcmp(nameToken, "glGetBooleanvRobustANGLE") == 0)
2550
    {
2551
        ParamBuffer params =
2552
            ParseParameters<std::remove_pointer<PFNGLGETBOOLEANVROBUSTANGLEPROC>::type>(paramTokens,
2553
                                                                                        strings);
2554
        return CallCapture(EntryPoint::GLGetBooleanvRobustANGLE, std::move(params));
2555
    }
2556
    if (strcmp(nameToken, "glGetBufferParameteri64v") == 0)
2557
    {
2558
        ParamBuffer params =
2559
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VPROC>::type>(paramTokens,
2560
                                                                                        strings);
2561
        return CallCapture(EntryPoint::GLGetBufferParameteri64v, std::move(params));
2562
    }
2563
    if (strcmp(nameToken, "glGetBufferParameteri64vRobustANGLE") == 0)
2564
    {
2565
        ParamBuffer params =
2566
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERI64VROBUSTANGLEPROC>::type>(
2567
                paramTokens, strings);
2568
        return CallCapture(EntryPoint::GLGetBufferParameteri64vRobustANGLE, std::move(params));
2569
    }
2570
    if (strcmp(nameToken, "glGetBufferParameteriv") == 0)
2571
    {
2572
        ParamBuffer params =
2573
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVPROC>::type>(paramTokens,
2574
                                                                                      strings);
2575
        return CallCapture(EntryPoint::GLGetBufferParameteriv, std::move(params));
2576
    }
2577
    if (strcmp(nameToken, "glGetBufferParameterivRobustANGLE") == 0)
2578
    {
2579
        ParamBuffer params =
2580
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(
2581
                paramTokens, strings);
2582
        return CallCapture(EntryPoint::GLGetBufferParameterivRobustANGLE, std::move(params));
2583
    }
2584
    if (strcmp(nameToken, "glGetBufferPointerv") == 0)
2585
    {
2586
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVPROC>::type>(
2587
            paramTokens, strings);
2588
        return CallCapture(EntryPoint::GLGetBufferPointerv, std::move(params));
2589
    }
2590
    if (strcmp(nameToken, "glGetBufferPointervOES") == 0)
2591
    {
2592
        ParamBuffer params =
2593
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVOESPROC>::type>(paramTokens,
2594
                                                                                      strings);
2595
        return CallCapture(EntryPoint::GLGetBufferPointervOES, std::move(params));
2596
    }
2597
    if (strcmp(nameToken, "glGetBufferPointervRobustANGLE") == 0)
2598
    {
2599
        ParamBuffer params =
2600
            ParseParameters<std::remove_pointer<PFNGLGETBUFFERPOINTERVROBUSTANGLEPROC>::type>(
2601
                paramTokens, strings);
2602
        return CallCapture(EntryPoint::GLGetBufferPointervRobustANGLE, std::move(params));
2603
    }
2604
    if (strcmp(nameToken, "glGetClipPlanef") == 0)
2605
    {
2606
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEFPROC>::type>(
2607
            paramTokens, strings);
2608
        return CallCapture(EntryPoint::GLGetClipPlanef, std::move(params));
2609
    }
2610
    if (strcmp(nameToken, "glGetClipPlanex") == 0)
2611
    {
2612
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETCLIPPLANEXPROC>::type>(
2613
            paramTokens, strings);
2614
        return CallCapture(EntryPoint::GLGetClipPlanex, std::move(params));
2615
    }
2616
    if (strcmp(nameToken, "glGetCompressedTexImageANGLE") == 0)
2617
    {
2618
        ParamBuffer params =
2619
            ParseParameters<std::remove_pointer<PFNGLGETCOMPRESSEDTEXIMAGEANGLEPROC>::type>(
2620
                paramTokens, strings);
2621
        return CallCapture(EntryPoint::GLGetCompressedTexImageANGLE, std::move(params));
2622
    }
2623
    if (strcmp(nameToken, "glGetDebugMessageLog") == 0)
2624
    {
2625
        ParamBuffer params =
2626
            ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGPROC>::type>(paramTokens,
2627
                                                                                    strings);
2628
        return CallCapture(EntryPoint::GLGetDebugMessageLog, std::move(params));
2629
    }
2630
    if (strcmp(nameToken, "glGetDebugMessageLogKHR") == 0)
2631
    {
2632
        ParamBuffer params =
2633
            ParseParameters<std::remove_pointer<PFNGLGETDEBUGMESSAGELOGKHRPROC>::type>(paramTokens,
2634
                                                                                       strings);
2635
        return CallCapture(EntryPoint::GLGetDebugMessageLogKHR, std::move(params));
2636
    }
2637
    if (strcmp(nameToken, "glGetError") == 0)
2638
    {
2639
        ParamBuffer params =
2640
            ParseParameters<std::remove_pointer<PFNGLGETERRORPROC>::type>(paramTokens, strings);
2641
        return CallCapture(EntryPoint::GLGetError, std::move(params));
2642
    }
2643
    if (strcmp(nameToken, "glGetFenceivNV") == 0)
2644
    {
2645
        ParamBuffer params =
2646
            ParseParameters<std::remove_pointer<PFNGLGETFENCEIVNVPROC>::type>(paramTokens, strings);
2647
        return CallCapture(EntryPoint::GLGetFenceivNV, std::move(params));
2648
    }
2649
    if (strcmp(nameToken, "glGetFixedv") == 0)
2650
    {
2651
        ParamBuffer params =
2652
            ParseParameters<std::remove_pointer<PFNGLGETFIXEDVPROC>::type>(paramTokens, strings);
2653
        return CallCapture(EntryPoint::GLGetFixedv, std::move(params));
2654
    }
2655
    if (strcmp(nameToken, "glGetFloatv") == 0)
2656
    {
2657
        ParamBuffer params =
2658
            ParseParameters<std::remove_pointer<PFNGLGETFLOATVPROC>::type>(paramTokens, strings);
2659
        return CallCapture(EntryPoint::GLGetFloatv, std::move(params));
2660
    }
2661
    if (strcmp(nameToken, "glGetFloatvRobustANGLE") == 0)
2662
    {
2663
        ParamBuffer params =
2664
            ParseParameters<std::remove_pointer<PFNGLGETFLOATVROBUSTANGLEPROC>::type>(paramTokens,
2665
                                                                                      strings);
2666
        return CallCapture(EntryPoint::GLGetFloatvRobustANGLE, std::move(params));
2667
    }
2668
    if (strcmp(nameToken, "glGetFragDataIndexEXT") == 0)
2669
    {
2670
        ParamBuffer params =
2671
            ParseParameters<std::remove_pointer<PFNGLGETFRAGDATAINDEXEXTPROC>::type>(paramTokens,
2672
                                                                                     strings);
2673
        return CallCapture(EntryPoint::GLGetFragDataIndexEXT, std::move(params));
2674
    }
2675
    if (strcmp(nameToken, "glGetFragDataLocation") == 0)
2676
    {
2677
        ParamBuffer params =
2678
            ParseParameters<std::remove_pointer<PFNGLGETFRAGDATALOCATIONPROC>::type>(paramTokens,
2679
                                                                                     strings);
2680
        return CallCapture(EntryPoint::GLGetFragDataLocation, std::move(params));
2681
    }
2682
    if (strcmp(nameToken, "glGetFramebufferAttachmentParameteriv") == 0)
2683
    {
2684
        ParamBuffer params = ParseParameters<
2685
            std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC>::type>(paramTokens,
2686
                                                                                     strings);
2687
        return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameteriv, std::move(params));
2688
    }
2689
    if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivOES") == 0)
2690
    {
2691
        ParamBuffer params = ParseParameters<
2692
            std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC>::type>(paramTokens,
2693
                                                                                        strings);
2694
        return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivOES, std::move(params));
2695
    }
2696
    if (strcmp(nameToken, "glGetFramebufferAttachmentParameterivRobustANGLE") == 0)
2697
    {
2698
        ParamBuffer params = ParseParameters<
2699
            std::remove_pointer<PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVROBUSTANGLEPROC>::type>(
2700
            paramTokens, strings);
2701
        return CallCapture(EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE,
2702
                           std::move(params));
2703
    }
2704
    if (strcmp(nameToken, "glGetFramebufferParameteriv") == 0)
2705
    {
2706
        ParamBuffer params =
2707
            ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVPROC>::type>(
2708
                paramTokens, strings);
2709
        return CallCapture(EntryPoint::GLGetFramebufferParameteriv, std::move(params));
2710
    }
2711
    if (strcmp(nameToken, "glGetFramebufferParameterivMESA") == 0)
2712
    {
2713
        ParamBuffer params =
2714
            ParseParameters<std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVMESAPROC>::type>(
2715
                paramTokens, strings);
2716
        return CallCapture(EntryPoint::GLGetFramebufferParameterivMESA, std::move(params));
2717
    }
2718
    if (strcmp(nameToken, "glGetFramebufferParameterivRobustANGLE") == 0)
2719
    {
2720
        ParamBuffer params = ParseParameters<
2721
            std::remove_pointer<PFNGLGETFRAMEBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
2722
                                                                                      strings);
2723
        return CallCapture(EntryPoint::GLGetFramebufferParameterivRobustANGLE, std::move(params));
2724
    }
2725
    if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvANGLE") == 0)
2726
    {
2727
        ParamBuffer params = ParseParameters<
2728
            std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVANGLEPROC>::type>(
2729
            paramTokens, strings);
2730
        return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvANGLE,
2731
                           std::move(params));
2732
    }
2733
    if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterfvRobustANGLE") == 0)
2734
    {
2735
        ParamBuffer params = ParseParameters<std::remove_pointer<
2736
            PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERFVROBUSTANGLEPROC>::type>(paramTokens,
2737
                                                                                   strings);
2738
        return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterfvRobustANGLE,
2739
                           std::move(params));
2740
    }
2741
    if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivANGLE") == 0)
2742
    {
2743
        ParamBuffer params = ParseParameters<
2744
            std::remove_pointer<PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVANGLEPROC>::type>(
2745
            paramTokens, strings);
2746
        return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivANGLE,
2747
                           std::move(params));
2748
    }
2749
    if (strcmp(nameToken, "glGetFramebufferPixelLocalStorageParameterivRobustANGLE") == 0)
2750
    {
2751
        ParamBuffer params = ParseParameters<std::remove_pointer<
2752
            PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGEPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
2753
                                                                                   strings);
2754
        return CallCapture(EntryPoint::GLGetFramebufferPixelLocalStorageParameterivRobustANGLE,
2755
                           std::move(params));
2756
    }
2757
    if (strcmp(nameToken, "glGetGraphicsResetStatus") == 0)
2758
    {
2759
        ParamBuffer params =
2760
            ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSPROC>::type>(paramTokens,
2761
                                                                                        strings);
2762
        return CallCapture(EntryPoint::GLGetGraphicsResetStatus, std::move(params));
2763
    }
2764
    if (strcmp(nameToken, "glGetGraphicsResetStatusEXT") == 0)
2765
    {
2766
        ParamBuffer params =
2767
            ParseParameters<std::remove_pointer<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>::type>(
2768
                paramTokens, strings);
2769
        return CallCapture(EntryPoint::GLGetGraphicsResetStatusEXT, std::move(params));
2770
    }
2771
    if (strcmp(nameToken, "glGetInteger64i_v") == 0)
2772
    {
2773
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VPROC>::type>(
2774
            paramTokens, strings);
2775
        return CallCapture(EntryPoint::GLGetInteger64i_v, std::move(params));
2776
    }
2777
    if (strcmp(nameToken, "glGetInteger64i_vRobustANGLE") == 0)
2778
    {
2779
        ParamBuffer params =
2780
            ParseParameters<std::remove_pointer<PFNGLGETINTEGER64I_VROBUSTANGLEPROC>::type>(
2781
                paramTokens, strings);
2782
        return CallCapture(EntryPoint::GLGetInteger64i_vRobustANGLE, std::move(params));
2783
    }
2784
    if (strcmp(nameToken, "glGetInteger64v") == 0)
2785
    {
2786
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VPROC>::type>(
2787
            paramTokens, strings);
2788
        return CallCapture(EntryPoint::GLGetInteger64v, std::move(params));
2789
    }
2790
    if (strcmp(nameToken, "glGetInteger64vEXT") == 0)
2791
    {
2792
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VEXTPROC>::type>(
2793
            paramTokens, strings);
2794
        return CallCapture(EntryPoint::GLGetInteger64vEXT, std::move(params));
2795
    }
2796
    if (strcmp(nameToken, "glGetInteger64vRobustANGLE") == 0)
2797
    {
2798
        ParamBuffer params =
2799
            ParseParameters<std::remove_pointer<PFNGLGETINTEGER64VROBUSTANGLEPROC>::type>(
2800
                paramTokens, strings);
2801
        return CallCapture(EntryPoint::GLGetInteger64vRobustANGLE, std::move(params));
2802
    }
2803
    if (strcmp(nameToken, "glGetIntegeri_v") == 0)
2804
    {
2805
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VPROC>::type>(
2806
            paramTokens, strings);
2807
        return CallCapture(EntryPoint::GLGetIntegeri_v, std::move(params));
2808
    }
2809
    if (strcmp(nameToken, "glGetIntegeri_vRobustANGLE") == 0)
2810
    {
2811
        ParamBuffer params =
2812
            ParseParameters<std::remove_pointer<PFNGLGETINTEGERI_VROBUSTANGLEPROC>::type>(
2813
                paramTokens, strings);
2814
        return CallCapture(EntryPoint::GLGetIntegeri_vRobustANGLE, std::move(params));
2815
    }
2816
    if (strcmp(nameToken, "glGetIntegerv") == 0)
2817
    {
2818
        ParamBuffer params =
2819
            ParseParameters<std::remove_pointer<PFNGLGETINTEGERVPROC>::type>(paramTokens, strings);
2820
        return CallCapture(EntryPoint::GLGetIntegerv, std::move(params));
2821
    }
2822
    if (strcmp(nameToken, "glGetIntegervRobustANGLE") == 0)
2823
    {
2824
        ParamBuffer params =
2825
            ParseParameters<std::remove_pointer<PFNGLGETINTEGERVROBUSTANGLEPROC>::type>(paramTokens,
2826
                                                                                        strings);
2827
        return CallCapture(EntryPoint::GLGetIntegervRobustANGLE, std::move(params));
2828
    }
2829
    if (strcmp(nameToken, "glGetInternalformativ") == 0)
2830
    {
2831
        ParamBuffer params =
2832
            ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVPROC>::type>(paramTokens,
2833
                                                                                     strings);
2834
        return CallCapture(EntryPoint::GLGetInternalformativ, std::move(params));
2835
    }
2836
    if (strcmp(nameToken, "glGetInternalformativRobustANGLE") == 0)
2837
    {
2838
        ParamBuffer params =
2839
            ParseParameters<std::remove_pointer<PFNGLGETINTERNALFORMATIVROBUSTANGLEPROC>::type>(
2840
                paramTokens, strings);
2841
        return CallCapture(EntryPoint::GLGetInternalformativRobustANGLE, std::move(params));
2842
    }
2843
    if (strcmp(nameToken, "glGetLightfv") == 0)
2844
    {
2845
        ParamBuffer params =
2846
            ParseParameters<std::remove_pointer<PFNGLGETLIGHTFVPROC>::type>(paramTokens, strings);
2847
        return CallCapture(EntryPoint::GLGetLightfv, std::move(params));
2848
    }
2849
    if (strcmp(nameToken, "glGetLightxv") == 0)
2850
    {
2851
        ParamBuffer params =
2852
            ParseParameters<std::remove_pointer<PFNGLGETLIGHTXVPROC>::type>(paramTokens, strings);
2853
        return CallCapture(EntryPoint::GLGetLightxv, std::move(params));
2854
    }
2855
    if (strcmp(nameToken, "glGetMaterialfv") == 0)
2856
    {
2857
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALFVPROC>::type>(
2858
            paramTokens, strings);
2859
        return CallCapture(EntryPoint::GLGetMaterialfv, std::move(params));
2860
    }
2861
    if (strcmp(nameToken, "glGetMaterialxv") == 0)
2862
    {
2863
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMATERIALXVPROC>::type>(
2864
            paramTokens, strings);
2865
        return CallCapture(EntryPoint::GLGetMaterialxv, std::move(params));
2866
    }
2867
    if (strcmp(nameToken, "glGetMemoryObjectParameterivEXT") == 0)
2868
    {
2869
        ParamBuffer params =
2870
            ParseParameters<std::remove_pointer<PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
2871
                paramTokens, strings);
2872
        return CallCapture(EntryPoint::GLGetMemoryObjectParameterivEXT, std::move(params));
2873
    }
2874
    if (strcmp(nameToken, "glGetMultisamplefv") == 0)
2875
    {
2876
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVPROC>::type>(
2877
            paramTokens, strings);
2878
        return CallCapture(EntryPoint::GLGetMultisamplefv, std::move(params));
2879
    }
2880
    if (strcmp(nameToken, "glGetMultisamplefvANGLE") == 0)
2881
    {
2882
        ParamBuffer params =
2883
            ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVANGLEPROC>::type>(paramTokens,
2884
                                                                                       strings);
2885
        return CallCapture(EntryPoint::GLGetMultisamplefvANGLE, std::move(params));
2886
    }
2887
    if (strcmp(nameToken, "glGetMultisamplefvRobustANGLE") == 0)
2888
    {
2889
        ParamBuffer params =
2890
            ParseParameters<std::remove_pointer<PFNGLGETMULTISAMPLEFVROBUSTANGLEPROC>::type>(
2891
                paramTokens, strings);
2892
        return CallCapture(EntryPoint::GLGetMultisamplefvRobustANGLE, std::move(params));
2893
    }
2894
    if (strcmp(nameToken, "glGetObjectLabel") == 0)
2895
    {
2896
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELPROC>::type>(
2897
            paramTokens, strings);
2898
        return CallCapture(EntryPoint::GLGetObjectLabel, std::move(params));
2899
    }
2900
    if (strcmp(nameToken, "glGetObjectLabelEXT") == 0)
2901
    {
2902
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELEXTPROC>::type>(
2903
            paramTokens, strings);
2904
        return CallCapture(EntryPoint::GLGetObjectLabelEXT, std::move(params));
2905
    }
2906
    if (strcmp(nameToken, "glGetObjectLabelKHR") == 0)
2907
    {
2908
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTLABELKHRPROC>::type>(
2909
            paramTokens, strings);
2910
        return CallCapture(EntryPoint::GLGetObjectLabelKHR, std::move(params));
2911
    }
2912
    if (strcmp(nameToken, "glGetObjectPtrLabel") == 0)
2913
    {
2914
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELPROC>::type>(
2915
            paramTokens, strings);
2916
        return CallCapture(EntryPoint::GLGetObjectPtrLabel, std::move(params));
2917
    }
2918
    if (strcmp(nameToken, "glGetObjectPtrLabelKHR") == 0)
2919
    {
2920
        ParamBuffer params =
2921
            ParseParameters<std::remove_pointer<PFNGLGETOBJECTPTRLABELKHRPROC>::type>(paramTokens,
2922
                                                                                      strings);
2923
        return CallCapture(EntryPoint::GLGetObjectPtrLabelKHR, std::move(params));
2924
    }
2925
    if (strcmp(nameToken, "glGetPerfMonitorCounterDataAMD") == 0)
2926
    {
2927
        ParamBuffer params =
2928
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERDATAAMDPROC>::type>(
2929
                paramTokens, strings);
2930
        return CallCapture(EntryPoint::GLGetPerfMonitorCounterDataAMD, std::move(params));
2931
    }
2932
    if (strcmp(nameToken, "glGetPerfMonitorCounterInfoAMD") == 0)
2933
    {
2934
        ParamBuffer params =
2935
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERINFOAMDPROC>::type>(
2936
                paramTokens, strings);
2937
        return CallCapture(EntryPoint::GLGetPerfMonitorCounterInfoAMD, std::move(params));
2938
    }
2939
    if (strcmp(nameToken, "glGetPerfMonitorCounterStringAMD") == 0)
2940
    {
2941
        ParamBuffer params =
2942
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSTRINGAMDPROC>::type>(
2943
                paramTokens, strings);
2944
        return CallCapture(EntryPoint::GLGetPerfMonitorCounterStringAMD, std::move(params));
2945
    }
2946
    if (strcmp(nameToken, "glGetPerfMonitorCountersAMD") == 0)
2947
    {
2948
        ParamBuffer params =
2949
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORCOUNTERSAMDPROC>::type>(
2950
                paramTokens, strings);
2951
        return CallCapture(EntryPoint::GLGetPerfMonitorCountersAMD, std::move(params));
2952
    }
2953
    if (strcmp(nameToken, "glGetPerfMonitorGroupStringAMD") == 0)
2954
    {
2955
        ParamBuffer params =
2956
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSTRINGAMDPROC>::type>(
2957
                paramTokens, strings);
2958
        return CallCapture(EntryPoint::GLGetPerfMonitorGroupStringAMD, std::move(params));
2959
    }
2960
    if (strcmp(nameToken, "glGetPerfMonitorGroupsAMD") == 0)
2961
    {
2962
        ParamBuffer params =
2963
            ParseParameters<std::remove_pointer<PFNGLGETPERFMONITORGROUPSAMDPROC>::type>(
2964
                paramTokens, strings);
2965
        return CallCapture(EntryPoint::GLGetPerfMonitorGroupsAMD, std::move(params));
2966
    }
2967
    if (strcmp(nameToken, "glGetPointerv") == 0)
2968
    {
2969
        ParamBuffer params =
2970
            ParseParameters<std::remove_pointer<PFNGLGETPOINTERVPROC>::type>(paramTokens, strings);
2971
        return CallCapture(EntryPoint::GLGetPointerv, std::move(params));
2972
    }
2973
    if (strcmp(nameToken, "glGetPointervKHR") == 0)
2974
    {
2975
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPOINTERVKHRPROC>::type>(
2976
            paramTokens, strings);
2977
        return CallCapture(EntryPoint::GLGetPointervKHR, std::move(params));
2978
    }
2979
    if (strcmp(nameToken, "glGetPointervRobustANGLERobustANGLE") == 0)
2980
    {
2981
        ParamBuffer params =
2982
            ParseParameters<std::remove_pointer<PFNGLGETPOINTERVROBUSTANGLEROBUSTANGLEPROC>::type>(
2983
                paramTokens, strings);
2984
        return CallCapture(EntryPoint::GLGetPointervRobustANGLERobustANGLE, std::move(params));
2985
    }
2986
    if (strcmp(nameToken, "glGetProgramBinary") == 0)
2987
    {
2988
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYPROC>::type>(
2989
            paramTokens, strings);
2990
        return CallCapture(EntryPoint::GLGetProgramBinary, std::move(params));
2991
    }
2992
    if (strcmp(nameToken, "glGetProgramBinaryOES") == 0)
2993
    {
2994
        ParamBuffer params =
2995
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMBINARYOESPROC>::type>(paramTokens,
2996
                                                                                     strings);
2997
        return CallCapture(EntryPoint::GLGetProgramBinaryOES, std::move(params));
2998
    }
2999
    if (strcmp(nameToken, "glGetProgramInfoLog") == 0)
3000
    {
3001
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINFOLOGPROC>::type>(
3002
            paramTokens, strings);
3003
        return CallCapture(EntryPoint::GLGetProgramInfoLog, std::move(params));
3004
    }
3005
    if (strcmp(nameToken, "glGetProgramInterfaceiv") == 0)
3006
    {
3007
        ParamBuffer params =
3008
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVPROC>::type>(paramTokens,
3009
                                                                                       strings);
3010
        return CallCapture(EntryPoint::GLGetProgramInterfaceiv, std::move(params));
3011
    }
3012
    if (strcmp(nameToken, "glGetProgramInterfaceivRobustANGLE") == 0)
3013
    {
3014
        ParamBuffer params =
3015
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMINTERFACEIVROBUSTANGLEPROC>::type>(
3016
                paramTokens, strings);
3017
        return CallCapture(EntryPoint::GLGetProgramInterfaceivRobustANGLE, std::move(params));
3018
    }
3019
    if (strcmp(nameToken, "glGetProgramPipelineInfoLog") == 0)
3020
    {
3021
        ParamBuffer params =
3022
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGPROC>::type>(
3023
                paramTokens, strings);
3024
        return CallCapture(EntryPoint::GLGetProgramPipelineInfoLog, std::move(params));
3025
    }
3026
    if (strcmp(nameToken, "glGetProgramPipelineInfoLogEXT") == 0)
3027
    {
3028
        ParamBuffer params =
3029
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEINFOLOGEXTPROC>::type>(
3030
                paramTokens, strings);
3031
        return CallCapture(EntryPoint::GLGetProgramPipelineInfoLogEXT, std::move(params));
3032
    }
3033
    if (strcmp(nameToken, "glGetProgramPipelineiv") == 0)
3034
    {
3035
        ParamBuffer params =
3036
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVPROC>::type>(paramTokens,
3037
                                                                                      strings);
3038
        return CallCapture(EntryPoint::GLGetProgramPipelineiv, std::move(params));
3039
    }
3040
    if (strcmp(nameToken, "glGetProgramPipelineivEXT") == 0)
3041
    {
3042
        ParamBuffer params =
3043
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMPIPELINEIVEXTPROC>::type>(
3044
                paramTokens, strings);
3045
        return CallCapture(EntryPoint::GLGetProgramPipelineivEXT, std::move(params));
3046
    }
3047
    if (strcmp(nameToken, "glGetProgramResourceIndex") == 0)
3048
    {
3049
        ParamBuffer params =
3050
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEINDEXPROC>::type>(
3051
                paramTokens, strings);
3052
        return CallCapture(EntryPoint::GLGetProgramResourceIndex, std::move(params));
3053
    }
3054
    if (strcmp(nameToken, "glGetProgramResourceLocation") == 0)
3055
    {
3056
        ParamBuffer params =
3057
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONPROC>::type>(
3058
                paramTokens, strings);
3059
        return CallCapture(EntryPoint::GLGetProgramResourceLocation, std::move(params));
3060
    }
3061
    if (strcmp(nameToken, "glGetProgramResourceLocationIndexEXT") == 0)
3062
    {
3063
        ParamBuffer params =
3064
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC>::type>(
3065
                paramTokens, strings);
3066
        return CallCapture(EntryPoint::GLGetProgramResourceLocationIndexEXT, std::move(params));
3067
    }
3068
    if (strcmp(nameToken, "glGetProgramResourceName") == 0)
3069
    {
3070
        ParamBuffer params =
3071
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCENAMEPROC>::type>(paramTokens,
3072
                                                                                        strings);
3073
        return CallCapture(EntryPoint::GLGetProgramResourceName, std::move(params));
3074
    }
3075
    if (strcmp(nameToken, "glGetProgramResourceiv") == 0)
3076
    {
3077
        ParamBuffer params =
3078
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMRESOURCEIVPROC>::type>(paramTokens,
3079
                                                                                      strings);
3080
        return CallCapture(EntryPoint::GLGetProgramResourceiv, std::move(params));
3081
    }
3082
    if (strcmp(nameToken, "glGetProgramiv") == 0)
3083
    {
3084
        ParamBuffer params =
3085
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVPROC>::type>(paramTokens, strings);
3086
        return CallCapture(EntryPoint::GLGetProgramiv, std::move(params));
3087
    }
3088
    if (strcmp(nameToken, "glGetProgramivRobustANGLE") == 0)
3089
    {
3090
        ParamBuffer params =
3091
            ParseParameters<std::remove_pointer<PFNGLGETPROGRAMIVROBUSTANGLEPROC>::type>(
3092
                paramTokens, strings);
3093
        return CallCapture(EntryPoint::GLGetProgramivRobustANGLE, std::move(params));
3094
    }
3095
    if (strcmp(nameToken, "glGetQueryObjecti64vEXT") == 0)
3096
    {
3097
        ParamBuffer params =
3098
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VEXTPROC>::type>(paramTokens,
3099
                                                                                       strings);
3100
        return CallCapture(EntryPoint::GLGetQueryObjecti64vEXT, std::move(params));
3101
    }
3102
    if (strcmp(nameToken, "glGetQueryObjecti64vRobustANGLE") == 0)
3103
    {
3104
        ParamBuffer params =
3105
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTI64VROBUSTANGLEPROC>::type>(
3106
                paramTokens, strings);
3107
        return CallCapture(EntryPoint::GLGetQueryObjecti64vRobustANGLE, std::move(params));
3108
    }
3109
    if (strcmp(nameToken, "glGetQueryObjectivEXT") == 0)
3110
    {
3111
        ParamBuffer params =
3112
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVEXTPROC>::type>(paramTokens,
3113
                                                                                     strings);
3114
        return CallCapture(EntryPoint::GLGetQueryObjectivEXT, std::move(params));
3115
    }
3116
    if (strcmp(nameToken, "glGetQueryObjectivRobustANGLE") == 0)
3117
    {
3118
        ParamBuffer params =
3119
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTIVROBUSTANGLEPROC>::type>(
3120
                paramTokens, strings);
3121
        return CallCapture(EntryPoint::GLGetQueryObjectivRobustANGLE, std::move(params));
3122
    }
3123
    if (strcmp(nameToken, "glGetQueryObjectui64vEXT") == 0)
3124
    {
3125
        ParamBuffer params =
3126
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VEXTPROC>::type>(paramTokens,
3127
                                                                                        strings);
3128
        return CallCapture(EntryPoint::GLGetQueryObjectui64vEXT, std::move(params));
3129
    }
3130
    if (strcmp(nameToken, "glGetQueryObjectui64vRobustANGLE") == 0)
3131
    {
3132
        ParamBuffer params =
3133
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUI64VROBUSTANGLEPROC>::type>(
3134
                paramTokens, strings);
3135
        return CallCapture(EntryPoint::GLGetQueryObjectui64vRobustANGLE, std::move(params));
3136
    }
3137
    if (strcmp(nameToken, "glGetQueryObjectuiv") == 0)
3138
    {
3139
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVPROC>::type>(
3140
            paramTokens, strings);
3141
        return CallCapture(EntryPoint::GLGetQueryObjectuiv, std::move(params));
3142
    }
3143
    if (strcmp(nameToken, "glGetQueryObjectuivEXT") == 0)
3144
    {
3145
        ParamBuffer params =
3146
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVEXTPROC>::type>(paramTokens,
3147
                                                                                      strings);
3148
        return CallCapture(EntryPoint::GLGetQueryObjectuivEXT, std::move(params));
3149
    }
3150
    if (strcmp(nameToken, "glGetQueryObjectuivRobustANGLE") == 0)
3151
    {
3152
        ParamBuffer params =
3153
            ParseParameters<std::remove_pointer<PFNGLGETQUERYOBJECTUIVROBUSTANGLEPROC>::type>(
3154
                paramTokens, strings);
3155
        return CallCapture(EntryPoint::GLGetQueryObjectuivRobustANGLE, std::move(params));
3156
    }
3157
    if (strcmp(nameToken, "glGetQueryiv") == 0)
3158
    {
3159
        ParamBuffer params =
3160
            ParseParameters<std::remove_pointer<PFNGLGETQUERYIVPROC>::type>(paramTokens, strings);
3161
        return CallCapture(EntryPoint::GLGetQueryiv, std::move(params));
3162
    }
3163
    if (strcmp(nameToken, "glGetQueryivEXT") == 0)
3164
    {
3165
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETQUERYIVEXTPROC>::type>(
3166
            paramTokens, strings);
3167
        return CallCapture(EntryPoint::GLGetQueryivEXT, std::move(params));
3168
    }
3169
    if (strcmp(nameToken, "glGetQueryivRobustANGLE") == 0)
3170
    {
3171
        ParamBuffer params =
3172
            ParseParameters<std::remove_pointer<PFNGLGETQUERYIVROBUSTANGLEPROC>::type>(paramTokens,
3173
                                                                                       strings);
3174
        return CallCapture(EntryPoint::GLGetQueryivRobustANGLE, std::move(params));
3175
    }
3176
    if (strcmp(nameToken, "glGetRenderbufferImageANGLE") == 0)
3177
    {
3178
        ParamBuffer params =
3179
            ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERIMAGEANGLEPROC>::type>(
3180
                paramTokens, strings);
3181
        return CallCapture(EntryPoint::GLGetRenderbufferImageANGLE, std::move(params));
3182
    }
3183
    if (strcmp(nameToken, "glGetRenderbufferParameteriv") == 0)
3184
    {
3185
        ParamBuffer params =
3186
            ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVPROC>::type>(
3187
                paramTokens, strings);
3188
        return CallCapture(EntryPoint::GLGetRenderbufferParameteriv, std::move(params));
3189
    }
3190
    if (strcmp(nameToken, "glGetRenderbufferParameterivOES") == 0)
3191
    {
3192
        ParamBuffer params =
3193
            ParseParameters<std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVOESPROC>::type>(
3194
                paramTokens, strings);
3195
        return CallCapture(EntryPoint::GLGetRenderbufferParameterivOES, std::move(params));
3196
    }
3197
    if (strcmp(nameToken, "glGetRenderbufferParameterivRobustANGLE") == 0)
3198
    {
3199
        ParamBuffer params = ParseParameters<
3200
            std::remove_pointer<PFNGLGETRENDERBUFFERPARAMETERIVROBUSTANGLEPROC>::type>(paramTokens,
3201
                                                                                       strings);
3202
        return CallCapture(EntryPoint::GLGetRenderbufferParameterivRobustANGLE, std::move(params));
3203
    }
3204
    if (strcmp(nameToken, "glGetSamplerParameterIiv") == 0)
3205
    {
3206
        ParamBuffer params =
3207
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
3208
                                                                                        strings);
3209
        return CallCapture(EntryPoint::GLGetSamplerParameterIiv, std::move(params));
3210
    }
3211
    if (strcmp(nameToken, "glGetSamplerParameterIivEXT") == 0)
3212
    {
3213
        ParamBuffer params =
3214
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVEXTPROC>::type>(
3215
                paramTokens, strings);
3216
        return CallCapture(EntryPoint::GLGetSamplerParameterIivEXT, std::move(params));
3217
    }
3218
    if (strcmp(nameToken, "glGetSamplerParameterIivOES") == 0)
3219
    {
3220
        ParamBuffer params =
3221
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVOESPROC>::type>(
3222
                paramTokens, strings);
3223
        return CallCapture(EntryPoint::GLGetSamplerParameterIivOES, std::move(params));
3224
    }
3225
    if (strcmp(nameToken, "glGetSamplerParameterIivRobustANGLE") == 0)
3226
    {
3227
        ParamBuffer params =
3228
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
3229
                paramTokens, strings);
3230
        return CallCapture(EntryPoint::GLGetSamplerParameterIivRobustANGLE, std::move(params));
3231
    }
3232
    if (strcmp(nameToken, "glGetSamplerParameterIuiv") == 0)
3233
    {
3234
        ParamBuffer params =
3235
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVPROC>::type>(
3236
                paramTokens, strings);
3237
        return CallCapture(EntryPoint::GLGetSamplerParameterIuiv, std::move(params));
3238
    }
3239
    if (strcmp(nameToken, "glGetSamplerParameterIuivEXT") == 0)
3240
    {
3241
        ParamBuffer params =
3242
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVEXTPROC>::type>(
3243
                paramTokens, strings);
3244
        return CallCapture(EntryPoint::GLGetSamplerParameterIuivEXT, std::move(params));
3245
    }
3246
    if (strcmp(nameToken, "glGetSamplerParameterIuivOES") == 0)
3247
    {
3248
        ParamBuffer params =
3249
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVOESPROC>::type>(
3250
                paramTokens, strings);
3251
        return CallCapture(EntryPoint::GLGetSamplerParameterIuivOES, std::move(params));
3252
    }
3253
    if (strcmp(nameToken, "glGetSamplerParameterIuivRobustANGLE") == 0)
3254
    {
3255
        ParamBuffer params =
3256
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
3257
                paramTokens, strings);
3258
        return CallCapture(EntryPoint::GLGetSamplerParameterIuivRobustANGLE, std::move(params));
3259
    }
3260
    if (strcmp(nameToken, "glGetSamplerParameterfv") == 0)
3261
    {
3262
        ParamBuffer params =
3263
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVPROC>::type>(paramTokens,
3264
                                                                                       strings);
3265
        return CallCapture(EntryPoint::GLGetSamplerParameterfv, std::move(params));
3266
    }
3267
    if (strcmp(nameToken, "glGetSamplerParameterfvRobustANGLE") == 0)
3268
    {
3269
        ParamBuffer params =
3270
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
3271
                paramTokens, strings);
3272
        return CallCapture(EntryPoint::GLGetSamplerParameterfvRobustANGLE, std::move(params));
3273
    }
3274
    if (strcmp(nameToken, "glGetSamplerParameteriv") == 0)
3275
    {
3276
        ParamBuffer params =
3277
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVPROC>::type>(paramTokens,
3278
                                                                                       strings);
3279
        return CallCapture(EntryPoint::GLGetSamplerParameteriv, std::move(params));
3280
    }
3281
    if (strcmp(nameToken, "glGetSamplerParameterivRobustANGLE") == 0)
3282
    {
3283
        ParamBuffer params =
3284
            ParseParameters<std::remove_pointer<PFNGLGETSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
3285
                paramTokens, strings);
3286
        return CallCapture(EntryPoint::GLGetSamplerParameterivRobustANGLE, std::move(params));
3287
    }
3288
    if (strcmp(nameToken, "glGetSemaphoreParameterui64vEXT") == 0)
3289
    {
3290
        ParamBuffer params =
3291
            ParseParameters<std::remove_pointer<PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
3292
                paramTokens, strings);
3293
        return CallCapture(EntryPoint::GLGetSemaphoreParameterui64vEXT, std::move(params));
3294
    }
3295
    if (strcmp(nameToken, "glGetShaderInfoLog") == 0)
3296
    {
3297
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERINFOLOGPROC>::type>(
3298
            paramTokens, strings);
3299
        return CallCapture(EntryPoint::GLGetShaderInfoLog, std::move(params));
3300
    }
3301
    if (strcmp(nameToken, "glGetShaderPrecisionFormat") == 0)
3302
    {
3303
        ParamBuffer params =
3304
            ParseParameters<std::remove_pointer<PFNGLGETSHADERPRECISIONFORMATPROC>::type>(
3305
                paramTokens, strings);
3306
        return CallCapture(EntryPoint::GLGetShaderPrecisionFormat, std::move(params));
3307
    }
3308
    if (strcmp(nameToken, "glGetShaderSource") == 0)
3309
    {
3310
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETSHADERSOURCEPROC>::type>(
3311
            paramTokens, strings);
3312
        return CallCapture(EntryPoint::GLGetShaderSource, std::move(params));
3313
    }
3314
    if (strcmp(nameToken, "glGetShaderiv") == 0)
3315
    {
3316
        ParamBuffer params =
3317
            ParseParameters<std::remove_pointer<PFNGLGETSHADERIVPROC>::type>(paramTokens, strings);
3318
        return CallCapture(EntryPoint::GLGetShaderiv, std::move(params));
3319
    }
3320
    if (strcmp(nameToken, "glGetShaderivRobustANGLE") == 0)
3321
    {
3322
        ParamBuffer params =
3323
            ParseParameters<std::remove_pointer<PFNGLGETSHADERIVROBUSTANGLEPROC>::type>(paramTokens,
3324
                                                                                        strings);
3325
        return CallCapture(EntryPoint::GLGetShaderivRobustANGLE, std::move(params));
3326
    }
3327
    if (strcmp(nameToken, "glGetString") == 0)
3328
    {
3329
        ParamBuffer params =
3330
            ParseParameters<std::remove_pointer<PFNGLGETSTRINGPROC>::type>(paramTokens, strings);
3331
        return CallCapture(EntryPoint::GLGetString, std::move(params));
3332
    }
3333
    if (strcmp(nameToken, "glGetStringi") == 0)
3334
    {
3335
        ParamBuffer params =
3336
            ParseParameters<std::remove_pointer<PFNGLGETSTRINGIPROC>::type>(paramTokens, strings);
3337
        return CallCapture(EntryPoint::GLGetStringi, std::move(params));
3338
    }
3339
    if (strcmp(nameToken, "glGetSynciv") == 0)
3340
    {
3341
        ParamBuffer params =
3342
            ParseParameters<std::remove_pointer<PFNGLGETSYNCIVPROC>::type>(paramTokens, strings);
3343
        return CallCapture(EntryPoint::GLGetSynciv, std::move(params));
3344
    }
3345
    if (strcmp(nameToken, "glGetTexEnvfv") == 0)
3346
    {
3347
        ParamBuffer params =
3348
            ParseParameters<std::remove_pointer<PFNGLGETTEXENVFVPROC>::type>(paramTokens, strings);
3349
        return CallCapture(EntryPoint::GLGetTexEnvfv, std::move(params));
3350
    }
3351
    if (strcmp(nameToken, "glGetTexEnviv") == 0)
3352
    {
3353
        ParamBuffer params =
3354
            ParseParameters<std::remove_pointer<PFNGLGETTEXENVIVPROC>::type>(paramTokens, strings);
3355
        return CallCapture(EntryPoint::GLGetTexEnviv, std::move(params));
3356
    }
3357
    if (strcmp(nameToken, "glGetTexEnvxv") == 0)
3358
    {
3359
        ParamBuffer params =
3360
            ParseParameters<std::remove_pointer<PFNGLGETTEXENVXVPROC>::type>(paramTokens, strings);
3361
        return CallCapture(EntryPoint::GLGetTexEnvxv, std::move(params));
3362
    }
3363
    if (strcmp(nameToken, "glGetTexGenfvOES") == 0)
3364
    {
3365
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENFVOESPROC>::type>(
3366
            paramTokens, strings);
3367
        return CallCapture(EntryPoint::GLGetTexGenfvOES, std::move(params));
3368
    }
3369
    if (strcmp(nameToken, "glGetTexGenivOES") == 0)
3370
    {
3371
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENIVOESPROC>::type>(
3372
            paramTokens, strings);
3373
        return CallCapture(EntryPoint::GLGetTexGenivOES, std::move(params));
3374
    }
3375
    if (strcmp(nameToken, "glGetTexGenxvOES") == 0)
3376
    {
3377
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXGENXVOESPROC>::type>(
3378
            paramTokens, strings);
3379
        return CallCapture(EntryPoint::GLGetTexGenxvOES, std::move(params));
3380
    }
3381
    if (strcmp(nameToken, "glGetTexImageANGLE") == 0)
3382
    {
3383
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXIMAGEANGLEPROC>::type>(
3384
            paramTokens, strings);
3385
        return CallCapture(EntryPoint::GLGetTexImageANGLE, std::move(params));
3386
    }
3387
    if (strcmp(nameToken, "glGetTexLevelParameterfv") == 0)
3388
    {
3389
        ParamBuffer params =
3390
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVPROC>::type>(paramTokens,
3391
                                                                                        strings);
3392
        return CallCapture(EntryPoint::GLGetTexLevelParameterfv, std::move(params));
3393
    }
3394
    if (strcmp(nameToken, "glGetTexLevelParameterfvANGLE") == 0)
3395
    {
3396
        ParamBuffer params =
3397
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVANGLEPROC>::type>(
3398
                paramTokens, strings);
3399
        return CallCapture(EntryPoint::GLGetTexLevelParameterfvANGLE, std::move(params));
3400
    }
3401
    if (strcmp(nameToken, "glGetTexLevelParameterfvRobustANGLE") == 0)
3402
    {
3403
        ParamBuffer params =
3404
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERFVROBUSTANGLEPROC>::type>(
3405
                paramTokens, strings);
3406
        return CallCapture(EntryPoint::GLGetTexLevelParameterfvRobustANGLE, std::move(params));
3407
    }
3408
    if (strcmp(nameToken, "glGetTexLevelParameteriv") == 0)
3409
    {
3410
        ParamBuffer params =
3411
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVPROC>::type>(paramTokens,
3412
                                                                                        strings);
3413
        return CallCapture(EntryPoint::GLGetTexLevelParameteriv, std::move(params));
3414
    }
3415
    if (strcmp(nameToken, "glGetTexLevelParameterivANGLE") == 0)
3416
    {
3417
        ParamBuffer params =
3418
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVANGLEPROC>::type>(
3419
                paramTokens, strings);
3420
        return CallCapture(EntryPoint::GLGetTexLevelParameterivANGLE, std::move(params));
3421
    }
3422
    if (strcmp(nameToken, "glGetTexLevelParameterivRobustANGLE") == 0)
3423
    {
3424
        ParamBuffer params =
3425
            ParseParameters<std::remove_pointer<PFNGLGETTEXLEVELPARAMETERIVROBUSTANGLEPROC>::type>(
3426
                paramTokens, strings);
3427
        return CallCapture(EntryPoint::GLGetTexLevelParameterivRobustANGLE, std::move(params));
3428
    }
3429
    if (strcmp(nameToken, "glGetTexParameterIiv") == 0)
3430
    {
3431
        ParamBuffer params =
3432
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVPROC>::type>(paramTokens,
3433
                                                                                    strings);
3434
        return CallCapture(EntryPoint::GLGetTexParameterIiv, std::move(params));
3435
    }
3436
    if (strcmp(nameToken, "glGetTexParameterIivEXT") == 0)
3437
    {
3438
        ParamBuffer params =
3439
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
3440
                                                                                       strings);
3441
        return CallCapture(EntryPoint::GLGetTexParameterIivEXT, std::move(params));
3442
    }
3443
    if (strcmp(nameToken, "glGetTexParameterIivOES") == 0)
3444
    {
3445
        ParamBuffer params =
3446
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVOESPROC>::type>(paramTokens,
3447
                                                                                       strings);
3448
        return CallCapture(EntryPoint::GLGetTexParameterIivOES, std::move(params));
3449
    }
3450
    if (strcmp(nameToken, "glGetTexParameterIivRobustANGLE") == 0)
3451
    {
3452
        ParamBuffer params =
3453
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
3454
                paramTokens, strings);
3455
        return CallCapture(EntryPoint::GLGetTexParameterIivRobustANGLE, std::move(params));
3456
    }
3457
    if (strcmp(nameToken, "glGetTexParameterIuiv") == 0)
3458
    {
3459
        ParamBuffer params =
3460
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVPROC>::type>(paramTokens,
3461
                                                                                     strings);
3462
        return CallCapture(EntryPoint::GLGetTexParameterIuiv, std::move(params));
3463
    }
3464
    if (strcmp(nameToken, "glGetTexParameterIuivEXT") == 0)
3465
    {
3466
        ParamBuffer params =
3467
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
3468
                                                                                        strings);
3469
        return CallCapture(EntryPoint::GLGetTexParameterIuivEXT, std::move(params));
3470
    }
3471
    if (strcmp(nameToken, "glGetTexParameterIuivOES") == 0)
3472
    {
3473
        ParamBuffer params =
3474
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
3475
                                                                                        strings);
3476
        return CallCapture(EntryPoint::GLGetTexParameterIuivOES, std::move(params));
3477
    }
3478
    if (strcmp(nameToken, "glGetTexParameterIuivRobustANGLE") == 0)
3479
    {
3480
        ParamBuffer params =
3481
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
3482
                paramTokens, strings);
3483
        return CallCapture(EntryPoint::GLGetTexParameterIuivRobustANGLE, std::move(params));
3484
    }
3485
    if (strcmp(nameToken, "glGetTexParameterfv") == 0)
3486
    {
3487
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVPROC>::type>(
3488
            paramTokens, strings);
3489
        return CallCapture(EntryPoint::GLGetTexParameterfv, std::move(params));
3490
    }
3491
    if (strcmp(nameToken, "glGetTexParameterfvRobustANGLE") == 0)
3492
    {
3493
        ParamBuffer params =
3494
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERFVROBUSTANGLEPROC>::type>(
3495
                paramTokens, strings);
3496
        return CallCapture(EntryPoint::GLGetTexParameterfvRobustANGLE, std::move(params));
3497
    }
3498
    if (strcmp(nameToken, "glGetTexParameteriv") == 0)
3499
    {
3500
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVPROC>::type>(
3501
            paramTokens, strings);
3502
        return CallCapture(EntryPoint::GLGetTexParameteriv, std::move(params));
3503
    }
3504
    if (strcmp(nameToken, "glGetTexParameterivRobustANGLE") == 0)
3505
    {
3506
        ParamBuffer params =
3507
            ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERIVROBUSTANGLEPROC>::type>(
3508
                paramTokens, strings);
3509
        return CallCapture(EntryPoint::GLGetTexParameterivRobustANGLE, std::move(params));
3510
    }
3511
    if (strcmp(nameToken, "glGetTexParameterxv") == 0)
3512
    {
3513
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETTEXPARAMETERXVPROC>::type>(
3514
            paramTokens, strings);
3515
        return CallCapture(EntryPoint::GLGetTexParameterxv, std::move(params));
3516
    }
3517
    if (strcmp(nameToken, "glGetTransformFeedbackVarying") == 0)
3518
    {
3519
        ParamBuffer params =
3520
            ParseParameters<std::remove_pointer<PFNGLGETTRANSFORMFEEDBACKVARYINGPROC>::type>(
3521
                paramTokens, strings);
3522
        return CallCapture(EntryPoint::GLGetTransformFeedbackVarying, std::move(params));
3523
    }
3524
    if (strcmp(nameToken, "glGetTranslatedShaderSourceANGLE") == 0)
3525
    {
3526
        ParamBuffer params =
3527
            ParseParameters<std::remove_pointer<PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC>::type>(
3528
                paramTokens, strings);
3529
        return CallCapture(EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(params));
3530
    }
3531
    if (strcmp(nameToken, "glGetUniformBlockIndex") == 0)
3532
    {
3533
        ParamBuffer params =
3534
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMBLOCKINDEXPROC>::type>(paramTokens,
3535
                                                                                      strings);
3536
        return CallCapture(EntryPoint::GLGetUniformBlockIndex, std::move(params));
3537
    }
3538
    if (strcmp(nameToken, "glGetUniformIndices") == 0)
3539
    {
3540
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMINDICESPROC>::type>(
3541
            paramTokens, strings);
3542
        return CallCapture(EntryPoint::GLGetUniformIndices, std::move(params));
3543
    }
3544
    if (strcmp(nameToken, "glGetUniformLocation") == 0)
3545
    {
3546
        ParamBuffer params =
3547
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMLOCATIONPROC>::type>(paramTokens,
3548
                                                                                    strings);
3549
        return CallCapture(EntryPoint::GLGetUniformLocation, std::move(params));
3550
    }
3551
    if (strcmp(nameToken, "glGetUniformfv") == 0)
3552
    {
3553
        ParamBuffer params =
3554
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVPROC>::type>(paramTokens, strings);
3555
        return CallCapture(EntryPoint::GLGetUniformfv, std::move(params));
3556
    }
3557
    if (strcmp(nameToken, "glGetUniformfvRobustANGLE") == 0)
3558
    {
3559
        ParamBuffer params =
3560
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMFVROBUSTANGLEPROC>::type>(
3561
                paramTokens, strings);
3562
        return CallCapture(EntryPoint::GLGetUniformfvRobustANGLE, std::move(params));
3563
    }
3564
    if (strcmp(nameToken, "glGetUniformiv") == 0)
3565
    {
3566
        ParamBuffer params =
3567
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVPROC>::type>(paramTokens, strings);
3568
        return CallCapture(EntryPoint::GLGetUniformiv, std::move(params));
3569
    }
3570
    if (strcmp(nameToken, "glGetUniformivRobustANGLE") == 0)
3571
    {
3572
        ParamBuffer params =
3573
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMIVROBUSTANGLEPROC>::type>(
3574
                paramTokens, strings);
3575
        return CallCapture(EntryPoint::GLGetUniformivRobustANGLE, std::move(params));
3576
    }
3577
    if (strcmp(nameToken, "glGetUniformuiv") == 0)
3578
    {
3579
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVPROC>::type>(
3580
            paramTokens, strings);
3581
        return CallCapture(EntryPoint::GLGetUniformuiv, std::move(params));
3582
    }
3583
    if (strcmp(nameToken, "glGetUniformuivRobustANGLE") == 0)
3584
    {
3585
        ParamBuffer params =
3586
            ParseParameters<std::remove_pointer<PFNGLGETUNIFORMUIVROBUSTANGLEPROC>::type>(
3587
                paramTokens, strings);
3588
        return CallCapture(EntryPoint::GLGetUniformuivRobustANGLE, std::move(params));
3589
    }
3590
    if (strcmp(nameToken, "glGetUnsignedBytei_vEXT") == 0)
3591
    {
3592
        ParamBuffer params =
3593
            ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEI_VEXTPROC>::type>(paramTokens,
3594
                                                                                       strings);
3595
        return CallCapture(EntryPoint::GLGetUnsignedBytei_vEXT, std::move(params));
3596
    }
3597
    if (strcmp(nameToken, "glGetUnsignedBytevEXT") == 0)
3598
    {
3599
        ParamBuffer params =
3600
            ParseParameters<std::remove_pointer<PFNGLGETUNSIGNEDBYTEVEXTPROC>::type>(paramTokens,
3601
                                                                                     strings);
3602
        return CallCapture(EntryPoint::GLGetUnsignedBytevEXT, std::move(params));
3603
    }
3604
    if (strcmp(nameToken, "glGetVertexAttribIiv") == 0)
3605
    {
3606
        ParamBuffer params =
3607
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVPROC>::type>(paramTokens,
3608
                                                                                    strings);
3609
        return CallCapture(EntryPoint::GLGetVertexAttribIiv, std::move(params));
3610
    }
3611
    if (strcmp(nameToken, "glGetVertexAttribIivRobustANGLE") == 0)
3612
    {
3613
        ParamBuffer params =
3614
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIIVROBUSTANGLEPROC>::type>(
3615
                paramTokens, strings);
3616
        return CallCapture(EntryPoint::GLGetVertexAttribIivRobustANGLE, std::move(params));
3617
    }
3618
    if (strcmp(nameToken, "glGetVertexAttribIuiv") == 0)
3619
    {
3620
        ParamBuffer params =
3621
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVPROC>::type>(paramTokens,
3622
                                                                                     strings);
3623
        return CallCapture(EntryPoint::GLGetVertexAttribIuiv, std::move(params));
3624
    }
3625
    if (strcmp(nameToken, "glGetVertexAttribIuivRobustANGLE") == 0)
3626
    {
3627
        ParamBuffer params =
3628
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIUIVROBUSTANGLEPROC>::type>(
3629
                paramTokens, strings);
3630
        return CallCapture(EntryPoint::GLGetVertexAttribIuivRobustANGLE, std::move(params));
3631
    }
3632
    if (strcmp(nameToken, "glGetVertexAttribPointerv") == 0)
3633
    {
3634
        ParamBuffer params =
3635
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVPROC>::type>(
3636
                paramTokens, strings);
3637
        return CallCapture(EntryPoint::GLGetVertexAttribPointerv, std::move(params));
3638
    }
3639
    if (strcmp(nameToken, "glGetVertexAttribPointervRobustANGLE") == 0)
3640
    {
3641
        ParamBuffer params =
3642
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBPOINTERVROBUSTANGLEPROC>::type>(
3643
                paramTokens, strings);
3644
        return CallCapture(EntryPoint::GLGetVertexAttribPointervRobustANGLE, std::move(params));
3645
    }
3646
    if (strcmp(nameToken, "glGetVertexAttribfv") == 0)
3647
    {
3648
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVPROC>::type>(
3649
            paramTokens, strings);
3650
        return CallCapture(EntryPoint::GLGetVertexAttribfv, std::move(params));
3651
    }
3652
    if (strcmp(nameToken, "glGetVertexAttribfvRobustANGLE") == 0)
3653
    {
3654
        ParamBuffer params =
3655
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBFVROBUSTANGLEPROC>::type>(
3656
                paramTokens, strings);
3657
        return CallCapture(EntryPoint::GLGetVertexAttribfvRobustANGLE, std::move(params));
3658
    }
3659
    if (strcmp(nameToken, "glGetVertexAttribiv") == 0)
3660
    {
3661
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVPROC>::type>(
3662
            paramTokens, strings);
3663
        return CallCapture(EntryPoint::GLGetVertexAttribiv, std::move(params));
3664
    }
3665
    if (strcmp(nameToken, "glGetVertexAttribivRobustANGLE") == 0)
3666
    {
3667
        ParamBuffer params =
3668
            ParseParameters<std::remove_pointer<PFNGLGETVERTEXATTRIBIVROBUSTANGLEPROC>::type>(
3669
                paramTokens, strings);
3670
        return CallCapture(EntryPoint::GLGetVertexAttribivRobustANGLE, std::move(params));
3671
    }
3672
    if (strcmp(nameToken, "glGetnUniformfv") == 0)
3673
    {
3674
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVPROC>::type>(
3675
            paramTokens, strings);
3676
        return CallCapture(EntryPoint::GLGetnUniformfv, std::move(params));
3677
    }
3678
    if (strcmp(nameToken, "glGetnUniformfvEXT") == 0)
3679
    {
3680
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVEXTPROC>::type>(
3681
            paramTokens, strings);
3682
        return CallCapture(EntryPoint::GLGetnUniformfvEXT, std::move(params));
3683
    }
3684
    if (strcmp(nameToken, "glGetnUniformfvRobustANGLE") == 0)
3685
    {
3686
        ParamBuffer params =
3687
            ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMFVROBUSTANGLEPROC>::type>(
3688
                paramTokens, strings);
3689
        return CallCapture(EntryPoint::GLGetnUniformfvRobustANGLE, std::move(params));
3690
    }
3691
    if (strcmp(nameToken, "glGetnUniformiv") == 0)
3692
    {
3693
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVPROC>::type>(
3694
            paramTokens, strings);
3695
        return CallCapture(EntryPoint::GLGetnUniformiv, std::move(params));
3696
    }
3697
    if (strcmp(nameToken, "glGetnUniformivEXT") == 0)
3698
    {
3699
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVEXTPROC>::type>(
3700
            paramTokens, strings);
3701
        return CallCapture(EntryPoint::GLGetnUniformivEXT, std::move(params));
3702
    }
3703
    if (strcmp(nameToken, "glGetnUniformivRobustANGLE") == 0)
3704
    {
3705
        ParamBuffer params =
3706
            ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMIVROBUSTANGLEPROC>::type>(
3707
                paramTokens, strings);
3708
        return CallCapture(EntryPoint::GLGetnUniformivRobustANGLE, std::move(params));
3709
    }
3710
    if (strcmp(nameToken, "glGetnUniformuiv") == 0)
3711
    {
3712
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVPROC>::type>(
3713
            paramTokens, strings);
3714
        return CallCapture(EntryPoint::GLGetnUniformuiv, std::move(params));
3715
    }
3716
    if (strcmp(nameToken, "glGetnUniformuivRobustANGLE") == 0)
3717
    {
3718
        ParamBuffer params =
3719
            ParseParameters<std::remove_pointer<PFNGLGETNUNIFORMUIVROBUSTANGLEPROC>::type>(
3720
                paramTokens, strings);
3721
        return CallCapture(EntryPoint::GLGetnUniformuivRobustANGLE, std::move(params));
3722
    }
3723
    if (strcmp(nameToken, "glHint") == 0)
3724
    {
3725
        ParamBuffer params =
3726
            ParseParameters<std::remove_pointer<PFNGLHINTPROC>::type>(paramTokens, strings);
3727
        return CallCapture(EntryPoint::GLHint, std::move(params));
3728
    }
3729
    if (strcmp(nameToken, "glImportMemoryFdEXT") == 0)
3730
    {
3731
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYFDEXTPROC>::type>(
3732
            paramTokens, strings);
3733
        return CallCapture(EntryPoint::GLImportMemoryFdEXT, std::move(params));
3734
    }
3735
    if (strcmp(nameToken, "glImportMemoryZirconHandleANGLE") == 0)
3736
    {
3737
        ParamBuffer params =
3738
            ParseParameters<std::remove_pointer<PFNGLIMPORTMEMORYZIRCONHANDLEANGLEPROC>::type>(
3739
                paramTokens, strings);
3740
        return CallCapture(EntryPoint::GLImportMemoryZirconHandleANGLE, std::move(params));
3741
    }
3742
    if (strcmp(nameToken, "glImportSemaphoreFdEXT") == 0)
3743
    {
3744
        ParamBuffer params =
3745
            ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREFDEXTPROC>::type>(paramTokens,
3746
                                                                                      strings);
3747
        return CallCapture(EntryPoint::GLImportSemaphoreFdEXT, std::move(params));
3748
    }
3749
    if (strcmp(nameToken, "glImportSemaphoreZirconHandleANGLE") == 0)
3750
    {
3751
        ParamBuffer params =
3752
            ParseParameters<std::remove_pointer<PFNGLIMPORTSEMAPHOREZIRCONHANDLEANGLEPROC>::type>(
3753
                paramTokens, strings);
3754
        return CallCapture(EntryPoint::GLImportSemaphoreZirconHandleANGLE, std::move(params));
3755
    }
3756
    if (strcmp(nameToken, "glInsertEventMarkerEXT") == 0)
3757
    {
3758
        ParamBuffer params =
3759
            ParseParameters<std::remove_pointer<PFNGLINSERTEVENTMARKEREXTPROC>::type>(paramTokens,
3760
                                                                                      strings);
3761
        return CallCapture(EntryPoint::GLInsertEventMarkerEXT, std::move(params));
3762
    }
3763
    if (strcmp(nameToken, "glInvalidateFramebuffer") == 0)
3764
    {
3765
        ParamBuffer params =
3766
            ParseParameters<std::remove_pointer<PFNGLINVALIDATEFRAMEBUFFERPROC>::type>(paramTokens,
3767
                                                                                       strings);
3768
        return CallCapture(EntryPoint::GLInvalidateFramebuffer, std::move(params));
3769
    }
3770
    if (strcmp(nameToken, "glInvalidateSubFramebuffer") == 0)
3771
    {
3772
        ParamBuffer params =
3773
            ParseParameters<std::remove_pointer<PFNGLINVALIDATESUBFRAMEBUFFERPROC>::type>(
3774
                paramTokens, strings);
3775
        return CallCapture(EntryPoint::GLInvalidateSubFramebuffer, std::move(params));
3776
    }
3777
    if (strcmp(nameToken, "glInvalidateTextureANGLE") == 0)
3778
    {
3779
        ParamBuffer params =
3780
            ParseParameters<std::remove_pointer<PFNGLINVALIDATETEXTUREANGLEPROC>::type>(paramTokens,
3781
                                                                                        strings);
3782
        return CallCapture(EntryPoint::GLInvalidateTextureANGLE, std::move(params));
3783
    }
3784
    if (strcmp(nameToken, "glIsBuffer") == 0)
3785
    {
3786
        ParamBuffer params =
3787
            ParseParameters<std::remove_pointer<PFNGLISBUFFERPROC>::type>(paramTokens, strings);
3788
        return CallCapture(EntryPoint::GLIsBuffer, std::move(params));
3789
    }
3790
    if (strcmp(nameToken, "glIsEnabled") == 0)
3791
    {
3792
        ParamBuffer params =
3793
            ParseParameters<std::remove_pointer<PFNGLISENABLEDPROC>::type>(paramTokens, strings);
3794
        return CallCapture(EntryPoint::GLIsEnabled, std::move(params));
3795
    }
3796
    if (strcmp(nameToken, "glIsEnabledi") == 0)
3797
    {
3798
        ParamBuffer params =
3799
            ParseParameters<std::remove_pointer<PFNGLISENABLEDIPROC>::type>(paramTokens, strings);
3800
        return CallCapture(EntryPoint::GLIsEnabledi, std::move(params));
3801
    }
3802
    if (strcmp(nameToken, "glIsEnablediEXT") == 0)
3803
    {
3804
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIEXTPROC>::type>(
3805
            paramTokens, strings);
3806
        return CallCapture(EntryPoint::GLIsEnablediEXT, std::move(params));
3807
    }
3808
    if (strcmp(nameToken, "glIsEnablediOES") == 0)
3809
    {
3810
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISENABLEDIOESPROC>::type>(
3811
            paramTokens, strings);
3812
        return CallCapture(EntryPoint::GLIsEnablediOES, std::move(params));
3813
    }
3814
    if (strcmp(nameToken, "glIsFenceNV") == 0)
3815
    {
3816
        ParamBuffer params =
3817
            ParseParameters<std::remove_pointer<PFNGLISFENCENVPROC>::type>(paramTokens, strings);
3818
        return CallCapture(EntryPoint::GLIsFenceNV, std::move(params));
3819
    }
3820
    if (strcmp(nameToken, "glIsFramebuffer") == 0)
3821
    {
3822
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFERPROC>::type>(
3823
            paramTokens, strings);
3824
        return CallCapture(EntryPoint::GLIsFramebuffer, std::move(params));
3825
    }
3826
    if (strcmp(nameToken, "glIsFramebufferOES") == 0)
3827
    {
3828
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISFRAMEBUFFEROESPROC>::type>(
3829
            paramTokens, strings);
3830
        return CallCapture(EntryPoint::GLIsFramebufferOES, std::move(params));
3831
    }
3832
    if (strcmp(nameToken, "glIsMemoryObjectEXT") == 0)
3833
    {
3834
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISMEMORYOBJECTEXTPROC>::type>(
3835
            paramTokens, strings);
3836
        return CallCapture(EntryPoint::GLIsMemoryObjectEXT, std::move(params));
3837
    }
3838
    if (strcmp(nameToken, "glIsProgram") == 0)
3839
    {
3840
        ParamBuffer params =
3841
            ParseParameters<std::remove_pointer<PFNGLISPROGRAMPROC>::type>(paramTokens, strings);
3842
        return CallCapture(EntryPoint::GLIsProgram, std::move(params));
3843
    }
3844
    if (strcmp(nameToken, "glIsProgramPipeline") == 0)
3845
    {
3846
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEPROC>::type>(
3847
            paramTokens, strings);
3848
        return CallCapture(EntryPoint::GLIsProgramPipeline, std::move(params));
3849
    }
3850
    if (strcmp(nameToken, "glIsProgramPipelineEXT") == 0)
3851
    {
3852
        ParamBuffer params =
3853
            ParseParameters<std::remove_pointer<PFNGLISPROGRAMPIPELINEEXTPROC>::type>(paramTokens,
3854
                                                                                      strings);
3855
        return CallCapture(EntryPoint::GLIsProgramPipelineEXT, std::move(params));
3856
    }
3857
    if (strcmp(nameToken, "glIsQuery") == 0)
3858
    {
3859
        ParamBuffer params =
3860
            ParseParameters<std::remove_pointer<PFNGLISQUERYPROC>::type>(paramTokens, strings);
3861
        return CallCapture(EntryPoint::GLIsQuery, std::move(params));
3862
    }
3863
    if (strcmp(nameToken, "glIsQueryEXT") == 0)
3864
    {
3865
        ParamBuffer params =
3866
            ParseParameters<std::remove_pointer<PFNGLISQUERYEXTPROC>::type>(paramTokens, strings);
3867
        return CallCapture(EntryPoint::GLIsQueryEXT, std::move(params));
3868
    }
3869
    if (strcmp(nameToken, "glIsRenderbuffer") == 0)
3870
    {
3871
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFERPROC>::type>(
3872
            paramTokens, strings);
3873
        return CallCapture(EntryPoint::GLIsRenderbuffer, std::move(params));
3874
    }
3875
    if (strcmp(nameToken, "glIsRenderbufferOES") == 0)
3876
    {
3877
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISRENDERBUFFEROESPROC>::type>(
3878
            paramTokens, strings);
3879
        return CallCapture(EntryPoint::GLIsRenderbufferOES, std::move(params));
3880
    }
3881
    if (strcmp(nameToken, "glIsSampler") == 0)
3882
    {
3883
        ParamBuffer params =
3884
            ParseParameters<std::remove_pointer<PFNGLISSAMPLERPROC>::type>(paramTokens, strings);
3885
        return CallCapture(EntryPoint::GLIsSampler, std::move(params));
3886
    }
3887
    if (strcmp(nameToken, "glIsSemaphoreEXT") == 0)
3888
    {
3889
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISSEMAPHOREEXTPROC>::type>(
3890
            paramTokens, strings);
3891
        return CallCapture(EntryPoint::GLIsSemaphoreEXT, std::move(params));
3892
    }
3893
    if (strcmp(nameToken, "glIsShader") == 0)
3894
    {
3895
        ParamBuffer params =
3896
            ParseParameters<std::remove_pointer<PFNGLISSHADERPROC>::type>(paramTokens, strings);
3897
        return CallCapture(EntryPoint::GLIsShader, std::move(params));
3898
    }
3899
    if (strcmp(nameToken, "glIsSync") == 0)
3900
    {
3901
        ParamBuffer params =
3902
            ParseParameters<std::remove_pointer<PFNGLISSYNCPROC>::type>(paramTokens, strings);
3903
        return CallCapture(EntryPoint::GLIsSync, std::move(params));
3904
    }
3905
    if (strcmp(nameToken, "glIsTexture") == 0)
3906
    {
3907
        ParamBuffer params =
3908
            ParseParameters<std::remove_pointer<PFNGLISTEXTUREPROC>::type>(paramTokens, strings);
3909
        return CallCapture(EntryPoint::GLIsTexture, std::move(params));
3910
    }
3911
    if (strcmp(nameToken, "glIsTransformFeedback") == 0)
3912
    {
3913
        ParamBuffer params =
3914
            ParseParameters<std::remove_pointer<PFNGLISTRANSFORMFEEDBACKPROC>::type>(paramTokens,
3915
                                                                                     strings);
3916
        return CallCapture(EntryPoint::GLIsTransformFeedback, std::move(params));
3917
    }
3918
    if (strcmp(nameToken, "glIsVertexArray") == 0)
3919
    {
3920
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYPROC>::type>(
3921
            paramTokens, strings);
3922
        return CallCapture(EntryPoint::GLIsVertexArray, std::move(params));
3923
    }
3924
    if (strcmp(nameToken, "glIsVertexArrayOES") == 0)
3925
    {
3926
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLISVERTEXARRAYOESPROC>::type>(
3927
            paramTokens, strings);
3928
        return CallCapture(EntryPoint::GLIsVertexArrayOES, std::move(params));
3929
    }
3930
    if (strcmp(nameToken, "glLabelObjectEXT") == 0)
3931
    {
3932
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLLABELOBJECTEXTPROC>::type>(
3933
            paramTokens, strings);
3934
        return CallCapture(EntryPoint::GLLabelObjectEXT, std::move(params));
3935
    }
3936
    if (strcmp(nameToken, "glLightModelf") == 0)
3937
    {
3938
        ParamBuffer params =
3939
            ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFPROC>::type>(paramTokens, strings);
3940
        return CallCapture(EntryPoint::GLLightModelf, std::move(params));
3941
    }
3942
    if (strcmp(nameToken, "glLightModelfv") == 0)
3943
    {
3944
        ParamBuffer params =
3945
            ParseParameters<std::remove_pointer<PFNGLLIGHTMODELFVPROC>::type>(paramTokens, strings);
3946
        return CallCapture(EntryPoint::GLLightModelfv, std::move(params));
3947
    }
3948
    if (strcmp(nameToken, "glLightModelx") == 0)
3949
    {
3950
        ParamBuffer params =
3951
            ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXPROC>::type>(paramTokens, strings);
3952
        return CallCapture(EntryPoint::GLLightModelx, std::move(params));
3953
    }
3954
    if (strcmp(nameToken, "glLightModelxv") == 0)
3955
    {
3956
        ParamBuffer params =
3957
            ParseParameters<std::remove_pointer<PFNGLLIGHTMODELXVPROC>::type>(paramTokens, strings);
3958
        return CallCapture(EntryPoint::GLLightModelxv, std::move(params));
3959
    }
3960
    if (strcmp(nameToken, "glLightf") == 0)
3961
    {
3962
        ParamBuffer params =
3963
            ParseParameters<std::remove_pointer<PFNGLLIGHTFPROC>::type>(paramTokens, strings);
3964
        return CallCapture(EntryPoint::GLLightf, std::move(params));
3965
    }
3966
    if (strcmp(nameToken, "glLightfv") == 0)
3967
    {
3968
        ParamBuffer params =
3969
            ParseParameters<std::remove_pointer<PFNGLLIGHTFVPROC>::type>(paramTokens, strings);
3970
        return CallCapture(EntryPoint::GLLightfv, std::move(params));
3971
    }
3972
    if (strcmp(nameToken, "glLightx") == 0)
3973
    {
3974
        ParamBuffer params =
3975
            ParseParameters<std::remove_pointer<PFNGLLIGHTXPROC>::type>(paramTokens, strings);
3976
        return CallCapture(EntryPoint::GLLightx, std::move(params));
3977
    }
3978
    if (strcmp(nameToken, "glLightxv") == 0)
3979
    {
3980
        ParamBuffer params =
3981
            ParseParameters<std::remove_pointer<PFNGLLIGHTXVPROC>::type>(paramTokens, strings);
3982
        return CallCapture(EntryPoint::GLLightxv, std::move(params));
3983
    }
3984
    if (strcmp(nameToken, "glLineWidth") == 0)
3985
    {
3986
        ParamBuffer params =
3987
            ParseParameters<std::remove_pointer<PFNGLLINEWIDTHPROC>::type>(paramTokens, strings);
3988
        return CallCapture(EntryPoint::GLLineWidth, std::move(params));
3989
    }
3990
    if (strcmp(nameToken, "glLineWidthx") == 0)
3991
    {
3992
        ParamBuffer params =
3993
            ParseParameters<std::remove_pointer<PFNGLLINEWIDTHXPROC>::type>(paramTokens, strings);
3994
        return CallCapture(EntryPoint::GLLineWidthx, std::move(params));
3995
    }
3996
    if (strcmp(nameToken, "glLinkProgram") == 0)
3997
    {
3998
        ParamBuffer params =
3999
            ParseParameters<std::remove_pointer<PFNGLLINKPROGRAMPROC>::type>(paramTokens, strings);
4000
        return CallCapture(EntryPoint::GLLinkProgram, std::move(params));
4001
    }
4002
    if (strcmp(nameToken, "glLoadIdentity") == 0)
4003
    {
4004
        ParamBuffer params =
4005
            ParseParameters<std::remove_pointer<PFNGLLOADIDENTITYPROC>::type>(paramTokens, strings);
4006
        return CallCapture(EntryPoint::GLLoadIdentity, std::move(params));
4007
    }
4008
    if (strcmp(nameToken, "glLoadMatrixf") == 0)
4009
    {
4010
        ParamBuffer params =
4011
            ParseParameters<std::remove_pointer<PFNGLLOADMATRIXFPROC>::type>(paramTokens, strings);
4012
        return CallCapture(EntryPoint::GLLoadMatrixf, std::move(params));
4013
    }
4014
    if (strcmp(nameToken, "glLoadMatrixx") == 0)
4015
    {
4016
        ParamBuffer params =
4017
            ParseParameters<std::remove_pointer<PFNGLLOADMATRIXXPROC>::type>(paramTokens, strings);
4018
        return CallCapture(EntryPoint::GLLoadMatrixx, std::move(params));
4019
    }
4020
    if (strcmp(nameToken, "glLoadPaletteFromModelViewMatrixOES") == 0)
4021
    {
4022
        ParamBuffer params =
4023
            ParseParameters<std::remove_pointer<PFNGLLOADPALETTEFROMMODELVIEWMATRIXOESPROC>::type>(
4024
                paramTokens, strings);
4025
        return CallCapture(EntryPoint::GLLoadPaletteFromModelViewMatrixOES, std::move(params));
4026
    }
4027
    if (strcmp(nameToken, "glLogicOp") == 0)
4028
    {
4029
        ParamBuffer params =
4030
            ParseParameters<std::remove_pointer<PFNGLLOGICOPPROC>::type>(paramTokens, strings);
4031
        return CallCapture(EntryPoint::GLLogicOp, std::move(params));
4032
    }
4033
    if (strcmp(nameToken, "glLogicOpANGLE") == 0)
4034
    {
4035
        ParamBuffer params =
4036
            ParseParameters<std::remove_pointer<PFNGLLOGICOPANGLEPROC>::type>(paramTokens, strings);
4037
        return CallCapture(EntryPoint::GLLogicOpANGLE, std::move(params));
4038
    }
4039
    if (strcmp(nameToken, "glLoseContextCHROMIUM") == 0)
4040
    {
4041
        ParamBuffer params =
4042
            ParseParameters<std::remove_pointer<PFNGLLOSECONTEXTCHROMIUMPROC>::type>(paramTokens,
4043
                                                                                     strings);
4044
        return CallCapture(EntryPoint::GLLoseContextCHROMIUM, std::move(params));
4045
    }
4046
    if (strcmp(nameToken, "glMapBufferOES") == 0)
4047
    {
4048
        ParamBuffer params =
4049
            ParseParameters<std::remove_pointer<PFNGLMAPBUFFEROESPROC>::type>(paramTokens, strings);
4050
        return CallCapture(EntryPoint::GLMapBufferOES, std::move(params));
4051
    }
4052
    if (strcmp(nameToken, "glMapBufferRange") == 0)
4053
    {
4054
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEPROC>::type>(
4055
            paramTokens, strings);
4056
        return CallCapture(EntryPoint::GLMapBufferRange, std::move(params));
4057
    }
4058
    if (strcmp(nameToken, "glMapBufferRangeEXT") == 0)
4059
    {
4060
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMAPBUFFERRANGEEXTPROC>::type>(
4061
            paramTokens, strings);
4062
        return CallCapture(EntryPoint::GLMapBufferRangeEXT, std::move(params));
4063
    }
4064
    if (strcmp(nameToken, "glMaterialf") == 0)
4065
    {
4066
        ParamBuffer params =
4067
            ParseParameters<std::remove_pointer<PFNGLMATERIALFPROC>::type>(paramTokens, strings);
4068
        return CallCapture(EntryPoint::GLMaterialf, std::move(params));
4069
    }
4070
    if (strcmp(nameToken, "glMaterialfv") == 0)
4071
    {
4072
        ParamBuffer params =
4073
            ParseParameters<std::remove_pointer<PFNGLMATERIALFVPROC>::type>(paramTokens, strings);
4074
        return CallCapture(EntryPoint::GLMaterialfv, std::move(params));
4075
    }
4076
    if (strcmp(nameToken, "glMaterialx") == 0)
4077
    {
4078
        ParamBuffer params =
4079
            ParseParameters<std::remove_pointer<PFNGLMATERIALXPROC>::type>(paramTokens, strings);
4080
        return CallCapture(EntryPoint::GLMaterialx, std::move(params));
4081
    }
4082
    if (strcmp(nameToken, "glMaterialxv") == 0)
4083
    {
4084
        ParamBuffer params =
4085
            ParseParameters<std::remove_pointer<PFNGLMATERIALXVPROC>::type>(paramTokens, strings);
4086
        return CallCapture(EntryPoint::GLMaterialxv, std::move(params));
4087
    }
4088
    if (strcmp(nameToken, "glMatrixIndexPointerOES") == 0)
4089
    {
4090
        ParamBuffer params =
4091
            ParseParameters<std::remove_pointer<PFNGLMATRIXINDEXPOINTEROESPROC>::type>(paramTokens,
4092
                                                                                       strings);
4093
        return CallCapture(EntryPoint::GLMatrixIndexPointerOES, std::move(params));
4094
    }
4095
    if (strcmp(nameToken, "glMatrixMode") == 0)
4096
    {
4097
        ParamBuffer params =
4098
            ParseParameters<std::remove_pointer<PFNGLMATRIXMODEPROC>::type>(paramTokens, strings);
4099
        return CallCapture(EntryPoint::GLMatrixMode, std::move(params));
4100
    }
4101
    if (strcmp(nameToken, "glMaxShaderCompilerThreadsKHR") == 0)
4102
    {
4103
        ParamBuffer params =
4104
            ParseParameters<std::remove_pointer<PFNGLMAXSHADERCOMPILERTHREADSKHRPROC>::type>(
4105
                paramTokens, strings);
4106
        return CallCapture(EntryPoint::GLMaxShaderCompilerThreadsKHR, std::move(params));
4107
    }
4108
    if (strcmp(nameToken, "glMemoryBarrier") == 0)
4109
    {
4110
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERPROC>::type>(
4111
            paramTokens, strings);
4112
        return CallCapture(EntryPoint::GLMemoryBarrier, std::move(params));
4113
    }
4114
    if (strcmp(nameToken, "glMemoryBarrierByRegion") == 0)
4115
    {
4116
        ParamBuffer params =
4117
            ParseParameters<std::remove_pointer<PFNGLMEMORYBARRIERBYREGIONPROC>::type>(paramTokens,
4118
                                                                                       strings);
4119
        return CallCapture(EntryPoint::GLMemoryBarrierByRegion, std::move(params));
4120
    }
4121
    if (strcmp(nameToken, "glMemoryObjectParameterivEXT") == 0)
4122
    {
4123
        ParamBuffer params =
4124
            ParseParameters<std::remove_pointer<PFNGLMEMORYOBJECTPARAMETERIVEXTPROC>::type>(
4125
                paramTokens, strings);
4126
        return CallCapture(EntryPoint::GLMemoryObjectParameterivEXT, std::move(params));
4127
    }
4128
    if (strcmp(nameToken, "glMinSampleShading") == 0)
4129
    {
4130
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGPROC>::type>(
4131
            paramTokens, strings);
4132
        return CallCapture(EntryPoint::GLMinSampleShading, std::move(params));
4133
    }
4134
    if (strcmp(nameToken, "glMinSampleShadingOES") == 0)
4135
    {
4136
        ParamBuffer params =
4137
            ParseParameters<std::remove_pointer<PFNGLMINSAMPLESHADINGOESPROC>::type>(paramTokens,
4138
                                                                                     strings);
4139
        return CallCapture(EntryPoint::GLMinSampleShadingOES, std::move(params));
4140
    }
4141
    if (strcmp(nameToken, "glMultMatrixf") == 0)
4142
    {
4143
        ParamBuffer params =
4144
            ParseParameters<std::remove_pointer<PFNGLMULTMATRIXFPROC>::type>(paramTokens, strings);
4145
        return CallCapture(EntryPoint::GLMultMatrixf, std::move(params));
4146
    }
4147
    if (strcmp(nameToken, "glMultMatrixx") == 0)
4148
    {
4149
        ParamBuffer params =
4150
            ParseParameters<std::remove_pointer<PFNGLMULTMATRIXXPROC>::type>(paramTokens, strings);
4151
        return CallCapture(EntryPoint::GLMultMatrixx, std::move(params));
4152
    }
4153
    if (strcmp(nameToken, "glMultiDrawArraysANGLE") == 0)
4154
    {
4155
        ParamBuffer params =
4156
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSANGLEPROC>::type>(paramTokens,
4157
                                                                                      strings);
4158
        return CallCapture(EntryPoint::GLMultiDrawArraysANGLE, std::move(params));
4159
    }
4160
    if (strcmp(nameToken, "glMultiDrawArraysIndirectEXT") == 0)
4161
    {
4162
        ParamBuffer params =
4163
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC>::type>(
4164
                paramTokens, strings);
4165
        return CallCapture(EntryPoint::GLMultiDrawArraysIndirectEXT, std::move(params));
4166
    }
4167
    if (strcmp(nameToken, "glMultiDrawArraysInstancedANGLE") == 0)
4168
    {
4169
        ParamBuffer params =
4170
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDANGLEPROC>::type>(
4171
                paramTokens, strings);
4172
        return CallCapture(EntryPoint::GLMultiDrawArraysInstancedANGLE, std::move(params));
4173
    }
4174
    if (strcmp(nameToken, "glMultiDrawArraysInstancedBaseInstanceANGLE") == 0)
4175
    {
4176
        ParamBuffer params = ParseParameters<
4177
            std::remove_pointer<PFNGLMULTIDRAWARRAYSINSTANCEDBASEINSTANCEANGLEPROC>::type>(
4178
            paramTokens, strings);
4179
        return CallCapture(EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE,
4180
                           std::move(params));
4181
    }
4182
    if (strcmp(nameToken, "glMultiDrawElementsANGLE") == 0)
4183
    {
4184
        ParamBuffer params =
4185
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSANGLEPROC>::type>(paramTokens,
4186
                                                                                        strings);
4187
        return CallCapture(EntryPoint::GLMultiDrawElementsANGLE, std::move(params));
4188
    }
4189
    if (strcmp(nameToken, "glMultiDrawElementsBaseVertexEXT") == 0)
4190
    {
4191
        ParamBuffer params =
4192
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC>::type>(
4193
                paramTokens, strings);
4194
        return CallCapture(EntryPoint::GLMultiDrawElementsBaseVertexEXT, std::move(params));
4195
    }
4196
    if (strcmp(nameToken, "glMultiDrawElementsIndirectEXT") == 0)
4197
    {
4198
        ParamBuffer params =
4199
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC>::type>(
4200
                paramTokens, strings);
4201
        return CallCapture(EntryPoint::GLMultiDrawElementsIndirectEXT, std::move(params));
4202
    }
4203
    if (strcmp(nameToken, "glMultiDrawElementsInstancedANGLE") == 0)
4204
    {
4205
        ParamBuffer params =
4206
            ParseParameters<std::remove_pointer<PFNGLMULTIDRAWELEMENTSINSTANCEDANGLEPROC>::type>(
4207
                paramTokens, strings);
4208
        return CallCapture(EntryPoint::GLMultiDrawElementsInstancedANGLE, std::move(params));
4209
    }
4210
    if (strcmp(nameToken, "glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE") == 0)
4211
    {
4212
        ParamBuffer params = ParseParameters<std::remove_pointer<
4213
            PFNGLMULTIDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEANGLEPROC>::type>(paramTokens,
4214
                                                                                   strings);
4215
        return CallCapture(EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE,
4216
                           std::move(params));
4217
    }
4218
    if (strcmp(nameToken, "glMultiTexCoord4f") == 0)
4219
    {
4220
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4FPROC>::type>(
4221
            paramTokens, strings);
4222
        return CallCapture(EntryPoint::GLMultiTexCoord4f, std::move(params));
4223
    }
4224
    if (strcmp(nameToken, "glMultiTexCoord4x") == 0)
4225
    {
4226
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLMULTITEXCOORD4XPROC>::type>(
4227
            paramTokens, strings);
4228
        return CallCapture(EntryPoint::GLMultiTexCoord4x, std::move(params));
4229
    }
4230
    if (strcmp(nameToken, "glNamedBufferStorageExternalEXT") == 0)
4231
    {
4232
        ParamBuffer params =
4233
            ParseParameters<std::remove_pointer<PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC>::type>(
4234
                paramTokens, strings);
4235
        return CallCapture(EntryPoint::GLNamedBufferStorageExternalEXT, std::move(params));
4236
    }
4237
    if (strcmp(nameToken, "glNormal3f") == 0)
4238
    {
4239
        ParamBuffer params =
4240
            ParseParameters<std::remove_pointer<PFNGLNORMAL3FPROC>::type>(paramTokens, strings);
4241
        return CallCapture(EntryPoint::GLNormal3f, std::move(params));
4242
    }
4243
    if (strcmp(nameToken, "glNormal3x") == 0)
4244
    {
4245
        ParamBuffer params =
4246
            ParseParameters<std::remove_pointer<PFNGLNORMAL3XPROC>::type>(paramTokens, strings);
4247
        return CallCapture(EntryPoint::GLNormal3x, std::move(params));
4248
    }
4249
    if (strcmp(nameToken, "glNormalPointer") == 0)
4250
    {
4251
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLNORMALPOINTERPROC>::type>(
4252
            paramTokens, strings);
4253
        return CallCapture(EntryPoint::GLNormalPointer, std::move(params));
4254
    }
4255
    if (strcmp(nameToken, "glObjectLabel") == 0)
4256
    {
4257
        ParamBuffer params =
4258
            ParseParameters<std::remove_pointer<PFNGLOBJECTLABELPROC>::type>(paramTokens, strings);
4259
        return CallCapture(EntryPoint::GLObjectLabel, std::move(params));
4260
    }
4261
    if (strcmp(nameToken, "glObjectLabelKHR") == 0)
4262
    {
4263
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTLABELKHRPROC>::type>(
4264
            paramTokens, strings);
4265
        return CallCapture(EntryPoint::GLObjectLabelKHR, std::move(params));
4266
    }
4267
    if (strcmp(nameToken, "glObjectPtrLabel") == 0)
4268
    {
4269
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELPROC>::type>(
4270
            paramTokens, strings);
4271
        return CallCapture(EntryPoint::GLObjectPtrLabel, std::move(params));
4272
    }
4273
    if (strcmp(nameToken, "glObjectPtrLabelKHR") == 0)
4274
    {
4275
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLOBJECTPTRLABELKHRPROC>::type>(
4276
            paramTokens, strings);
4277
        return CallCapture(EntryPoint::GLObjectPtrLabelKHR, std::move(params));
4278
    }
4279
    if (strcmp(nameToken, "glOrthof") == 0)
4280
    {
4281
        ParamBuffer params =
4282
            ParseParameters<std::remove_pointer<PFNGLORTHOFPROC>::type>(paramTokens, strings);
4283
        return CallCapture(EntryPoint::GLOrthof, std::move(params));
4284
    }
4285
    if (strcmp(nameToken, "glOrthox") == 0)
4286
    {
4287
        ParamBuffer params =
4288
            ParseParameters<std::remove_pointer<PFNGLORTHOXPROC>::type>(paramTokens, strings);
4289
        return CallCapture(EntryPoint::GLOrthox, std::move(params));
4290
    }
4291
    if (strcmp(nameToken, "glPatchParameteri") == 0)
4292
    {
4293
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIPROC>::type>(
4294
            paramTokens, strings);
4295
        return CallCapture(EntryPoint::GLPatchParameteri, std::move(params));
4296
    }
4297
    if (strcmp(nameToken, "glPatchParameteriEXT") == 0)
4298
    {
4299
        ParamBuffer params =
4300
            ParseParameters<std::remove_pointer<PFNGLPATCHPARAMETERIEXTPROC>::type>(paramTokens,
4301
                                                                                    strings);
4302
        return CallCapture(EntryPoint::GLPatchParameteriEXT, std::move(params));
4303
    }
4304
    if (strcmp(nameToken, "glPauseTransformFeedback") == 0)
4305
    {
4306
        ParamBuffer params =
4307
            ParseParameters<std::remove_pointer<PFNGLPAUSETRANSFORMFEEDBACKPROC>::type>(paramTokens,
4308
                                                                                        strings);
4309
        return CallCapture(EntryPoint::GLPauseTransformFeedback, std::move(params));
4310
    }
4311
    if (strcmp(nameToken, "glPixelLocalStorageBarrierANGLE") == 0)
4312
    {
4313
        ParamBuffer params =
4314
            ParseParameters<std::remove_pointer<PFNGLPIXELLOCALSTORAGEBARRIERANGLEPROC>::type>(
4315
                paramTokens, strings);
4316
        return CallCapture(EntryPoint::GLPixelLocalStorageBarrierANGLE, std::move(params));
4317
    }
4318
    if (strcmp(nameToken, "glPixelStorei") == 0)
4319
    {
4320
        ParamBuffer params =
4321
            ParseParameters<std::remove_pointer<PFNGLPIXELSTOREIPROC>::type>(paramTokens, strings);
4322
        return CallCapture(EntryPoint::GLPixelStorei, std::move(params));
4323
    }
4324
    if (strcmp(nameToken, "glPointParameterf") == 0)
4325
    {
4326
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFPROC>::type>(
4327
            paramTokens, strings);
4328
        return CallCapture(EntryPoint::GLPointParameterf, std::move(params));
4329
    }
4330
    if (strcmp(nameToken, "glPointParameterfv") == 0)
4331
    {
4332
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERFVPROC>::type>(
4333
            paramTokens, strings);
4334
        return CallCapture(EntryPoint::GLPointParameterfv, std::move(params));
4335
    }
4336
    if (strcmp(nameToken, "glPointParameterx") == 0)
4337
    {
4338
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXPROC>::type>(
4339
            paramTokens, strings);
4340
        return CallCapture(EntryPoint::GLPointParameterx, std::move(params));
4341
    }
4342
    if (strcmp(nameToken, "glPointParameterxv") == 0)
4343
    {
4344
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOINTPARAMETERXVPROC>::type>(
4345
            paramTokens, strings);
4346
        return CallCapture(EntryPoint::GLPointParameterxv, std::move(params));
4347
    }
4348
    if (strcmp(nameToken, "glPointSize") == 0)
4349
    {
4350
        ParamBuffer params =
4351
            ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPROC>::type>(paramTokens, strings);
4352
        return CallCapture(EntryPoint::GLPointSize, std::move(params));
4353
    }
4354
    if (strcmp(nameToken, "glPointSizePointerOES") == 0)
4355
    {
4356
        ParamBuffer params =
4357
            ParseParameters<std::remove_pointer<PFNGLPOINTSIZEPOINTEROESPROC>::type>(paramTokens,
4358
                                                                                     strings);
4359
        return CallCapture(EntryPoint::GLPointSizePointerOES, std::move(params));
4360
    }
4361
    if (strcmp(nameToken, "glPointSizex") == 0)
4362
    {
4363
        ParamBuffer params =
4364
            ParseParameters<std::remove_pointer<PFNGLPOINTSIZEXPROC>::type>(paramTokens, strings);
4365
        return CallCapture(EntryPoint::GLPointSizex, std::move(params));
4366
    }
4367
    if (strcmp(nameToken, "glPolygonModeANGLE") == 0)
4368
    {
4369
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODEANGLEPROC>::type>(
4370
            paramTokens, strings);
4371
        return CallCapture(EntryPoint::GLPolygonModeANGLE, std::move(params));
4372
    }
4373
    if (strcmp(nameToken, "glPolygonModeNV") == 0)
4374
    {
4375
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONMODENVPROC>::type>(
4376
            paramTokens, strings);
4377
        return CallCapture(EntryPoint::GLPolygonModeNV, std::move(params));
4378
    }
4379
    if (strcmp(nameToken, "glPolygonOffset") == 0)
4380
    {
4381
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETPROC>::type>(
4382
            paramTokens, strings);
4383
        return CallCapture(EntryPoint::GLPolygonOffset, std::move(params));
4384
    }
4385
    if (strcmp(nameToken, "glPolygonOffsetClampEXT") == 0)
4386
    {
4387
        ParamBuffer params =
4388
            ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETCLAMPEXTPROC>::type>(paramTokens,
4389
                                                                                       strings);
4390
        return CallCapture(EntryPoint::GLPolygonOffsetClampEXT, std::move(params));
4391
    }
4392
    if (strcmp(nameToken, "glPolygonOffsetx") == 0)
4393
    {
4394
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOLYGONOFFSETXPROC>::type>(
4395
            paramTokens, strings);
4396
        return CallCapture(EntryPoint::GLPolygonOffsetx, std::move(params));
4397
    }
4398
    if (strcmp(nameToken, "glPopDebugGroup") == 0)
4399
    {
4400
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPPROC>::type>(
4401
            paramTokens, strings);
4402
        return CallCapture(EntryPoint::GLPopDebugGroup, std::move(params));
4403
    }
4404
    if (strcmp(nameToken, "glPopDebugGroupKHR") == 0)
4405
    {
4406
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPDEBUGGROUPKHRPROC>::type>(
4407
            paramTokens, strings);
4408
        return CallCapture(EntryPoint::GLPopDebugGroupKHR, std::move(params));
4409
    }
4410
    if (strcmp(nameToken, "glPopGroupMarkerEXT") == 0)
4411
    {
4412
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPOPGROUPMARKEREXTPROC>::type>(
4413
            paramTokens, strings);
4414
        return CallCapture(EntryPoint::GLPopGroupMarkerEXT, std::move(params));
4415
    }
4416
    if (strcmp(nameToken, "glPopMatrix") == 0)
4417
    {
4418
        ParamBuffer params =
4419
            ParseParameters<std::remove_pointer<PFNGLPOPMATRIXPROC>::type>(paramTokens, strings);
4420
        return CallCapture(EntryPoint::GLPopMatrix, std::move(params));
4421
    }
4422
    if (strcmp(nameToken, "glPrimitiveBoundingBox") == 0)
4423
    {
4424
        ParamBuffer params =
4425
            ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXPROC>::type>(paramTokens,
4426
                                                                                      strings);
4427
        return CallCapture(EntryPoint::GLPrimitiveBoundingBox, std::move(params));
4428
    }
4429
    if (strcmp(nameToken, "glPrimitiveBoundingBoxEXT") == 0)
4430
    {
4431
        ParamBuffer params =
4432
            ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXEXTPROC>::type>(
4433
                paramTokens, strings);
4434
        return CallCapture(EntryPoint::GLPrimitiveBoundingBoxEXT, std::move(params));
4435
    }
4436
    if (strcmp(nameToken, "glPrimitiveBoundingBoxOES") == 0)
4437
    {
4438
        ParamBuffer params =
4439
            ParseParameters<std::remove_pointer<PFNGLPRIMITIVEBOUNDINGBOXOESPROC>::type>(
4440
                paramTokens, strings);
4441
        return CallCapture(EntryPoint::GLPrimitiveBoundingBoxOES, std::move(params));
4442
    }
4443
    if (strcmp(nameToken, "glProgramBinary") == 0)
4444
    {
4445
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYPROC>::type>(
4446
            paramTokens, strings);
4447
        return CallCapture(EntryPoint::GLProgramBinary, std::move(params));
4448
    }
4449
    if (strcmp(nameToken, "glProgramBinaryOES") == 0)
4450
    {
4451
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMBINARYOESPROC>::type>(
4452
            paramTokens, strings);
4453
        return CallCapture(EntryPoint::GLProgramBinaryOES, std::move(params));
4454
    }
4455
    if (strcmp(nameToken, "glProgramParameteri") == 0)
4456
    {
4457
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIPROC>::type>(
4458
            paramTokens, strings);
4459
        return CallCapture(EntryPoint::GLProgramParameteri, std::move(params));
4460
    }
4461
    if (strcmp(nameToken, "glProgramParameteriEXT") == 0)
4462
    {
4463
        ParamBuffer params =
4464
            ParseParameters<std::remove_pointer<PFNGLPROGRAMPARAMETERIEXTPROC>::type>(paramTokens,
4465
                                                                                      strings);
4466
        return CallCapture(EntryPoint::GLProgramParameteriEXT, std::move(params));
4467
    }
4468
    if (strcmp(nameToken, "glProgramUniform1f") == 0)
4469
    {
4470
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FPROC>::type>(
4471
            paramTokens, strings);
4472
        return CallCapture(EntryPoint::GLProgramUniform1f, std::move(params));
4473
    }
4474
    if (strcmp(nameToken, "glProgramUniform1fEXT") == 0)
4475
    {
4476
        ParamBuffer params =
4477
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FEXTPROC>::type>(paramTokens,
4478
                                                                                     strings);
4479
        return CallCapture(EntryPoint::GLProgramUniform1fEXT, std::move(params));
4480
    }
4481
    if (strcmp(nameToken, "glProgramUniform1fv") == 0)
4482
    {
4483
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVPROC>::type>(
4484
            paramTokens, strings);
4485
        return CallCapture(EntryPoint::GLProgramUniform1fv, std::move(params));
4486
    }
4487
    if (strcmp(nameToken, "glProgramUniform1fvEXT") == 0)
4488
    {
4489
        ParamBuffer params =
4490
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1FVEXTPROC>::type>(paramTokens,
4491
                                                                                      strings);
4492
        return CallCapture(EntryPoint::GLProgramUniform1fvEXT, std::move(params));
4493
    }
4494
    if (strcmp(nameToken, "glProgramUniform1i") == 0)
4495
    {
4496
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IPROC>::type>(
4497
            paramTokens, strings);
4498
        return CallCapture(EntryPoint::GLProgramUniform1i, std::move(params));
4499
    }
4500
    if (strcmp(nameToken, "glProgramUniform1iEXT") == 0)
4501
    {
4502
        ParamBuffer params =
4503
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IEXTPROC>::type>(paramTokens,
4504
                                                                                     strings);
4505
        return CallCapture(EntryPoint::GLProgramUniform1iEXT, std::move(params));
4506
    }
4507
    if (strcmp(nameToken, "glProgramUniform1iv") == 0)
4508
    {
4509
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVPROC>::type>(
4510
            paramTokens, strings);
4511
        return CallCapture(EntryPoint::GLProgramUniform1iv, std::move(params));
4512
    }
4513
    if (strcmp(nameToken, "glProgramUniform1ivEXT") == 0)
4514
    {
4515
        ParamBuffer params =
4516
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1IVEXTPROC>::type>(paramTokens,
4517
                                                                                      strings);
4518
        return CallCapture(EntryPoint::GLProgramUniform1ivEXT, std::move(params));
4519
    }
4520
    if (strcmp(nameToken, "glProgramUniform1ui") == 0)
4521
    {
4522
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIPROC>::type>(
4523
            paramTokens, strings);
4524
        return CallCapture(EntryPoint::GLProgramUniform1ui, std::move(params));
4525
    }
4526
    if (strcmp(nameToken, "glProgramUniform1uiEXT") == 0)
4527
    {
4528
        ParamBuffer params =
4529
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIEXTPROC>::type>(paramTokens,
4530
                                                                                      strings);
4531
        return CallCapture(EntryPoint::GLProgramUniform1uiEXT, std::move(params));
4532
    }
4533
    if (strcmp(nameToken, "glProgramUniform1uiv") == 0)
4534
    {
4535
        ParamBuffer params =
4536
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVPROC>::type>(paramTokens,
4537
                                                                                    strings);
4538
        return CallCapture(EntryPoint::GLProgramUniform1uiv, std::move(params));
4539
    }
4540
    if (strcmp(nameToken, "glProgramUniform1uivEXT") == 0)
4541
    {
4542
        ParamBuffer params =
4543
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM1UIVEXTPROC>::type>(paramTokens,
4544
                                                                                       strings);
4545
        return CallCapture(EntryPoint::GLProgramUniform1uivEXT, std::move(params));
4546
    }
4547
    if (strcmp(nameToken, "glProgramUniform2f") == 0)
4548
    {
4549
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FPROC>::type>(
4550
            paramTokens, strings);
4551
        return CallCapture(EntryPoint::GLProgramUniform2f, std::move(params));
4552
    }
4553
    if (strcmp(nameToken, "glProgramUniform2fEXT") == 0)
4554
    {
4555
        ParamBuffer params =
4556
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FEXTPROC>::type>(paramTokens,
4557
                                                                                     strings);
4558
        return CallCapture(EntryPoint::GLProgramUniform2fEXT, std::move(params));
4559
    }
4560
    if (strcmp(nameToken, "glProgramUniform2fv") == 0)
4561
    {
4562
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVPROC>::type>(
4563
            paramTokens, strings);
4564
        return CallCapture(EntryPoint::GLProgramUniform2fv, std::move(params));
4565
    }
4566
    if (strcmp(nameToken, "glProgramUniform2fvEXT") == 0)
4567
    {
4568
        ParamBuffer params =
4569
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2FVEXTPROC>::type>(paramTokens,
4570
                                                                                      strings);
4571
        return CallCapture(EntryPoint::GLProgramUniform2fvEXT, std::move(params));
4572
    }
4573
    if (strcmp(nameToken, "glProgramUniform2i") == 0)
4574
    {
4575
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IPROC>::type>(
4576
            paramTokens, strings);
4577
        return CallCapture(EntryPoint::GLProgramUniform2i, std::move(params));
4578
    }
4579
    if (strcmp(nameToken, "glProgramUniform2iEXT") == 0)
4580
    {
4581
        ParamBuffer params =
4582
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IEXTPROC>::type>(paramTokens,
4583
                                                                                     strings);
4584
        return CallCapture(EntryPoint::GLProgramUniform2iEXT, std::move(params));
4585
    }
4586
    if (strcmp(nameToken, "glProgramUniform2iv") == 0)
4587
    {
4588
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVPROC>::type>(
4589
            paramTokens, strings);
4590
        return CallCapture(EntryPoint::GLProgramUniform2iv, std::move(params));
4591
    }
4592
    if (strcmp(nameToken, "glProgramUniform2ivEXT") == 0)
4593
    {
4594
        ParamBuffer params =
4595
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2IVEXTPROC>::type>(paramTokens,
4596
                                                                                      strings);
4597
        return CallCapture(EntryPoint::GLProgramUniform2ivEXT, std::move(params));
4598
    }
4599
    if (strcmp(nameToken, "glProgramUniform2ui") == 0)
4600
    {
4601
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIPROC>::type>(
4602
            paramTokens, strings);
4603
        return CallCapture(EntryPoint::GLProgramUniform2ui, std::move(params));
4604
    }
4605
    if (strcmp(nameToken, "glProgramUniform2uiEXT") == 0)
4606
    {
4607
        ParamBuffer params =
4608
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIEXTPROC>::type>(paramTokens,
4609
                                                                                      strings);
4610
        return CallCapture(EntryPoint::GLProgramUniform2uiEXT, std::move(params));
4611
    }
4612
    if (strcmp(nameToken, "glProgramUniform2uiv") == 0)
4613
    {
4614
        ParamBuffer params =
4615
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVPROC>::type>(paramTokens,
4616
                                                                                    strings);
4617
        return CallCapture(EntryPoint::GLProgramUniform2uiv, std::move(params));
4618
    }
4619
    if (strcmp(nameToken, "glProgramUniform2uivEXT") == 0)
4620
    {
4621
        ParamBuffer params =
4622
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM2UIVEXTPROC>::type>(paramTokens,
4623
                                                                                       strings);
4624
        return CallCapture(EntryPoint::GLProgramUniform2uivEXT, std::move(params));
4625
    }
4626
    if (strcmp(nameToken, "glProgramUniform3f") == 0)
4627
    {
4628
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FPROC>::type>(
4629
            paramTokens, strings);
4630
        return CallCapture(EntryPoint::GLProgramUniform3f, std::move(params));
4631
    }
4632
    if (strcmp(nameToken, "glProgramUniform3fEXT") == 0)
4633
    {
4634
        ParamBuffer params =
4635
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FEXTPROC>::type>(paramTokens,
4636
                                                                                     strings);
4637
        return CallCapture(EntryPoint::GLProgramUniform3fEXT, std::move(params));
4638
    }
4639
    if (strcmp(nameToken, "glProgramUniform3fv") == 0)
4640
    {
4641
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVPROC>::type>(
4642
            paramTokens, strings);
4643
        return CallCapture(EntryPoint::GLProgramUniform3fv, std::move(params));
4644
    }
4645
    if (strcmp(nameToken, "glProgramUniform3fvEXT") == 0)
4646
    {
4647
        ParamBuffer params =
4648
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3FVEXTPROC>::type>(paramTokens,
4649
                                                                                      strings);
4650
        return CallCapture(EntryPoint::GLProgramUniform3fvEXT, std::move(params));
4651
    }
4652
    if (strcmp(nameToken, "glProgramUniform3i") == 0)
4653
    {
4654
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IPROC>::type>(
4655
            paramTokens, strings);
4656
        return CallCapture(EntryPoint::GLProgramUniform3i, std::move(params));
4657
    }
4658
    if (strcmp(nameToken, "glProgramUniform3iEXT") == 0)
4659
    {
4660
        ParamBuffer params =
4661
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IEXTPROC>::type>(paramTokens,
4662
                                                                                     strings);
4663
        return CallCapture(EntryPoint::GLProgramUniform3iEXT, std::move(params));
4664
    }
4665
    if (strcmp(nameToken, "glProgramUniform3iv") == 0)
4666
    {
4667
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVPROC>::type>(
4668
            paramTokens, strings);
4669
        return CallCapture(EntryPoint::GLProgramUniform3iv, std::move(params));
4670
    }
4671
    if (strcmp(nameToken, "glProgramUniform3ivEXT") == 0)
4672
    {
4673
        ParamBuffer params =
4674
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3IVEXTPROC>::type>(paramTokens,
4675
                                                                                      strings);
4676
        return CallCapture(EntryPoint::GLProgramUniform3ivEXT, std::move(params));
4677
    }
4678
    if (strcmp(nameToken, "glProgramUniform3ui") == 0)
4679
    {
4680
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIPROC>::type>(
4681
            paramTokens, strings);
4682
        return CallCapture(EntryPoint::GLProgramUniform3ui, std::move(params));
4683
    }
4684
    if (strcmp(nameToken, "glProgramUniform3uiEXT") == 0)
4685
    {
4686
        ParamBuffer params =
4687
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIEXTPROC>::type>(paramTokens,
4688
                                                                                      strings);
4689
        return CallCapture(EntryPoint::GLProgramUniform3uiEXT, std::move(params));
4690
    }
4691
    if (strcmp(nameToken, "glProgramUniform3uiv") == 0)
4692
    {
4693
        ParamBuffer params =
4694
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVPROC>::type>(paramTokens,
4695
                                                                                    strings);
4696
        return CallCapture(EntryPoint::GLProgramUniform3uiv, std::move(params));
4697
    }
4698
    if (strcmp(nameToken, "glProgramUniform3uivEXT") == 0)
4699
    {
4700
        ParamBuffer params =
4701
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM3UIVEXTPROC>::type>(paramTokens,
4702
                                                                                       strings);
4703
        return CallCapture(EntryPoint::GLProgramUniform3uivEXT, std::move(params));
4704
    }
4705
    if (strcmp(nameToken, "glProgramUniform4f") == 0)
4706
    {
4707
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FPROC>::type>(
4708
            paramTokens, strings);
4709
        return CallCapture(EntryPoint::GLProgramUniform4f, std::move(params));
4710
    }
4711
    if (strcmp(nameToken, "glProgramUniform4fEXT") == 0)
4712
    {
4713
        ParamBuffer params =
4714
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FEXTPROC>::type>(paramTokens,
4715
                                                                                     strings);
4716
        return CallCapture(EntryPoint::GLProgramUniform4fEXT, std::move(params));
4717
    }
4718
    if (strcmp(nameToken, "glProgramUniform4fv") == 0)
4719
    {
4720
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVPROC>::type>(
4721
            paramTokens, strings);
4722
        return CallCapture(EntryPoint::GLProgramUniform4fv, std::move(params));
4723
    }
4724
    if (strcmp(nameToken, "glProgramUniform4fvEXT") == 0)
4725
    {
4726
        ParamBuffer params =
4727
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4FVEXTPROC>::type>(paramTokens,
4728
                                                                                      strings);
4729
        return CallCapture(EntryPoint::GLProgramUniform4fvEXT, std::move(params));
4730
    }
4731
    if (strcmp(nameToken, "glProgramUniform4i") == 0)
4732
    {
4733
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IPROC>::type>(
4734
            paramTokens, strings);
4735
        return CallCapture(EntryPoint::GLProgramUniform4i, std::move(params));
4736
    }
4737
    if (strcmp(nameToken, "glProgramUniform4iEXT") == 0)
4738
    {
4739
        ParamBuffer params =
4740
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IEXTPROC>::type>(paramTokens,
4741
                                                                                     strings);
4742
        return CallCapture(EntryPoint::GLProgramUniform4iEXT, std::move(params));
4743
    }
4744
    if (strcmp(nameToken, "glProgramUniform4iv") == 0)
4745
    {
4746
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVPROC>::type>(
4747
            paramTokens, strings);
4748
        return CallCapture(EntryPoint::GLProgramUniform4iv, std::move(params));
4749
    }
4750
    if (strcmp(nameToken, "glProgramUniform4ivEXT") == 0)
4751
    {
4752
        ParamBuffer params =
4753
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4IVEXTPROC>::type>(paramTokens,
4754
                                                                                      strings);
4755
        return CallCapture(EntryPoint::GLProgramUniform4ivEXT, std::move(params));
4756
    }
4757
    if (strcmp(nameToken, "glProgramUniform4ui") == 0)
4758
    {
4759
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIPROC>::type>(
4760
            paramTokens, strings);
4761
        return CallCapture(EntryPoint::GLProgramUniform4ui, std::move(params));
4762
    }
4763
    if (strcmp(nameToken, "glProgramUniform4uiEXT") == 0)
4764
    {
4765
        ParamBuffer params =
4766
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIEXTPROC>::type>(paramTokens,
4767
                                                                                      strings);
4768
        return CallCapture(EntryPoint::GLProgramUniform4uiEXT, std::move(params));
4769
    }
4770
    if (strcmp(nameToken, "glProgramUniform4uiv") == 0)
4771
    {
4772
        ParamBuffer params =
4773
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVPROC>::type>(paramTokens,
4774
                                                                                    strings);
4775
        return CallCapture(EntryPoint::GLProgramUniform4uiv, std::move(params));
4776
    }
4777
    if (strcmp(nameToken, "glProgramUniform4uivEXT") == 0)
4778
    {
4779
        ParamBuffer params =
4780
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORM4UIVEXTPROC>::type>(paramTokens,
4781
                                                                                       strings);
4782
        return CallCapture(EntryPoint::GLProgramUniform4uivEXT, std::move(params));
4783
    }
4784
    if (strcmp(nameToken, "glProgramUniformMatrix2fv") == 0)
4785
    {
4786
        ParamBuffer params =
4787
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVPROC>::type>(
4788
                paramTokens, strings);
4789
        return CallCapture(EntryPoint::GLProgramUniformMatrix2fv, std::move(params));
4790
    }
4791
    if (strcmp(nameToken, "glProgramUniformMatrix2fvEXT") == 0)
4792
    {
4793
        ParamBuffer params =
4794
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC>::type>(
4795
                paramTokens, strings);
4796
        return CallCapture(EntryPoint::GLProgramUniformMatrix2fvEXT, std::move(params));
4797
    }
4798
    if (strcmp(nameToken, "glProgramUniformMatrix2x3fv") == 0)
4799
    {
4800
        ParamBuffer params =
4801
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVPROC>::type>(
4802
                paramTokens, strings);
4803
        return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fv, std::move(params));
4804
    }
4805
    if (strcmp(nameToken, "glProgramUniformMatrix2x3fvEXT") == 0)
4806
    {
4807
        ParamBuffer params =
4808
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC>::type>(
4809
                paramTokens, strings);
4810
        return CallCapture(EntryPoint::GLProgramUniformMatrix2x3fvEXT, std::move(params));
4811
    }
4812
    if (strcmp(nameToken, "glProgramUniformMatrix2x4fv") == 0)
4813
    {
4814
        ParamBuffer params =
4815
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVPROC>::type>(
4816
                paramTokens, strings);
4817
        return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fv, std::move(params));
4818
    }
4819
    if (strcmp(nameToken, "glProgramUniformMatrix2x4fvEXT") == 0)
4820
    {
4821
        ParamBuffer params =
4822
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC>::type>(
4823
                paramTokens, strings);
4824
        return CallCapture(EntryPoint::GLProgramUniformMatrix2x4fvEXT, std::move(params));
4825
    }
4826
    if (strcmp(nameToken, "glProgramUniformMatrix3fv") == 0)
4827
    {
4828
        ParamBuffer params =
4829
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVPROC>::type>(
4830
                paramTokens, strings);
4831
        return CallCapture(EntryPoint::GLProgramUniformMatrix3fv, std::move(params));
4832
    }
4833
    if (strcmp(nameToken, "glProgramUniformMatrix3fvEXT") == 0)
4834
    {
4835
        ParamBuffer params =
4836
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC>::type>(
4837
                paramTokens, strings);
4838
        return CallCapture(EntryPoint::GLProgramUniformMatrix3fvEXT, std::move(params));
4839
    }
4840
    if (strcmp(nameToken, "glProgramUniformMatrix3x2fv") == 0)
4841
    {
4842
        ParamBuffer params =
4843
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVPROC>::type>(
4844
                paramTokens, strings);
4845
        return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fv, std::move(params));
4846
    }
4847
    if (strcmp(nameToken, "glProgramUniformMatrix3x2fvEXT") == 0)
4848
    {
4849
        ParamBuffer params =
4850
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC>::type>(
4851
                paramTokens, strings);
4852
        return CallCapture(EntryPoint::GLProgramUniformMatrix3x2fvEXT, std::move(params));
4853
    }
4854
    if (strcmp(nameToken, "glProgramUniformMatrix3x4fv") == 0)
4855
    {
4856
        ParamBuffer params =
4857
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVPROC>::type>(
4858
                paramTokens, strings);
4859
        return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fv, std::move(params));
4860
    }
4861
    if (strcmp(nameToken, "glProgramUniformMatrix3x4fvEXT") == 0)
4862
    {
4863
        ParamBuffer params =
4864
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC>::type>(
4865
                paramTokens, strings);
4866
        return CallCapture(EntryPoint::GLProgramUniformMatrix3x4fvEXT, std::move(params));
4867
    }
4868
    if (strcmp(nameToken, "glProgramUniformMatrix4fv") == 0)
4869
    {
4870
        ParamBuffer params =
4871
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVPROC>::type>(
4872
                paramTokens, strings);
4873
        return CallCapture(EntryPoint::GLProgramUniformMatrix4fv, std::move(params));
4874
    }
4875
    if (strcmp(nameToken, "glProgramUniformMatrix4fvEXT") == 0)
4876
    {
4877
        ParamBuffer params =
4878
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC>::type>(
4879
                paramTokens, strings);
4880
        return CallCapture(EntryPoint::GLProgramUniformMatrix4fvEXT, std::move(params));
4881
    }
4882
    if (strcmp(nameToken, "glProgramUniformMatrix4x2fv") == 0)
4883
    {
4884
        ParamBuffer params =
4885
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVPROC>::type>(
4886
                paramTokens, strings);
4887
        return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fv, std::move(params));
4888
    }
4889
    if (strcmp(nameToken, "glProgramUniformMatrix4x2fvEXT") == 0)
4890
    {
4891
        ParamBuffer params =
4892
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC>::type>(
4893
                paramTokens, strings);
4894
        return CallCapture(EntryPoint::GLProgramUniformMatrix4x2fvEXT, std::move(params));
4895
    }
4896
    if (strcmp(nameToken, "glProgramUniformMatrix4x3fv") == 0)
4897
    {
4898
        ParamBuffer params =
4899
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVPROC>::type>(
4900
                paramTokens, strings);
4901
        return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fv, std::move(params));
4902
    }
4903
    if (strcmp(nameToken, "glProgramUniformMatrix4x3fvEXT") == 0)
4904
    {
4905
        ParamBuffer params =
4906
            ParseParameters<std::remove_pointer<PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC>::type>(
4907
                paramTokens, strings);
4908
        return CallCapture(EntryPoint::GLProgramUniformMatrix4x3fvEXT, std::move(params));
4909
    }
4910
    if (strcmp(nameToken, "glProvokingVertexANGLE") == 0)
4911
    {
4912
        ParamBuffer params =
4913
            ParseParameters<std::remove_pointer<PFNGLPROVOKINGVERTEXANGLEPROC>::type>(paramTokens,
4914
                                                                                      strings);
4915
        return CallCapture(EntryPoint::GLProvokingVertexANGLE, std::move(params));
4916
    }
4917
    if (strcmp(nameToken, "glPushDebugGroup") == 0)
4918
    {
4919
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPPROC>::type>(
4920
            paramTokens, strings);
4921
        return CallCapture(EntryPoint::GLPushDebugGroup, std::move(params));
4922
    }
4923
    if (strcmp(nameToken, "glPushDebugGroupKHR") == 0)
4924
    {
4925
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLPUSHDEBUGGROUPKHRPROC>::type>(
4926
            paramTokens, strings);
4927
        return CallCapture(EntryPoint::GLPushDebugGroupKHR, std::move(params));
4928
    }
4929
    if (strcmp(nameToken, "glPushGroupMarkerEXT") == 0)
4930
    {
4931
        ParamBuffer params =
4932
            ParseParameters<std::remove_pointer<PFNGLPUSHGROUPMARKEREXTPROC>::type>(paramTokens,
4933
                                                                                    strings);
4934
        return CallCapture(EntryPoint::GLPushGroupMarkerEXT, std::move(params));
4935
    }
4936
    if (strcmp(nameToken, "glPushMatrix") == 0)
4937
    {
4938
        ParamBuffer params =
4939
            ParseParameters<std::remove_pointer<PFNGLPUSHMATRIXPROC>::type>(paramTokens, strings);
4940
        return CallCapture(EntryPoint::GLPushMatrix, std::move(params));
4941
    }
4942
    if (strcmp(nameToken, "glQueryCounterEXT") == 0)
4943
    {
4944
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYCOUNTEREXTPROC>::type>(
4945
            paramTokens, strings);
4946
        return CallCapture(EntryPoint::GLQueryCounterEXT, std::move(params));
4947
    }
4948
    if (strcmp(nameToken, "glQueryMatrixxOES") == 0)
4949
    {
4950
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLQUERYMATRIXXOESPROC>::type>(
4951
            paramTokens, strings);
4952
        return CallCapture(EntryPoint::GLQueryMatrixxOES, std::move(params));
4953
    }
4954
    if (strcmp(nameToken, "glReadBuffer") == 0)
4955
    {
4956
        ParamBuffer params =
4957
            ParseParameters<std::remove_pointer<PFNGLREADBUFFERPROC>::type>(paramTokens, strings);
4958
        return CallCapture(EntryPoint::GLReadBuffer, std::move(params));
4959
    }
4960
    if (strcmp(nameToken, "glReadPixels") == 0)
4961
    {
4962
        ParamBuffer params =
4963
            ParseParameters<std::remove_pointer<PFNGLREADPIXELSPROC>::type>(paramTokens, strings);
4964
        return CallCapture(EntryPoint::GLReadPixels, std::move(params));
4965
    }
4966
    if (strcmp(nameToken, "glReadPixelsRobustANGLE") == 0)
4967
    {
4968
        ParamBuffer params =
4969
            ParseParameters<std::remove_pointer<PFNGLREADPIXELSROBUSTANGLEPROC>::type>(paramTokens,
4970
                                                                                       strings);
4971
        return CallCapture(EntryPoint::GLReadPixelsRobustANGLE, std::move(params));
4972
    }
4973
    if (strcmp(nameToken, "glReadnPixels") == 0)
4974
    {
4975
        ParamBuffer params =
4976
            ParseParameters<std::remove_pointer<PFNGLREADNPIXELSPROC>::type>(paramTokens, strings);
4977
        return CallCapture(EntryPoint::GLReadnPixels, std::move(params));
4978
    }
4979
    if (strcmp(nameToken, "glReadnPixelsEXT") == 0)
4980
    {
4981
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLREADNPIXELSEXTPROC>::type>(
4982
            paramTokens, strings);
4983
        return CallCapture(EntryPoint::GLReadnPixelsEXT, std::move(params));
4984
    }
4985
    if (strcmp(nameToken, "glReadnPixelsRobustANGLE") == 0)
4986
    {
4987
        ParamBuffer params =
4988
            ParseParameters<std::remove_pointer<PFNGLREADNPIXELSROBUSTANGLEPROC>::type>(paramTokens,
4989
                                                                                        strings);
4990
        return CallCapture(EntryPoint::GLReadnPixelsRobustANGLE, std::move(params));
4991
    }
4992
    if (strcmp(nameToken, "glReleaseShaderCompiler") == 0)
4993
    {
4994
        ParamBuffer params =
4995
            ParseParameters<std::remove_pointer<PFNGLRELEASESHADERCOMPILERPROC>::type>(paramTokens,
4996
                                                                                       strings);
4997
        return CallCapture(EntryPoint::GLReleaseShaderCompiler, std::move(params));
4998
    }
4999
    if (strcmp(nameToken, "glReleaseTexturesANGLE") == 0)
5000
    {
5001
        ParamBuffer params =
5002
            ParseParameters<std::remove_pointer<PFNGLRELEASETEXTURESANGLEPROC>::type>(paramTokens,
5003
                                                                                      strings);
5004
        return CallCapture(EntryPoint::GLReleaseTexturesANGLE, std::move(params));
5005
    }
5006
    if (strcmp(nameToken, "glRenderbufferStorage") == 0)
5007
    {
5008
        ParamBuffer params =
5009
            ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEPROC>::type>(paramTokens,
5010
                                                                                     strings);
5011
        return CallCapture(EntryPoint::GLRenderbufferStorage, std::move(params));
5012
    }
5013
    if (strcmp(nameToken, "glRenderbufferStorageMultisample") == 0)
5014
    {
5015
        ParamBuffer params =
5016
            ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC>::type>(
5017
                paramTokens, strings);
5018
        return CallCapture(EntryPoint::GLRenderbufferStorageMultisample, std::move(params));
5019
    }
5020
    if (strcmp(nameToken, "glRenderbufferStorageMultisampleANGLE") == 0)
5021
    {
5022
        ParamBuffer params = ParseParameters<
5023
            std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEANGLEPROC>::type>(paramTokens,
5024
                                                                                     strings);
5025
        return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleANGLE, std::move(params));
5026
    }
5027
    if (strcmp(nameToken, "glRenderbufferStorageMultisampleEXT") == 0)
5028
    {
5029
        ParamBuffer params =
5030
            ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC>::type>(
5031
                paramTokens, strings);
5032
        return CallCapture(EntryPoint::GLRenderbufferStorageMultisampleEXT, std::move(params));
5033
    }
5034
    if (strcmp(nameToken, "glRenderbufferStorageOES") == 0)
5035
    {
5036
        ParamBuffer params =
5037
            ParseParameters<std::remove_pointer<PFNGLRENDERBUFFERSTORAGEOESPROC>::type>(paramTokens,
5038
                                                                                        strings);
5039
        return CallCapture(EntryPoint::GLRenderbufferStorageOES, std::move(params));
5040
    }
5041
    if (strcmp(nameToken, "glRequestExtensionANGLE") == 0)
5042
    {
5043
        ParamBuffer params =
5044
            ParseParameters<std::remove_pointer<PFNGLREQUESTEXTENSIONANGLEPROC>::type>(paramTokens,
5045
                                                                                       strings);
5046
        return CallCapture(EntryPoint::GLRequestExtensionANGLE, std::move(params));
5047
    }
5048
    if (strcmp(nameToken, "glResumeTransformFeedback") == 0)
5049
    {
5050
        ParamBuffer params =
5051
            ParseParameters<std::remove_pointer<PFNGLRESUMETRANSFORMFEEDBACKPROC>::type>(
5052
                paramTokens, strings);
5053
        return CallCapture(EntryPoint::GLResumeTransformFeedback, std::move(params));
5054
    }
5055
    if (strcmp(nameToken, "glRotatef") == 0)
5056
    {
5057
        ParamBuffer params =
5058
            ParseParameters<std::remove_pointer<PFNGLROTATEFPROC>::type>(paramTokens, strings);
5059
        return CallCapture(EntryPoint::GLRotatef, std::move(params));
5060
    }
5061
    if (strcmp(nameToken, "glRotatex") == 0)
5062
    {
5063
        ParamBuffer params =
5064
            ParseParameters<std::remove_pointer<PFNGLROTATEXPROC>::type>(paramTokens, strings);
5065
        return CallCapture(EntryPoint::GLRotatex, std::move(params));
5066
    }
5067
    if (strcmp(nameToken, "glSampleCoverage") == 0)
5068
    {
5069
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEPROC>::type>(
5070
            paramTokens, strings);
5071
        return CallCapture(EntryPoint::GLSampleCoverage, std::move(params));
5072
    }
5073
    if (strcmp(nameToken, "glSampleCoveragex") == 0)
5074
    {
5075
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLECOVERAGEXPROC>::type>(
5076
            paramTokens, strings);
5077
        return CallCapture(EntryPoint::GLSampleCoveragex, std::move(params));
5078
    }
5079
    if (strcmp(nameToken, "glSampleMaski") == 0)
5080
    {
5081
        ParamBuffer params =
5082
            ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIPROC>::type>(paramTokens, strings);
5083
        return CallCapture(EntryPoint::GLSampleMaski, std::move(params));
5084
    }
5085
    if (strcmp(nameToken, "glSampleMaskiANGLE") == 0)
5086
    {
5087
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLEMASKIANGLEPROC>::type>(
5088
            paramTokens, strings);
5089
        return CallCapture(EntryPoint::GLSampleMaskiANGLE, std::move(params));
5090
    }
5091
    if (strcmp(nameToken, "glSamplerParameterIiv") == 0)
5092
    {
5093
        ParamBuffer params =
5094
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVPROC>::type>(paramTokens,
5095
                                                                                     strings);
5096
        return CallCapture(EntryPoint::GLSamplerParameterIiv, std::move(params));
5097
    }
5098
    if (strcmp(nameToken, "glSamplerParameterIivEXT") == 0)
5099
    {
5100
        ParamBuffer params =
5101
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVEXTPROC>::type>(paramTokens,
5102
                                                                                        strings);
5103
        return CallCapture(EntryPoint::GLSamplerParameterIivEXT, std::move(params));
5104
    }
5105
    if (strcmp(nameToken, "glSamplerParameterIivOES") == 0)
5106
    {
5107
        ParamBuffer params =
5108
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVOESPROC>::type>(paramTokens,
5109
                                                                                        strings);
5110
        return CallCapture(EntryPoint::GLSamplerParameterIivOES, std::move(params));
5111
    }
5112
    if (strcmp(nameToken, "glSamplerParameterIivRobustANGLE") == 0)
5113
    {
5114
        ParamBuffer params =
5115
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIIVROBUSTANGLEPROC>::type>(
5116
                paramTokens, strings);
5117
        return CallCapture(EntryPoint::GLSamplerParameterIivRobustANGLE, std::move(params));
5118
    }
5119
    if (strcmp(nameToken, "glSamplerParameterIuiv") == 0)
5120
    {
5121
        ParamBuffer params =
5122
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVPROC>::type>(paramTokens,
5123
                                                                                      strings);
5124
        return CallCapture(EntryPoint::GLSamplerParameterIuiv, std::move(params));
5125
    }
5126
    if (strcmp(nameToken, "glSamplerParameterIuivEXT") == 0)
5127
    {
5128
        ParamBuffer params =
5129
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVEXTPROC>::type>(
5130
                paramTokens, strings);
5131
        return CallCapture(EntryPoint::GLSamplerParameterIuivEXT, std::move(params));
5132
    }
5133
    if (strcmp(nameToken, "glSamplerParameterIuivOES") == 0)
5134
    {
5135
        ParamBuffer params =
5136
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVOESPROC>::type>(
5137
                paramTokens, strings);
5138
        return CallCapture(EntryPoint::GLSamplerParameterIuivOES, std::move(params));
5139
    }
5140
    if (strcmp(nameToken, "glSamplerParameterIuivRobustANGLE") == 0)
5141
    {
5142
        ParamBuffer params =
5143
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIUIVROBUSTANGLEPROC>::type>(
5144
                paramTokens, strings);
5145
        return CallCapture(EntryPoint::GLSamplerParameterIuivRobustANGLE, std::move(params));
5146
    }
5147
    if (strcmp(nameToken, "glSamplerParameterf") == 0)
5148
    {
5149
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFPROC>::type>(
5150
            paramTokens, strings);
5151
        return CallCapture(EntryPoint::GLSamplerParameterf, std::move(params));
5152
    }
5153
    if (strcmp(nameToken, "glSamplerParameterfv") == 0)
5154
    {
5155
        ParamBuffer params =
5156
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVPROC>::type>(paramTokens,
5157
                                                                                    strings);
5158
        return CallCapture(EntryPoint::GLSamplerParameterfv, std::move(params));
5159
    }
5160
    if (strcmp(nameToken, "glSamplerParameterfvRobustANGLE") == 0)
5161
    {
5162
        ParamBuffer params =
5163
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERFVROBUSTANGLEPROC>::type>(
5164
                paramTokens, strings);
5165
        return CallCapture(EntryPoint::GLSamplerParameterfvRobustANGLE, std::move(params));
5166
    }
5167
    if (strcmp(nameToken, "glSamplerParameteri") == 0)
5168
    {
5169
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIPROC>::type>(
5170
            paramTokens, strings);
5171
        return CallCapture(EntryPoint::GLSamplerParameteri, std::move(params));
5172
    }
5173
    if (strcmp(nameToken, "glSamplerParameteriv") == 0)
5174
    {
5175
        ParamBuffer params =
5176
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVPROC>::type>(paramTokens,
5177
                                                                                    strings);
5178
        return CallCapture(EntryPoint::GLSamplerParameteriv, std::move(params));
5179
    }
5180
    if (strcmp(nameToken, "glSamplerParameterivRobustANGLE") == 0)
5181
    {
5182
        ParamBuffer params =
5183
            ParseParameters<std::remove_pointer<PFNGLSAMPLERPARAMETERIVROBUSTANGLEPROC>::type>(
5184
                paramTokens, strings);
5185
        return CallCapture(EntryPoint::GLSamplerParameterivRobustANGLE, std::move(params));
5186
    }
5187
    if (strcmp(nameToken, "glScalef") == 0)
5188
    {
5189
        ParamBuffer params =
5190
            ParseParameters<std::remove_pointer<PFNGLSCALEFPROC>::type>(paramTokens, strings);
5191
        return CallCapture(EntryPoint::GLScalef, std::move(params));
5192
    }
5193
    if (strcmp(nameToken, "glScalex") == 0)
5194
    {
5195
        ParamBuffer params =
5196
            ParseParameters<std::remove_pointer<PFNGLSCALEXPROC>::type>(paramTokens, strings);
5197
        return CallCapture(EntryPoint::GLScalex, std::move(params));
5198
    }
5199
    if (strcmp(nameToken, "glScissor") == 0)
5200
    {
5201
        ParamBuffer params =
5202
            ParseParameters<std::remove_pointer<PFNGLSCISSORPROC>::type>(paramTokens, strings);
5203
        return CallCapture(EntryPoint::GLScissor, std::move(params));
5204
    }
5205
    if (strcmp(nameToken, "glSelectPerfMonitorCountersAMD") == 0)
5206
    {
5207
        ParamBuffer params =
5208
            ParseParameters<std::remove_pointer<PFNGLSELECTPERFMONITORCOUNTERSAMDPROC>::type>(
5209
                paramTokens, strings);
5210
        return CallCapture(EntryPoint::GLSelectPerfMonitorCountersAMD, std::move(params));
5211
    }
5212
    if (strcmp(nameToken, "glSemaphoreParameterui64vEXT") == 0)
5213
    {
5214
        ParamBuffer params =
5215
            ParseParameters<std::remove_pointer<PFNGLSEMAPHOREPARAMETERUI64VEXTPROC>::type>(
5216
                paramTokens, strings);
5217
        return CallCapture(EntryPoint::GLSemaphoreParameterui64vEXT, std::move(params));
5218
    }
5219
    if (strcmp(nameToken, "glSetFenceNV") == 0)
5220
    {
5221
        ParamBuffer params =
5222
            ParseParameters<std::remove_pointer<PFNGLSETFENCENVPROC>::type>(paramTokens, strings);
5223
        return CallCapture(EntryPoint::GLSetFenceNV, std::move(params));
5224
    }
5225
    if (strcmp(nameToken, "glShadeModel") == 0)
5226
    {
5227
        ParamBuffer params =
5228
            ParseParameters<std::remove_pointer<PFNGLSHADEMODELPROC>::type>(paramTokens, strings);
5229
        return CallCapture(EntryPoint::GLShadeModel, std::move(params));
5230
    }
5231
    if (strcmp(nameToken, "glShaderBinary") == 0)
5232
    {
5233
        ParamBuffer params =
5234
            ParseParameters<std::remove_pointer<PFNGLSHADERBINARYPROC>::type>(paramTokens, strings);
5235
        return CallCapture(EntryPoint::GLShaderBinary, std::move(params));
5236
    }
5237
    if (strcmp(nameToken, "glShaderSource") == 0)
5238
    {
5239
        ParamBuffer params =
5240
            ParseParameters<std::remove_pointer<PFNGLSHADERSOURCEPROC>::type>(paramTokens, strings);
5241
        return CallCapture(EntryPoint::GLShaderSource, std::move(params));
5242
    }
5243
    if (strcmp(nameToken, "glShadingRateQCOM") == 0)
5244
    {
5245
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSHADINGRATEQCOMPROC>::type>(
5246
            paramTokens, strings);
5247
        return CallCapture(EntryPoint::GLShadingRateQCOM, std::move(params));
5248
    }
5249
    if (strcmp(nameToken, "glSignalSemaphoreEXT") == 0)
5250
    {
5251
        ParamBuffer params =
5252
            ParseParameters<std::remove_pointer<PFNGLSIGNALSEMAPHOREEXTPROC>::type>(paramTokens,
5253
                                                                                    strings);
5254
        return CallCapture(EntryPoint::GLSignalSemaphoreEXT, std::move(params));
5255
    }
5256
    if (strcmp(nameToken, "glStencilFunc") == 0)
5257
    {
5258
        ParamBuffer params =
5259
            ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCPROC>::type>(paramTokens, strings);
5260
        return CallCapture(EntryPoint::GLStencilFunc, std::move(params));
5261
    }
5262
    if (strcmp(nameToken, "glStencilFuncSeparate") == 0)
5263
    {
5264
        ParamBuffer params =
5265
            ParseParameters<std::remove_pointer<PFNGLSTENCILFUNCSEPARATEPROC>::type>(paramTokens,
5266
                                                                                     strings);
5267
        return CallCapture(EntryPoint::GLStencilFuncSeparate, std::move(params));
5268
    }
5269
    if (strcmp(nameToken, "glStencilMask") == 0)
5270
    {
5271
        ParamBuffer params =
5272
            ParseParameters<std::remove_pointer<PFNGLSTENCILMASKPROC>::type>(paramTokens, strings);
5273
        return CallCapture(EntryPoint::GLStencilMask, std::move(params));
5274
    }
5275
    if (strcmp(nameToken, "glStencilMaskSeparate") == 0)
5276
    {
5277
        ParamBuffer params =
5278
            ParseParameters<std::remove_pointer<PFNGLSTENCILMASKSEPARATEPROC>::type>(paramTokens,
5279
                                                                                     strings);
5280
        return CallCapture(EntryPoint::GLStencilMaskSeparate, std::move(params));
5281
    }
5282
    if (strcmp(nameToken, "glStencilOp") == 0)
5283
    {
5284
        ParamBuffer params =
5285
            ParseParameters<std::remove_pointer<PFNGLSTENCILOPPROC>::type>(paramTokens, strings);
5286
        return CallCapture(EntryPoint::GLStencilOp, std::move(params));
5287
    }
5288
    if (strcmp(nameToken, "glStencilOpSeparate") == 0)
5289
    {
5290
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLSTENCILOPSEPARATEPROC>::type>(
5291
            paramTokens, strings);
5292
        return CallCapture(EntryPoint::GLStencilOpSeparate, std::move(params));
5293
    }
5294
    if (strcmp(nameToken, "glTestFenceNV") == 0)
5295
    {
5296
        ParamBuffer params =
5297
            ParseParameters<std::remove_pointer<PFNGLTESTFENCENVPROC>::type>(paramTokens, strings);
5298
        return CallCapture(EntryPoint::GLTestFenceNV, std::move(params));
5299
    }
5300
    if (strcmp(nameToken, "glTexBuffer") == 0)
5301
    {
5302
        ParamBuffer params =
5303
            ParseParameters<std::remove_pointer<PFNGLTEXBUFFERPROC>::type>(paramTokens, strings);
5304
        return CallCapture(EntryPoint::GLTexBuffer, std::move(params));
5305
    }
5306
    if (strcmp(nameToken, "glTexBufferEXT") == 0)
5307
    {
5308
        ParamBuffer params =
5309
            ParseParameters<std::remove_pointer<PFNGLTEXBUFFEREXTPROC>::type>(paramTokens, strings);
5310
        return CallCapture(EntryPoint::GLTexBufferEXT, std::move(params));
5311
    }
5312
    if (strcmp(nameToken, "glTexBufferOES") == 0)
5313
    {
5314
        ParamBuffer params =
5315
            ParseParameters<std::remove_pointer<PFNGLTEXBUFFEROESPROC>::type>(paramTokens, strings);
5316
        return CallCapture(EntryPoint::GLTexBufferOES, std::move(params));
5317
    }
5318
    if (strcmp(nameToken, "glTexBufferRange") == 0)
5319
    {
5320
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEPROC>::type>(
5321
            paramTokens, strings);
5322
        return CallCapture(EntryPoint::GLTexBufferRange, std::move(params));
5323
    }
5324
    if (strcmp(nameToken, "glTexBufferRangeEXT") == 0)
5325
    {
5326
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEEXTPROC>::type>(
5327
            paramTokens, strings);
5328
        return CallCapture(EntryPoint::GLTexBufferRangeEXT, std::move(params));
5329
    }
5330
    if (strcmp(nameToken, "glTexBufferRangeOES") == 0)
5331
    {
5332
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXBUFFERRANGEOESPROC>::type>(
5333
            paramTokens, strings);
5334
        return CallCapture(EntryPoint::GLTexBufferRangeOES, std::move(params));
5335
    }
5336
    if (strcmp(nameToken, "glTexCoordPointer") == 0)
5337
    {
5338
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXCOORDPOINTERPROC>::type>(
5339
            paramTokens, strings);
5340
        return CallCapture(EntryPoint::GLTexCoordPointer, std::move(params));
5341
    }
5342
    if (strcmp(nameToken, "glTexEnvf") == 0)
5343
    {
5344
        ParamBuffer params =
5345
            ParseParameters<std::remove_pointer<PFNGLTEXENVFPROC>::type>(paramTokens, strings);
5346
        return CallCapture(EntryPoint::GLTexEnvf, std::move(params));
5347
    }
5348
    if (strcmp(nameToken, "glTexEnvfv") == 0)
5349
    {
5350
        ParamBuffer params =
5351
            ParseParameters<std::remove_pointer<PFNGLTEXENVFVPROC>::type>(paramTokens, strings);
5352
        return CallCapture(EntryPoint::GLTexEnvfv, std::move(params));
5353
    }
5354
    if (strcmp(nameToken, "glTexEnvi") == 0)
5355
    {
5356
        ParamBuffer params =
5357
            ParseParameters<std::remove_pointer<PFNGLTEXENVIPROC>::type>(paramTokens, strings);
5358
        return CallCapture(EntryPoint::GLTexEnvi, std::move(params));
5359
    }
5360
    if (strcmp(nameToken, "glTexEnviv") == 0)
5361
    {
5362
        ParamBuffer params =
5363
            ParseParameters<std::remove_pointer<PFNGLTEXENVIVPROC>::type>(paramTokens, strings);
5364
        return CallCapture(EntryPoint::GLTexEnviv, std::move(params));
5365
    }
5366
    if (strcmp(nameToken, "glTexEnvx") == 0)
5367
    {
5368
        ParamBuffer params =
5369
            ParseParameters<std::remove_pointer<PFNGLTEXENVXPROC>::type>(paramTokens, strings);
5370
        return CallCapture(EntryPoint::GLTexEnvx, std::move(params));
5371
    }
5372
    if (strcmp(nameToken, "glTexEnvxv") == 0)
5373
    {
5374
        ParamBuffer params =
5375
            ParseParameters<std::remove_pointer<PFNGLTEXENVXVPROC>::type>(paramTokens, strings);
5376
        return CallCapture(EntryPoint::GLTexEnvxv, std::move(params));
5377
    }
5378
    if (strcmp(nameToken, "glTexGenfOES") == 0)
5379
    {
5380
        ParamBuffer params =
5381
            ParseParameters<std::remove_pointer<PFNGLTEXGENFOESPROC>::type>(paramTokens, strings);
5382
        return CallCapture(EntryPoint::GLTexGenfOES, std::move(params));
5383
    }
5384
    if (strcmp(nameToken, "glTexGenfvOES") == 0)
5385
    {
5386
        ParamBuffer params =
5387
            ParseParameters<std::remove_pointer<PFNGLTEXGENFVOESPROC>::type>(paramTokens, strings);
5388
        return CallCapture(EntryPoint::GLTexGenfvOES, std::move(params));
5389
    }
5390
    if (strcmp(nameToken, "glTexGeniOES") == 0)
5391
    {
5392
        ParamBuffer params =
5393
            ParseParameters<std::remove_pointer<PFNGLTEXGENIOESPROC>::type>(paramTokens, strings);
5394
        return CallCapture(EntryPoint::GLTexGeniOES, std::move(params));
5395
    }
5396
    if (strcmp(nameToken, "glTexGenivOES") == 0)
5397
    {
5398
        ParamBuffer params =
5399
            ParseParameters<std::remove_pointer<PFNGLTEXGENIVOESPROC>::type>(paramTokens, strings);
5400
        return CallCapture(EntryPoint::GLTexGenivOES, std::move(params));
5401
    }
5402
    if (strcmp(nameToken, "glTexGenxOES") == 0)
5403
    {
5404
        ParamBuffer params =
5405
            ParseParameters<std::remove_pointer<PFNGLTEXGENXOESPROC>::type>(paramTokens, strings);
5406
        return CallCapture(EntryPoint::GLTexGenxOES, std::move(params));
5407
    }
5408
    if (strcmp(nameToken, "glTexGenxvOES") == 0)
5409
    {
5410
        ParamBuffer params =
5411
            ParseParameters<std::remove_pointer<PFNGLTEXGENXVOESPROC>::type>(paramTokens, strings);
5412
        return CallCapture(EntryPoint::GLTexGenxvOES, std::move(params));
5413
    }
5414
    if (strcmp(nameToken, "glTexImage2D") == 0)
5415
    {
5416
        ParamBuffer params =
5417
            ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DPROC>::type>(paramTokens, strings);
5418
        return CallCapture(EntryPoint::GLTexImage2D, std::move(params));
5419
    }
5420
    if (strcmp(nameToken, "glTexImage2DExternalANGLE") == 0)
5421
    {
5422
        ParamBuffer params =
5423
            ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DEXTERNALANGLEPROC>::type>(
5424
                paramTokens, strings);
5425
        return CallCapture(EntryPoint::GLTexImage2DExternalANGLE, std::move(params));
5426
    }
5427
    if (strcmp(nameToken, "glTexImage2DRobustANGLE") == 0)
5428
    {
5429
        ParamBuffer params =
5430
            ParseParameters<std::remove_pointer<PFNGLTEXIMAGE2DROBUSTANGLEPROC>::type>(paramTokens,
5431
                                                                                       strings);
5432
        return CallCapture(EntryPoint::GLTexImage2DRobustANGLE, std::move(params));
5433
    }
5434
    if (strcmp(nameToken, "glTexImage3D") == 0)
5435
    {
5436
        ParamBuffer params =
5437
            ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DPROC>::type>(paramTokens, strings);
5438
        return CallCapture(EntryPoint::GLTexImage3D, std::move(params));
5439
    }
5440
    if (strcmp(nameToken, "glTexImage3DOES") == 0)
5441
    {
5442
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DOESPROC>::type>(
5443
            paramTokens, strings);
5444
        return CallCapture(EntryPoint::GLTexImage3DOES, std::move(params));
5445
    }
5446
    if (strcmp(nameToken, "glTexImage3DRobustANGLE") == 0)
5447
    {
5448
        ParamBuffer params =
5449
            ParseParameters<std::remove_pointer<PFNGLTEXIMAGE3DROBUSTANGLEPROC>::type>(paramTokens,
5450
                                                                                       strings);
5451
        return CallCapture(EntryPoint::GLTexImage3DRobustANGLE, std::move(params));
5452
    }
5453
    if (strcmp(nameToken, "glTexParameterIiv") == 0)
5454
    {
5455
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVPROC>::type>(
5456
            paramTokens, strings);
5457
        return CallCapture(EntryPoint::GLTexParameterIiv, std::move(params));
5458
    }
5459
    if (strcmp(nameToken, "glTexParameterIivEXT") == 0)
5460
    {
5461
        ParamBuffer params =
5462
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVEXTPROC>::type>(paramTokens,
5463
                                                                                    strings);
5464
        return CallCapture(EntryPoint::GLTexParameterIivEXT, std::move(params));
5465
    }
5466
    if (strcmp(nameToken, "glTexParameterIivOES") == 0)
5467
    {
5468
        ParamBuffer params =
5469
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVOESPROC>::type>(paramTokens,
5470
                                                                                    strings);
5471
        return CallCapture(EntryPoint::GLTexParameterIivOES, std::move(params));
5472
    }
5473
    if (strcmp(nameToken, "glTexParameterIivRobustANGLE") == 0)
5474
    {
5475
        ParamBuffer params =
5476
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIIVROBUSTANGLEPROC>::type>(
5477
                paramTokens, strings);
5478
        return CallCapture(EntryPoint::GLTexParameterIivRobustANGLE, std::move(params));
5479
    }
5480
    if (strcmp(nameToken, "glTexParameterIuiv") == 0)
5481
    {
5482
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVPROC>::type>(
5483
            paramTokens, strings);
5484
        return CallCapture(EntryPoint::GLTexParameterIuiv, std::move(params));
5485
    }
5486
    if (strcmp(nameToken, "glTexParameterIuivEXT") == 0)
5487
    {
5488
        ParamBuffer params =
5489
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVEXTPROC>::type>(paramTokens,
5490
                                                                                     strings);
5491
        return CallCapture(EntryPoint::GLTexParameterIuivEXT, std::move(params));
5492
    }
5493
    if (strcmp(nameToken, "glTexParameterIuivOES") == 0)
5494
    {
5495
        ParamBuffer params =
5496
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVOESPROC>::type>(paramTokens,
5497
                                                                                     strings);
5498
        return CallCapture(EntryPoint::GLTexParameterIuivOES, std::move(params));
5499
    }
5500
    if (strcmp(nameToken, "glTexParameterIuivRobustANGLE") == 0)
5501
    {
5502
        ParamBuffer params =
5503
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIUIVROBUSTANGLEPROC>::type>(
5504
                paramTokens, strings);
5505
        return CallCapture(EntryPoint::GLTexParameterIuivRobustANGLE, std::move(params));
5506
    }
5507
    if (strcmp(nameToken, "glTexParameterf") == 0)
5508
    {
5509
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFPROC>::type>(
5510
            paramTokens, strings);
5511
        return CallCapture(EntryPoint::GLTexParameterf, std::move(params));
5512
    }
5513
    if (strcmp(nameToken, "glTexParameterfv") == 0)
5514
    {
5515
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVPROC>::type>(
5516
            paramTokens, strings);
5517
        return CallCapture(EntryPoint::GLTexParameterfv, std::move(params));
5518
    }
5519
    if (strcmp(nameToken, "glTexParameterfvRobustANGLE") == 0)
5520
    {
5521
        ParamBuffer params =
5522
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERFVROBUSTANGLEPROC>::type>(
5523
                paramTokens, strings);
5524
        return CallCapture(EntryPoint::GLTexParameterfvRobustANGLE, std::move(params));
5525
    }
5526
    if (strcmp(nameToken, "glTexParameteri") == 0)
5527
    {
5528
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIPROC>::type>(
5529
            paramTokens, strings);
5530
        return CallCapture(EntryPoint::GLTexParameteri, std::move(params));
5531
    }
5532
    if (strcmp(nameToken, "glTexParameteriv") == 0)
5533
    {
5534
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVPROC>::type>(
5535
            paramTokens, strings);
5536
        return CallCapture(EntryPoint::GLTexParameteriv, std::move(params));
5537
    }
5538
    if (strcmp(nameToken, "glTexParameterivRobustANGLE") == 0)
5539
    {
5540
        ParamBuffer params =
5541
            ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERIVROBUSTANGLEPROC>::type>(
5542
                paramTokens, strings);
5543
        return CallCapture(EntryPoint::GLTexParameterivRobustANGLE, std::move(params));
5544
    }
5545
    if (strcmp(nameToken, "glTexParameterx") == 0)
5546
    {
5547
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXPROC>::type>(
5548
            paramTokens, strings);
5549
        return CallCapture(EntryPoint::GLTexParameterx, std::move(params));
5550
    }
5551
    if (strcmp(nameToken, "glTexParameterxv") == 0)
5552
    {
5553
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXPARAMETERXVPROC>::type>(
5554
            paramTokens, strings);
5555
        return CallCapture(EntryPoint::GLTexParameterxv, std::move(params));
5556
    }
5557
    if (strcmp(nameToken, "glTexStorage1DEXT") == 0)
5558
    {
5559
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE1DEXTPROC>::type>(
5560
            paramTokens, strings);
5561
        return CallCapture(EntryPoint::GLTexStorage1DEXT, std::move(params));
5562
    }
5563
    if (strcmp(nameToken, "glTexStorage2D") == 0)
5564
    {
5565
        ParamBuffer params =
5566
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DPROC>::type>(paramTokens, strings);
5567
        return CallCapture(EntryPoint::GLTexStorage2D, std::move(params));
5568
    }
5569
    if (strcmp(nameToken, "glTexStorage2DEXT") == 0)
5570
    {
5571
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DEXTPROC>::type>(
5572
            paramTokens, strings);
5573
        return CallCapture(EntryPoint::GLTexStorage2DEXT, std::move(params));
5574
    }
5575
    if (strcmp(nameToken, "glTexStorage2DMultisample") == 0)
5576
    {
5577
        ParamBuffer params =
5578
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEPROC>::type>(
5579
                paramTokens, strings);
5580
        return CallCapture(EntryPoint::GLTexStorage2DMultisample, std::move(params));
5581
    }
5582
    if (strcmp(nameToken, "glTexStorage2DMultisampleANGLE") == 0)
5583
    {
5584
        ParamBuffer params =
5585
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC>::type>(
5586
                paramTokens, strings);
5587
        return CallCapture(EntryPoint::GLTexStorage2DMultisampleANGLE, std::move(params));
5588
    }
5589
    if (strcmp(nameToken, "glTexStorage3D") == 0)
5590
    {
5591
        ParamBuffer params =
5592
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DPROC>::type>(paramTokens, strings);
5593
        return CallCapture(EntryPoint::GLTexStorage3D, std::move(params));
5594
    }
5595
    if (strcmp(nameToken, "glTexStorage3DEXT") == 0)
5596
    {
5597
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DEXTPROC>::type>(
5598
            paramTokens, strings);
5599
        return CallCapture(EntryPoint::GLTexStorage3DEXT, std::move(params));
5600
    }
5601
    if (strcmp(nameToken, "glTexStorage3DMultisample") == 0)
5602
    {
5603
        ParamBuffer params =
5604
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEPROC>::type>(
5605
                paramTokens, strings);
5606
        return CallCapture(EntryPoint::GLTexStorage3DMultisample, std::move(params));
5607
    }
5608
    if (strcmp(nameToken, "glTexStorage3DMultisampleOES") == 0)
5609
    {
5610
        ParamBuffer params =
5611
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC>::type>(
5612
                paramTokens, strings);
5613
        return CallCapture(EntryPoint::GLTexStorage3DMultisampleOES, std::move(params));
5614
    }
5615
    if (strcmp(nameToken, "glTexStorageMem2DEXT") == 0)
5616
    {
5617
        ParamBuffer params =
5618
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DEXTPROC>::type>(paramTokens,
5619
                                                                                    strings);
5620
        return CallCapture(EntryPoint::GLTexStorageMem2DEXT, std::move(params));
5621
    }
5622
    if (strcmp(nameToken, "glTexStorageMem2DMultisampleEXT") == 0)
5623
    {
5624
        ParamBuffer params =
5625
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC>::type>(
5626
                paramTokens, strings);
5627
        return CallCapture(EntryPoint::GLTexStorageMem2DMultisampleEXT, std::move(params));
5628
    }
5629
    if (strcmp(nameToken, "glTexStorageMem3DEXT") == 0)
5630
    {
5631
        ParamBuffer params =
5632
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DEXTPROC>::type>(paramTokens,
5633
                                                                                    strings);
5634
        return CallCapture(EntryPoint::GLTexStorageMem3DEXT, std::move(params));
5635
    }
5636
    if (strcmp(nameToken, "glTexStorageMem3DMultisampleEXT") == 0)
5637
    {
5638
        ParamBuffer params =
5639
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC>::type>(
5640
                paramTokens, strings);
5641
        return CallCapture(EntryPoint::GLTexStorageMem3DMultisampleEXT, std::move(params));
5642
    }
5643
    if (strcmp(nameToken, "glTexStorageMemFlags2DANGLE") == 0)
5644
    {
5645
        ParamBuffer params =
5646
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DANGLEPROC>::type>(
5647
                paramTokens, strings);
5648
        return CallCapture(EntryPoint::GLTexStorageMemFlags2DANGLE, std::move(params));
5649
    }
5650
    if (strcmp(nameToken, "glTexStorageMemFlags2DMultisampleANGLE") == 0)
5651
    {
5652
        ParamBuffer params = ParseParameters<
5653
            std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS2DMULTISAMPLEANGLEPROC>::type>(paramTokens,
5654
                                                                                      strings);
5655
        return CallCapture(EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, std::move(params));
5656
    }
5657
    if (strcmp(nameToken, "glTexStorageMemFlags3DANGLE") == 0)
5658
    {
5659
        ParamBuffer params =
5660
            ParseParameters<std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DANGLEPROC>::type>(
5661
                paramTokens, strings);
5662
        return CallCapture(EntryPoint::GLTexStorageMemFlags3DANGLE, std::move(params));
5663
    }
5664
    if (strcmp(nameToken, "glTexStorageMemFlags3DMultisampleANGLE") == 0)
5665
    {
5666
        ParamBuffer params = ParseParameters<
5667
            std::remove_pointer<PFNGLTEXSTORAGEMEMFLAGS3DMULTISAMPLEANGLEPROC>::type>(paramTokens,
5668
                                                                                      strings);
5669
        return CallCapture(EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, std::move(params));
5670
    }
5671
    if (strcmp(nameToken, "glTexSubImage2D") == 0)
5672
    {
5673
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DPROC>::type>(
5674
            paramTokens, strings);
5675
        return CallCapture(EntryPoint::GLTexSubImage2D, std::move(params));
5676
    }
5677
    if (strcmp(nameToken, "glTexSubImage2DRobustANGLE") == 0)
5678
    {
5679
        ParamBuffer params =
5680
            ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE2DROBUSTANGLEPROC>::type>(
5681
                paramTokens, strings);
5682
        return CallCapture(EntryPoint::GLTexSubImage2DRobustANGLE, std::move(params));
5683
    }
5684
    if (strcmp(nameToken, "glTexSubImage3D") == 0)
5685
    {
5686
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DPROC>::type>(
5687
            paramTokens, strings);
5688
        return CallCapture(EntryPoint::GLTexSubImage3D, std::move(params));
5689
    }
5690
    if (strcmp(nameToken, "glTexSubImage3DOES") == 0)
5691
    {
5692
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DOESPROC>::type>(
5693
            paramTokens, strings);
5694
        return CallCapture(EntryPoint::GLTexSubImage3DOES, std::move(params));
5695
    }
5696
    if (strcmp(nameToken, "glTexSubImage3DRobustANGLE") == 0)
5697
    {
5698
        ParamBuffer params =
5699
            ParseParameters<std::remove_pointer<PFNGLTEXSUBIMAGE3DROBUSTANGLEPROC>::type>(
5700
                paramTokens, strings);
5701
        return CallCapture(EntryPoint::GLTexSubImage3DRobustANGLE, std::move(params));
5702
    }
5703
    if (strcmp(nameToken, "glTextureFoveationParametersQCOM") == 0)
5704
    {
5705
        ParamBuffer params =
5706
            ParseParameters<std::remove_pointer<PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC>::type>(
5707
                paramTokens, strings);
5708
        return CallCapture(EntryPoint::GLTextureFoveationParametersQCOM, std::move(params));
5709
    }
5710
    if (strcmp(nameToken, "glTransformFeedbackVaryings") == 0)
5711
    {
5712
        ParamBuffer params =
5713
            ParseParameters<std::remove_pointer<PFNGLTRANSFORMFEEDBACKVARYINGSPROC>::type>(
5714
                paramTokens, strings);
5715
        return CallCapture(EntryPoint::GLTransformFeedbackVaryings, std::move(params));
5716
    }
5717
    if (strcmp(nameToken, "glTranslatef") == 0)
5718
    {
5719
        ParamBuffer params =
5720
            ParseParameters<std::remove_pointer<PFNGLTRANSLATEFPROC>::type>(paramTokens, strings);
5721
        return CallCapture(EntryPoint::GLTranslatef, std::move(params));
5722
    }
5723
    if (strcmp(nameToken, "glTranslatex") == 0)
5724
    {
5725
        ParamBuffer params =
5726
            ParseParameters<std::remove_pointer<PFNGLTRANSLATEXPROC>::type>(paramTokens, strings);
5727
        return CallCapture(EntryPoint::GLTranslatex, std::move(params));
5728
    }
5729
    if (strcmp(nameToken, "glUniform1f") == 0)
5730
    {
5731
        ParamBuffer params =
5732
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1FPROC>::type>(paramTokens, strings);
5733
        return CallCapture(EntryPoint::GLUniform1f, std::move(params));
5734
    }
5735
    if (strcmp(nameToken, "glUniform1fv") == 0)
5736
    {
5737
        ParamBuffer params =
5738
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1FVPROC>::type>(paramTokens, strings);
5739
        return CallCapture(EntryPoint::GLUniform1fv, std::move(params));
5740
    }
5741
    if (strcmp(nameToken, "glUniform1i") == 0)
5742
    {
5743
        ParamBuffer params =
5744
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1IPROC>::type>(paramTokens, strings);
5745
        return CallCapture(EntryPoint::GLUniform1i, std::move(params));
5746
    }
5747
    if (strcmp(nameToken, "glUniform1iv") == 0)
5748
    {
5749
        ParamBuffer params =
5750
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1IVPROC>::type>(paramTokens, strings);
5751
        return CallCapture(EntryPoint::GLUniform1iv, std::move(params));
5752
    }
5753
    if (strcmp(nameToken, "glUniform1ui") == 0)
5754
    {
5755
        ParamBuffer params =
5756
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIPROC>::type>(paramTokens, strings);
5757
        return CallCapture(EntryPoint::GLUniform1ui, std::move(params));
5758
    }
5759
    if (strcmp(nameToken, "glUniform1uiv") == 0)
5760
    {
5761
        ParamBuffer params =
5762
            ParseParameters<std::remove_pointer<PFNGLUNIFORM1UIVPROC>::type>(paramTokens, strings);
5763
        return CallCapture(EntryPoint::GLUniform1uiv, std::move(params));
5764
    }
5765
    if (strcmp(nameToken, "glUniform2f") == 0)
5766
    {
5767
        ParamBuffer params =
5768
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2FPROC>::type>(paramTokens, strings);
5769
        return CallCapture(EntryPoint::GLUniform2f, std::move(params));
5770
    }
5771
    if (strcmp(nameToken, "glUniform2fv") == 0)
5772
    {
5773
        ParamBuffer params =
5774
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2FVPROC>::type>(paramTokens, strings);
5775
        return CallCapture(EntryPoint::GLUniform2fv, std::move(params));
5776
    }
5777
    if (strcmp(nameToken, "glUniform2i") == 0)
5778
    {
5779
        ParamBuffer params =
5780
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2IPROC>::type>(paramTokens, strings);
5781
        return CallCapture(EntryPoint::GLUniform2i, std::move(params));
5782
    }
5783
    if (strcmp(nameToken, "glUniform2iv") == 0)
5784
    {
5785
        ParamBuffer params =
5786
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2IVPROC>::type>(paramTokens, strings);
5787
        return CallCapture(EntryPoint::GLUniform2iv, std::move(params));
5788
    }
5789
    if (strcmp(nameToken, "glUniform2ui") == 0)
5790
    {
5791
        ParamBuffer params =
5792
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIPROC>::type>(paramTokens, strings);
5793
        return CallCapture(EntryPoint::GLUniform2ui, std::move(params));
5794
    }
5795
    if (strcmp(nameToken, "glUniform2uiv") == 0)
5796
    {
5797
        ParamBuffer params =
5798
            ParseParameters<std::remove_pointer<PFNGLUNIFORM2UIVPROC>::type>(paramTokens, strings);
5799
        return CallCapture(EntryPoint::GLUniform2uiv, std::move(params));
5800
    }
5801
    if (strcmp(nameToken, "glUniform3f") == 0)
5802
    {
5803
        ParamBuffer params =
5804
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3FPROC>::type>(paramTokens, strings);
5805
        return CallCapture(EntryPoint::GLUniform3f, std::move(params));
5806
    }
5807
    if (strcmp(nameToken, "glUniform3fv") == 0)
5808
    {
5809
        ParamBuffer params =
5810
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3FVPROC>::type>(paramTokens, strings);
5811
        return CallCapture(EntryPoint::GLUniform3fv, std::move(params));
5812
    }
5813
    if (strcmp(nameToken, "glUniform3i") == 0)
5814
    {
5815
        ParamBuffer params =
5816
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3IPROC>::type>(paramTokens, strings);
5817
        return CallCapture(EntryPoint::GLUniform3i, std::move(params));
5818
    }
5819
    if (strcmp(nameToken, "glUniform3iv") == 0)
5820
    {
5821
        ParamBuffer params =
5822
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3IVPROC>::type>(paramTokens, strings);
5823
        return CallCapture(EntryPoint::GLUniform3iv, std::move(params));
5824
    }
5825
    if (strcmp(nameToken, "glUniform3ui") == 0)
5826
    {
5827
        ParamBuffer params =
5828
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIPROC>::type>(paramTokens, strings);
5829
        return CallCapture(EntryPoint::GLUniform3ui, std::move(params));
5830
    }
5831
    if (strcmp(nameToken, "glUniform3uiv") == 0)
5832
    {
5833
        ParamBuffer params =
5834
            ParseParameters<std::remove_pointer<PFNGLUNIFORM3UIVPROC>::type>(paramTokens, strings);
5835
        return CallCapture(EntryPoint::GLUniform3uiv, std::move(params));
5836
    }
5837
    if (strcmp(nameToken, "glUniform4f") == 0)
5838
    {
5839
        ParamBuffer params =
5840
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4FPROC>::type>(paramTokens, strings);
5841
        return CallCapture(EntryPoint::GLUniform4f, std::move(params));
5842
    }
5843
    if (strcmp(nameToken, "glUniform4fv") == 0)
5844
    {
5845
        ParamBuffer params =
5846
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4FVPROC>::type>(paramTokens, strings);
5847
        return CallCapture(EntryPoint::GLUniform4fv, std::move(params));
5848
    }
5849
    if (strcmp(nameToken, "glUniform4i") == 0)
5850
    {
5851
        ParamBuffer params =
5852
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4IPROC>::type>(paramTokens, strings);
5853
        return CallCapture(EntryPoint::GLUniform4i, std::move(params));
5854
    }
5855
    if (strcmp(nameToken, "glUniform4iv") == 0)
5856
    {
5857
        ParamBuffer params =
5858
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4IVPROC>::type>(paramTokens, strings);
5859
        return CallCapture(EntryPoint::GLUniform4iv, std::move(params));
5860
    }
5861
    if (strcmp(nameToken, "glUniform4ui") == 0)
5862
    {
5863
        ParamBuffer params =
5864
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIPROC>::type>(paramTokens, strings);
5865
        return CallCapture(EntryPoint::GLUniform4ui, std::move(params));
5866
    }
5867
    if (strcmp(nameToken, "glUniform4uiv") == 0)
5868
    {
5869
        ParamBuffer params =
5870
            ParseParameters<std::remove_pointer<PFNGLUNIFORM4UIVPROC>::type>(paramTokens, strings);
5871
        return CallCapture(EntryPoint::GLUniform4uiv, std::move(params));
5872
    }
5873
    if (strcmp(nameToken, "glUniformBlockBinding") == 0)
5874
    {
5875
        ParamBuffer params =
5876
            ParseParameters<std::remove_pointer<PFNGLUNIFORMBLOCKBINDINGPROC>::type>(paramTokens,
5877
                                                                                     strings);
5878
        return CallCapture(EntryPoint::GLUniformBlockBinding, std::move(params));
5879
    }
5880
    if (strcmp(nameToken, "glUniformMatrix2fv") == 0)
5881
    {
5882
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2FVPROC>::type>(
5883
            paramTokens, strings);
5884
        return CallCapture(EntryPoint::GLUniformMatrix2fv, std::move(params));
5885
    }
5886
    if (strcmp(nameToken, "glUniformMatrix2x3fv") == 0)
5887
    {
5888
        ParamBuffer params =
5889
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X3FVPROC>::type>(paramTokens,
5890
                                                                                    strings);
5891
        return CallCapture(EntryPoint::GLUniformMatrix2x3fv, std::move(params));
5892
    }
5893
    if (strcmp(nameToken, "glUniformMatrix2x4fv") == 0)
5894
    {
5895
        ParamBuffer params =
5896
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX2X4FVPROC>::type>(paramTokens,
5897
                                                                                    strings);
5898
        return CallCapture(EntryPoint::GLUniformMatrix2x4fv, std::move(params));
5899
    }
5900
    if (strcmp(nameToken, "glUniformMatrix3fv") == 0)
5901
    {
5902
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3FVPROC>::type>(
5903
            paramTokens, strings);
5904
        return CallCapture(EntryPoint::GLUniformMatrix3fv, std::move(params));
5905
    }
5906
    if (strcmp(nameToken, "glUniformMatrix3x2fv") == 0)
5907
    {
5908
        ParamBuffer params =
5909
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X2FVPROC>::type>(paramTokens,
5910
                                                                                    strings);
5911
        return CallCapture(EntryPoint::GLUniformMatrix3x2fv, std::move(params));
5912
    }
5913
    if (strcmp(nameToken, "glUniformMatrix3x4fv") == 0)
5914
    {
5915
        ParamBuffer params =
5916
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX3X4FVPROC>::type>(paramTokens,
5917
                                                                                    strings);
5918
        return CallCapture(EntryPoint::GLUniformMatrix3x4fv, std::move(params));
5919
    }
5920
    if (strcmp(nameToken, "glUniformMatrix4fv") == 0)
5921
    {
5922
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4FVPROC>::type>(
5923
            paramTokens, strings);
5924
        return CallCapture(EntryPoint::GLUniformMatrix4fv, std::move(params));
5925
    }
5926
    if (strcmp(nameToken, "glUniformMatrix4x2fv") == 0)
5927
    {
5928
        ParamBuffer params =
5929
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X2FVPROC>::type>(paramTokens,
5930
                                                                                    strings);
5931
        return CallCapture(EntryPoint::GLUniformMatrix4x2fv, std::move(params));
5932
    }
5933
    if (strcmp(nameToken, "glUniformMatrix4x3fv") == 0)
5934
    {
5935
        ParamBuffer params =
5936
            ParseParameters<std::remove_pointer<PFNGLUNIFORMMATRIX4X3FVPROC>::type>(paramTokens,
5937
                                                                                    strings);
5938
        return CallCapture(EntryPoint::GLUniformMatrix4x3fv, std::move(params));
5939
    }
5940
    if (strcmp(nameToken, "glUnmapBuffer") == 0)
5941
    {
5942
        ParamBuffer params =
5943
            ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFERPROC>::type>(paramTokens, strings);
5944
        return CallCapture(EntryPoint::GLUnmapBuffer, std::move(params));
5945
    }
5946
    if (strcmp(nameToken, "glUnmapBufferOES") == 0)
5947
    {
5948
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUNMAPBUFFEROESPROC>::type>(
5949
            paramTokens, strings);
5950
        return CallCapture(EntryPoint::GLUnmapBufferOES, std::move(params));
5951
    }
5952
    if (strcmp(nameToken, "glUseProgram") == 0)
5953
    {
5954
        ParamBuffer params =
5955
            ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMPROC>::type>(paramTokens, strings);
5956
        return CallCapture(EntryPoint::GLUseProgram, std::move(params));
5957
    }
5958
    if (strcmp(nameToken, "glUseProgramStages") == 0)
5959
    {
5960
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESPROC>::type>(
5961
            paramTokens, strings);
5962
        return CallCapture(EntryPoint::GLUseProgramStages, std::move(params));
5963
    }
5964
    if (strcmp(nameToken, "glUseProgramStagesEXT") == 0)
5965
    {
5966
        ParamBuffer params =
5967
            ParseParameters<std::remove_pointer<PFNGLUSEPROGRAMSTAGESEXTPROC>::type>(paramTokens,
5968
                                                                                     strings);
5969
        return CallCapture(EntryPoint::GLUseProgramStagesEXT, std::move(params));
5970
    }
5971
    if (strcmp(nameToken, "glValidateProgram") == 0)
5972
    {
5973
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPROC>::type>(
5974
            paramTokens, strings);
5975
        return CallCapture(EntryPoint::GLValidateProgram, std::move(params));
5976
    }
5977
    if (strcmp(nameToken, "glValidateProgramPipeline") == 0)
5978
    {
5979
        ParamBuffer params =
5980
            ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEPROC>::type>(
5981
                paramTokens, strings);
5982
        return CallCapture(EntryPoint::GLValidateProgramPipeline, std::move(params));
5983
    }
5984
    if (strcmp(nameToken, "glValidateProgramPipelineEXT") == 0)
5985
    {
5986
        ParamBuffer params =
5987
            ParseParameters<std::remove_pointer<PFNGLVALIDATEPROGRAMPIPELINEEXTPROC>::type>(
5988
                paramTokens, strings);
5989
        return CallCapture(EntryPoint::GLValidateProgramPipelineEXT, std::move(params));
5990
    }
5991
    if (strcmp(nameToken, "glVertexAttrib1f") == 0)
5992
    {
5993
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FPROC>::type>(
5994
            paramTokens, strings);
5995
        return CallCapture(EntryPoint::GLVertexAttrib1f, std::move(params));
5996
    }
5997
    if (strcmp(nameToken, "glVertexAttrib1fv") == 0)
5998
    {
5999
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB1FVPROC>::type>(
6000
            paramTokens, strings);
6001
        return CallCapture(EntryPoint::GLVertexAttrib1fv, std::move(params));
6002
    }
6003
    if (strcmp(nameToken, "glVertexAttrib2f") == 0)
6004
    {
6005
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FPROC>::type>(
6006
            paramTokens, strings);
6007
        return CallCapture(EntryPoint::GLVertexAttrib2f, std::move(params));
6008
    }
6009
    if (strcmp(nameToken, "glVertexAttrib2fv") == 0)
6010
    {
6011
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB2FVPROC>::type>(
6012
            paramTokens, strings);
6013
        return CallCapture(EntryPoint::GLVertexAttrib2fv, std::move(params));
6014
    }
6015
    if (strcmp(nameToken, "glVertexAttrib3f") == 0)
6016
    {
6017
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FPROC>::type>(
6018
            paramTokens, strings);
6019
        return CallCapture(EntryPoint::GLVertexAttrib3f, std::move(params));
6020
    }
6021
    if (strcmp(nameToken, "glVertexAttrib3fv") == 0)
6022
    {
6023
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB3FVPROC>::type>(
6024
            paramTokens, strings);
6025
        return CallCapture(EntryPoint::GLVertexAttrib3fv, std::move(params));
6026
    }
6027
    if (strcmp(nameToken, "glVertexAttrib4f") == 0)
6028
    {
6029
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FPROC>::type>(
6030
            paramTokens, strings);
6031
        return CallCapture(EntryPoint::GLVertexAttrib4f, std::move(params));
6032
    }
6033
    if (strcmp(nameToken, "glVertexAttrib4fv") == 0)
6034
    {
6035
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIB4FVPROC>::type>(
6036
            paramTokens, strings);
6037
        return CallCapture(EntryPoint::GLVertexAttrib4fv, std::move(params));
6038
    }
6039
    if (strcmp(nameToken, "glVertexAttribBinding") == 0)
6040
    {
6041
        ParamBuffer params =
6042
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBBINDINGPROC>::type>(paramTokens,
6043
                                                                                     strings);
6044
        return CallCapture(EntryPoint::GLVertexAttribBinding, std::move(params));
6045
    }
6046
    if (strcmp(nameToken, "glVertexAttribDivisor") == 0)
6047
    {
6048
        ParamBuffer params =
6049
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORPROC>::type>(paramTokens,
6050
                                                                                     strings);
6051
        return CallCapture(EntryPoint::GLVertexAttribDivisor, std::move(params));
6052
    }
6053
    if (strcmp(nameToken, "glVertexAttribDivisorANGLE") == 0)
6054
    {
6055
        ParamBuffer params =
6056
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISORANGLEPROC>::type>(
6057
                paramTokens, strings);
6058
        return CallCapture(EntryPoint::GLVertexAttribDivisorANGLE, std::move(params));
6059
    }
6060
    if (strcmp(nameToken, "glVertexAttribDivisorEXT") == 0)
6061
    {
6062
        ParamBuffer params =
6063
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBDIVISOREXTPROC>::type>(paramTokens,
6064
                                                                                        strings);
6065
        return CallCapture(EntryPoint::GLVertexAttribDivisorEXT, std::move(params));
6066
    }
6067
    if (strcmp(nameToken, "glVertexAttribFormat") == 0)
6068
    {
6069
        ParamBuffer params =
6070
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBFORMATPROC>::type>(paramTokens,
6071
                                                                                    strings);
6072
        return CallCapture(EntryPoint::GLVertexAttribFormat, std::move(params));
6073
    }
6074
    if (strcmp(nameToken, "glVertexAttribI4i") == 0)
6075
    {
6076
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IPROC>::type>(
6077
            paramTokens, strings);
6078
        return CallCapture(EntryPoint::GLVertexAttribI4i, std::move(params));
6079
    }
6080
    if (strcmp(nameToken, "glVertexAttribI4iv") == 0)
6081
    {
6082
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4IVPROC>::type>(
6083
            paramTokens, strings);
6084
        return CallCapture(EntryPoint::GLVertexAttribI4iv, std::move(params));
6085
    }
6086
    if (strcmp(nameToken, "glVertexAttribI4ui") == 0)
6087
    {
6088
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIPROC>::type>(
6089
            paramTokens, strings);
6090
        return CallCapture(EntryPoint::GLVertexAttribI4ui, std::move(params));
6091
    }
6092
    if (strcmp(nameToken, "glVertexAttribI4uiv") == 0)
6093
    {
6094
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBI4UIVPROC>::type>(
6095
            paramTokens, strings);
6096
        return CallCapture(EntryPoint::GLVertexAttribI4uiv, std::move(params));
6097
    }
6098
    if (strcmp(nameToken, "glVertexAttribIFormat") == 0)
6099
    {
6100
        ParamBuffer params =
6101
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIFORMATPROC>::type>(paramTokens,
6102
                                                                                     strings);
6103
        return CallCapture(EntryPoint::GLVertexAttribIFormat, std::move(params));
6104
    }
6105
    if (strcmp(nameToken, "glVertexAttribIPointer") == 0)
6106
    {
6107
        ParamBuffer params =
6108
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBIPOINTERPROC>::type>(paramTokens,
6109
                                                                                      strings);
6110
        return CallCapture(EntryPoint::GLVertexAttribIPointer, std::move(params));
6111
    }
6112
    if (strcmp(nameToken, "glVertexAttribPointer") == 0)
6113
    {
6114
        ParamBuffer params =
6115
            ParseParameters<std::remove_pointer<PFNGLVERTEXATTRIBPOINTERPROC>::type>(paramTokens,
6116
                                                                                     strings);
6117
        return CallCapture(EntryPoint::GLVertexAttribPointer, std::move(params));
6118
    }
6119
    if (strcmp(nameToken, "glVertexBindingDivisor") == 0)
6120
    {
6121
        ParamBuffer params =
6122
            ParseParameters<std::remove_pointer<PFNGLVERTEXBINDINGDIVISORPROC>::type>(paramTokens,
6123
                                                                                      strings);
6124
        return CallCapture(EntryPoint::GLVertexBindingDivisor, std::move(params));
6125
    }
6126
    if (strcmp(nameToken, "glVertexPointer") == 0)
6127
    {
6128
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLVERTEXPOINTERPROC>::type>(
6129
            paramTokens, strings);
6130
        return CallCapture(EntryPoint::GLVertexPointer, std::move(params));
6131
    }
6132
    if (strcmp(nameToken, "glViewport") == 0)
6133
    {
6134
        ParamBuffer params =
6135
            ParseParameters<std::remove_pointer<PFNGLVIEWPORTPROC>::type>(paramTokens, strings);
6136
        return CallCapture(EntryPoint::GLViewport, std::move(params));
6137
    }
6138
    if (strcmp(nameToken, "glWaitSemaphoreEXT") == 0)
6139
    {
6140
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWAITSEMAPHOREEXTPROC>::type>(
6141
            paramTokens, strings);
6142
        return CallCapture(EntryPoint::GLWaitSemaphoreEXT, std::move(params));
6143
    }
6144
    if (strcmp(nameToken, "glWaitSync") == 0)
6145
    {
6146
        ParamBuffer params =
6147
            ParseParameters<std::remove_pointer<PFNGLWAITSYNCPROC>::type>(paramTokens, strings);
6148
        return CallCapture(EntryPoint::GLWaitSync, std::move(params));
6149
    }
6150
    if (strcmp(nameToken, "glWeightPointerOES") == 0)
6151
    {
6152
        ParamBuffer params = ParseParameters<std::remove_pointer<PFNGLWEIGHTPOINTEROESPROC>::type>(
6153
            paramTokens, strings);
6154
        return CallCapture(EntryPoint::GLWeightPointerOES, std::move(params));
6155
    }
6156
    if (strcmp(nameToken, "CreateContext") == 0)
6157
    {
6158
        ParamBuffer params = ParseParameters<decltype(CreateContext)>(paramTokens, strings);
6159
        return CallCapture("CreateContext", std::move(params));
6160
    }
6161
    if (strcmp(nameToken, "CreateEGLImage") == 0)
6162
    {
6163
        ParamBuffer params = ParseParameters<decltype(CreateEGLImage)>(paramTokens, strings);
6164
        return CallCapture("CreateEGLImage", std::move(params));
6165
    }
6166
    if (strcmp(nameToken, "CreateEGLImageKHR") == 0)
6167
    {
6168
        ParamBuffer params = ParseParameters<decltype(CreateEGLImageKHR)>(paramTokens, strings);
6169
        return CallCapture("CreateEGLImageKHR", std::move(params));
6170
    }
6171
    if (strcmp(nameToken, "CreateEGLSync") == 0)
6172
    {
6173
        ParamBuffer params = ParseParameters<decltype(CreateEGLSync)>(paramTokens, strings);
6174
        return CallCapture("CreateEGLSync", std::move(params));
6175
    }
6176
    if (strcmp(nameToken, "CreateEGLSyncKHR") == 0)
6177
    {
6178
        ParamBuffer params = ParseParameters<decltype(CreateEGLSyncKHR)>(paramTokens, strings);
6179
        return CallCapture("CreateEGLSyncKHR", std::move(params));
6180
    }
6181
    if (strcmp(nameToken, "CreateNativeClientBufferANDROID") == 0)
6182
    {
6183
        ParamBuffer params =
6184
            ParseParameters<decltype(CreateNativeClientBufferANDROID)>(paramTokens, strings);
6185
        return CallCapture("CreateNativeClientBufferANDROID", std::move(params));
6186
    }
6187
    if (strcmp(nameToken, "CreatePbufferSurface") == 0)
6188
    {
6189
        ParamBuffer params = ParseParameters<decltype(CreatePbufferSurface)>(paramTokens, strings);
6190
        return CallCapture("CreatePbufferSurface", std::move(params));
6191
    }
6192
    if (strcmp(nameToken, "CreateProgram") == 0)
6193
    {
6194
        ParamBuffer params = ParseParameters<decltype(CreateProgram)>(paramTokens, strings);
6195
        return CallCapture("CreateProgram", std::move(params));
6196
    }
6197
    if (strcmp(nameToken, "CreateShader") == 0)
6198
    {
6199
        ParamBuffer params = ParseParameters<decltype(CreateShader)>(paramTokens, strings);
6200
        return CallCapture("CreateShader", std::move(params));
6201
    }
6202
    if (strcmp(nameToken, "CreateShaderProgramv") == 0)
6203
    {
6204
        ParamBuffer params = ParseParameters<decltype(CreateShaderProgramv)>(paramTokens, strings);
6205
        return CallCapture("CreateShaderProgramv", std::move(params));
6206
    }
6207
    if (strcmp(nameToken, "DeleteUniformLocations") == 0)
6208
    {
6209
        ParamBuffer params =
6210
            ParseParameters<decltype(DeleteUniformLocations)>(paramTokens, strings);
6211
        return CallCapture("DeleteUniformLocations", std::move(params));
6212
    }
6213
    if (strcmp(nameToken, "DestroyEGLImage") == 0)
6214
    {
6215
        ParamBuffer params = ParseParameters<decltype(DestroyEGLImage)>(paramTokens, strings);
6216
        return CallCapture("DestroyEGLImage", std::move(params));
6217
    }
6218
    if (strcmp(nameToken, "DestroyEGLImageKHR") == 0)
6219
    {
6220
        ParamBuffer params = ParseParameters<decltype(DestroyEGLImageKHR)>(paramTokens, strings);
6221
        return CallCapture("DestroyEGLImageKHR", std::move(params));
6222
    }
6223
    if (strcmp(nameToken, "FenceSync") == 0)
6224
    {
6225
        ParamBuffer params = ParseParameters<decltype(FenceSync)>(paramTokens, strings);
6226
        return CallCapture("FenceSync", std::move(params));
6227
    }
6228
    if (strcmp(nameToken, "FenceSync2") == 0)
6229
    {
6230
        ParamBuffer params = ParseParameters<decltype(FenceSync2)>(paramTokens, strings);
6231
        return CallCapture("FenceSync2", std::move(params));
6232
    }
6233
    if (strcmp(nameToken, "InitializeReplay") == 0)
6234
    {
6235
        ParamBuffer params = ParseParameters<decltype(InitializeReplay)>(paramTokens, strings);
6236
        return CallCapture("InitializeReplay", std::move(params));
6237
    }
6238
    if (strcmp(nameToken, "InitializeReplay2") == 0)
6239
    {
6240
        ParamBuffer params = ParseParameters<decltype(InitializeReplay2)>(paramTokens, strings);
6241
        return CallCapture("InitializeReplay2", std::move(params));
6242
    }
6243
    if (strcmp(nameToken, "InitializeReplay3") == 0)
6244
    {
6245
        ParamBuffer params = ParseParameters<decltype(InitializeReplay3)>(paramTokens, strings);
6246
        return CallCapture("InitializeReplay3", std::move(params));
6247
    }
6248
    if (strcmp(nameToken, "InitializeReplay4") == 0)
6249
    {
6250
        ParamBuffer params = ParseParameters<decltype(InitializeReplay4)>(paramTokens, strings);
6251
        return CallCapture("InitializeReplay4", std::move(params));
6252
    }
6253
    if (strcmp(nameToken, "MapBufferOES") == 0)
6254
    {
6255
        ParamBuffer params = ParseParameters<decltype(MapBufferOES)>(paramTokens, strings);
6256
        return CallCapture("MapBufferOES", std::move(params));
6257
    }
6258
    if (strcmp(nameToken, "MapBufferRange") == 0)
6259
    {
6260
        ParamBuffer params = ParseParameters<decltype(MapBufferRange)>(paramTokens, strings);
6261
        return CallCapture("MapBufferRange", std::move(params));
6262
    }
6263
    if (strcmp(nameToken, "MapBufferRangeEXT") == 0)
6264
    {
6265
        ParamBuffer params = ParseParameters<decltype(MapBufferRangeEXT)>(paramTokens, strings);
6266
        return CallCapture("MapBufferRangeEXT", std::move(params));
6267
    }
6268
    if (strcmp(nameToken, "SetBufferID") == 0)
6269
    {
6270
        ParamBuffer params = ParseParameters<decltype(SetBufferID)>(paramTokens, strings);
6271
        return CallCapture("SetBufferID", std::move(params));
6272
    }
6273
    if (strcmp(nameToken, "SetCurrentContextID") == 0)
6274
    {
6275
        ParamBuffer params = ParseParameters<decltype(SetCurrentContextID)>(paramTokens, strings);
6276
        return CallCapture("SetCurrentContextID", std::move(params));
6277
    }
6278
    if (strcmp(nameToken, "SetFramebufferID") == 0)
6279
    {
6280
        ParamBuffer params = ParseParameters<decltype(SetFramebufferID)>(paramTokens, strings);
6281
        return CallCapture("SetFramebufferID", std::move(params));
6282
    }
6283
    if (strcmp(nameToken, "SetRenderbufferID") == 0)
6284
    {
6285
        ParamBuffer params = ParseParameters<decltype(SetRenderbufferID)>(paramTokens, strings);
6286
        return CallCapture("SetRenderbufferID", std::move(params));
6287
    }
6288
    if (strcmp(nameToken, "SetTextureID") == 0)
6289
    {
6290
        ParamBuffer params = ParseParameters<decltype(SetTextureID)>(paramTokens, strings);
6291
        return CallCapture("SetTextureID", std::move(params));
6292
    }
6293
    if (strcmp(nameToken, "UniformBlockBinding") == 0)
6294
    {
6295
        ParamBuffer params = ParseParameters<decltype(UniformBlockBinding)>(paramTokens, strings);
6296
        return CallCapture("UniformBlockBinding", std::move(params));
6297
    }
6298
    if (strcmp(nameToken, "UpdateBufferID") == 0)
6299
    {
6300
        ParamBuffer params = ParseParameters<decltype(UpdateBufferID)>(paramTokens, strings);
6301
        return CallCapture("UpdateBufferID", std::move(params));
6302
    }
6303
    if (strcmp(nameToken, "UpdateClientArrayPointer") == 0)
6304
    {
6305
        ParamBuffer params =
6306
            ParseParameters<decltype(UpdateClientArrayPointer)>(paramTokens, strings);
6307
        return CallCapture("UpdateClientArrayPointer", std::move(params));
6308
    }
6309
    if (strcmp(nameToken, "UpdateClientBufferData") == 0)
6310
    {
6311
        ParamBuffer params =
6312
            ParseParameters<decltype(UpdateClientBufferData)>(paramTokens, strings);
6313
        return CallCapture("UpdateClientBufferData", std::move(params));
6314
    }
6315
    if (strcmp(nameToken, "UpdateClientBufferDataWithOffset") == 0)
6316
    {
6317
        ParamBuffer params =
6318
            ParseParameters<decltype(UpdateClientBufferDataWithOffset)>(paramTokens, strings);
6319
        return CallCapture("UpdateClientBufferDataWithOffset", std::move(params));
6320
    }
6321
    if (strcmp(nameToken, "UpdateCurrentProgram") == 0)
6322
    {
6323
        ParamBuffer params = ParseParameters<decltype(UpdateCurrentProgram)>(paramTokens, strings);
6324
        return CallCapture("UpdateCurrentProgram", std::move(params));
6325
    }
6326
    if (strcmp(nameToken, "UpdateFenceNVID") == 0)
6327
    {
6328
        ParamBuffer params = ParseParameters<decltype(UpdateFenceNVID)>(paramTokens, strings);
6329
        return CallCapture("UpdateFenceNVID", std::move(params));
6330
    }
6331
    if (strcmp(nameToken, "UpdateFramebufferID") == 0)
6332
    {
6333
        ParamBuffer params = ParseParameters<decltype(UpdateFramebufferID)>(paramTokens, strings);
6334
        return CallCapture("UpdateFramebufferID", std::move(params));
6335
    }
6336
    if (strcmp(nameToken, "UpdateMemoryObjectID") == 0)
6337
    {
6338
        ParamBuffer params = ParseParameters<decltype(UpdateMemoryObjectID)>(paramTokens, strings);
6339
        return CallCapture("UpdateMemoryObjectID", std::move(params));
6340
    }
6341
    if (strcmp(nameToken, "UpdateProgramPipelineID") == 0)
6342
    {
6343
        ParamBuffer params =
6344
            ParseParameters<decltype(UpdateProgramPipelineID)>(paramTokens, strings);
6345
        return CallCapture("UpdateProgramPipelineID", std::move(params));
6346
    }
6347
    if (strcmp(nameToken, "UpdateQueryID") == 0)
6348
    {
6349
        ParamBuffer params = ParseParameters<decltype(UpdateQueryID)>(paramTokens, strings);
6350
        return CallCapture("UpdateQueryID", std::move(params));
6351
    }
6352
    if (strcmp(nameToken, "UpdateRenderbufferID") == 0)
6353
    {
6354
        ParamBuffer params = ParseParameters<decltype(UpdateRenderbufferID)>(paramTokens, strings);
6355
        return CallCapture("UpdateRenderbufferID", std::move(params));
6356
    }
6357
    if (strcmp(nameToken, "UpdateResourceIDBuffer") == 0)
6358
    {
6359
        ParamBuffer params =
6360
            ParseParameters<decltype(UpdateResourceIDBuffer)>(paramTokens, strings);
6361
        return CallCapture("UpdateResourceIDBuffer", std::move(params));
6362
    }
6363
    if (strcmp(nameToken, "UpdateSamplerID") == 0)
6364
    {
6365
        ParamBuffer params = ParseParameters<decltype(UpdateSamplerID)>(paramTokens, strings);
6366
        return CallCapture("UpdateSamplerID", std::move(params));
6367
    }
6368
    if (strcmp(nameToken, "UpdateSemaphoreID") == 0)
6369
    {
6370
        ParamBuffer params = ParseParameters<decltype(UpdateSemaphoreID)>(paramTokens, strings);
6371
        return CallCapture("UpdateSemaphoreID", std::move(params));
6372
    }
6373
    if (strcmp(nameToken, "UpdateShaderProgramID") == 0)
6374
    {
6375
        ParamBuffer params = ParseParameters<decltype(UpdateShaderProgramID)>(paramTokens, strings);
6376
        return CallCapture("UpdateShaderProgramID", std::move(params));
6377
    }
6378
    if (strcmp(nameToken, "UpdateTextureID") == 0)
6379
    {
6380
        ParamBuffer params = ParseParameters<decltype(UpdateTextureID)>(paramTokens, strings);
6381
        return CallCapture("UpdateTextureID", std::move(params));
6382
    }
6383
    if (strcmp(nameToken, "UpdateTransformFeedbackID") == 0)
6384
    {
6385
        ParamBuffer params =
6386
            ParseParameters<decltype(UpdateTransformFeedbackID)>(paramTokens, strings);
6387
        return CallCapture("UpdateTransformFeedbackID", std::move(params));
6388
    }
6389
    if (strcmp(nameToken, "UpdateUniformBlockIndex") == 0)
6390
    {
6391
        ParamBuffer params =
6392
            ParseParameters<decltype(UpdateUniformBlockIndex)>(paramTokens, strings);
6393
        return CallCapture("UpdateUniformBlockIndex", std::move(params));
6394
    }
6395
    if (strcmp(nameToken, "UpdateUniformLocation") == 0)
6396
    {
6397
        ParamBuffer params = ParseParameters<decltype(UpdateUniformLocation)>(paramTokens, strings);
6398
        return CallCapture("UpdateUniformLocation", std::move(params));
6399
    }
6400
    if (strcmp(nameToken, "UpdateVertexArrayID") == 0)
6401
    {
6402
        ParamBuffer params = ParseParameters<decltype(UpdateVertexArrayID)>(paramTokens, strings);
6403
        return CallCapture("UpdateVertexArrayID", std::move(params));
6404
    }
6405
    if (strcmp(nameToken, "ValidateSerializedState") == 0)
6406
    {
6407
        ParamBuffer params =
6408
            ParseParameters<decltype(ValidateSerializedState)>(paramTokens, strings);
6409
        return CallCapture("ValidateSerializedState", std::move(params));
6410
    }
6411

6412
    if (numParamTokens > 0)
6413
    {
6414
        printf("Expected zero parameter tokens for %s\n", nameToken);
6415
        UNREACHABLE();
6416
    }
6417
    return CallCapture(nameToken, ParamBuffer());
6418
}
6419

6420
template <typename Fn, EnableIfNArgs<Fn, 1> = 0>
6421
void DispatchCallCapture(Fn *fn, const Captures &cap)
6422
{
6423
    (*fn)(Arg<Fn, 0>(cap));
6424
}
6425

6426
template <typename Fn, EnableIfNArgs<Fn, 2> = 0>
6427
void DispatchCallCapture(Fn *fn, const Captures &cap)
6428
{
6429
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap));
6430
}
6431

6432
template <typename Fn, EnableIfNArgs<Fn, 3> = 0>
6433
void DispatchCallCapture(Fn *fn, const Captures &cap)
6434
{
6435
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap));
6436
}
6437

6438
template <typename Fn, EnableIfNArgs<Fn, 4> = 0>
6439
void DispatchCallCapture(Fn *fn, const Captures &cap)
6440
{
6441
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap));
6442
}
6443

6444
template <typename Fn, EnableIfNArgs<Fn, 5> = 0>
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
}
6449

6450
template <typename Fn, EnableIfNArgs<Fn, 8> = 0>
6451
void DispatchCallCapture(Fn *fn, const Captures &cap)
6452
{
6453
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6454
          Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap));
6455
}
6456

6457
template <typename Fn, EnableIfNArgs<Fn, 16> = 0>
6458
void DispatchCallCapture(Fn *fn, const Captures &cap)
6459
{
6460
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6461
          Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6462
          Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6463
          Arg<Fn, 15>(cap));
6464
}
6465

6466
template <typename Fn, EnableIfNArgs<Fn, 20> = 0>
6467
void DispatchCallCapture(Fn *fn, const Captures &cap)
6468
{
6469
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6470
          Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6471
          Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6472
          Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap));
6473
}
6474

6475
template <typename Fn, EnableIfNArgs<Fn, 22> = 0>
6476
void DispatchCallCapture(Fn *fn, const Captures &cap)
6477
{
6478
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6479
          Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6480
          Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6481
          Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
6482
          Arg<Fn, 20>(cap), Arg<Fn, 21>(cap));
6483
}
6484

6485
template <typename Fn, EnableIfNArgs<Fn, 23> = 0>
6486
void DispatchCallCapture(Fn *fn, const Captures &cap)
6487
{
6488
    (*fn)(Arg<Fn, 0>(cap), Arg<Fn, 1>(cap), Arg<Fn, 2>(cap), Arg<Fn, 3>(cap), Arg<Fn, 4>(cap),
6489
          Arg<Fn, 5>(cap), Arg<Fn, 6>(cap), Arg<Fn, 7>(cap), Arg<Fn, 8>(cap), Arg<Fn, 9>(cap),
6490
          Arg<Fn, 10>(cap), Arg<Fn, 11>(cap), Arg<Fn, 12>(cap), Arg<Fn, 13>(cap), Arg<Fn, 14>(cap),
6491
          Arg<Fn, 15>(cap), Arg<Fn, 16>(cap), Arg<Fn, 17>(cap), Arg<Fn, 18>(cap), Arg<Fn, 19>(cap),
6492
          Arg<Fn, 20>(cap), Arg<Fn, 21>(cap), Arg<Fn, 22>(cap));
6493
}
6494

6495
void ReplayCustomFunctionCall(const CallCapture &call, const TraceFunctionMap &customFunctions)
6496
{
6497
    ASSERT(call.entryPoint == EntryPoint::Invalid);
6498
    const Captures &captures = call.params.getParamCaptures();
6499

6500
    if (call.customFunctionName == "CreateContext")
6501
    {
6502
        DispatchCallCapture(CreateContext, captures);
6503
        return;
6504
    }
6505
    if (call.customFunctionName == "CreateEGLImage")
6506
    {
6507
        DispatchCallCapture(CreateEGLImage, captures);
6508
        return;
6509
    }
6510
    if (call.customFunctionName == "CreateEGLImageKHR")
6511
    {
6512
        DispatchCallCapture(CreateEGLImageKHR, captures);
6513
        return;
6514
    }
6515
    if (call.customFunctionName == "CreateEGLSync")
6516
    {
6517
        DispatchCallCapture(CreateEGLSync, captures);
6518
        return;
6519
    }
6520
    if (call.customFunctionName == "CreateEGLSyncKHR")
6521
    {
6522
        DispatchCallCapture(CreateEGLSyncKHR, captures);
6523
        return;
6524
    }
6525
    if (call.customFunctionName == "CreateNativeClientBufferANDROID")
6526
    {
6527
        DispatchCallCapture(CreateNativeClientBufferANDROID, captures);
6528
        return;
6529
    }
6530
    if (call.customFunctionName == "CreatePbufferSurface")
6531
    {
6532
        DispatchCallCapture(CreatePbufferSurface, captures);
6533
        return;
6534
    }
6535
    if (call.customFunctionName == "CreateProgram")
6536
    {
6537
        DispatchCallCapture(CreateProgram, captures);
6538
        return;
6539
    }
6540
    if (call.customFunctionName == "CreateShader")
6541
    {
6542
        DispatchCallCapture(CreateShader, captures);
6543
        return;
6544
    }
6545
    if (call.customFunctionName == "CreateShaderProgramv")
6546
    {
6547
        DispatchCallCapture(CreateShaderProgramv, captures);
6548
        return;
6549
    }
6550
    if (call.customFunctionName == "DeleteUniformLocations")
6551
    {
6552
        DispatchCallCapture(DeleteUniformLocations, captures);
6553
        return;
6554
    }
6555
    if (call.customFunctionName == "DestroyEGLImage")
6556
    {
6557
        DispatchCallCapture(DestroyEGLImage, captures);
6558
        return;
6559
    }
6560
    if (call.customFunctionName == "DestroyEGLImageKHR")
6561
    {
6562
        DispatchCallCapture(DestroyEGLImageKHR, captures);
6563
        return;
6564
    }
6565
    if (call.customFunctionName == "FenceSync")
6566
    {
6567
        DispatchCallCapture(FenceSync, captures);
6568
        return;
6569
    }
6570
    if (call.customFunctionName == "FenceSync2")
6571
    {
6572
        DispatchCallCapture(FenceSync2, captures);
6573
        return;
6574
    }
6575
    if (call.customFunctionName == "InitializeReplay")
6576
    {
6577
        DispatchCallCapture(InitializeReplay, captures);
6578
        return;
6579
    }
6580
    if (call.customFunctionName == "InitializeReplay2")
6581
    {
6582
        DispatchCallCapture(InitializeReplay2, captures);
6583
        return;
6584
    }
6585
    if (call.customFunctionName == "InitializeReplay3")
6586
    {
6587
        DispatchCallCapture(InitializeReplay3, captures);
6588
        return;
6589
    }
6590
    if (call.customFunctionName == "InitializeReplay4")
6591
    {
6592
        DispatchCallCapture(InitializeReplay4, captures);
6593
        return;
6594
    }
6595
    if (call.customFunctionName == "MapBufferOES")
6596
    {
6597
        DispatchCallCapture(MapBufferOES, captures);
6598
        return;
6599
    }
6600
    if (call.customFunctionName == "MapBufferRange")
6601
    {
6602
        DispatchCallCapture(MapBufferRange, captures);
6603
        return;
6604
    }
6605
    if (call.customFunctionName == "MapBufferRangeEXT")
6606
    {
6607
        DispatchCallCapture(MapBufferRangeEXT, captures);
6608
        return;
6609
    }
6610
    if (call.customFunctionName == "SetBufferID")
6611
    {
6612
        DispatchCallCapture(SetBufferID, captures);
6613
        return;
6614
    }
6615
    if (call.customFunctionName == "SetCurrentContextID")
6616
    {
6617
        DispatchCallCapture(SetCurrentContextID, captures);
6618
        return;
6619
    }
6620
    if (call.customFunctionName == "SetFramebufferID")
6621
    {
6622
        DispatchCallCapture(SetFramebufferID, captures);
6623
        return;
6624
    }
6625
    if (call.customFunctionName == "SetRenderbufferID")
6626
    {
6627
        DispatchCallCapture(SetRenderbufferID, captures);
6628
        return;
6629
    }
6630
    if (call.customFunctionName == "SetTextureID")
6631
    {
6632
        DispatchCallCapture(SetTextureID, captures);
6633
        return;
6634
    }
6635
    if (call.customFunctionName == "UniformBlockBinding")
6636
    {
6637
        DispatchCallCapture(UniformBlockBinding, captures);
6638
        return;
6639
    }
6640
    if (call.customFunctionName == "UpdateBufferID")
6641
    {
6642
        DispatchCallCapture(UpdateBufferID, captures);
6643
        return;
6644
    }
6645
    if (call.customFunctionName == "UpdateClientArrayPointer")
6646
    {
6647
        DispatchCallCapture(UpdateClientArrayPointer, captures);
6648
        return;
6649
    }
6650
    if (call.customFunctionName == "UpdateClientBufferData")
6651
    {
6652
        DispatchCallCapture(UpdateClientBufferData, captures);
6653
        return;
6654
    }
6655
    if (call.customFunctionName == "UpdateClientBufferDataWithOffset")
6656
    {
6657
        DispatchCallCapture(UpdateClientBufferDataWithOffset, captures);
6658
        return;
6659
    }
6660
    if (call.customFunctionName == "UpdateCurrentProgram")
6661
    {
6662
        DispatchCallCapture(UpdateCurrentProgram, captures);
6663
        return;
6664
    }
6665
    if (call.customFunctionName == "UpdateFenceNVID")
6666
    {
6667
        DispatchCallCapture(UpdateFenceNVID, captures);
6668
        return;
6669
    }
6670
    if (call.customFunctionName == "UpdateFramebufferID")
6671
    {
6672
        DispatchCallCapture(UpdateFramebufferID, captures);
6673
        return;
6674
    }
6675
    if (call.customFunctionName == "UpdateMemoryObjectID")
6676
    {
6677
        DispatchCallCapture(UpdateMemoryObjectID, captures);
6678
        return;
6679
    }
6680
    if (call.customFunctionName == "UpdateProgramPipelineID")
6681
    {
6682
        DispatchCallCapture(UpdateProgramPipelineID, captures);
6683
        return;
6684
    }
6685
    if (call.customFunctionName == "UpdateQueryID")
6686
    {
6687
        DispatchCallCapture(UpdateQueryID, captures);
6688
        return;
6689
    }
6690
    if (call.customFunctionName == "UpdateRenderbufferID")
6691
    {
6692
        DispatchCallCapture(UpdateRenderbufferID, captures);
6693
        return;
6694
    }
6695
    if (call.customFunctionName == "UpdateResourceIDBuffer")
6696
    {
6697
        DispatchCallCapture(UpdateResourceIDBuffer, captures);
6698
        return;
6699
    }
6700
    if (call.customFunctionName == "UpdateSamplerID")
6701
    {
6702
        DispatchCallCapture(UpdateSamplerID, captures);
6703
        return;
6704
    }
6705
    if (call.customFunctionName == "UpdateSemaphoreID")
6706
    {
6707
        DispatchCallCapture(UpdateSemaphoreID, captures);
6708
        return;
6709
    }
6710
    if (call.customFunctionName == "UpdateShaderProgramID")
6711
    {
6712
        DispatchCallCapture(UpdateShaderProgramID, captures);
6713
        return;
6714
    }
6715
    if (call.customFunctionName == "UpdateTextureID")
6716
    {
6717
        DispatchCallCapture(UpdateTextureID, captures);
6718
        return;
6719
    }
6720
    if (call.customFunctionName == "UpdateTransformFeedbackID")
6721
    {
6722
        DispatchCallCapture(UpdateTransformFeedbackID, captures);
6723
        return;
6724
    }
6725
    if (call.customFunctionName == "UpdateUniformBlockIndex")
6726
    {
6727
        DispatchCallCapture(UpdateUniformBlockIndex, captures);
6728
        return;
6729
    }
6730
    if (call.customFunctionName == "UpdateUniformLocation")
6731
    {
6732
        DispatchCallCapture(UpdateUniformLocation, captures);
6733
        return;
6734
    }
6735
    if (call.customFunctionName == "UpdateVertexArrayID")
6736
    {
6737
        DispatchCallCapture(UpdateVertexArrayID, captures);
6738
        return;
6739
    }
6740
    if (call.customFunctionName == "ValidateSerializedState")
6741
    {
6742
        DispatchCallCapture(ValidateSerializedState, captures);
6743
        return;
6744
    }
6745

6746
    auto iter = customFunctions.find(call.customFunctionName);
6747
    if (iter == customFunctions.end())
6748
    {
6749
        printf("Unknown custom function: %s\n", call.customFunctionName.c_str());
6750
        UNREACHABLE();
6751
    }
6752
    else
6753
    {
6754
        ASSERT(call.params.empty());
6755
        const TraceFunction &customFunc = iter->second;
6756
        for (const CallCapture &customCall : customFunc)
6757
        {
6758
            ReplayTraceFunctionCall(customCall, customFunctions);
6759
        }
6760
    }
6761
}
6762
}  // namespace angle
6763

6764
Product

Resources

Company
