CoCalc -- egl.c

GitHub Repository: stenzek/duckstation
Path: blob/master/dep/glad/src/egl.c
⁴²⁴⁶ views
1
/**
2
 * SPDX-License-Identifier: (WTFPL OR CC0-1.0) AND Apache-2.0
3
 */
4
#include <stdio.h>
5
#include <stdlib.h>
6
#include <string.h>
7
#include <glad/egl.h>
8

9
#ifndef GLAD_IMPL_UTIL_C_
10
#define GLAD_IMPL_UTIL_C_
11

12
#ifdef _MSC_VER
13
#define GLAD_IMPL_UTIL_SSCANF sscanf_s
14
#else
15
#define GLAD_IMPL_UTIL_SSCANF sscanf
16
#endif
17

18
#endif /* GLAD_IMPL_UTIL_C_ */
19

20
#ifdef __cplusplus
21
extern "C" {
22
#endif
23

24

25

26
int GLAD_EGL_VERSION_1_0 = 0;
27
int GLAD_EGL_VERSION_1_1 = 0;
28
int GLAD_EGL_VERSION_1_2 = 0;
29
int GLAD_EGL_VERSION_1_3 = 0;
30
int GLAD_EGL_VERSION_1_4 = 0;
31
int GLAD_EGL_VERSION_1_5 = 0;
32
int GLAD_EGL_ANDROID_GLES_layers = 0;
33
int GLAD_EGL_ANDROID_blob_cache = 0;
34
int GLAD_EGL_ANDROID_create_native_client_buffer = 0;
35
int GLAD_EGL_ANDROID_framebuffer_target = 0;
36
int GLAD_EGL_ANDROID_front_buffer_auto_refresh = 0;
37
int GLAD_EGL_ANDROID_get_frame_timestamps = 0;
38
int GLAD_EGL_ANDROID_get_native_client_buffer = 0;
39
int GLAD_EGL_ANDROID_image_native_buffer = 0;
40
int GLAD_EGL_ANDROID_native_fence_sync = 0;
41
int GLAD_EGL_ANDROID_presentation_time = 0;
42
int GLAD_EGL_ANDROID_recordable = 0;
43
int GLAD_EGL_ANGLE_d3d_share_handle_client_buffer = 0;
44
int GLAD_EGL_ANGLE_device_d3d = 0;
45
int GLAD_EGL_ANGLE_query_surface_pointer = 0;
46
int GLAD_EGL_ANGLE_surface_d3d_texture_2d_share_handle = 0;
47
int GLAD_EGL_ANGLE_sync_control_rate = 0;
48
int GLAD_EGL_ANGLE_window_fixed_size = 0;
49
int GLAD_EGL_ARM_image_format = 0;
50
int GLAD_EGL_ARM_implicit_external_sync = 0;
51
int GLAD_EGL_ARM_pixmap_multisample_discard = 0;
52
int GLAD_EGL_EXT_bind_to_front = 0;
53
int GLAD_EGL_EXT_buffer_age = 0;
54
int GLAD_EGL_EXT_client_extensions = 0;
55
int GLAD_EGL_EXT_client_sync = 0;
56
int GLAD_EGL_EXT_compositor = 0;
57
int GLAD_EGL_EXT_config_select_group = 0;
58
int GLAD_EGL_EXT_create_context_robustness = 0;
59
int GLAD_EGL_EXT_device_base = 0;
60
int GLAD_EGL_EXT_device_drm = 0;
61
int GLAD_EGL_EXT_device_drm_render_node = 0;
62
int GLAD_EGL_EXT_device_enumeration = 0;
63
int GLAD_EGL_EXT_device_openwf = 0;
64
int GLAD_EGL_EXT_device_persistent_id = 0;
65
int GLAD_EGL_EXT_device_query = 0;
66
int GLAD_EGL_EXT_device_query_name = 0;
67
int GLAD_EGL_EXT_explicit_device = 0;
68
int GLAD_EGL_EXT_gl_colorspace_bt2020_hlg = 0;
69
int GLAD_EGL_EXT_gl_colorspace_bt2020_linear = 0;
70
int GLAD_EGL_EXT_gl_colorspace_bt2020_pq = 0;
71
int GLAD_EGL_EXT_gl_colorspace_display_p3 = 0;
72
int GLAD_EGL_EXT_gl_colorspace_display_p3_linear = 0;
73
int GLAD_EGL_EXT_gl_colorspace_display_p3_passthrough = 0;
74
int GLAD_EGL_EXT_gl_colorspace_scrgb = 0;
75
int GLAD_EGL_EXT_gl_colorspace_scrgb_linear = 0;
76
int GLAD_EGL_EXT_image_dma_buf_import = 0;
77
int GLAD_EGL_EXT_image_dma_buf_import_modifiers = 0;
78
int GLAD_EGL_EXT_image_gl_colorspace = 0;
79
int GLAD_EGL_EXT_image_implicit_sync_control = 0;
80
int GLAD_EGL_EXT_multiview_window = 0;
81
int GLAD_EGL_EXT_output_base = 0;
82
int GLAD_EGL_EXT_output_drm = 0;
83
int GLAD_EGL_EXT_output_openwf = 0;
84
int GLAD_EGL_EXT_pixel_format_float = 0;
85
int GLAD_EGL_EXT_platform_base = 0;
86
int GLAD_EGL_EXT_platform_device = 0;
87
int GLAD_EGL_EXT_platform_wayland = 0;
88
int GLAD_EGL_EXT_platform_x11 = 0;
89
int GLAD_EGL_EXT_platform_xcb = 0;
90
int GLAD_EGL_EXT_present_opaque = 0;
91
int GLAD_EGL_EXT_protected_content = 0;
92
int GLAD_EGL_EXT_protected_surface = 0;
93
int GLAD_EGL_EXT_query_reset_notification_strategy = 0;
94
int GLAD_EGL_EXT_stream_consumer_egloutput = 0;
95
int GLAD_EGL_EXT_surface_CTA861_3_metadata = 0;
96
int GLAD_EGL_EXT_surface_SMPTE2086_metadata = 0;
97
int GLAD_EGL_EXT_surface_compression = 0;
98
int GLAD_EGL_EXT_swap_buffers_with_damage = 0;
99
int GLAD_EGL_EXT_sync_reuse = 0;
100
int GLAD_EGL_EXT_yuv_surface = 0;
101
int GLAD_EGL_HI_clientpixmap = 0;
102
int GLAD_EGL_HI_colorformats = 0;
103
int GLAD_EGL_IMG_context_priority = 0;
104
int GLAD_EGL_IMG_image_plane_attribs = 0;
105
int GLAD_EGL_KHR_cl_event = 0;
106
int GLAD_EGL_KHR_cl_event2 = 0;
107
int GLAD_EGL_KHR_client_get_all_proc_addresses = 0;
108
int GLAD_EGL_KHR_config_attribs = 0;
109
int GLAD_EGL_KHR_context_flush_control = 0;
110
int GLAD_EGL_KHR_create_context = 0;
111
int GLAD_EGL_KHR_create_context_no_error = 0;
112
int GLAD_EGL_KHR_debug = 0;
113
int GLAD_EGL_KHR_display_reference = 0;
114
int GLAD_EGL_KHR_fence_sync = 0;
115
int GLAD_EGL_KHR_get_all_proc_addresses = 0;
116
int GLAD_EGL_KHR_gl_colorspace = 0;
117
int GLAD_EGL_KHR_gl_renderbuffer_image = 0;
118
int GLAD_EGL_KHR_gl_texture_2D_image = 0;
119
int GLAD_EGL_KHR_gl_texture_3D_image = 0;
120
int GLAD_EGL_KHR_gl_texture_cubemap_image = 0;
121
int GLAD_EGL_KHR_image = 0;
122
int GLAD_EGL_KHR_image_base = 0;
123
int GLAD_EGL_KHR_image_pixmap = 0;
124
int GLAD_EGL_KHR_lock_surface = 0;
125
int GLAD_EGL_KHR_lock_surface2 = 0;
126
int GLAD_EGL_KHR_lock_surface3 = 0;
127
int GLAD_EGL_KHR_mutable_render_buffer = 0;
128
int GLAD_EGL_KHR_no_config_context = 0;
129
int GLAD_EGL_KHR_partial_update = 0;
130
int GLAD_EGL_KHR_platform_android = 0;
131
int GLAD_EGL_KHR_platform_gbm = 0;
132
int GLAD_EGL_KHR_platform_wayland = 0;
133
int GLAD_EGL_KHR_platform_x11 = 0;
134
int GLAD_EGL_KHR_reusable_sync = 0;
135
int GLAD_EGL_KHR_stream = 0;
136
int GLAD_EGL_KHR_stream_attrib = 0;
137
int GLAD_EGL_KHR_stream_consumer_gltexture = 0;
138
int GLAD_EGL_KHR_stream_cross_process_fd = 0;
139
int GLAD_EGL_KHR_stream_fifo = 0;
140
int GLAD_EGL_KHR_stream_producer_aldatalocator = 0;
141
int GLAD_EGL_KHR_stream_producer_eglsurface = 0;
142
int GLAD_EGL_KHR_surfaceless_context = 0;
143
int GLAD_EGL_KHR_swap_buffers_with_damage = 0;
144
int GLAD_EGL_KHR_vg_parent_image = 0;
145
int GLAD_EGL_KHR_wait_sync = 0;
146
int GLAD_EGL_MESA_drm_image = 0;
147
int GLAD_EGL_MESA_image_dma_buf_export = 0;
148
int GLAD_EGL_MESA_platform_gbm = 0;
149
int GLAD_EGL_MESA_platform_surfaceless = 0;
150
int GLAD_EGL_MESA_query_driver = 0;
151
int GLAD_EGL_NOK_swap_region = 0;
152
int GLAD_EGL_NOK_swap_region2 = 0;
153
int GLAD_EGL_NOK_texture_from_pixmap = 0;
154
int GLAD_EGL_NV_3dvision_surface = 0;
155
int GLAD_EGL_NV_context_priority_realtime = 0;
156
int GLAD_EGL_NV_coverage_sample = 0;
157
int GLAD_EGL_NV_coverage_sample_resolve = 0;
158
int GLAD_EGL_NV_cuda_event = 0;
159
int GLAD_EGL_NV_depth_nonlinear = 0;
160
int GLAD_EGL_NV_device_cuda = 0;
161
int GLAD_EGL_NV_native_query = 0;
162
int GLAD_EGL_NV_post_convert_rounding = 0;
163
int GLAD_EGL_NV_post_sub_buffer = 0;
164
int GLAD_EGL_NV_quadruple_buffer = 0;
165
int GLAD_EGL_NV_robustness_video_memory_purge = 0;
166
int GLAD_EGL_NV_stream_consumer_eglimage = 0;
167
int GLAD_EGL_NV_stream_consumer_eglimage_use_scanout_attrib = 0;
168
int GLAD_EGL_NV_stream_consumer_gltexture_yuv = 0;
169
int GLAD_EGL_NV_stream_cross_display = 0;
170
int GLAD_EGL_NV_stream_cross_object = 0;
171
int GLAD_EGL_NV_stream_cross_partition = 0;
172
int GLAD_EGL_NV_stream_cross_process = 0;
173
int GLAD_EGL_NV_stream_cross_system = 0;
174
int GLAD_EGL_NV_stream_dma = 0;
175
int GLAD_EGL_NV_stream_fifo_next = 0;
176
int GLAD_EGL_NV_stream_fifo_synchronous = 0;
177
int GLAD_EGL_NV_stream_flush = 0;
178
int GLAD_EGL_NV_stream_frame_limits = 0;
179
int GLAD_EGL_NV_stream_metadata = 0;
180
int GLAD_EGL_NV_stream_origin = 0;
181
int GLAD_EGL_NV_stream_remote = 0;
182
int GLAD_EGL_NV_stream_reset = 0;
183
int GLAD_EGL_NV_stream_socket = 0;
184
int GLAD_EGL_NV_stream_socket_inet = 0;
185
int GLAD_EGL_NV_stream_socket_unix = 0;
186
int GLAD_EGL_NV_stream_sync = 0;
187
int GLAD_EGL_NV_sync = 0;
188
int GLAD_EGL_NV_system_time = 0;
189
int GLAD_EGL_NV_triple_buffer = 0;
190
int GLAD_EGL_QNX_image_native_buffer = 0;
191
int GLAD_EGL_QNX_platform_screen = 0;
192
int GLAD_EGL_TIZEN_image_native_buffer = 0;
193
int GLAD_EGL_TIZEN_image_native_surface = 0;
194
int GLAD_EGL_WL_bind_wayland_display = 0;
195
int GLAD_EGL_WL_create_wayland_buffer_from_image = 0;
196

197

198

199
PFNEGLBINDAPIPROC glad_eglBindAPI = NULL;
200
PFNEGLBINDTEXIMAGEPROC glad_eglBindTexImage = NULL;
201
PFNEGLBINDWAYLANDDISPLAYWLPROC glad_eglBindWaylandDisplayWL = NULL;
202
PFNEGLCHOOSECONFIGPROC glad_eglChooseConfig = NULL;
203
PFNEGLCLIENTSIGNALSYNCEXTPROC glad_eglClientSignalSyncEXT = NULL;
204
PFNEGLCLIENTWAITSYNCPROC glad_eglClientWaitSync = NULL;
205
PFNEGLCLIENTWAITSYNCKHRPROC glad_eglClientWaitSyncKHR = NULL;
206
PFNEGLCLIENTWAITSYNCNVPROC glad_eglClientWaitSyncNV = NULL;
207
PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC glad_eglCompositorBindTexWindowEXT = NULL;
208
PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC glad_eglCompositorSetContextAttributesEXT = NULL;
209
PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC glad_eglCompositorSetContextListEXT = NULL;
210
PFNEGLCOMPOSITORSETSIZEEXTPROC glad_eglCompositorSetSizeEXT = NULL;
211
PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC glad_eglCompositorSetWindowAttributesEXT = NULL;
212
PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC glad_eglCompositorSetWindowListEXT = NULL;
213
PFNEGLCOMPOSITORSWAPPOLICYEXTPROC glad_eglCompositorSwapPolicyEXT = NULL;
214
PFNEGLCOPYBUFFERSPROC glad_eglCopyBuffers = NULL;
215
PFNEGLCREATECONTEXTPROC glad_eglCreateContext = NULL;
216
PFNEGLCREATEDRMIMAGEMESAPROC glad_eglCreateDRMImageMESA = NULL;
217
PFNEGLCREATEFENCESYNCNVPROC glad_eglCreateFenceSyncNV = NULL;
218
PFNEGLCREATEIMAGEPROC glad_eglCreateImage = NULL;
219
PFNEGLCREATEIMAGEKHRPROC glad_eglCreateImageKHR = NULL;
220
PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC glad_eglCreateNativeClientBufferANDROID = NULL;
221
PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC glad_eglCreatePbufferFromClientBuffer = NULL;
222
PFNEGLCREATEPBUFFERSURFACEPROC glad_eglCreatePbufferSurface = NULL;
223
PFNEGLCREATEPIXMAPSURFACEPROC glad_eglCreatePixmapSurface = NULL;
224
PFNEGLCREATEPIXMAPSURFACEHIPROC glad_eglCreatePixmapSurfaceHI = NULL;
225
PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC glad_eglCreatePlatformPixmapSurface = NULL;
226
PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC glad_eglCreatePlatformPixmapSurfaceEXT = NULL;
227
PFNEGLCREATEPLATFORMWINDOWSURFACEPROC glad_eglCreatePlatformWindowSurface = NULL;
228
PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC glad_eglCreatePlatformWindowSurfaceEXT = NULL;
229
PFNEGLCREATESTREAMATTRIBKHRPROC glad_eglCreateStreamAttribKHR = NULL;
230
PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC glad_eglCreateStreamFromFileDescriptorKHR = NULL;
231
PFNEGLCREATESTREAMKHRPROC glad_eglCreateStreamKHR = NULL;
232
PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC glad_eglCreateStreamProducerSurfaceKHR = NULL;
233
PFNEGLCREATESTREAMSYNCNVPROC glad_eglCreateStreamSyncNV = NULL;
234
PFNEGLCREATESYNCPROC glad_eglCreateSync = NULL;
235
PFNEGLCREATESYNC64KHRPROC glad_eglCreateSync64KHR = NULL;
236
PFNEGLCREATESYNCKHRPROC glad_eglCreateSyncKHR = NULL;
237
PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC glad_eglCreateWaylandBufferFromImageWL = NULL;
238
PFNEGLCREATEWINDOWSURFACEPROC glad_eglCreateWindowSurface = NULL;
239
PFNEGLDEBUGMESSAGECONTROLKHRPROC glad_eglDebugMessageControlKHR = NULL;
240
PFNEGLDESTROYCONTEXTPROC glad_eglDestroyContext = NULL;
241
PFNEGLDESTROYIMAGEPROC glad_eglDestroyImage = NULL;
242
PFNEGLDESTROYIMAGEKHRPROC glad_eglDestroyImageKHR = NULL;
243
PFNEGLDESTROYSTREAMKHRPROC glad_eglDestroyStreamKHR = NULL;
244
PFNEGLDESTROYSURFACEPROC glad_eglDestroySurface = NULL;
245
PFNEGLDESTROYSYNCPROC glad_eglDestroySync = NULL;
246
PFNEGLDESTROYSYNCKHRPROC glad_eglDestroySyncKHR = NULL;
247
PFNEGLDESTROYSYNCNVPROC glad_eglDestroySyncNV = NULL;
248
PFNEGLDUPNATIVEFENCEFDANDROIDPROC glad_eglDupNativeFenceFDANDROID = NULL;
249
PFNEGLEXPORTDMABUFIMAGEMESAPROC glad_eglExportDMABUFImageMESA = NULL;
250
PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC glad_eglExportDMABUFImageQueryMESA = NULL;
251
PFNEGLEXPORTDRMIMAGEMESAPROC glad_eglExportDRMImageMESA = NULL;
252
PFNEGLFENCENVPROC glad_eglFenceNV = NULL;
253
PFNEGLGETCOMPOSITORTIMINGANDROIDPROC glad_eglGetCompositorTimingANDROID = NULL;
254
PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC glad_eglGetCompositorTimingSupportedANDROID = NULL;
255
PFNEGLGETCONFIGATTRIBPROC glad_eglGetConfigAttrib = NULL;
256
PFNEGLGETCONFIGSPROC glad_eglGetConfigs = NULL;
257
PFNEGLGETCURRENTCONTEXTPROC glad_eglGetCurrentContext = NULL;
258
PFNEGLGETCURRENTDISPLAYPROC glad_eglGetCurrentDisplay = NULL;
259
PFNEGLGETCURRENTSURFACEPROC glad_eglGetCurrentSurface = NULL;
260
PFNEGLGETDISPLAYPROC glad_eglGetDisplay = NULL;
261
PFNEGLGETDISPLAYDRIVERCONFIGPROC glad_eglGetDisplayDriverConfig = NULL;
262
PFNEGLGETDISPLAYDRIVERNAMEPROC glad_eglGetDisplayDriverName = NULL;
263
PFNEGLGETERRORPROC glad_eglGetError = NULL;
264
PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC glad_eglGetFrameTimestampSupportedANDROID = NULL;
265
PFNEGLGETFRAMETIMESTAMPSANDROIDPROC glad_eglGetFrameTimestampsANDROID = NULL;
266
PFNEGLGETMSCRATEANGLEPROC glad_eglGetMscRateANGLE = NULL;
267
PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC glad_eglGetNativeClientBufferANDROID = NULL;
268
PFNEGLGETNEXTFRAMEIDANDROIDPROC glad_eglGetNextFrameIdANDROID = NULL;
269
PFNEGLGETOUTPUTLAYERSEXTPROC glad_eglGetOutputLayersEXT = NULL;
270
PFNEGLGETOUTPUTPORTSEXTPROC glad_eglGetOutputPortsEXT = NULL;
271
PFNEGLGETPLATFORMDISPLAYPROC glad_eglGetPlatformDisplay = NULL;
272
PFNEGLGETPLATFORMDISPLAYEXTPROC glad_eglGetPlatformDisplayEXT = NULL;
273
PFNEGLGETPROCADDRESSPROC glad_eglGetProcAddress = NULL;
274
PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC glad_eglGetStreamFileDescriptorKHR = NULL;
275
PFNEGLGETSYNCATTRIBPROC glad_eglGetSyncAttrib = NULL;
276
PFNEGLGETSYNCATTRIBKHRPROC glad_eglGetSyncAttribKHR = NULL;
277
PFNEGLGETSYNCATTRIBNVPROC glad_eglGetSyncAttribNV = NULL;
278
PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC glad_eglGetSystemTimeFrequencyNV = NULL;
279
PFNEGLGETSYSTEMTIMENVPROC glad_eglGetSystemTimeNV = NULL;
280
PFNEGLINITIALIZEPROC glad_eglInitialize = NULL;
281
PFNEGLLABELOBJECTKHRPROC glad_eglLabelObjectKHR = NULL;
282
PFNEGLLOCKSURFACEKHRPROC glad_eglLockSurfaceKHR = NULL;
283
PFNEGLMAKECURRENTPROC glad_eglMakeCurrent = NULL;
284
PFNEGLOUTPUTLAYERATTRIBEXTPROC glad_eglOutputLayerAttribEXT = NULL;
285
PFNEGLOUTPUTPORTATTRIBEXTPROC glad_eglOutputPortAttribEXT = NULL;
286
PFNEGLPOSTSUBBUFFERNVPROC glad_eglPostSubBufferNV = NULL;
287
PFNEGLPRESENTATIONTIMEANDROIDPROC glad_eglPresentationTimeANDROID = NULL;
288
PFNEGLQUERYAPIPROC glad_eglQueryAPI = NULL;
289
PFNEGLQUERYCONTEXTPROC glad_eglQueryContext = NULL;
290
PFNEGLQUERYDEBUGKHRPROC glad_eglQueryDebugKHR = NULL;
291
PFNEGLQUERYDEVICEATTRIBEXTPROC glad_eglQueryDeviceAttribEXT = NULL;
292
PFNEGLQUERYDEVICEBINARYEXTPROC glad_eglQueryDeviceBinaryEXT = NULL;
293
PFNEGLQUERYDEVICESTRINGEXTPROC glad_eglQueryDeviceStringEXT = NULL;
294
PFNEGLQUERYDEVICESEXTPROC glad_eglQueryDevicesEXT = NULL;
295
PFNEGLQUERYDISPLAYATTRIBEXTPROC glad_eglQueryDisplayAttribEXT = NULL;
296
PFNEGLQUERYDISPLAYATTRIBKHRPROC glad_eglQueryDisplayAttribKHR = NULL;
297
PFNEGLQUERYDISPLAYATTRIBNVPROC glad_eglQueryDisplayAttribNV = NULL;
298
PFNEGLQUERYDMABUFFORMATSEXTPROC glad_eglQueryDmaBufFormatsEXT = NULL;
299
PFNEGLQUERYDMABUFMODIFIERSEXTPROC glad_eglQueryDmaBufModifiersEXT = NULL;
300
PFNEGLQUERYNATIVEDISPLAYNVPROC glad_eglQueryNativeDisplayNV = NULL;
301
PFNEGLQUERYNATIVEPIXMAPNVPROC glad_eglQueryNativePixmapNV = NULL;
302
PFNEGLQUERYNATIVEWINDOWNVPROC glad_eglQueryNativeWindowNV = NULL;
303
PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC glad_eglQueryOutputLayerAttribEXT = NULL;
304
PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC glad_eglQueryOutputLayerStringEXT = NULL;
305
PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC glad_eglQueryOutputPortAttribEXT = NULL;
306
PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC glad_eglQueryOutputPortStringEXT = NULL;
307
PFNEGLQUERYSTREAMATTRIBKHRPROC glad_eglQueryStreamAttribKHR = NULL;
308
PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC glad_eglQueryStreamConsumerEventNV = NULL;
309
PFNEGLQUERYSTREAMKHRPROC glad_eglQueryStreamKHR = NULL;
310
PFNEGLQUERYSTREAMMETADATANVPROC glad_eglQueryStreamMetadataNV = NULL;
311
PFNEGLQUERYSTREAMTIMEKHRPROC glad_eglQueryStreamTimeKHR = NULL;
312
PFNEGLQUERYSTREAMU64KHRPROC glad_eglQueryStreamu64KHR = NULL;
313
PFNEGLQUERYSTRINGPROC glad_eglQueryString = NULL;
314
PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC glad_eglQuerySupportedCompressionRatesEXT = NULL;
315
PFNEGLQUERYSURFACEPROC glad_eglQuerySurface = NULL;
316
PFNEGLQUERYSURFACE64KHRPROC glad_eglQuerySurface64KHR = NULL;
317
PFNEGLQUERYSURFACEPOINTERANGLEPROC glad_eglQuerySurfacePointerANGLE = NULL;
318
PFNEGLQUERYWAYLANDBUFFERWLPROC glad_eglQueryWaylandBufferWL = NULL;
319
PFNEGLRELEASETEXIMAGEPROC glad_eglReleaseTexImage = NULL;
320
PFNEGLRELEASETHREADPROC glad_eglReleaseThread = NULL;
321
PFNEGLRESETSTREAMNVPROC glad_eglResetStreamNV = NULL;
322
PFNEGLSETBLOBCACHEFUNCSANDROIDPROC glad_eglSetBlobCacheFuncsANDROID = NULL;
323
PFNEGLSETDAMAGEREGIONKHRPROC glad_eglSetDamageRegionKHR = NULL;
324
PFNEGLSETSTREAMATTRIBKHRPROC glad_eglSetStreamAttribKHR = NULL;
325
PFNEGLSETSTREAMMETADATANVPROC glad_eglSetStreamMetadataNV = NULL;
326
PFNEGLSIGNALSYNCKHRPROC glad_eglSignalSyncKHR = NULL;
327
PFNEGLSIGNALSYNCNVPROC glad_eglSignalSyncNV = NULL;
328
PFNEGLSTREAMACQUIREIMAGENVPROC glad_eglStreamAcquireImageNV = NULL;
329
PFNEGLSTREAMATTRIBKHRPROC glad_eglStreamAttribKHR = NULL;
330
PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC glad_eglStreamConsumerAcquireAttribKHR = NULL;
331
PFNEGLSTREAMCONSUMERACQUIREKHRPROC glad_eglStreamConsumerAcquireKHR = NULL;
332
PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC glad_eglStreamConsumerGLTextureExternalAttribsNV = NULL;
333
PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC glad_eglStreamConsumerGLTextureExternalKHR = NULL;
334
PFNEGLSTREAMCONSUMEROUTPUTEXTPROC glad_eglStreamConsumerOutputEXT = NULL;
335
PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC glad_eglStreamConsumerReleaseAttribKHR = NULL;
336
PFNEGLSTREAMCONSUMERRELEASEKHRPROC glad_eglStreamConsumerReleaseKHR = NULL;
337
PFNEGLSTREAMFLUSHNVPROC glad_eglStreamFlushNV = NULL;
338
PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC glad_eglStreamImageConsumerConnectNV = NULL;
339
PFNEGLSTREAMRELEASEIMAGENVPROC glad_eglStreamReleaseImageNV = NULL;
340
PFNEGLSURFACEATTRIBPROC glad_eglSurfaceAttrib = NULL;
341
PFNEGLSWAPBUFFERSPROC glad_eglSwapBuffers = NULL;
342
PFNEGLSWAPBUFFERSREGION2NOKPROC glad_eglSwapBuffersRegion2NOK = NULL;
343
PFNEGLSWAPBUFFERSREGIONNOKPROC glad_eglSwapBuffersRegionNOK = NULL;
344
PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC glad_eglSwapBuffersWithDamageEXT = NULL;
345
PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC glad_eglSwapBuffersWithDamageKHR = NULL;
346
PFNEGLSWAPINTERVALPROC glad_eglSwapInterval = NULL;
347
PFNEGLTERMINATEPROC glad_eglTerminate = NULL;
348
PFNEGLUNBINDWAYLANDDISPLAYWLPROC glad_eglUnbindWaylandDisplayWL = NULL;
349
PFNEGLUNLOCKSURFACEKHRPROC glad_eglUnlockSurfaceKHR = NULL;
350
PFNEGLUNSIGNALSYNCEXTPROC glad_eglUnsignalSyncEXT = NULL;
351
PFNEGLWAITCLIENTPROC glad_eglWaitClient = NULL;
352
PFNEGLWAITGLPROC glad_eglWaitGL = NULL;
353
PFNEGLWAITNATIVEPROC glad_eglWaitNative = NULL;
354
PFNEGLWAITSYNCPROC glad_eglWaitSync = NULL;
355
PFNEGLWAITSYNCKHRPROC glad_eglWaitSyncKHR = NULL;
356

357

358
static void glad_egl_load_EGL_VERSION_1_0( GLADuserptrloadfunc load, void* userptr) {
359
    if(!GLAD_EGL_VERSION_1_0) return;
360
    glad_eglChooseConfig = (PFNEGLCHOOSECONFIGPROC) load(userptr, "eglChooseConfig");
361
    glad_eglCopyBuffers = (PFNEGLCOPYBUFFERSPROC) load(userptr, "eglCopyBuffers");
362
    glad_eglCreateContext = (PFNEGLCREATECONTEXTPROC) load(userptr, "eglCreateContext");
363
    glad_eglCreatePbufferSurface = (PFNEGLCREATEPBUFFERSURFACEPROC) load(userptr, "eglCreatePbufferSurface");
364
    glad_eglCreatePixmapSurface = (PFNEGLCREATEPIXMAPSURFACEPROC) load(userptr, "eglCreatePixmapSurface");
365
    glad_eglCreateWindowSurface = (PFNEGLCREATEWINDOWSURFACEPROC) load(userptr, "eglCreateWindowSurface");
366
    glad_eglDestroyContext = (PFNEGLDESTROYCONTEXTPROC) load(userptr, "eglDestroyContext");
367
    glad_eglDestroySurface = (PFNEGLDESTROYSURFACEPROC) load(userptr, "eglDestroySurface");
368
    glad_eglGetConfigAttrib = (PFNEGLGETCONFIGATTRIBPROC) load(userptr, "eglGetConfigAttrib");
369
    glad_eglGetConfigs = (PFNEGLGETCONFIGSPROC) load(userptr, "eglGetConfigs");
370
    glad_eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay");
371
    glad_eglGetCurrentSurface = (PFNEGLGETCURRENTSURFACEPROC) load(userptr, "eglGetCurrentSurface");
372
    glad_eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay");
373
    glad_eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError");
374
    glad_eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC) load(userptr, "eglGetProcAddress");
375
    glad_eglInitialize = (PFNEGLINITIALIZEPROC) load(userptr, "eglInitialize");
376
    glad_eglMakeCurrent = (PFNEGLMAKECURRENTPROC) load(userptr, "eglMakeCurrent");
377
    glad_eglQueryContext = (PFNEGLQUERYCONTEXTPROC) load(userptr, "eglQueryContext");
378
    glad_eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString");
379
    glad_eglQuerySurface = (PFNEGLQUERYSURFACEPROC) load(userptr, "eglQuerySurface");
380
    glad_eglSwapBuffers = (PFNEGLSWAPBUFFERSPROC) load(userptr, "eglSwapBuffers");
381
    glad_eglTerminate = (PFNEGLTERMINATEPROC) load(userptr, "eglTerminate");
382
    glad_eglWaitGL = (PFNEGLWAITGLPROC) load(userptr, "eglWaitGL");
383
    glad_eglWaitNative = (PFNEGLWAITNATIVEPROC) load(userptr, "eglWaitNative");
384
}
385
static void glad_egl_load_EGL_VERSION_1_1( GLADuserptrloadfunc load, void* userptr) {
386
    if(!GLAD_EGL_VERSION_1_1) return;
387
    glad_eglBindTexImage = (PFNEGLBINDTEXIMAGEPROC) load(userptr, "eglBindTexImage");
388
    glad_eglReleaseTexImage = (PFNEGLRELEASETEXIMAGEPROC) load(userptr, "eglReleaseTexImage");
389
    glad_eglSurfaceAttrib = (PFNEGLSURFACEATTRIBPROC) load(userptr, "eglSurfaceAttrib");
390
    glad_eglSwapInterval = (PFNEGLSWAPINTERVALPROC) load(userptr, "eglSwapInterval");
391
}
392
static void glad_egl_load_EGL_VERSION_1_2( GLADuserptrloadfunc load, void* userptr) {
393
    if(!GLAD_EGL_VERSION_1_2) return;
394
    glad_eglBindAPI = (PFNEGLBINDAPIPROC) load(userptr, "eglBindAPI");
395
    glad_eglCreatePbufferFromClientBuffer = (PFNEGLCREATEPBUFFERFROMCLIENTBUFFERPROC) load(userptr, "eglCreatePbufferFromClientBuffer");
396
    glad_eglQueryAPI = (PFNEGLQUERYAPIPROC) load(userptr, "eglQueryAPI");
397
    glad_eglReleaseThread = (PFNEGLRELEASETHREADPROC) load(userptr, "eglReleaseThread");
398
    glad_eglWaitClient = (PFNEGLWAITCLIENTPROC) load(userptr, "eglWaitClient");
399
}
400
static void glad_egl_load_EGL_VERSION_1_4( GLADuserptrloadfunc load, void* userptr) {
401
    if(!GLAD_EGL_VERSION_1_4) return;
402
    glad_eglGetCurrentContext = (PFNEGLGETCURRENTCONTEXTPROC) load(userptr, "eglGetCurrentContext");
403
}
404
static void glad_egl_load_EGL_VERSION_1_5( GLADuserptrloadfunc load, void* userptr) {
405
    if(!GLAD_EGL_VERSION_1_5) return;
406
    glad_eglClientWaitSync = (PFNEGLCLIENTWAITSYNCPROC) load(userptr, "eglClientWaitSync");
407
    glad_eglCreateImage = (PFNEGLCREATEIMAGEPROC) load(userptr, "eglCreateImage");
408
    glad_eglCreatePlatformPixmapSurface = (PFNEGLCREATEPLATFORMPIXMAPSURFACEPROC) load(userptr, "eglCreatePlatformPixmapSurface");
409
    glad_eglCreatePlatformWindowSurface = (PFNEGLCREATEPLATFORMWINDOWSURFACEPROC) load(userptr, "eglCreatePlatformWindowSurface");
410
    glad_eglCreateSync = (PFNEGLCREATESYNCPROC) load(userptr, "eglCreateSync");
411
    glad_eglDestroyImage = (PFNEGLDESTROYIMAGEPROC) load(userptr, "eglDestroyImage");
412
    glad_eglDestroySync = (PFNEGLDESTROYSYNCPROC) load(userptr, "eglDestroySync");
413
    glad_eglGetPlatformDisplay = (PFNEGLGETPLATFORMDISPLAYPROC) load(userptr, "eglGetPlatformDisplay");
414
    glad_eglGetSyncAttrib = (PFNEGLGETSYNCATTRIBPROC) load(userptr, "eglGetSyncAttrib");
415
    glad_eglWaitSync = (PFNEGLWAITSYNCPROC) load(userptr, "eglWaitSync");
416
}
417
static void glad_egl_load_EGL_ANDROID_blob_cache( GLADuserptrloadfunc load, void* userptr) {
418
    if(!GLAD_EGL_ANDROID_blob_cache) return;
419
    glad_eglSetBlobCacheFuncsANDROID = (PFNEGLSETBLOBCACHEFUNCSANDROIDPROC) load(userptr, "eglSetBlobCacheFuncsANDROID");
420
}
421
static void glad_egl_load_EGL_ANDROID_create_native_client_buffer( GLADuserptrloadfunc load, void* userptr) {
422
    if(!GLAD_EGL_ANDROID_create_native_client_buffer) return;
423
    glad_eglCreateNativeClientBufferANDROID = (PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC) load(userptr, "eglCreateNativeClientBufferANDROID");
424
}
425
static void glad_egl_load_EGL_ANDROID_get_frame_timestamps( GLADuserptrloadfunc load, void* userptr) {
426
    if(!GLAD_EGL_ANDROID_get_frame_timestamps) return;
427
    glad_eglGetCompositorTimingANDROID = (PFNEGLGETCOMPOSITORTIMINGANDROIDPROC) load(userptr, "eglGetCompositorTimingANDROID");
428
    glad_eglGetCompositorTimingSupportedANDROID = (PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC) load(userptr, "eglGetCompositorTimingSupportedANDROID");
429
    glad_eglGetFrameTimestampSupportedANDROID = (PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC) load(userptr, "eglGetFrameTimestampSupportedANDROID");
430
    glad_eglGetFrameTimestampsANDROID = (PFNEGLGETFRAMETIMESTAMPSANDROIDPROC) load(userptr, "eglGetFrameTimestampsANDROID");
431
    glad_eglGetNextFrameIdANDROID = (PFNEGLGETNEXTFRAMEIDANDROIDPROC) load(userptr, "eglGetNextFrameIdANDROID");
432
}
433
static void glad_egl_load_EGL_ANDROID_get_native_client_buffer( GLADuserptrloadfunc load, void* userptr) {
434
    if(!GLAD_EGL_ANDROID_get_native_client_buffer) return;
435
    glad_eglGetNativeClientBufferANDROID = (PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) load(userptr, "eglGetNativeClientBufferANDROID");
436
}
437
static void glad_egl_load_EGL_ANDROID_native_fence_sync( GLADuserptrloadfunc load, void* userptr) {
438
    if(!GLAD_EGL_ANDROID_native_fence_sync) return;
439
    glad_eglDupNativeFenceFDANDROID = (PFNEGLDUPNATIVEFENCEFDANDROIDPROC) load(userptr, "eglDupNativeFenceFDANDROID");
440
}
441
static void glad_egl_load_EGL_ANDROID_presentation_time( GLADuserptrloadfunc load, void* userptr) {
442
    if(!GLAD_EGL_ANDROID_presentation_time) return;
443
    glad_eglPresentationTimeANDROID = (PFNEGLPRESENTATIONTIMEANDROIDPROC) load(userptr, "eglPresentationTimeANDROID");
444
}
445
static void glad_egl_load_EGL_ANGLE_query_surface_pointer( GLADuserptrloadfunc load, void* userptr) {
446
    if(!GLAD_EGL_ANGLE_query_surface_pointer) return;
447
    glad_eglQuerySurfacePointerANGLE = (PFNEGLQUERYSURFACEPOINTERANGLEPROC) load(userptr, "eglQuerySurfacePointerANGLE");
448
}
449
static void glad_egl_load_EGL_ANGLE_sync_control_rate( GLADuserptrloadfunc load, void* userptr) {
450
    if(!GLAD_EGL_ANGLE_sync_control_rate) return;
451
    glad_eglGetMscRateANGLE = (PFNEGLGETMSCRATEANGLEPROC) load(userptr, "eglGetMscRateANGLE");
452
}
453
static void glad_egl_load_EGL_EXT_client_sync( GLADuserptrloadfunc load, void* userptr) {
454
    if(!GLAD_EGL_EXT_client_sync) return;
455
    glad_eglClientSignalSyncEXT = (PFNEGLCLIENTSIGNALSYNCEXTPROC) load(userptr, "eglClientSignalSyncEXT");
456
}
457
static void glad_egl_load_EGL_EXT_compositor( GLADuserptrloadfunc load, void* userptr) {
458
    if(!GLAD_EGL_EXT_compositor) return;
459
    glad_eglCompositorBindTexWindowEXT = (PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC) load(userptr, "eglCompositorBindTexWindowEXT");
460
    glad_eglCompositorSetContextAttributesEXT = (PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC) load(userptr, "eglCompositorSetContextAttributesEXT");
461
    glad_eglCompositorSetContextListEXT = (PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC) load(userptr, "eglCompositorSetContextListEXT");
462
    glad_eglCompositorSetSizeEXT = (PFNEGLCOMPOSITORSETSIZEEXTPROC) load(userptr, "eglCompositorSetSizeEXT");
463
    glad_eglCompositorSetWindowAttributesEXT = (PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC) load(userptr, "eglCompositorSetWindowAttributesEXT");
464
    glad_eglCompositorSetWindowListEXT = (PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC) load(userptr, "eglCompositorSetWindowListEXT");
465
    glad_eglCompositorSwapPolicyEXT = (PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) load(userptr, "eglCompositorSwapPolicyEXT");
466
}
467
static void glad_egl_load_EGL_EXT_device_base( GLADuserptrloadfunc load, void* userptr) {
468
    if(!GLAD_EGL_EXT_device_base) return;
469
    glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC) load(userptr, "eglQueryDeviceAttribEXT");
470
    glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC) load(userptr, "eglQueryDeviceStringEXT");
471
    glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC) load(userptr, "eglQueryDevicesEXT");
472
    glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC) load(userptr, "eglQueryDisplayAttribEXT");
473
}
474
static void glad_egl_load_EGL_EXT_device_enumeration( GLADuserptrloadfunc load, void* userptr) {
475
    if(!GLAD_EGL_EXT_device_enumeration) return;
476
    glad_eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC) load(userptr, "eglQueryDevicesEXT");
477
}
478
static void glad_egl_load_EGL_EXT_device_persistent_id( GLADuserptrloadfunc load, void* userptr) {
479
    if(!GLAD_EGL_EXT_device_persistent_id) return;
480
    glad_eglQueryDeviceBinaryEXT = (PFNEGLQUERYDEVICEBINARYEXTPROC) load(userptr, "eglQueryDeviceBinaryEXT");
481
}
482
static void glad_egl_load_EGL_EXT_device_query( GLADuserptrloadfunc load, void* userptr) {
483
    if(!GLAD_EGL_EXT_device_query) return;
484
    glad_eglQueryDeviceAttribEXT = (PFNEGLQUERYDEVICEATTRIBEXTPROC) load(userptr, "eglQueryDeviceAttribEXT");
485
    glad_eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC) load(userptr, "eglQueryDeviceStringEXT");
486
    glad_eglQueryDisplayAttribEXT = (PFNEGLQUERYDISPLAYATTRIBEXTPROC) load(userptr, "eglQueryDisplayAttribEXT");
487
}
488
static void glad_egl_load_EGL_EXT_image_dma_buf_import_modifiers( GLADuserptrloadfunc load, void* userptr) {
489
    if(!GLAD_EGL_EXT_image_dma_buf_import_modifiers) return;
490
    glad_eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC) load(userptr, "eglQueryDmaBufFormatsEXT");
491
    glad_eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC) load(userptr, "eglQueryDmaBufModifiersEXT");
492
}
493
static void glad_egl_load_EGL_EXT_output_base( GLADuserptrloadfunc load, void* userptr) {
494
    if(!GLAD_EGL_EXT_output_base) return;
495
    glad_eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC) load(userptr, "eglGetOutputLayersEXT");
496
    glad_eglGetOutputPortsEXT = (PFNEGLGETOUTPUTPORTSEXTPROC) load(userptr, "eglGetOutputPortsEXT");
497
    glad_eglOutputLayerAttribEXT = (PFNEGLOUTPUTLAYERATTRIBEXTPROC) load(userptr, "eglOutputLayerAttribEXT");
498
    glad_eglOutputPortAttribEXT = (PFNEGLOUTPUTPORTATTRIBEXTPROC) load(userptr, "eglOutputPortAttribEXT");
499
    glad_eglQueryOutputLayerAttribEXT = (PFNEGLQUERYOUTPUTLAYERATTRIBEXTPROC) load(userptr, "eglQueryOutputLayerAttribEXT");
500
    glad_eglQueryOutputLayerStringEXT = (PFNEGLQUERYOUTPUTLAYERSTRINGEXTPROC) load(userptr, "eglQueryOutputLayerStringEXT");
501
    glad_eglQueryOutputPortAttribEXT = (PFNEGLQUERYOUTPUTPORTATTRIBEXTPROC) load(userptr, "eglQueryOutputPortAttribEXT");
502
    glad_eglQueryOutputPortStringEXT = (PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC) load(userptr, "eglQueryOutputPortStringEXT");
503
}
504
static void glad_egl_load_EGL_EXT_platform_base( GLADuserptrloadfunc load, void* userptr) {
505
    if(!GLAD_EGL_EXT_platform_base) return;
506
    glad_eglCreatePlatformPixmapSurfaceEXT = (PFNEGLCREATEPLATFORMPIXMAPSURFACEEXTPROC) load(userptr, "eglCreatePlatformPixmapSurfaceEXT");
507
    glad_eglCreatePlatformWindowSurfaceEXT = (PFNEGLCREATEPLATFORMWINDOWSURFACEEXTPROC) load(userptr, "eglCreatePlatformWindowSurfaceEXT");
508
    glad_eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC) load(userptr, "eglGetPlatformDisplayEXT");
509
}
510
static void glad_egl_load_EGL_EXT_stream_consumer_egloutput( GLADuserptrloadfunc load, void* userptr) {
511
    if(!GLAD_EGL_EXT_stream_consumer_egloutput) return;
512
    glad_eglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) load(userptr, "eglStreamConsumerOutputEXT");
513
}
514
static void glad_egl_load_EGL_EXT_surface_compression( GLADuserptrloadfunc load, void* userptr) {
515
    if(!GLAD_EGL_EXT_surface_compression) return;
516
    glad_eglQuerySupportedCompressionRatesEXT = (PFNEGLQUERYSUPPORTEDCOMPRESSIONRATESEXTPROC) load(userptr, "eglQuerySupportedCompressionRatesEXT");
517
}
518
static void glad_egl_load_EGL_EXT_swap_buffers_with_damage( GLADuserptrloadfunc load, void* userptr) {
519
    if(!GLAD_EGL_EXT_swap_buffers_with_damage) return;
520
    glad_eglSwapBuffersWithDamageEXT = (PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) load(userptr, "eglSwapBuffersWithDamageEXT");
521
}
522
static void glad_egl_load_EGL_EXT_sync_reuse( GLADuserptrloadfunc load, void* userptr) {
523
    if(!GLAD_EGL_EXT_sync_reuse) return;
524
    glad_eglUnsignalSyncEXT = (PFNEGLUNSIGNALSYNCEXTPROC) load(userptr, "eglUnsignalSyncEXT");
525
}
526
static void glad_egl_load_EGL_HI_clientpixmap( GLADuserptrloadfunc load, void* userptr) {
527
    if(!GLAD_EGL_HI_clientpixmap) return;
528
    glad_eglCreatePixmapSurfaceHI = (PFNEGLCREATEPIXMAPSURFACEHIPROC) load(userptr, "eglCreatePixmapSurfaceHI");
529
}
530
static void glad_egl_load_EGL_KHR_cl_event2( GLADuserptrloadfunc load, void* userptr) {
531
    if(!GLAD_EGL_KHR_cl_event2) return;
532
    glad_eglCreateSync64KHR = (PFNEGLCREATESYNC64KHRPROC) load(userptr, "eglCreateSync64KHR");
533
}
534
static void glad_egl_load_EGL_KHR_debug( GLADuserptrloadfunc load, void* userptr) {
535
    if(!GLAD_EGL_KHR_debug) return;
536
    glad_eglDebugMessageControlKHR = (PFNEGLDEBUGMESSAGECONTROLKHRPROC) load(userptr, "eglDebugMessageControlKHR");
537
    glad_eglLabelObjectKHR = (PFNEGLLABELOBJECTKHRPROC) load(userptr, "eglLabelObjectKHR");
538
    glad_eglQueryDebugKHR = (PFNEGLQUERYDEBUGKHRPROC) load(userptr, "eglQueryDebugKHR");
539
}
540
static void glad_egl_load_EGL_KHR_display_reference( GLADuserptrloadfunc load, void* userptr) {
541
    if(!GLAD_EGL_KHR_display_reference) return;
542
    glad_eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC) load(userptr, "eglQueryDisplayAttribKHR");
543
}
544
static void glad_egl_load_EGL_KHR_fence_sync( GLADuserptrloadfunc load, void* userptr) {
545
    if(!GLAD_EGL_KHR_fence_sync) return;
546
    glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC) load(userptr, "eglClientWaitSyncKHR");
547
    glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC) load(userptr, "eglCreateSyncKHR");
548
    glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC) load(userptr, "eglDestroySyncKHR");
549
    glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC) load(userptr, "eglGetSyncAttribKHR");
550
}
551
static void glad_egl_load_EGL_KHR_image( GLADuserptrloadfunc load, void* userptr) {
552
    if(!GLAD_EGL_KHR_image) return;
553
    glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC) load(userptr, "eglCreateImageKHR");
554
    glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC) load(userptr, "eglDestroyImageKHR");
555
}
556
static void glad_egl_load_EGL_KHR_image_base( GLADuserptrloadfunc load, void* userptr) {
557
    if(!GLAD_EGL_KHR_image_base) return;
558
    glad_eglCreateImageKHR = (PFNEGLCREATEIMAGEKHRPROC) load(userptr, "eglCreateImageKHR");
559
    glad_eglDestroyImageKHR = (PFNEGLDESTROYIMAGEKHRPROC) load(userptr, "eglDestroyImageKHR");
560
}
561
static void glad_egl_load_EGL_KHR_lock_surface( GLADuserptrloadfunc load, void* userptr) {
562
    if(!GLAD_EGL_KHR_lock_surface) return;
563
    glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC) load(userptr, "eglLockSurfaceKHR");
564
    glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC) load(userptr, "eglUnlockSurfaceKHR");
565
}
566
static void glad_egl_load_EGL_KHR_lock_surface3( GLADuserptrloadfunc load, void* userptr) {
567
    if(!GLAD_EGL_KHR_lock_surface3) return;
568
    glad_eglLockSurfaceKHR = (PFNEGLLOCKSURFACEKHRPROC) load(userptr, "eglLockSurfaceKHR");
569
    glad_eglQuerySurface64KHR = (PFNEGLQUERYSURFACE64KHRPROC) load(userptr, "eglQuerySurface64KHR");
570
    glad_eglUnlockSurfaceKHR = (PFNEGLUNLOCKSURFACEKHRPROC) load(userptr, "eglUnlockSurfaceKHR");
571
}
572
static void glad_egl_load_EGL_KHR_partial_update( GLADuserptrloadfunc load, void* userptr) {
573
    if(!GLAD_EGL_KHR_partial_update) return;
574
    glad_eglSetDamageRegionKHR = (PFNEGLSETDAMAGEREGIONKHRPROC) load(userptr, "eglSetDamageRegionKHR");
575
}
576
static void glad_egl_load_EGL_KHR_reusable_sync( GLADuserptrloadfunc load, void* userptr) {
577
    if(!GLAD_EGL_KHR_reusable_sync) return;
578
    glad_eglClientWaitSyncKHR = (PFNEGLCLIENTWAITSYNCKHRPROC) load(userptr, "eglClientWaitSyncKHR");
579
    glad_eglCreateSyncKHR = (PFNEGLCREATESYNCKHRPROC) load(userptr, "eglCreateSyncKHR");
580
    glad_eglDestroySyncKHR = (PFNEGLDESTROYSYNCKHRPROC) load(userptr, "eglDestroySyncKHR");
581
    glad_eglGetSyncAttribKHR = (PFNEGLGETSYNCATTRIBKHRPROC) load(userptr, "eglGetSyncAttribKHR");
582
    glad_eglSignalSyncKHR = (PFNEGLSIGNALSYNCKHRPROC) load(userptr, "eglSignalSyncKHR");
583
}
584
static void glad_egl_load_EGL_KHR_stream( GLADuserptrloadfunc load, void* userptr) {
585
    if(!GLAD_EGL_KHR_stream) return;
586
    glad_eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC) load(userptr, "eglCreateStreamKHR");
587
    glad_eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC) load(userptr, "eglDestroyStreamKHR");
588
    glad_eglQueryStreamKHR = (PFNEGLQUERYSTREAMKHRPROC) load(userptr, "eglQueryStreamKHR");
589
    glad_eglQueryStreamu64KHR = (PFNEGLQUERYSTREAMU64KHRPROC) load(userptr, "eglQueryStreamu64KHR");
590
    glad_eglStreamAttribKHR = (PFNEGLSTREAMATTRIBKHRPROC) load(userptr, "eglStreamAttribKHR");
591
}
592
static void glad_egl_load_EGL_KHR_stream_attrib( GLADuserptrloadfunc load, void* userptr) {
593
    if(!GLAD_EGL_KHR_stream_attrib) return;
594
    glad_eglCreateStreamAttribKHR = (PFNEGLCREATESTREAMATTRIBKHRPROC) load(userptr, "eglCreateStreamAttribKHR");
595
    glad_eglQueryStreamAttribKHR = (PFNEGLQUERYSTREAMATTRIBKHRPROC) load(userptr, "eglQueryStreamAttribKHR");
596
    glad_eglSetStreamAttribKHR = (PFNEGLSETSTREAMATTRIBKHRPROC) load(userptr, "eglSetStreamAttribKHR");
597
    glad_eglStreamConsumerAcquireAttribKHR = (PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC) load(userptr, "eglStreamConsumerAcquireAttribKHR");
598
    glad_eglStreamConsumerReleaseAttribKHR = (PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC) load(userptr, "eglStreamConsumerReleaseAttribKHR");
599
}
600
static void glad_egl_load_EGL_KHR_stream_consumer_gltexture( GLADuserptrloadfunc load, void* userptr) {
601
    if(!GLAD_EGL_KHR_stream_consumer_gltexture) return;
602
    glad_eglStreamConsumerAcquireKHR = (PFNEGLSTREAMCONSUMERACQUIREKHRPROC) load(userptr, "eglStreamConsumerAcquireKHR");
603
    glad_eglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC) load(userptr, "eglStreamConsumerGLTextureExternalKHR");
604
    glad_eglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHRPROC) load(userptr, "eglStreamConsumerReleaseKHR");
605
}
606
static void glad_egl_load_EGL_KHR_stream_cross_process_fd( GLADuserptrloadfunc load, void* userptr) {
607
    if(!GLAD_EGL_KHR_stream_cross_process_fd) return;
608
    glad_eglCreateStreamFromFileDescriptorKHR = (PFNEGLCREATESTREAMFROMFILEDESCRIPTORKHRPROC) load(userptr, "eglCreateStreamFromFileDescriptorKHR");
609
    glad_eglGetStreamFileDescriptorKHR = (PFNEGLGETSTREAMFILEDESCRIPTORKHRPROC) load(userptr, "eglGetStreamFileDescriptorKHR");
610
}
611
static void glad_egl_load_EGL_KHR_stream_fifo( GLADuserptrloadfunc load, void* userptr) {
612
    if(!GLAD_EGL_KHR_stream_fifo) return;
613
    glad_eglQueryStreamTimeKHR = (PFNEGLQUERYSTREAMTIMEKHRPROC) load(userptr, "eglQueryStreamTimeKHR");
614
}
615
static void glad_egl_load_EGL_KHR_stream_producer_eglsurface( GLADuserptrloadfunc load, void* userptr) {
616
    if(!GLAD_EGL_KHR_stream_producer_eglsurface) return;
617
    glad_eglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC) load(userptr, "eglCreateStreamProducerSurfaceKHR");
618
}
619
static void glad_egl_load_EGL_KHR_swap_buffers_with_damage( GLADuserptrloadfunc load, void* userptr) {
620
    if(!GLAD_EGL_KHR_swap_buffers_with_damage) return;
621
    glad_eglSwapBuffersWithDamageKHR = (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC) load(userptr, "eglSwapBuffersWithDamageKHR");
622
}
623
static void glad_egl_load_EGL_KHR_wait_sync( GLADuserptrloadfunc load, void* userptr) {
624
    if(!GLAD_EGL_KHR_wait_sync) return;
625
    glad_eglWaitSyncKHR = (PFNEGLWAITSYNCKHRPROC) load(userptr, "eglWaitSyncKHR");
626
}
627
static void glad_egl_load_EGL_MESA_drm_image( GLADuserptrloadfunc load, void* userptr) {
628
    if(!GLAD_EGL_MESA_drm_image) return;
629
    glad_eglCreateDRMImageMESA = (PFNEGLCREATEDRMIMAGEMESAPROC) load(userptr, "eglCreateDRMImageMESA");
630
    glad_eglExportDRMImageMESA = (PFNEGLEXPORTDRMIMAGEMESAPROC) load(userptr, "eglExportDRMImageMESA");
631
}
632
static void glad_egl_load_EGL_MESA_image_dma_buf_export( GLADuserptrloadfunc load, void* userptr) {
633
    if(!GLAD_EGL_MESA_image_dma_buf_export) return;
634
    glad_eglExportDMABUFImageMESA = (PFNEGLEXPORTDMABUFIMAGEMESAPROC) load(userptr, "eglExportDMABUFImageMESA");
635
    glad_eglExportDMABUFImageQueryMESA = (PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC) load(userptr, "eglExportDMABUFImageQueryMESA");
636
}
637
static void glad_egl_load_EGL_MESA_query_driver( GLADuserptrloadfunc load, void* userptr) {
638
    if(!GLAD_EGL_MESA_query_driver) return;
639
    glad_eglGetDisplayDriverConfig = (PFNEGLGETDISPLAYDRIVERCONFIGPROC) load(userptr, "eglGetDisplayDriverConfig");
640
    glad_eglGetDisplayDriverName = (PFNEGLGETDISPLAYDRIVERNAMEPROC) load(userptr, "eglGetDisplayDriverName");
641
}
642
static void glad_egl_load_EGL_NOK_swap_region( GLADuserptrloadfunc load, void* userptr) {
643
    if(!GLAD_EGL_NOK_swap_region) return;
644
    glad_eglSwapBuffersRegionNOK = (PFNEGLSWAPBUFFERSREGIONNOKPROC) load(userptr, "eglSwapBuffersRegionNOK");
645
}
646
static void glad_egl_load_EGL_NOK_swap_region2( GLADuserptrloadfunc load, void* userptr) {
647
    if(!GLAD_EGL_NOK_swap_region2) return;
648
    glad_eglSwapBuffersRegion2NOK = (PFNEGLSWAPBUFFERSREGION2NOKPROC) load(userptr, "eglSwapBuffersRegion2NOK");
649
}
650
static void glad_egl_load_EGL_NV_native_query( GLADuserptrloadfunc load, void* userptr) {
651
    if(!GLAD_EGL_NV_native_query) return;
652
    glad_eglQueryNativeDisplayNV = (PFNEGLQUERYNATIVEDISPLAYNVPROC) load(userptr, "eglQueryNativeDisplayNV");
653
    glad_eglQueryNativePixmapNV = (PFNEGLQUERYNATIVEPIXMAPNVPROC) load(userptr, "eglQueryNativePixmapNV");
654
    glad_eglQueryNativeWindowNV = (PFNEGLQUERYNATIVEWINDOWNVPROC) load(userptr, "eglQueryNativeWindowNV");
655
}
656
static void glad_egl_load_EGL_NV_post_sub_buffer( GLADuserptrloadfunc load, void* userptr) {
657
    if(!GLAD_EGL_NV_post_sub_buffer) return;
658
    glad_eglPostSubBufferNV = (PFNEGLPOSTSUBBUFFERNVPROC) load(userptr, "eglPostSubBufferNV");
659
}
660
static void glad_egl_load_EGL_NV_stream_consumer_eglimage( GLADuserptrloadfunc load, void* userptr) {
661
    if(!GLAD_EGL_NV_stream_consumer_eglimage) return;
662
    glad_eglQueryStreamConsumerEventNV = (PFNEGLQUERYSTREAMCONSUMEREVENTNVPROC) load(userptr, "eglQueryStreamConsumerEventNV");
663
    glad_eglStreamAcquireImageNV = (PFNEGLSTREAMACQUIREIMAGENVPROC) load(userptr, "eglStreamAcquireImageNV");
664
    glad_eglStreamImageConsumerConnectNV = (PFNEGLSTREAMIMAGECONSUMERCONNECTNVPROC) load(userptr, "eglStreamImageConsumerConnectNV");
665
    glad_eglStreamReleaseImageNV = (PFNEGLSTREAMRELEASEIMAGENVPROC) load(userptr, "eglStreamReleaseImageNV");
666
}
667
static void glad_egl_load_EGL_NV_stream_consumer_gltexture_yuv( GLADuserptrloadfunc load, void* userptr) {
668
    if(!GLAD_EGL_NV_stream_consumer_gltexture_yuv) return;
669
    glad_eglStreamConsumerGLTextureExternalAttribsNV = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) load(userptr, "eglStreamConsumerGLTextureExternalAttribsNV");
670
}
671
static void glad_egl_load_EGL_NV_stream_flush( GLADuserptrloadfunc load, void* userptr) {
672
    if(!GLAD_EGL_NV_stream_flush) return;
673
    glad_eglStreamFlushNV = (PFNEGLSTREAMFLUSHNVPROC) load(userptr, "eglStreamFlushNV");
674
}
675
static void glad_egl_load_EGL_NV_stream_metadata( GLADuserptrloadfunc load, void* userptr) {
676
    if(!GLAD_EGL_NV_stream_metadata) return;
677
    glad_eglQueryDisplayAttribNV = (PFNEGLQUERYDISPLAYATTRIBNVPROC) load(userptr, "eglQueryDisplayAttribNV");
678
    glad_eglQueryStreamMetadataNV = (PFNEGLQUERYSTREAMMETADATANVPROC) load(userptr, "eglQueryStreamMetadataNV");
679
    glad_eglSetStreamMetadataNV = (PFNEGLSETSTREAMMETADATANVPROC) load(userptr, "eglSetStreamMetadataNV");
680
}
681
static void glad_egl_load_EGL_NV_stream_reset( GLADuserptrloadfunc load, void* userptr) {
682
    if(!GLAD_EGL_NV_stream_reset) return;
683
    glad_eglResetStreamNV = (PFNEGLRESETSTREAMNVPROC) load(userptr, "eglResetStreamNV");
684
}
685
static void glad_egl_load_EGL_NV_stream_sync( GLADuserptrloadfunc load, void* userptr) {
686
    if(!GLAD_EGL_NV_stream_sync) return;
687
    glad_eglCreateStreamSyncNV = (PFNEGLCREATESTREAMSYNCNVPROC) load(userptr, "eglCreateStreamSyncNV");
688
}
689
static void glad_egl_load_EGL_NV_sync( GLADuserptrloadfunc load, void* userptr) {
690
    if(!GLAD_EGL_NV_sync) return;
691
    glad_eglClientWaitSyncNV = (PFNEGLCLIENTWAITSYNCNVPROC) load(userptr, "eglClientWaitSyncNV");
692
    glad_eglCreateFenceSyncNV = (PFNEGLCREATEFENCESYNCNVPROC) load(userptr, "eglCreateFenceSyncNV");
693
    glad_eglDestroySyncNV = (PFNEGLDESTROYSYNCNVPROC) load(userptr, "eglDestroySyncNV");
694
    glad_eglFenceNV = (PFNEGLFENCENVPROC) load(userptr, "eglFenceNV");
695
    glad_eglGetSyncAttribNV = (PFNEGLGETSYNCATTRIBNVPROC) load(userptr, "eglGetSyncAttribNV");
696
    glad_eglSignalSyncNV = (PFNEGLSIGNALSYNCNVPROC) load(userptr, "eglSignalSyncNV");
697
}
698
static void glad_egl_load_EGL_NV_system_time( GLADuserptrloadfunc load, void* userptr) {
699
    if(!GLAD_EGL_NV_system_time) return;
700
    glad_eglGetSystemTimeFrequencyNV = (PFNEGLGETSYSTEMTIMEFREQUENCYNVPROC) load(userptr, "eglGetSystemTimeFrequencyNV");
701
    glad_eglGetSystemTimeNV = (PFNEGLGETSYSTEMTIMENVPROC) load(userptr, "eglGetSystemTimeNV");
702
}
703
static void glad_egl_load_EGL_WL_bind_wayland_display( GLADuserptrloadfunc load, void* userptr) {
704
    if(!GLAD_EGL_WL_bind_wayland_display) return;
705
    glad_eglBindWaylandDisplayWL = (PFNEGLBINDWAYLANDDISPLAYWLPROC) load(userptr, "eglBindWaylandDisplayWL");
706
    glad_eglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWLPROC) load(userptr, "eglQueryWaylandBufferWL");
707
    glad_eglUnbindWaylandDisplayWL = (PFNEGLUNBINDWAYLANDDISPLAYWLPROC) load(userptr, "eglUnbindWaylandDisplayWL");
708
}
709
static void glad_egl_load_EGL_WL_create_wayland_buffer_from_image( GLADuserptrloadfunc load, void* userptr) {
710
    if(!GLAD_EGL_WL_create_wayland_buffer_from_image) return;
711
    glad_eglCreateWaylandBufferFromImageWL = (PFNEGLCREATEWAYLANDBUFFERFROMIMAGEWLPROC) load(userptr, "eglCreateWaylandBufferFromImageWL");
712
}
713

714

715

716
static int glad_egl_get_extensions(EGLDisplay display, const char **extensions) {
717
    *extensions = eglQueryString(display, EGL_EXTENSIONS);
718

719
    return extensions != NULL;
720
}
721

722
static int glad_egl_has_extension(const char *extensions, const char *ext) {
723
    const char *loc;
724
    const char *terminator;
725
    if(extensions == NULL) {
726
        return 0;
727
    }
728
    while(1) {
729
        loc = strstr(extensions, ext);
730
        if(loc == NULL) {
731
            return 0;
732
        }
733
        terminator = loc + strlen(ext);
734
        if((loc == extensions || *(loc - 1) == ' ') &&
735
            (*terminator == ' ' || *terminator == '\0')) {
736
            return 1;
737
        }
738
        extensions = terminator;
739
    }
740
}
741

742
static GLADapiproc glad_egl_get_proc_from_userptr(void *userptr, const char *name) {
743
    return (GLAD_GNUC_EXTENSION (GLADapiproc (*)(const char *name)) userptr)(name);
744
}
745

746
static int glad_egl_find_extensions_egl(EGLDisplay display) {
747
    const char *extensions;
748
    if (!glad_egl_get_extensions(display, &extensions)) return 0;
749

750
    GLAD_EGL_ANDROID_GLES_layers = glad_egl_has_extension(extensions, "EGL_ANDROID_GLES_layers");
751
    GLAD_EGL_ANDROID_blob_cache = glad_egl_has_extension(extensions, "EGL_ANDROID_blob_cache");
752
    GLAD_EGL_ANDROID_create_native_client_buffer = glad_egl_has_extension(extensions, "EGL_ANDROID_create_native_client_buffer");
753
    GLAD_EGL_ANDROID_framebuffer_target = glad_egl_has_extension(extensions, "EGL_ANDROID_framebuffer_target");
754
    GLAD_EGL_ANDROID_front_buffer_auto_refresh = glad_egl_has_extension(extensions, "EGL_ANDROID_front_buffer_auto_refresh");
755
    GLAD_EGL_ANDROID_get_frame_timestamps = glad_egl_has_extension(extensions, "EGL_ANDROID_get_frame_timestamps");
756
    GLAD_EGL_ANDROID_get_native_client_buffer = glad_egl_has_extension(extensions, "EGL_ANDROID_get_native_client_buffer");
757
    GLAD_EGL_ANDROID_image_native_buffer = glad_egl_has_extension(extensions, "EGL_ANDROID_image_native_buffer");
758
    GLAD_EGL_ANDROID_native_fence_sync = glad_egl_has_extension(extensions, "EGL_ANDROID_native_fence_sync");
759
    GLAD_EGL_ANDROID_presentation_time = glad_egl_has_extension(extensions, "EGL_ANDROID_presentation_time");
760
    GLAD_EGL_ANDROID_recordable = glad_egl_has_extension(extensions, "EGL_ANDROID_recordable");
761
    GLAD_EGL_ANGLE_d3d_share_handle_client_buffer = glad_egl_has_extension(extensions, "EGL_ANGLE_d3d_share_handle_client_buffer");
762
    GLAD_EGL_ANGLE_device_d3d = glad_egl_has_extension(extensions, "EGL_ANGLE_device_d3d");
763
    GLAD_EGL_ANGLE_query_surface_pointer = glad_egl_has_extension(extensions, "EGL_ANGLE_query_surface_pointer");
764
    GLAD_EGL_ANGLE_surface_d3d_texture_2d_share_handle = glad_egl_has_extension(extensions, "EGL_ANGLE_surface_d3d_texture_2d_share_handle");
765
    GLAD_EGL_ANGLE_sync_control_rate = glad_egl_has_extension(extensions, "EGL_ANGLE_sync_control_rate");
766
    GLAD_EGL_ANGLE_window_fixed_size = glad_egl_has_extension(extensions, "EGL_ANGLE_window_fixed_size");
767
    GLAD_EGL_ARM_image_format = glad_egl_has_extension(extensions, "EGL_ARM_image_format");
768
    GLAD_EGL_ARM_implicit_external_sync = glad_egl_has_extension(extensions, "EGL_ARM_implicit_external_sync");
769
    GLAD_EGL_ARM_pixmap_multisample_discard = glad_egl_has_extension(extensions, "EGL_ARM_pixmap_multisample_discard");
770
    GLAD_EGL_EXT_bind_to_front = glad_egl_has_extension(extensions, "EGL_EXT_bind_to_front");
771
    GLAD_EGL_EXT_buffer_age = glad_egl_has_extension(extensions, "EGL_EXT_buffer_age");
772
    GLAD_EGL_EXT_client_extensions = glad_egl_has_extension(extensions, "EGL_EXT_client_extensions");
773
    GLAD_EGL_EXT_client_sync = glad_egl_has_extension(extensions, "EGL_EXT_client_sync");
774
    GLAD_EGL_EXT_compositor = glad_egl_has_extension(extensions, "EGL_EXT_compositor");
775
    GLAD_EGL_EXT_config_select_group = glad_egl_has_extension(extensions, "EGL_EXT_config_select_group");
776
    GLAD_EGL_EXT_create_context_robustness = glad_egl_has_extension(extensions, "EGL_EXT_create_context_robustness");
777
    GLAD_EGL_EXT_device_base = glad_egl_has_extension(extensions, "EGL_EXT_device_base");
778
    GLAD_EGL_EXT_device_drm = glad_egl_has_extension(extensions, "EGL_EXT_device_drm");
779
    GLAD_EGL_EXT_device_drm_render_node = glad_egl_has_extension(extensions, "EGL_EXT_device_drm_render_node");
780
    GLAD_EGL_EXT_device_enumeration = glad_egl_has_extension(extensions, "EGL_EXT_device_enumeration");
781
    GLAD_EGL_EXT_device_openwf = glad_egl_has_extension(extensions, "EGL_EXT_device_openwf");
782
    GLAD_EGL_EXT_device_persistent_id = glad_egl_has_extension(extensions, "EGL_EXT_device_persistent_id");
783
    GLAD_EGL_EXT_device_query = glad_egl_has_extension(extensions, "EGL_EXT_device_query");
784
    GLAD_EGL_EXT_device_query_name = glad_egl_has_extension(extensions, "EGL_EXT_device_query_name");
785
    GLAD_EGL_EXT_explicit_device = glad_egl_has_extension(extensions, "EGL_EXT_explicit_device");
786
    GLAD_EGL_EXT_gl_colorspace_bt2020_hlg = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_bt2020_hlg");
787
    GLAD_EGL_EXT_gl_colorspace_bt2020_linear = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_bt2020_linear");
788
    GLAD_EGL_EXT_gl_colorspace_bt2020_pq = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_bt2020_pq");
789
    GLAD_EGL_EXT_gl_colorspace_display_p3 = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_display_p3");
790
    GLAD_EGL_EXT_gl_colorspace_display_p3_linear = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_display_p3_linear");
791
    GLAD_EGL_EXT_gl_colorspace_display_p3_passthrough = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_display_p3_passthrough");
792
    GLAD_EGL_EXT_gl_colorspace_scrgb = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_scrgb");
793
    GLAD_EGL_EXT_gl_colorspace_scrgb_linear = glad_egl_has_extension(extensions, "EGL_EXT_gl_colorspace_scrgb_linear");
794
    GLAD_EGL_EXT_image_dma_buf_import = glad_egl_has_extension(extensions, "EGL_EXT_image_dma_buf_import");
795
    GLAD_EGL_EXT_image_dma_buf_import_modifiers = glad_egl_has_extension(extensions, "EGL_EXT_image_dma_buf_import_modifiers");
796
    GLAD_EGL_EXT_image_gl_colorspace = glad_egl_has_extension(extensions, "EGL_EXT_image_gl_colorspace");
797
    GLAD_EGL_EXT_image_implicit_sync_control = glad_egl_has_extension(extensions, "EGL_EXT_image_implicit_sync_control");
798
    GLAD_EGL_EXT_multiview_window = glad_egl_has_extension(extensions, "EGL_EXT_multiview_window");
799
    GLAD_EGL_EXT_output_base = glad_egl_has_extension(extensions, "EGL_EXT_output_base");
800
    GLAD_EGL_EXT_output_drm = glad_egl_has_extension(extensions, "EGL_EXT_output_drm");
801
    GLAD_EGL_EXT_output_openwf = glad_egl_has_extension(extensions, "EGL_EXT_output_openwf");
802
    GLAD_EGL_EXT_pixel_format_float = glad_egl_has_extension(extensions, "EGL_EXT_pixel_format_float");
803
    GLAD_EGL_EXT_platform_base = glad_egl_has_extension(extensions, "EGL_EXT_platform_base");
804
    GLAD_EGL_EXT_platform_device = glad_egl_has_extension(extensions, "EGL_EXT_platform_device");
805
    GLAD_EGL_EXT_platform_wayland = glad_egl_has_extension(extensions, "EGL_EXT_platform_wayland");
806
    GLAD_EGL_EXT_platform_x11 = glad_egl_has_extension(extensions, "EGL_EXT_platform_x11");
807
    GLAD_EGL_EXT_platform_xcb = glad_egl_has_extension(extensions, "EGL_EXT_platform_xcb");
808
    GLAD_EGL_EXT_present_opaque = glad_egl_has_extension(extensions, "EGL_EXT_present_opaque");
809
    GLAD_EGL_EXT_protected_content = glad_egl_has_extension(extensions, "EGL_EXT_protected_content");
810
    GLAD_EGL_EXT_protected_surface = glad_egl_has_extension(extensions, "EGL_EXT_protected_surface");
811
    GLAD_EGL_EXT_query_reset_notification_strategy = glad_egl_has_extension(extensions, "EGL_EXT_query_reset_notification_strategy");
812
    GLAD_EGL_EXT_stream_consumer_egloutput = glad_egl_has_extension(extensions, "EGL_EXT_stream_consumer_egloutput");
813
    GLAD_EGL_EXT_surface_CTA861_3_metadata = glad_egl_has_extension(extensions, "EGL_EXT_surface_CTA861_3_metadata");
814
    GLAD_EGL_EXT_surface_SMPTE2086_metadata = glad_egl_has_extension(extensions, "EGL_EXT_surface_SMPTE2086_metadata");
815
    GLAD_EGL_EXT_surface_compression = glad_egl_has_extension(extensions, "EGL_EXT_surface_compression");
816
    GLAD_EGL_EXT_swap_buffers_with_damage = glad_egl_has_extension(extensions, "EGL_EXT_swap_buffers_with_damage");
817
    GLAD_EGL_EXT_sync_reuse = glad_egl_has_extension(extensions, "EGL_EXT_sync_reuse");
818
    GLAD_EGL_EXT_yuv_surface = glad_egl_has_extension(extensions, "EGL_EXT_yuv_surface");
819
    GLAD_EGL_HI_clientpixmap = glad_egl_has_extension(extensions, "EGL_HI_clientpixmap");
820
    GLAD_EGL_HI_colorformats = glad_egl_has_extension(extensions, "EGL_HI_colorformats");
821
    GLAD_EGL_IMG_context_priority = glad_egl_has_extension(extensions, "EGL_IMG_context_priority");
822
    GLAD_EGL_IMG_image_plane_attribs = glad_egl_has_extension(extensions, "EGL_IMG_image_plane_attribs");
823
    GLAD_EGL_KHR_cl_event = glad_egl_has_extension(extensions, "EGL_KHR_cl_event");
824
    GLAD_EGL_KHR_cl_event2 = glad_egl_has_extension(extensions, "EGL_KHR_cl_event2");
825
    GLAD_EGL_KHR_client_get_all_proc_addresses = glad_egl_has_extension(extensions, "EGL_KHR_client_get_all_proc_addresses");
826
    GLAD_EGL_KHR_config_attribs = glad_egl_has_extension(extensions, "EGL_KHR_config_attribs");
827
    GLAD_EGL_KHR_context_flush_control = glad_egl_has_extension(extensions, "EGL_KHR_context_flush_control");
828
    GLAD_EGL_KHR_create_context = glad_egl_has_extension(extensions, "EGL_KHR_create_context");
829
    GLAD_EGL_KHR_create_context_no_error = glad_egl_has_extension(extensions, "EGL_KHR_create_context_no_error");
830
    GLAD_EGL_KHR_debug = glad_egl_has_extension(extensions, "EGL_KHR_debug");
831
    GLAD_EGL_KHR_display_reference = glad_egl_has_extension(extensions, "EGL_KHR_display_reference");
832
    GLAD_EGL_KHR_fence_sync = glad_egl_has_extension(extensions, "EGL_KHR_fence_sync");
833
    GLAD_EGL_KHR_get_all_proc_addresses = glad_egl_has_extension(extensions, "EGL_KHR_get_all_proc_addresses");
834
    GLAD_EGL_KHR_gl_colorspace = glad_egl_has_extension(extensions, "EGL_KHR_gl_colorspace");
835
    GLAD_EGL_KHR_gl_renderbuffer_image = glad_egl_has_extension(extensions, "EGL_KHR_gl_renderbuffer_image");
836
    GLAD_EGL_KHR_gl_texture_2D_image = glad_egl_has_extension(extensions, "EGL_KHR_gl_texture_2D_image");
837
    GLAD_EGL_KHR_gl_texture_3D_image = glad_egl_has_extension(extensions, "EGL_KHR_gl_texture_3D_image");
838
    GLAD_EGL_KHR_gl_texture_cubemap_image = glad_egl_has_extension(extensions, "EGL_KHR_gl_texture_cubemap_image");
839
    GLAD_EGL_KHR_image = glad_egl_has_extension(extensions, "EGL_KHR_image");
840
    GLAD_EGL_KHR_image_base = glad_egl_has_extension(extensions, "EGL_KHR_image_base");
841
    GLAD_EGL_KHR_image_pixmap = glad_egl_has_extension(extensions, "EGL_KHR_image_pixmap");
842
    GLAD_EGL_KHR_lock_surface = glad_egl_has_extension(extensions, "EGL_KHR_lock_surface");
843
    GLAD_EGL_KHR_lock_surface2 = glad_egl_has_extension(extensions, "EGL_KHR_lock_surface2");
844
    GLAD_EGL_KHR_lock_surface3 = glad_egl_has_extension(extensions, "EGL_KHR_lock_surface3");
845
    GLAD_EGL_KHR_mutable_render_buffer = glad_egl_has_extension(extensions, "EGL_KHR_mutable_render_buffer");
846
    GLAD_EGL_KHR_no_config_context = glad_egl_has_extension(extensions, "EGL_KHR_no_config_context");
847
    GLAD_EGL_KHR_partial_update = glad_egl_has_extension(extensions, "EGL_KHR_partial_update");
848
    GLAD_EGL_KHR_platform_android = glad_egl_has_extension(extensions, "EGL_KHR_platform_android");
849
    GLAD_EGL_KHR_platform_gbm = glad_egl_has_extension(extensions, "EGL_KHR_platform_gbm");
850
    GLAD_EGL_KHR_platform_wayland = glad_egl_has_extension(extensions, "EGL_KHR_platform_wayland");
851
    GLAD_EGL_KHR_platform_x11 = glad_egl_has_extension(extensions, "EGL_KHR_platform_x11");
852
    GLAD_EGL_KHR_reusable_sync = glad_egl_has_extension(extensions, "EGL_KHR_reusable_sync");
853
    GLAD_EGL_KHR_stream = glad_egl_has_extension(extensions, "EGL_KHR_stream");
854
    GLAD_EGL_KHR_stream_attrib = glad_egl_has_extension(extensions, "EGL_KHR_stream_attrib");
855
    GLAD_EGL_KHR_stream_consumer_gltexture = glad_egl_has_extension(extensions, "EGL_KHR_stream_consumer_gltexture");
856
    GLAD_EGL_KHR_stream_cross_process_fd = glad_egl_has_extension(extensions, "EGL_KHR_stream_cross_process_fd");
857
    GLAD_EGL_KHR_stream_fifo = glad_egl_has_extension(extensions, "EGL_KHR_stream_fifo");
858
    GLAD_EGL_KHR_stream_producer_aldatalocator = glad_egl_has_extension(extensions, "EGL_KHR_stream_producer_aldatalocator");
859
    GLAD_EGL_KHR_stream_producer_eglsurface = glad_egl_has_extension(extensions, "EGL_KHR_stream_producer_eglsurface");
860
    GLAD_EGL_KHR_surfaceless_context = glad_egl_has_extension(extensions, "EGL_KHR_surfaceless_context");
861
    GLAD_EGL_KHR_swap_buffers_with_damage = glad_egl_has_extension(extensions, "EGL_KHR_swap_buffers_with_damage");
862
    GLAD_EGL_KHR_vg_parent_image = glad_egl_has_extension(extensions, "EGL_KHR_vg_parent_image");
863
    GLAD_EGL_KHR_wait_sync = glad_egl_has_extension(extensions, "EGL_KHR_wait_sync");
864
    GLAD_EGL_MESA_drm_image = glad_egl_has_extension(extensions, "EGL_MESA_drm_image");
865
    GLAD_EGL_MESA_image_dma_buf_export = glad_egl_has_extension(extensions, "EGL_MESA_image_dma_buf_export");
866
    GLAD_EGL_MESA_platform_gbm = glad_egl_has_extension(extensions, "EGL_MESA_platform_gbm");
867
    GLAD_EGL_MESA_platform_surfaceless = glad_egl_has_extension(extensions, "EGL_MESA_platform_surfaceless");
868
    GLAD_EGL_MESA_query_driver = glad_egl_has_extension(extensions, "EGL_MESA_query_driver");
869
    GLAD_EGL_NOK_swap_region = glad_egl_has_extension(extensions, "EGL_NOK_swap_region");
870
    GLAD_EGL_NOK_swap_region2 = glad_egl_has_extension(extensions, "EGL_NOK_swap_region2");
871
    GLAD_EGL_NOK_texture_from_pixmap = glad_egl_has_extension(extensions, "EGL_NOK_texture_from_pixmap");
872
    GLAD_EGL_NV_3dvision_surface = glad_egl_has_extension(extensions, "EGL_NV_3dvision_surface");
873
    GLAD_EGL_NV_context_priority_realtime = glad_egl_has_extension(extensions, "EGL_NV_context_priority_realtime");
874
    GLAD_EGL_NV_coverage_sample = glad_egl_has_extension(extensions, "EGL_NV_coverage_sample");
875
    GLAD_EGL_NV_coverage_sample_resolve = glad_egl_has_extension(extensions, "EGL_NV_coverage_sample_resolve");
876
    GLAD_EGL_NV_cuda_event = glad_egl_has_extension(extensions, "EGL_NV_cuda_event");
877
    GLAD_EGL_NV_depth_nonlinear = glad_egl_has_extension(extensions, "EGL_NV_depth_nonlinear");
878
    GLAD_EGL_NV_device_cuda = glad_egl_has_extension(extensions, "EGL_NV_device_cuda");
879
    GLAD_EGL_NV_native_query = glad_egl_has_extension(extensions, "EGL_NV_native_query");
880
    GLAD_EGL_NV_post_convert_rounding = glad_egl_has_extension(extensions, "EGL_NV_post_convert_rounding");
881
    GLAD_EGL_NV_post_sub_buffer = glad_egl_has_extension(extensions, "EGL_NV_post_sub_buffer");
882
    GLAD_EGL_NV_quadruple_buffer = glad_egl_has_extension(extensions, "EGL_NV_quadruple_buffer");
883
    GLAD_EGL_NV_robustness_video_memory_purge = glad_egl_has_extension(extensions, "EGL_NV_robustness_video_memory_purge");
884
    GLAD_EGL_NV_stream_consumer_eglimage = glad_egl_has_extension(extensions, "EGL_NV_stream_consumer_eglimage");
885
    GLAD_EGL_NV_stream_consumer_eglimage_use_scanout_attrib = glad_egl_has_extension(extensions, "EGL_NV_stream_consumer_eglimage_use_scanout_attrib");
886
    GLAD_EGL_NV_stream_consumer_gltexture_yuv = glad_egl_has_extension(extensions, "EGL_NV_stream_consumer_gltexture_yuv");
887
    GLAD_EGL_NV_stream_cross_display = glad_egl_has_extension(extensions, "EGL_NV_stream_cross_display");
888
    GLAD_EGL_NV_stream_cross_object = glad_egl_has_extension(extensions, "EGL_NV_stream_cross_object");
889
    GLAD_EGL_NV_stream_cross_partition = glad_egl_has_extension(extensions, "EGL_NV_stream_cross_partition");
890
    GLAD_EGL_NV_stream_cross_process = glad_egl_has_extension(extensions, "EGL_NV_stream_cross_process");
891
    GLAD_EGL_NV_stream_cross_system = glad_egl_has_extension(extensions, "EGL_NV_stream_cross_system");
892
    GLAD_EGL_NV_stream_dma = glad_egl_has_extension(extensions, "EGL_NV_stream_dma");
893
    GLAD_EGL_NV_stream_fifo_next = glad_egl_has_extension(extensions, "EGL_NV_stream_fifo_next");
894
    GLAD_EGL_NV_stream_fifo_synchronous = glad_egl_has_extension(extensions, "EGL_NV_stream_fifo_synchronous");
895
    GLAD_EGL_NV_stream_flush = glad_egl_has_extension(extensions, "EGL_NV_stream_flush");
896
    GLAD_EGL_NV_stream_frame_limits = glad_egl_has_extension(extensions, "EGL_NV_stream_frame_limits");
897
    GLAD_EGL_NV_stream_metadata = glad_egl_has_extension(extensions, "EGL_NV_stream_metadata");
898
    GLAD_EGL_NV_stream_origin = glad_egl_has_extension(extensions, "EGL_NV_stream_origin");
899
    GLAD_EGL_NV_stream_remote = glad_egl_has_extension(extensions, "EGL_NV_stream_remote");
900
    GLAD_EGL_NV_stream_reset = glad_egl_has_extension(extensions, "EGL_NV_stream_reset");
901
    GLAD_EGL_NV_stream_socket = glad_egl_has_extension(extensions, "EGL_NV_stream_socket");
902
    GLAD_EGL_NV_stream_socket_inet = glad_egl_has_extension(extensions, "EGL_NV_stream_socket_inet");
903
    GLAD_EGL_NV_stream_socket_unix = glad_egl_has_extension(extensions, "EGL_NV_stream_socket_unix");
904
    GLAD_EGL_NV_stream_sync = glad_egl_has_extension(extensions, "EGL_NV_stream_sync");
905
    GLAD_EGL_NV_sync = glad_egl_has_extension(extensions, "EGL_NV_sync");
906
    GLAD_EGL_NV_system_time = glad_egl_has_extension(extensions, "EGL_NV_system_time");
907
    GLAD_EGL_NV_triple_buffer = glad_egl_has_extension(extensions, "EGL_NV_triple_buffer");
908
    GLAD_EGL_QNX_image_native_buffer = glad_egl_has_extension(extensions, "EGL_QNX_image_native_buffer");
909
    GLAD_EGL_QNX_platform_screen = glad_egl_has_extension(extensions, "EGL_QNX_platform_screen");
910
    GLAD_EGL_TIZEN_image_native_buffer = glad_egl_has_extension(extensions, "EGL_TIZEN_image_native_buffer");
911
    GLAD_EGL_TIZEN_image_native_surface = glad_egl_has_extension(extensions, "EGL_TIZEN_image_native_surface");
912
    GLAD_EGL_WL_bind_wayland_display = glad_egl_has_extension(extensions, "EGL_WL_bind_wayland_display");
913
    GLAD_EGL_WL_create_wayland_buffer_from_image = glad_egl_has_extension(extensions, "EGL_WL_create_wayland_buffer_from_image");
914

915
    return 1;
916
}
917

918
static int glad_egl_find_core_egl(EGLDisplay display) {
919
    int major, minor;
920
    const char *version;
921

922
    if (display == NULL) {
923
        display = EGL_NO_DISPLAY; /* this is usually NULL, better safe than sorry */
924
    }
925
    if (display == EGL_NO_DISPLAY) {
926
        display = eglGetCurrentDisplay();
927
    }
928
#ifdef EGL_VERSION_1_4
929
    if (display == EGL_NO_DISPLAY) {
930
        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
931
    }
932
#endif
933
#ifndef EGL_VERSION_1_5
934
    if (display == EGL_NO_DISPLAY) {
935
        return 0;
936
    }
937
#endif
938

939
    version = eglQueryString(display, EGL_VERSION);
940
    (void) eglGetError();
941

942
    if (version == NULL) {
943
        major = 1;
944
        minor = 0;
945
    } else {
946
        GLAD_IMPL_UTIL_SSCANF(version, "%d.%d", &major, &minor);
947
    }
948

949
    GLAD_EGL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1;
950
    GLAD_EGL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1;
951
    GLAD_EGL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1;
952
    GLAD_EGL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1;
953
    GLAD_EGL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1;
954
    GLAD_EGL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1;
955

956
    return GLAD_MAKE_VERSION(major, minor);
957
}
958

959
int gladLoadEGLUserPtr(EGLDisplay display, GLADuserptrloadfunc load, void* userptr) {
960
    int version;
961
    eglGetDisplay = (PFNEGLGETDISPLAYPROC) load(userptr, "eglGetDisplay");
962
    eglGetCurrentDisplay = (PFNEGLGETCURRENTDISPLAYPROC) load(userptr, "eglGetCurrentDisplay");
963
    eglQueryString = (PFNEGLQUERYSTRINGPROC) load(userptr, "eglQueryString");
964
    eglGetError = (PFNEGLGETERRORPROC) load(userptr, "eglGetError");
965
    if (eglGetDisplay == NULL || eglGetCurrentDisplay == NULL || eglQueryString == NULL || eglGetError == NULL) return 0;
966

967
    version = glad_egl_find_core_egl(display);
968
    if (!version) return 0;
969
    glad_egl_load_EGL_VERSION_1_0(load, userptr);
970
    glad_egl_load_EGL_VERSION_1_1(load, userptr);
971
    glad_egl_load_EGL_VERSION_1_2(load, userptr);
972
    glad_egl_load_EGL_VERSION_1_4(load, userptr);
973
    glad_egl_load_EGL_VERSION_1_5(load, userptr);
974

975
    if (!glad_egl_find_extensions_egl(display)) return 0;
976
    glad_egl_load_EGL_ANDROID_blob_cache(load, userptr);
977
    glad_egl_load_EGL_ANDROID_create_native_client_buffer(load, userptr);
978
    glad_egl_load_EGL_ANDROID_get_frame_timestamps(load, userptr);
979
    glad_egl_load_EGL_ANDROID_get_native_client_buffer(load, userptr);
980
    glad_egl_load_EGL_ANDROID_native_fence_sync(load, userptr);
981
    glad_egl_load_EGL_ANDROID_presentation_time(load, userptr);
982
    glad_egl_load_EGL_ANGLE_query_surface_pointer(load, userptr);
983
    glad_egl_load_EGL_ANGLE_sync_control_rate(load, userptr);
984
    glad_egl_load_EGL_EXT_client_sync(load, userptr);
985
    glad_egl_load_EGL_EXT_compositor(load, userptr);
986
    glad_egl_load_EGL_EXT_device_base(load, userptr);
987
    glad_egl_load_EGL_EXT_device_enumeration(load, userptr);
988
    glad_egl_load_EGL_EXT_device_persistent_id(load, userptr);
989
    glad_egl_load_EGL_EXT_device_query(load, userptr);
990
    glad_egl_load_EGL_EXT_image_dma_buf_import_modifiers(load, userptr);
991
    glad_egl_load_EGL_EXT_output_base(load, userptr);
992
    glad_egl_load_EGL_EXT_platform_base(load, userptr);
993
    glad_egl_load_EGL_EXT_stream_consumer_egloutput(load, userptr);
994
    glad_egl_load_EGL_EXT_surface_compression(load, userptr);
995
    glad_egl_load_EGL_EXT_swap_buffers_with_damage(load, userptr);
996
    glad_egl_load_EGL_EXT_sync_reuse(load, userptr);
997
    glad_egl_load_EGL_HI_clientpixmap(load, userptr);
998
    glad_egl_load_EGL_KHR_cl_event2(load, userptr);
999
    glad_egl_load_EGL_KHR_debug(load, userptr);
1000
    glad_egl_load_EGL_KHR_display_reference(load, userptr);
1001
    glad_egl_load_EGL_KHR_fence_sync(load, userptr);
1002
    glad_egl_load_EGL_KHR_image(load, userptr);
1003
    glad_egl_load_EGL_KHR_image_base(load, userptr);
1004
    glad_egl_load_EGL_KHR_lock_surface(load, userptr);
1005
    glad_egl_load_EGL_KHR_lock_surface3(load, userptr);
1006
    glad_egl_load_EGL_KHR_partial_update(load, userptr);
1007
    glad_egl_load_EGL_KHR_reusable_sync(load, userptr);
1008
    glad_egl_load_EGL_KHR_stream(load, userptr);
1009
    glad_egl_load_EGL_KHR_stream_attrib(load, userptr);
1010
    glad_egl_load_EGL_KHR_stream_consumer_gltexture(load, userptr);
1011
    glad_egl_load_EGL_KHR_stream_cross_process_fd(load, userptr);
1012
    glad_egl_load_EGL_KHR_stream_fifo(load, userptr);
1013
    glad_egl_load_EGL_KHR_stream_producer_eglsurface(load, userptr);
1014
    glad_egl_load_EGL_KHR_swap_buffers_with_damage(load, userptr);
1015
    glad_egl_load_EGL_KHR_wait_sync(load, userptr);
1016
    glad_egl_load_EGL_MESA_drm_image(load, userptr);
1017
    glad_egl_load_EGL_MESA_image_dma_buf_export(load, userptr);
1018
    glad_egl_load_EGL_MESA_query_driver(load, userptr);
1019
    glad_egl_load_EGL_NOK_swap_region(load, userptr);
1020
    glad_egl_load_EGL_NOK_swap_region2(load, userptr);
1021
    glad_egl_load_EGL_NV_native_query(load, userptr);
1022
    glad_egl_load_EGL_NV_post_sub_buffer(load, userptr);
1023
    glad_egl_load_EGL_NV_stream_consumer_eglimage(load, userptr);
1024
    glad_egl_load_EGL_NV_stream_consumer_gltexture_yuv(load, userptr);
1025
    glad_egl_load_EGL_NV_stream_flush(load, userptr);
1026
    glad_egl_load_EGL_NV_stream_metadata(load, userptr);
1027
    glad_egl_load_EGL_NV_stream_reset(load, userptr);
1028
    glad_egl_load_EGL_NV_stream_sync(load, userptr);
1029
    glad_egl_load_EGL_NV_sync(load, userptr);
1030
    glad_egl_load_EGL_NV_system_time(load, userptr);
1031
    glad_egl_load_EGL_WL_bind_wayland_display(load, userptr);
1032
    glad_egl_load_EGL_WL_create_wayland_buffer_from_image(load, userptr);
1033

1034

1035
    return version;
1036
}
1037

1038
int gladLoadEGL(EGLDisplay display, GLADloadfunc load) {
1039
    return gladLoadEGLUserPtr(display, glad_egl_get_proc_from_userptr, GLAD_GNUC_EXTENSION (void*) load);
1040
}
1041

1042
 
1043

1044

1045
#ifdef __cplusplus
1046
}
1047
#endif
1048

1049
Product

Resources

Company
