diff --git a/build/glew.rc b/build/glew.rc index cf434ba..0aa3e68 100644 --- a/build/glew.rc +++ b/build/glew.rc @@ -20,8 +20,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 1, 0, 0 -PRODUCTVERSION 2, 1, 0, 0 +FILEVERSION 2, 2, 0, 0 +PRODUCTVERSION 2, 2, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -117,14 +117,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "The OpenGL Extension Wrangler Library\0" - VALUE "FileVersion", "2,1,0,0\0" + VALUE "FileVersion", "2,2,0,0\0" VALUE "InternalName", "GLEW\0" VALUE "LegalCopyright", "© 2002-2008 Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,1,0,0\0" + VALUE "ProductVersion", "2,2,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/glewinfo.rc b/build/glewinfo.rc index 465e8ba..deb78e5 100644 --- a/build/glewinfo.rc +++ b/build/glewinfo.rc @@ -12,8 +12,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 1, 0, 0 -PRODUCTVERSION 2, 1, 0, 0 +FILEVERSION 2, 2, 0, 0 +PRODUCTVERSION 2, 2, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -105,14 +105,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "Utility for verifying extension entry points\0" - VALUE "FileVersion", "2,1,0,0\0" + VALUE "FileVersion", "2,2,0,0\0" VALUE "InternalName", "glewinfo\0" VALUE "LegalCopyright", "© 2002-2008 Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,1,0,0\0" + VALUE "ProductVersion", "2,2,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/visualinfo.rc b/build/visualinfo.rc index a3ca123..d2756ea 100644 --- a/build/visualinfo.rc +++ b/build/visualinfo.rc @@ -12,8 +12,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 1, 0, 0 -PRODUCTVERSION 2, 1, 0, 0 +FILEVERSION 2, 2, 0, 0 +PRODUCTVERSION 2, 2, 0, 0 FILEFLAGSMASK VS_FFI_FILEFLAGSMASK #ifdef _DEBUG FILEFLAGS VS_FF_DEBUG @@ -105,14 +105,14 @@ BEGIN "MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "Utility for listing pixelformat capabilities\0" - VALUE "FileVersion", "2,1,0,0\0" + VALUE "FileVersion", "2,2,0,0\0" VALUE "InternalName", "visualinfo\0" VALUE "LegalCopyright", "© 2002-2008 Milan Ikits & Marcelo Magallon\0" VALUE "LegalTrademarks", "\0" VALUE "OriginalFilename", FILENAME "\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "The OpenGL Extension Wrangler Library\0" - VALUE "ProductVersion", "2,1,0,0\0" + VALUE "ProductVersion", "2,2,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/doc/glew.html b/doc/glew.html index 7216aac..925c711 100644 --- a/doc/glew.html +++ b/doc/glew.html @@ -99,824 +99,946 @@ THE POSSIBILITY OF SUCH DAMAGE.

Supported OpenGL Extensions

- - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - - - + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + - - - - + + + + - - - - - - + + - - + + + + - - - - - - - + + + + + + - - - - - - - - - - - + + + + + + + + + + - + + - + + + + + + + + - - - - - + + + + + + + + + + + - - - - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - + + + + + + + + - - - + + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + - - - - - - - + + + - + + - + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + - - - - - - + - + + + + + + + + + + + + + + + + + + - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + + + + + + + + + + + + + + + +
1 3DFX_multisample
2 3DFX_tbuffer
3 3DFX_texture_compression_FXT1
1 3DFX_multisample
2 3DFX_tbuffer
3 3DFX_texture_compression_FXT1

4 AMD_blend_minmax_factor
5 AMD_compressed_3DC_texture
6 AMD_compressed_ATC_texture
7 AMD_conservative_depth
8 AMD_debug_output
9 AMD_depth_clamp_separate
10 AMD_draw_buffers_blend
11 AMD_framebuffer_sample_positions
12 AMD_gcn_shader
13 AMD_gpu_shader_half_float
14 AMD_gpu_shader_int16
15 AMD_gpu_shader_int64
16 AMD_interleaved_elements
17 AMD_multi_draw_indirect
18 AMD_name_gen_delete
19 AMD_occlusion_query_event
20 AMD_performance_monitor
21 AMD_pinned_memory
22 AMD_program_binary_Z400
23 AMD_query_buffer_object
24 AMD_sample_positions
25 AMD_seamless_cubemap_per_texture
26 AMD_shader_atomic_counter_ops
27 AMD_shader_ballot
28 AMD_shader_explicit_vertex_parameter
29 AMD_shader_stencil_export
30 AMD_shader_stencil_value_export
31 AMD_shader_trinary_minmax
32 AMD_sparse_texture
33 AMD_stencil_operation_extended
34 AMD_texture_gather_bias_lod
35 AMD_texture_texture4
36 AMD_transform_feedback3_lines_triangles
37 AMD_transform_feedback4
38 AMD_vertex_shader_layer
39 AMD_vertex_shader_tessellator
40 AMD_vertex_shader_viewport_index
4 AMD_blend_minmax_factor
5 AMD_compressed_3DC_texture
6 AMD_compressed_ATC_texture
7 AMD_conservative_depth
8 AMD_debug_output
9 AMD_depth_clamp_separate
10 AMD_draw_buffers_blend
11 AMD_framebuffer_multisample_advanced
12 AMD_framebuffer_sample_positions
13 AMD_gcn_shader
14 AMD_gpu_shader_half_float
15 AMD_gpu_shader_half_float_fetch
16 AMD_gpu_shader_int16
17 AMD_gpu_shader_int64
18 AMD_interleaved_elements
19 AMD_multi_draw_indirect
20 AMD_name_gen_delete
21 AMD_occlusion_query_event
22 AMD_performance_monitor
23 AMD_pinned_memory
24 AMD_program_binary_Z400
25 AMD_query_buffer_object
26 AMD_sample_positions
27 AMD_seamless_cubemap_per_texture
28 AMD_shader_atomic_counter_ops
29 AMD_shader_ballot
30 AMD_shader_explicit_vertex_parameter
31 AMD_shader_image_load_store_lod
32 AMD_shader_stencil_export
33 AMD_shader_stencil_value_export
34 AMD_shader_trinary_minmax
35 AMD_sparse_texture
36 AMD_stencil_operation_extended
37 AMD_texture_gather_bias_lod
38 AMD_texture_texture4
39 AMD_transform_feedback3_lines_triangles
40 AMD_transform_feedback4
41 AMD_vertex_shader_layer
42 AMD_vertex_shader_tessellator
43 AMD_vertex_shader_viewport_index

41 ANDROID_extension_pack_es31a
44 ANDROID_extension_pack_es31a

42 ANGLE_depth_texture
43 ANGLE_framebuffer_blit
44 ANGLE_framebuffer_multisample
45 ANGLE_instanced_arrays
46 ANGLE_pack_reverse_row_order
47 ANGLE_program_binary
48 ANGLE_texture_compression_dxt1
49 ANGLE_texture_compression_dxt3
50 ANGLE_texture_compression_dxt5
51 ANGLE_texture_usage
52 ANGLE_timer_query
53 ANGLE_translated_shader_source
45 ANGLE_depth_texture
46 ANGLE_framebuffer_blit
47 ANGLE_framebuffer_multisample
48 ANGLE_instanced_arrays
49 ANGLE_pack_reverse_row_order
50 ANGLE_program_binary
51 ANGLE_texture_compression_dxt1
52 ANGLE_texture_compression_dxt3
53 ANGLE_texture_compression_dxt5
54 ANGLE_texture_usage
55 ANGLE_timer_query
56 ANGLE_translated_shader_source

54 APPLE_aux_depth_stencil
55 APPLE_client_storage
56 APPLE_clip_distance
57 APPLE_color_buffer_packed_float
58 APPLE_copy_texture_levels
59 APPLE_element_array
60 APPLE_fence
61 APPLE_float_pixels
62 APPLE_flush_buffer_range
63 APPLE_framebuffer_multisample
64 APPLE_object_purgeable
65 APPLE_pixel_buffer
66 APPLE_rgb_422
67 APPLE_row_bytes
68 APPLE_specular_vector
69 APPLE_sync
70 APPLE_texture_2D_limited_npot
71 APPLE_texture_format_BGRA8888
72 APPLE_texture_max_level
73 APPLE_texture_packed_float
74 APPLE_texture_range
75 APPLE_transform_hint
76 APPLE_vertex_array_object
77 APPLE_vertex_array_range
78 APPLE_vertex_program_evaluators
79 APPLE_ycbcr_422
57 APPLE_aux_depth_stencil
58 APPLE_client_storage
59 APPLE_clip_distance
60 APPLE_color_buffer_packed_float
61 APPLE_copy_texture_levels
62 APPLE_element_array
63 APPLE_fence
64 APPLE_float_pixels
65 APPLE_flush_buffer_range
66 APPLE_framebuffer_multisample
67 APPLE_object_purgeable
68 APPLE_pixel_buffer
69 APPLE_rgb_422
70 APPLE_row_bytes
71 APPLE_specular_vector
72 APPLE_sync
73 APPLE_texture_2D_limited_npot
74 APPLE_texture_format_BGRA8888
75 APPLE_texture_max_level
76 APPLE_texture_packed_float
77 APPLE_texture_range
78 APPLE_transform_hint
79 APPLE_vertex_array_object
80 APPLE_vertex_array_range
81 APPLE_vertex_program_evaluators
82 APPLE_ycbcr_422

80 ARB_ES2_compatibility
81 ARB_ES3_1_compatibility
82 ARB_ES3_2_compatibility
83 ARB_ES3_compatibility
84 ARB_arrays_of_arrays
85 ARB_base_instance
86 ARB_bindless_texture
87 ARB_blend_func_extended
88 ARB_buffer_storage
89 ARB_cl_event
90 ARB_clear_buffer_object
91 ARB_clear_texture
92 ARB_clip_control
93 ARB_color_buffer_float
94 ARB_compatibility
95 ARB_compressed_texture_pixel_storage
96 ARB_compute_shader
97 ARB_compute_variable_group_size
98 ARB_conditional_render_inverted
99 ARB_conservative_depth
100 ARB_copy_buffer
101 ARB_copy_image
102 ARB_cull_distance
103 ARB_debug_output
104 ARB_depth_buffer_float
105 ARB_depth_clamp
106 ARB_depth_texture
107 ARB_derivative_control
108 ARB_direct_state_access
109 ARB_draw_buffers
110 ARB_draw_buffers_blend
111 ARB_draw_elements_base_vertex
112 ARB_draw_indirect
113 ARB_draw_instanced
114 ARB_enhanced_layouts
115 ARB_explicit_attrib_location
116 ARB_explicit_uniform_location
117 ARB_fragment_coord_conventions
118 ARB_fragment_layer_viewport
119 ARB_fragment_program
120 ARB_fragment_program_shadow
121 ARB_fragment_shader
122 ARB_fragment_shader_interlock
123 ARB_framebuffer_no_attachments
124 ARB_framebuffer_object
125 ARB_framebuffer_sRGB
126 ARB_geometry_shader4
127 ARB_get_program_binary
128 ARB_get_texture_sub_image
129 ARB_gl_spirv
130 ARB_gpu_shader5
131 ARB_gpu_shader_fp64
132 ARB_gpu_shader_int64
133 ARB_half_float_pixel
134 ARB_half_float_vertex
135 ARB_imaging
136 ARB_indirect_parameters
137 ARB_instanced_arrays
138 ARB_internalformat_query
139 ARB_internalformat_query2
140 ARB_invalidate_subdata
141 ARB_map_buffer_alignment
142 ARB_map_buffer_range
143 ARB_matrix_palette
144 ARB_multi_bind
145 ARB_multi_draw_indirect
146 ARB_multisample
147 ARB_multitexture
148 ARB_occlusion_query
149 ARB_occlusion_query2
150 ARB_parallel_shader_compile
151 ARB_pipeline_statistics_query
152 ARB_pixel_buffer_object
153 ARB_point_parameters
154 ARB_point_sprite
155 ARB_polygon_offset_clamp
156 ARB_post_depth_coverage
157 ARB_program_interface_query
158 ARB_provoking_vertex
159 ARB_query_buffer_object
160 ARB_robust_buffer_access_behavior
161 ARB_robustness
162 ARB_robustness_application_isolation
163 ARB_robustness_share_group_isolation
164 ARB_sample_locations
165 ARB_sample_shading
166 ARB_sampler_objects
167 ARB_seamless_cube_map
168 ARB_seamless_cubemap_per_texture
169 ARB_separate_shader_objects
170 ARB_shader_atomic_counter_ops
171 ARB_shader_atomic_counters
172 ARB_shader_ballot
173 ARB_shader_bit_encoding
174 ARB_shader_clock
175 ARB_shader_draw_parameters
176 ARB_shader_group_vote
177 ARB_shader_image_load_store
178 ARB_shader_image_size
179 ARB_shader_objects
180 ARB_shader_precision
181 ARB_shader_stencil_export
182 ARB_shader_storage_buffer_object
183 ARB_shader_subroutine
184 ARB_shader_texture_image_samples
185 ARB_shader_texture_lod
186 ARB_shader_viewport_layer_array
187 ARB_shading_language_100
188 ARB_shading_language_420pack
189 ARB_shading_language_include
190 ARB_shading_language_packing
191 ARB_shadow
192 ARB_shadow_ambient
193 ARB_sparse_buffer
194 ARB_sparse_texture
195 ARB_sparse_texture2
196 ARB_sparse_texture_clamp
197 ARB_spirv_extensions
198 ARB_stencil_texturing
199 ARB_sync
200 ARB_tessellation_shader
201 ARB_texture_barrier
202 ARB_texture_border_clamp
203 ARB_texture_buffer_object
204 ARB_texture_buffer_object_rgb32
205 ARB_texture_buffer_range
206 ARB_texture_compression
207 ARB_texture_compression_bptc
208 ARB_texture_compression_rgtc
209 ARB_texture_cube_map
210 ARB_texture_cube_map_array
211 ARB_texture_env_add
212 ARB_texture_env_combine
213 ARB_texture_env_crossbar
214 ARB_texture_env_dot3
215 ARB_texture_filter_anisotropic
216 ARB_texture_filter_minmax
217 ARB_texture_float
218 ARB_texture_gather
219 ARB_texture_mirror_clamp_to_edge
220 ARB_texture_mirrored_repeat
221 ARB_texture_multisample
222 ARB_texture_non_power_of_two
223 ARB_texture_query_levels
224 ARB_texture_query_lod
225 ARB_texture_rectangle
226 ARB_texture_rg
227 ARB_texture_rgb10_a2ui
228 ARB_texture_stencil8
229 ARB_texture_storage
230 ARB_texture_storage_multisample
231 ARB_texture_swizzle
232 ARB_texture_view
233 ARB_timer_query
234 ARB_transform_feedback2
235 ARB_transform_feedback3
236 ARB_transform_feedback_instanced
237 ARB_transform_feedback_overflow_query
238 ARB_transpose_matrix
239 ARB_uniform_buffer_object
240 ARB_vertex_array_bgra
241 ARB_vertex_array_object
242 ARB_vertex_attrib_64bit
243 ARB_vertex_attrib_binding
244 ARB_vertex_blend
245 ARB_vertex_buffer_object
246 ARB_vertex_program
247 ARB_vertex_shader
248 ARB_vertex_type_10f_11f_11f_rev
249 ARB_vertex_type_2_10_10_10_rev
250 ARB_viewport_array
251 ARB_window_pos
83 ARB_ES2_compatibility
84 ARB_ES3_1_compatibility
85 ARB_ES3_2_compatibility
86 ARB_ES3_compatibility
87 ARB_arrays_of_arrays
88 ARB_base_instance
89 ARB_bindless_texture
90 ARB_blend_func_extended
91 ARB_buffer_storage
92 ARB_cl_event
93 ARB_clear_buffer_object
94 ARB_clear_texture
95 ARB_clip_control
96 ARB_color_buffer_float
97 ARB_compatibility
98 ARB_compressed_texture_pixel_storage
99 ARB_compute_shader
100 ARB_compute_variable_group_size
101 ARB_conditional_render_inverted
102 ARB_conservative_depth
103 ARB_copy_buffer
104 ARB_copy_image
105 ARB_cull_distance
106 ARB_debug_output
107 ARB_depth_buffer_float
108 ARB_depth_clamp
109 ARB_depth_texture
110 ARB_derivative_control
111 ARB_direct_state_access
112 ARB_draw_buffers
113 ARB_draw_buffers_blend
114 ARB_draw_elements_base_vertex
115 ARB_draw_indirect
116 ARB_draw_instanced
117 ARB_enhanced_layouts
118 ARB_explicit_attrib_location
119 ARB_explicit_uniform_location
120 ARB_fragment_coord_conventions
121 ARB_fragment_layer_viewport
122 ARB_fragment_program
123 ARB_fragment_program_shadow
124 ARB_fragment_shader
125 ARB_fragment_shader_interlock
126 ARB_framebuffer_no_attachments
127 ARB_framebuffer_object
128 ARB_framebuffer_sRGB
129 ARB_geometry_shader4
130 ARB_get_program_binary
131 ARB_get_texture_sub_image
132 ARB_gl_spirv
133 ARB_gpu_shader5
134 ARB_gpu_shader_fp64
135 ARB_gpu_shader_int64
136 ARB_half_float_pixel
137 ARB_half_float_vertex
138 ARB_imaging
139 ARB_indirect_parameters
140 ARB_instanced_arrays
141 ARB_internalformat_query
142 ARB_internalformat_query2
143 ARB_invalidate_subdata
144 ARB_map_buffer_alignment
145 ARB_map_buffer_range
146 ARB_matrix_palette
147 ARB_multi_bind
148 ARB_multi_draw_indirect
149 ARB_multisample
150 ARB_multitexture
151 ARB_occlusion_query
152 ARB_occlusion_query2
153 ARB_parallel_shader_compile
154 ARB_pipeline_statistics_query
155 ARB_pixel_buffer_object
156 ARB_point_parameters
157 ARB_point_sprite
158 ARB_polygon_offset_clamp
159 ARB_post_depth_coverage
160 ARB_program_interface_query
161 ARB_provoking_vertex
162 ARB_query_buffer_object
163 ARB_robust_buffer_access_behavior
164 ARB_robustness
165 ARB_robustness_application_isolation
166 ARB_robustness_share_group_isolation
167 ARB_sample_locations
168 ARB_sample_shading
169 ARB_sampler_objects
170 ARB_seamless_cube_map
171 ARB_seamless_cubemap_per_texture
172 ARB_separate_shader_objects
173 ARB_shader_atomic_counter_ops
174 ARB_shader_atomic_counters
175 ARB_shader_ballot
176 ARB_shader_bit_encoding
177 ARB_shader_clock
178 ARB_shader_draw_parameters
179 ARB_shader_group_vote
180 ARB_shader_image_load_store
181 ARB_shader_image_size
182 ARB_shader_objects
183 ARB_shader_precision
184 ARB_shader_stencil_export
185 ARB_shader_storage_buffer_object
186 ARB_shader_subroutine
187 ARB_shader_texture_image_samples
188 ARB_shader_texture_lod
189 ARB_shader_viewport_layer_array
190 ARB_shading_language_100
191 ARB_shading_language_420pack
192 ARB_shading_language_include
193 ARB_shading_language_packing
194 ARB_shadow
195 ARB_shadow_ambient
196 ARB_sparse_buffer
197 ARB_sparse_texture
198 ARB_sparse_texture2
199 ARB_sparse_texture_clamp
200 ARB_spirv_extensions
201 ARB_stencil_texturing
202 ARB_sync
203 ARB_tessellation_shader
204 ARB_texture_barrier
205 ARB_texture_border_clamp
206 ARB_texture_buffer_object
207 ARB_texture_buffer_object_rgb32
208 ARB_texture_buffer_range
209 ARB_texture_compression
210 ARB_texture_compression_bptc
211 ARB_texture_compression_rgtc
212 ARB_texture_cube_map
213 ARB_texture_cube_map_array
214 ARB_texture_env_add
215 ARB_texture_env_combine
216 ARB_texture_env_crossbar
217 ARB_texture_env_dot3
218 ARB_texture_filter_anisotropic
219 ARB_texture_filter_minmax
220 ARB_texture_float
221 ARB_texture_gather
222 ARB_texture_mirror_clamp_to_edge
223 ARB_texture_mirrored_repeat
224 ARB_texture_multisample
225 ARB_texture_non_power_of_two
226 ARB_texture_query_levels
227 ARB_texture_query_lod
228 ARB_texture_rectangle
229 ARB_texture_rg
230 ARB_texture_rgb10_a2ui
231 ARB_texture_stencil8
232 ARB_texture_storage
233 ARB_texture_storage_multisample
234 ARB_texture_swizzle
235 ARB_texture_view
236 ARB_timer_query
237 ARB_transform_feedback2
238 ARB_transform_feedback3
239 ARB_transform_feedback_instanced
240 ARB_transform_feedback_overflow_query
241 ARB_transpose_matrix
242 ARB_uniform_buffer_object
243 ARB_vertex_array_bgra
244 ARB_vertex_array_object
245 ARB_vertex_attrib_64bit
246 ARB_vertex_attrib_binding
247 ARB_vertex_blend
248 ARB_vertex_buffer_object
249 ARB_vertex_program
250 ARB_vertex_shader
251 ARB_vertex_type_10f_11f_11f_rev
252 ARB_vertex_type_2_10_10_10_rev
253 ARB_viewport_array
254 ARB_window_pos

252 ARM_mali_program_binary
253 ARM_mali_shader_binary
254 ARM_rgba8
255 ARM_shader_framebuffer_fetch
256 ARM_shader_framebuffer_fetch_depth_stencil
255 ARM_mali_program_binary
256 ARM_mali_shader_binary
257 ARM_rgba8
258 ARM_shader_framebuffer_fetch
259 ARM_shader_framebuffer_fetch_depth_stencil

257 ATIX_point_sprites
258 ATIX_texture_env_combine3
259 ATIX_texture_env_route
260 ATIX_vertex_shader_output_point_size
260 ATIX_point_sprites
261 ATIX_texture_env_combine3
262 ATIX_texture_env_route
263 ATIX_vertex_shader_output_point_size

261 ATI_draw_buffers
262 ATI_element_array
263 ATI_envmap_bumpmap
264 ATI_fragment_shader
265 ATI_map_object_buffer
266 ATI_meminfo
267 ATI_pn_triangles
268 ATI_separate_stencil
269 ATI_shader_texture_lod
270 ATI_text_fragment_shader
271 ATI_texture_compression_3dc
272 ATI_texture_env_combine3
273 ATI_texture_float
274 ATI_texture_mirror_once
275 ATI_vertex_array_object
276 ATI_vertex_attrib_array_object
277 ATI_vertex_streams
264 ATI_draw_buffers
265 ATI_element_array
266 ATI_envmap_bumpmap
267 ATI_fragment_shader
268 ATI_map_object_buffer
269 ATI_meminfo
270 ATI_pn_triangles
271 ATI_separate_stencil
272 ATI_shader_texture_lod
273 ATI_text_fragment_shader
274 ATI_texture_compression_3dc
275 ATI_texture_env_combine3
276 ATI_texture_float
277 ATI_texture_mirror_once
278 ATI_vertex_array_object
279 ATI_vertex_attrib_array_object
280 ATI_vertex_streams

278 EGL_KHR_context_flush_control
279 EGL_NV_robustness_video_memory_purge
281 DMP_program_binary
282 DMP_shader_binary

280 EXT_422_pixels
281 EXT_Cg_shader
282 EXT_EGL_image_array
283 EXT_YUV_target
284 EXT_abgr
285 EXT_base_instance
286 EXT_bgra
287 EXT_bindable_uniform
288 EXT_blend_color
289 EXT_blend_equation_separate
290 EXT_blend_func_extended
291 EXT_blend_func_separate
292 EXT_blend_logic_op
293 EXT_blend_minmax
294 EXT_blend_subtract
295 EXT_buffer_storage
296 EXT_clear_texture
297 EXT_clip_cull_distance
298 EXT_clip_volume_hint
299 EXT_cmyka
300 EXT_color_buffer_float
301 EXT_color_buffer_half_float
302 EXT_color_subtable
303 EXT_compiled_vertex_array
304 EXT_compressed_ETC1_RGB8_sub_texture
305 EXT_conservative_depth
306 EXT_convolution
307 EXT_coordinate_frame
308 EXT_copy_image
309 EXT_copy_texture
310 EXT_cull_vertex
311 EXT_debug_label
312 EXT_debug_marker
313 EXT_depth_bounds_test
314 EXT_direct_state_access
315 EXT_discard_framebuffer
316 EXT_draw_buffers
317 EXT_draw_buffers2
318 EXT_draw_buffers_indexed
319 EXT_draw_elements_base_vertex
320 EXT_draw_instanced
321 EXT_draw_range_elements
322 EXT_external_buffer
323 EXT_float_blend
324 EXT_fog_coord
325 EXT_frag_depth
326 EXT_fragment_lighting
327 EXT_framebuffer_blit
328 EXT_framebuffer_multisample
329 EXT_framebuffer_multisample_blit_scaled
330 EXT_framebuffer_object
331 EXT_framebuffer_sRGB
332 EXT_geometry_point_size
333 EXT_geometry_shader
334 EXT_geometry_shader4
335 EXT_gpu_program_parameters
336 EXT_gpu_shader4
337 EXT_gpu_shader5
338 EXT_histogram
339 EXT_index_array_formats
340 EXT_index_func
341 EXT_index_material
342 EXT_index_texture
343 EXT_instanced_arrays
344 EXT_light_texture
345 EXT_map_buffer_range
346 EXT_memory_object
347 EXT_memory_object_fd
348 EXT_memory_object_win32
349 EXT_misc_attribute
350 EXT_multi_draw_arrays
351 EXT_multi_draw_indirect
352 EXT_multiple_textures
353 EXT_multisample
354 EXT_multisample_compatibility
355 EXT_multisampled_render_to_texture
356 EXT_multisampled_render_to_texture2
357 EXT_multiview_draw_buffers
358 EXT_packed_depth_stencil
359 EXT_packed_float
360 EXT_packed_pixels
361 EXT_paletted_texture
362 EXT_pixel_buffer_object
363 EXT_pixel_transform
364 EXT_pixel_transform_color_table
365 EXT_point_parameters
366 EXT_polygon_offset
367 EXT_polygon_offset_clamp
368 EXT_post_depth_coverage
369 EXT_provoking_vertex
370 EXT_pvrtc_sRGB
371 EXT_raster_multisample
372 EXT_read_format_bgra
373 EXT_render_snorm
374 EXT_rescale_normal
375 EXT_sRGB
376 EXT_sRGB_write_control
377 EXT_scene_marker
378 EXT_secondary_color
379 EXT_semaphore
380 EXT_semaphore_fd
381 EXT_semaphore_win32
382 EXT_separate_shader_objects
383 EXT_separate_specular_color
384 EXT_shader_framebuffer_fetch
385 EXT_shader_group_vote
386 EXT_shader_image_load_formatted
387 EXT_shader_image_load_store
388 EXT_shader_implicit_conversions
389 EXT_shader_integer_mix
390 EXT_shader_io_blocks
391 EXT_shader_non_constant_global_initializers
392 EXT_shader_pixel_local_storage
393 EXT_shader_pixel_local_storage2
394 EXT_shader_texture_lod
395 EXT_shadow_funcs
396 EXT_shadow_samplers
397 EXT_shared_texture_palette
398 EXT_sparse_texture
399 EXT_sparse_texture2
400 EXT_stencil_clear_tag
401 EXT_stencil_two_side
402 EXT_stencil_wrap
403 EXT_subtexture
404 EXT_texture
405 EXT_texture3D
406 EXT_texture_array
407 EXT_texture_buffer_object
408 EXT_texture_compression_astc_decode_mode
409 EXT_texture_compression_astc_decode_mode_rgb9e5
410 EXT_texture_compression_bptc
411 EXT_texture_compression_dxt1
412 EXT_texture_compression_latc
413 EXT_texture_compression_rgtc
414 EXT_texture_compression_s3tc
415 EXT_texture_cube_map
416 EXT_texture_cube_map_array
417 EXT_texture_edge_clamp
418 EXT_texture_env
419 EXT_texture_env_add
420 EXT_texture_env_combine
421 EXT_texture_env_dot3
422 EXT_texture_filter_anisotropic
423 EXT_texture_filter_minmax
424 EXT_texture_format_BGRA8888
425 EXT_texture_integer
426 EXT_texture_lod_bias
427 EXT_texture_mirror_clamp
428 EXT_texture_norm16
429 EXT_texture_object
430 EXT_texture_perturb_normal
431 EXT_texture_rectangle
432 EXT_texture_rg
433 EXT_texture_sRGB
434 EXT_texture_sRGB_R8
435 EXT_texture_sRGB_RG8
436 EXT_texture_sRGB_decode
437 EXT_texture_shared_exponent
438 EXT_texture_snorm
439 EXT_texture_storage
440 EXT_texture_swizzle
441 EXT_texture_type_2_10_10_10_REV
442 EXT_texture_view
443 EXT_timer_query
444 EXT_transform_feedback
445 EXT_unpack_subimage
446 EXT_vertex_array
447 EXT_vertex_array_bgra
448 EXT_vertex_array_setXXX
449 EXT_vertex_attrib_64bit
450 EXT_vertex_shader
451 EXT_vertex_weighting
452 EXT_win32_keyed_mutex
453 EXT_window_rectangles
454 EXT_x11_sync_object
283 EXT_422_pixels
284 EXT_Cg_shader
285 EXT_EGL_image_array
286 EXT_EGL_image_external_wrap_modes
287 EXT_EGL_image_storage
288 EXT_YUV_target
289 EXT_abgr
290 EXT_base_instance
291 EXT_bgra
292 EXT_bindable_uniform
293 EXT_blend_color
294 EXT_blend_equation_separate
295 EXT_blend_func_extended
296 EXT_blend_func_separate
297 EXT_blend_logic_op
298 EXT_blend_minmax
299 EXT_blend_subtract
300 EXT_buffer_storage
301 EXT_clear_texture
302 EXT_clip_control
303 EXT_clip_cull_distance
304 EXT_clip_volume_hint
305 EXT_cmyka
306 EXT_color_buffer_float
307 EXT_color_buffer_half_float
308 EXT_color_subtable
309 EXT_compiled_vertex_array
310 EXT_compressed_ETC1_RGB8_sub_texture
311 EXT_conservative_depth
312 EXT_convolution
313 EXT_coordinate_frame
314 EXT_copy_image
315 EXT_copy_texture
316 EXT_cull_vertex
317 EXT_debug_label
318 EXT_debug_marker
319 EXT_depth_bounds_test
320 EXT_direct_state_access
321 EXT_discard_framebuffer
322 EXT_disjoint_timer_query
323 EXT_draw_buffers
324 EXT_draw_buffers2
325 EXT_draw_buffers_indexed
326 EXT_draw_elements_base_vertex
327 EXT_draw_instanced
328 EXT_draw_range_elements
329 EXT_draw_transform_feedback
330 EXT_external_buffer
331 EXT_float_blend
332 EXT_fog_coord
333 EXT_frag_depth
334 EXT_fragment_lighting
335 EXT_framebuffer_blit
336 EXT_framebuffer_multisample
337 EXT_framebuffer_multisample_blit_scaled
338 EXT_framebuffer_object
339 EXT_framebuffer_sRGB
340 EXT_geometry_point_size
341 EXT_geometry_shader
342 EXT_geometry_shader4
343 EXT_gpu_program_parameters
344 EXT_gpu_shader4
345 EXT_gpu_shader5
346 EXT_histogram
347 EXT_index_array_formats
348 EXT_index_func
349 EXT_index_material
350 EXT_index_texture
351 EXT_instanced_arrays
352 EXT_light_texture
353 EXT_map_buffer_range
354 EXT_memory_object
355 EXT_memory_object_fd
356 EXT_memory_object_win32
357 EXT_misc_attribute
358 EXT_multi_draw_arrays
359 EXT_multi_draw_indirect
360 EXT_multiple_textures
361 EXT_multisample
362 EXT_multisample_compatibility
363 EXT_multisampled_render_to_texture
364 EXT_multisampled_render_to_texture2
365 EXT_multiview_draw_buffers
366 EXT_occlusion_query_boolean
367 EXT_packed_depth_stencil
368 EXT_packed_float
369 EXT_packed_pixels
370 EXT_paletted_texture
371 EXT_pixel_buffer_object
372 EXT_pixel_transform
373 EXT_pixel_transform_color_table
374 EXT_point_parameters
375 EXT_polygon_offset
376 EXT_polygon_offset_clamp
377 EXT_post_depth_coverage
378 EXT_protected_textures
379 EXT_provoking_vertex
380 EXT_pvrtc_sRGB
381 EXT_raster_multisample
382 EXT_read_format_bgra
383 EXT_render_snorm
384 EXT_rescale_normal
385 EXT_robustness
386 EXT_sRGB
387 EXT_sRGB_write_control
388 EXT_scene_marker
389 EXT_secondary_color
390 EXT_semaphore
391 EXT_semaphore_fd
392 EXT_semaphore_win32
393 EXT_separate_shader_objects
394 EXT_separate_specular_color
395 EXT_shader_framebuffer_fetch
396 EXT_shader_framebuffer_fetch_non_coherent
397 EXT_shader_group_vote
398 EXT_shader_image_load_formatted
399 EXT_shader_image_load_store
400 EXT_shader_implicit_conversions
401 EXT_shader_integer_mix
402 EXT_shader_io_blocks
403 EXT_shader_non_constant_global_initializers
404 EXT_shader_pixel_local_storage
405 EXT_shader_pixel_local_storage2
406 EXT_shader_texture_lod
407 EXT_shadow_funcs
408 EXT_shadow_samplers
409 EXT_shared_texture_palette
410 EXT_sparse_texture
411 EXT_sparse_texture2
412 EXT_static_vertex_array
413 EXT_stencil_clear_tag
414 EXT_stencil_two_side
415 EXT_stencil_wrap
416 EXT_subtexture
417 EXT_tessellation_point_size
418 EXT_tessellation_shader
419 EXT_texture
420 EXT_texture3D
421 EXT_texture_array
422 EXT_texture_border_clamp
423 EXT_texture_buffer
424 EXT_texture_buffer_object
425 EXT_texture_compression_astc_decode_mode
426 EXT_texture_compression_astc_decode_mode_rgb9e5
427 EXT_texture_compression_bptc
428 EXT_texture_compression_dxt1
429 EXT_texture_compression_latc
430 EXT_texture_compression_rgtc
431 EXT_texture_compression_s3tc
432 EXT_texture_compression_s3tc_srgb
433 EXT_texture_cube_map
434 EXT_texture_cube_map_array
435 EXT_texture_edge_clamp
436 EXT_texture_env
437 EXT_texture_env_add
438 EXT_texture_env_combine
439 EXT_texture_env_dot3
440 EXT_texture_filter_anisotropic
441 EXT_texture_filter_minmax
442 EXT_texture_format_BGRA8888
443 EXT_texture_format_sRGB_override
444 EXT_texture_integer
445 EXT_texture_lod_bias
446 EXT_texture_mirror_clamp
447 EXT_texture_mirror_clamp_to_edge
448 EXT_texture_norm16
449 EXT_texture_object
450 EXT_texture_perturb_normal
451 EXT_texture_rectangle
452 EXT_texture_rg
453 EXT_texture_sRGB
454 EXT_texture_sRGB_R8
455 EXT_texture_sRGB_RG8
456 EXT_texture_sRGB_decode
457 EXT_texture_shared_exponent
458 EXT_texture_snorm
459 EXT_texture_storage
460 EXT_texture_swizzle
461 EXT_texture_type_2_10_10_10_REV
462 EXT_texture_view
463 EXT_timer_query
464 EXT_transform_feedback
465 EXT_unpack_subimage
466 EXT_vertex_array
467 EXT_vertex_array_bgra
468 EXT_vertex_array_setXXX
469 EXT_vertex_attrib_64bit
470 EXT_vertex_shader
471 EXT_vertex_weighting
472 EXT_win32_keyed_mutex
473 EXT_window_rectangles
474 EXT_x11_sync_object

455 GREMEDY_frame_terminator
456 GREMEDY_string_marker
475 FJ_shader_binary_GCCSO

457 HP_convolution_border_modes
458 HP_image_transform
459 HP_occlusion_test
460 HP_texture_lighting
476 GLU_EXT_nurbs_tessellator
477 GLU_EXT_object_space_tess
478 GLU_SGIX_icc_compress
479 GLU_SGI_filter4_parameters

461 IBM_cull_vertex
462 IBM_multimode_draw_arrays
463 IBM_rasterpos_clip
464 IBM_static_data
465 IBM_texture_mirrored_repeat
466 IBM_vertex_array_lists
480 GREMEDY_frame_terminator
481 GREMEDY_string_marker

467 INGR_color_clamp
468 INGR_interlace_read
482 HP_convolution_border_modes
483 HP_image_transform
484 HP_occlusion_test
485 HP_texture_lighting

469 INTEL_conservative_rasterization
470 INTEL_fragment_shader_ordering
471 INTEL_framebuffer_CMAA
472 INTEL_map_texture
473 INTEL_parallel_arrays
474 INTEL_performance_query
475 INTEL_texture_scissor
486 IBM_cull_vertex
487 IBM_multimode_draw_arrays
488 IBM_rasterpos_clip
489 IBM_static_data
490 IBM_texture_mirrored_repeat
491 IBM_vertex_array_lists

476 KHR_blend_equation_advanced
477 KHR_blend_equation_advanced_coherent
478 KHR_context_flush_control
479 KHR_debug
480 KHR_no_error
481 KHR_parallel_shader_compile
482 KHR_robust_buffer_access_behavior
483 KHR_robustness
484 KHR_texture_compression_astc_hdr
485 KHR_texture_compression_astc_ldr
486 KHR_texture_compression_astc_sliced_3d
492 IMG_bindless_texture
493 IMG_framebuffer_downsample
494 IMG_multisampled_render_to_texture
495 IMG_program_binary
496 IMG_read_format
497 IMG_shader_binary
498 IMG_texture_compression_pvrtc
499 IMG_texture_compression_pvrtc2
500 IMG_texture_env_enhanced_fixed_function
501 IMG_texture_filter_cubic

487 KTX_buffer_region
502 INGR_color_clamp
503 INGR_interlace_read

488 MESAX_texture_stack
504 INTEL_blackhole_render
505 INTEL_conservative_rasterization
506 INTEL_fragment_shader_ordering
507 INTEL_framebuffer_CMAA
508 INTEL_map_texture
509 INTEL_parallel_arrays
510 INTEL_performance_query
511 INTEL_texture_scissor

489 MESA_pack_invert
490 MESA_resize_buffers
491 MESA_shader_integer_functions
492 MESA_window_pos
493 MESA_ycbcr_texture
512 KHR_blend_equation_advanced
513 KHR_blend_equation_advanced_coherent
514 KHR_context_flush_control
515 KHR_debug
516 KHR_no_error
517 KHR_parallel_shader_compile
518 KHR_robust_buffer_access_behavior
519 KHR_robustness
520 KHR_texture_compression_astc_hdr
521 KHR_texture_compression_astc_ldr
522 KHR_texture_compression_astc_sliced_3d

494 NVX_blend_equation_advanced_multi_draw_buffers
495 NVX_conditional_render
496 NVX_gpu_memory_info
497 NVX_linked_gpu_multicast
523 KTX_buffer_region

498 NV_3dvision_settings
499 NV_EGL_stream_consumer_external
500 NV_alpha_to_coverage_dither_control
501 NV_bgr
502 NV_bindless_multi_draw_indirect
503 NV_bindless_multi_draw_indirect_count
504 NV_bindless_texture
505 NV_blend_equation_advanced
506 NV_blend_equation_advanced_coherent
507 NV_blend_minmax_factor
508 NV_blend_square
509 NV_clip_space_w_scaling
510 NV_command_list
511 NV_compute_program5
512 NV_conditional_render
513 NV_conservative_raster
514 NV_conservative_raster_dilate
515 NV_conservative_raster_pre_snap_triangles
516 NV_copy_buffer
517 NV_copy_depth_to_color
518 NV_copy_image
519 NV_deep_texture3D
520 NV_depth_buffer_float
521 NV_depth_clamp
522 NV_depth_range_unclamped
523 NV_draw_buffers
524 NV_draw_instanced
525 NV_draw_texture
526 NV_draw_vulkan_image
527 NV_evaluators
528 NV_explicit_attrib_location
529 NV_explicit_multisample
530 NV_fbo_color_attachments
531 NV_fence
532 NV_fill_rectangle
533 NV_float_buffer
534 NV_fog_distance
535 NV_fragment_coverage_to_color
536 NV_fragment_program
537 NV_fragment_program2
538 NV_fragment_program4
539 NV_fragment_program_option
540 NV_fragment_shader_interlock
541 NV_framebuffer_blit
542 NV_framebuffer_mixed_samples
543 NV_framebuffer_multisample
544 NV_framebuffer_multisample_coverage
545 NV_generate_mipmap_sRGB
546 NV_geometry_program4
547 NV_geometry_shader4
548 NV_geometry_shader_passthrough
549 NV_gpu_multicast
550 NV_gpu_program4
551 NV_gpu_program5
552 NV_gpu_program5_mem_extended
553 NV_gpu_program_fp64
554 NV_gpu_shader5
555 NV_half_float
556 NV_image_formats
557 NV_instanced_arrays
558 NV_internalformat_sample_query
559 NV_light_max_exponent
560 NV_multisample_coverage
561 NV_multisample_filter_hint
562 NV_non_square_matrices
563 NV_occlusion_query
564 NV_pack_subimage
565 NV_packed_depth_stencil
566 NV_packed_float
567 NV_packed_float_linear
568 NV_parameter_buffer_object
569 NV_parameter_buffer_object2
570 NV_path_rendering
571 NV_path_rendering_shared_edge
572 NV_pixel_buffer_object
573 NV_pixel_data_range
574 NV_platform_binary
575 NV_point_sprite
576 NV_polygon_mode
577 NV_present_video
578 NV_primitive_restart
579 NV_read_depth
580 NV_read_depth_stencil
581 NV_read_stencil
582 NV_register_combiners
583 NV_register_combiners2
584 NV_robustness_video_memory_purge
585 NV_sRGB_formats
586 NV_sample_locations
587 NV_sample_mask_override_coverage
588 NV_shader_atomic_counters
589 NV_shader_atomic_float
590 NV_shader_atomic_float64
591 NV_shader_atomic_fp16_vector
592 NV_shader_atomic_int64
593 NV_shader_buffer_load
594 NV_shader_noperspective_interpolation
595 NV_shader_storage_buffer_object
596 NV_shader_thread_group
597 NV_shader_thread_shuffle
598 NV_shadow_samplers_array
599 NV_shadow_samplers_cube
600 NV_stereo_view_rendering
601 NV_tessellation_program5
602 NV_texgen_emboss
603 NV_texgen_reflection
604 NV_texture_array
605 NV_texture_barrier
606 NV_texture_border_clamp
607 NV_texture_compression_latc
608 NV_texture_compression_s3tc
609 NV_texture_compression_s3tc_update
610 NV_texture_compression_vtc
611 NV_texture_env_combine4
612 NV_texture_expand_normal
613 NV_texture_multisample
614 NV_texture_npot_2D_mipmap
615 NV_texture_rectangle
616 NV_texture_rectangle_compressed
617 NV_texture_shader
618 NV_texture_shader2
619 NV_texture_shader3
620 NV_transform_feedback
621 NV_transform_feedback2
622 NV_uniform_buffer_unified_memory
623 NV_vdpau_interop
624 NV_vertex_array_range
625 NV_vertex_array_range2
626 NV_vertex_attrib_integer_64bit
627 NV_vertex_buffer_unified_memory
628 NV_vertex_program
629 NV_vertex_program1_1
630 NV_vertex_program2
631 NV_vertex_program2_option
632 NV_vertex_program3
633 NV_vertex_program4
634 NV_video_capture
635 NV_viewport_array
636 NV_viewport_array2
637 NV_viewport_swizzle
524 MESAX_texture_stack

638 OES_byte_coordinates
525 MESA_framebuffer_flip_y
526 MESA_pack_invert
527 MESA_program_binary_formats
528 MESA_resize_buffers
529 MESA_shader_integer_functions
530 MESA_tile_raster_order
531 MESA_window_pos
532 MESA_ycbcr_texture

639 OML_interlace
640 OML_resample
641 OML_subsample
533 NVX_blend_equation_advanced_multi_draw_buffers
534 NVX_conditional_render
535 NVX_gpu_memory_info
536 NVX_linked_gpu_multicast

642 OVR_multiview
643 OVR_multiview2
644 OVR_multiview_multisampled_render_to_texture
537 NV_3dvision_settings
538 NV_EGL_stream_consumer_external
539 NV_alpha_to_coverage_dither_control
540 NV_bgr
541 NV_bindless_multi_draw_indirect
542 NV_bindless_multi_draw_indirect_count
543 NV_bindless_texture
544 NV_blend_equation_advanced
545 NV_blend_equation_advanced_coherent
546 NV_blend_minmax_factor
547 NV_blend_square
548 NV_clip_space_w_scaling
549 NV_command_list
550 NV_compute_program5
551 NV_compute_shader_derivatives
552 NV_conditional_render
553 NV_conservative_raster
554 NV_conservative_raster_dilate
555 NV_conservative_raster_pre_snap
556 NV_conservative_raster_pre_snap_triangles
557 NV_conservative_raster_underestimation
558 NV_copy_buffer
559 NV_copy_depth_to_color
560 NV_copy_image
561 NV_deep_texture3D
562 NV_depth_buffer_float
563 NV_depth_clamp
564 NV_depth_nonlinear
565 NV_depth_range_unclamped
566 NV_draw_buffers
567 NV_draw_instanced
568 NV_draw_texture
569 NV_draw_vulkan_image
570 NV_evaluators
571 NV_explicit_attrib_location
572 NV_explicit_multisample
573 NV_fbo_color_attachments
574 NV_fence
575 NV_fill_rectangle
576 NV_float_buffer
577 NV_fog_distance
578 NV_fragment_coverage_to_color
579 NV_fragment_program
580 NV_fragment_program2
581 NV_fragment_program4
582 NV_fragment_program_option
583 NV_fragment_shader_barycentric
584 NV_fragment_shader_interlock
585 NV_framebuffer_blit
586 NV_framebuffer_mixed_samples
587 NV_framebuffer_multisample
588 NV_framebuffer_multisample_coverage
589 NV_generate_mipmap_sRGB
590 NV_geometry_program4
591 NV_geometry_shader4
592 NV_geometry_shader_passthrough
593 NV_gpu_multicast
594 NV_gpu_program4
595 NV_gpu_program5
596 NV_gpu_program5_mem_extended
597 NV_gpu_program_fp64
598 NV_gpu_shader5
599 NV_half_float
600 NV_image_formats
601 NV_instanced_arrays
602 NV_internalformat_sample_query
603 NV_light_max_exponent
604 NV_memory_attachment
605 NV_mesh_shader
606 NV_multisample_coverage
607 NV_multisample_filter_hint
608 NV_non_square_matrices
609 NV_occlusion_query
610 NV_pack_subimage
611 NV_packed_depth_stencil
612 NV_packed_float
613 NV_packed_float_linear
614 NV_parameter_buffer_object
615 NV_parameter_buffer_object2
616 NV_path_rendering
617 NV_path_rendering_shared_edge
618 NV_pixel_buffer_object
619 NV_pixel_data_range
620 NV_platform_binary
621 NV_point_sprite
622 NV_polygon_mode
623 NV_present_video
624 NV_primitive_restart
625 NV_query_resource_tag
626 NV_read_buffer
627 NV_read_buffer_front
628 NV_read_depth
629 NV_read_depth_stencil
630 NV_read_stencil
631 NV_register_combiners
632 NV_register_combiners2
633 NV_representative_fragment_test
634 NV_robustness_video_memory_purge
635 NV_sRGB_formats
636 NV_sample_locations
637 NV_sample_mask_override_coverage
638 NV_scissor_exclusive
639 NV_shader_atomic_counters
640 NV_shader_atomic_float
641 NV_shader_atomic_float64
642 NV_shader_atomic_fp16_vector
643 NV_shader_atomic_int64
644 NV_shader_buffer_load
645 NV_shader_noperspective_interpolation
646 NV_shader_storage_buffer_object
647 NV_shader_texture_footprint
648 NV_shader_thread_group
649 NV_shader_thread_shuffle
650 NV_shading_rate_image
651 NV_shadow_samplers_array
652 NV_shadow_samplers_cube
653 NV_stereo_view_rendering
654 NV_tessellation_program5
655 NV_texgen_emboss
656 NV_texgen_reflection
657 NV_texture_array
658 NV_texture_barrier
659 NV_texture_border_clamp
660 NV_texture_compression_latc
661 NV_texture_compression_s3tc
662 NV_texture_compression_s3tc_update
663 NV_texture_compression_vtc
664 NV_texture_env_combine4
665 NV_texture_expand_normal
666 NV_texture_multisample
667 NV_texture_npot_2D_mipmap
668 NV_texture_rectangle
669 NV_texture_rectangle_compressed
670 NV_texture_shader
671 NV_texture_shader2
672 NV_texture_shader3
673 NV_transform_feedback
674 NV_transform_feedback2
675 NV_uniform_buffer_unified_memory
676 NV_vdpau_interop
677 NV_vertex_array_range
678 NV_vertex_array_range2
679 NV_vertex_attrib_integer_64bit
680 NV_vertex_buffer_unified_memory
681 NV_vertex_program
682 NV_vertex_program1_1
683 NV_vertex_program2
684 NV_vertex_program2_option
685 NV_vertex_program3
686 NV_vertex_program4
687 NV_video_capture
688 NV_viewport_array
689 NV_viewport_array2
690 NV_viewport_swizzle

645 PGI_misc_hints
646 PGI_vertex_hints
691 OES_EGL_image
692 OES_EGL_image_external
693 OES_EGL_image_external_essl3
694 OES_blend_equation_separate
695 OES_blend_func_separate
696 OES_blend_subtract
697 OES_byte_coordinates
698 OES_compressed_ETC1_RGB8_texture
699 OES_compressed_paletted_texture
700 OES_copy_image
701 OES_depth24
702 OES_depth32
703 OES_depth_texture
704 OES_depth_texture_cube_map
705 OES_draw_buffers_indexed
706 OES_draw_texture
707 OES_element_index_uint
708 OES_extended_matrix_palette
709 OES_fbo_render_mipmap
710 OES_fragment_precision_high
711 OES_framebuffer_object
712 OES_geometry_point_size
713 OES_geometry_shader
714 OES_get_program_binary
715 OES_gpu_shader5
716 OES_mapbuffer
717 OES_matrix_get
718 OES_matrix_palette
719 OES_packed_depth_stencil
720 OES_point_size_array
721 OES_point_sprite
722 OES_read_format
723 OES_required_internalformat
724 OES_rgb8_rgba8
725 OES_sample_shading
726 OES_sample_variables
727 OES_shader_image_atomic
728 OES_shader_io_blocks
729 OES_shader_multisample_interpolation
730 OES_single_precision
731 OES_standard_derivatives
732 OES_stencil1
733 OES_stencil4
734 OES_stencil8
735 OES_surfaceless_context
736 OES_tessellation_point_size
737 OES_tessellation_shader
738 OES_texture_3D
739 OES_texture_border_clamp
740 OES_texture_buffer
741 OES_texture_compression_astc
742 OES_texture_cube_map
743 OES_texture_cube_map_array
744 OES_texture_env_crossbar
745 OES_texture_mirrored_repeat
746 OES_texture_npot
747 OES_texture_stencil8
748 OES_texture_storage_multisample_2d_array
749 OES_texture_view
750 OES_vertex_array_object
751 OES_vertex_half_float
752 OES_vertex_type_10_10_10_2

647 QCOM_alpha_test
648 QCOM_binning_control
649 QCOM_driver_control
650 QCOM_extended_get
651 QCOM_extended_get2
652 QCOM_framebuffer_foveated
653 QCOM_perfmon_global_mode
654 QCOM_shader_framebuffer_fetch_noncoherent
655 QCOM_tiled_rendering
656 QCOM_writeonly_rendering
753 OML_interlace
754 OML_resample
755 OML_subsample

657 REGAL_ES1_0_compatibility
658 REGAL_ES1_1_compatibility
659 REGAL_enable
660 REGAL_error_string
661 REGAL_extension_query
662 REGAL_log
663 REGAL_proc_address
756 OVR_multiview
757 OVR_multiview2
758 OVR_multiview_multisampled_render_to_texture

664 REND_screen_coordinates
759 PGI_misc_hints
760 PGI_vertex_hints

665 S3_s3tc
761 QCOM_alpha_test
762 QCOM_binning_control
763 QCOM_driver_control
764 QCOM_extended_get
765 QCOM_extended_get2
766 QCOM_framebuffer_foveated
767 QCOM_perfmon_global_mode
768 QCOM_shader_framebuffer_fetch_noncoherent
769 QCOM_shader_framebuffer_fetch_rate
770 QCOM_texture_foveated
771 QCOM_texture_foveated_subsampled_layout
772 QCOM_tiled_rendering
773 QCOM_writeonly_rendering

666 SGIS_clip_band_hint
667 SGIS_color_range
668 SGIS_detail_texture
669 SGIS_fog_function
670 SGIS_generate_mipmap
671 SGIS_line_texgen
672 SGIS_multisample
673 SGIS_multitexture
674 SGIS_pixel_texture
675 SGIS_point_line_texgen
676 SGIS_shared_multisample
677 SGIS_sharpen_texture
678 SGIS_texture4D
679 SGIS_texture_border_clamp
680 SGIS_texture_edge_clamp
681 SGIS_texture_filter4
682 SGIS_texture_lod
683 SGIS_texture_select
774 REGAL_ES1_0_compatibility
775 REGAL_ES1_1_compatibility
776 REGAL_enable
777 REGAL_error_string
778 REGAL_extension_query
779 REGAL_log
780 REGAL_proc_address

684 SGIX_async
685 SGIX_async_histogram
686 SGIX_async_pixel
687 SGIX_bali_g_instruments
688 SGIX_bali_r_instruments
689 SGIX_bali_timer_instruments
690 SGIX_blend_alpha_minmax
691 SGIX_blend_cadd
692 SGIX_blend_cmultiply
693 SGIX_calligraphic_fragment
694 SGIX_clipmap
695 SGIX_color_matrix_accuracy
696 SGIX_color_table_index_mode
697 SGIX_complex_polar
698 SGIX_convolution_accuracy
699 SGIX_cube_map
700 SGIX_cylinder_texgen
701 SGIX_datapipe
702 SGIX_decimation
703 SGIX_depth_pass_instrument
704 SGIX_depth_texture
705 SGIX_dvc
706 SGIX_flush_raster
707 SGIX_fog_blend
708 SGIX_fog_factor_to_alpha
709 SGIX_fog_layers
710 SGIX_fog_offset
711 SGIX_fog_patchy
712 SGIX_fog_scale
713 SGIX_fog_texture
714 SGIX_fragment_lighting_space
715 SGIX_fragment_specular_lighting
716 SGIX_fragments_instrument
717 SGIX_framezoom
718 SGIX_icc_texture
719 SGIX_igloo_interface
720 SGIX_image_compression
721 SGIX_impact_pixel_texture
722 SGIX_instrument_error
723 SGIX_interlace
724 SGIX_ir_instrument1
725 SGIX_line_quality_hint
726 SGIX_list_priority
727 SGIX_mpeg1
728 SGIX_mpeg2
729 SGIX_nonlinear_lighting_pervertex
730 SGIX_nurbs_eval
731 SGIX_occlusion_instrument
732 SGIX_packed_6bytes
733 SGIX_pixel_texture
734 SGIX_pixel_texture_bits
735 SGIX_pixel_texture_lod
736 SGIX_pixel_tiles
737 SGIX_polynomial_ffd
738 SGIX_quad_mesh
739 SGIX_reference_plane
740 SGIX_resample
741 SGIX_scalebias_hint
742 SGIX_shadow
743 SGIX_shadow_ambient
744 SGIX_slim
745 SGIX_spotlight_cutoff
746 SGIX_sprite
747 SGIX_subdiv_patch
748 SGIX_subsample
749 SGIX_tag_sample_buffer
750 SGIX_texture_add_env
751 SGIX_texture_coordinate_clamp
752 SGIX_texture_lod_bias
753 SGIX_texture_mipmap_anisotropic
754 SGIX_texture_multi_buffer
755 SGIX_texture_phase
756 SGIX_texture_range
757 SGIX_texture_scale_bias
758 SGIX_texture_supersample
759 SGIX_vector_ops
760 SGIX_vertex_array_object
761 SGIX_vertex_preclip
762 SGIX_vertex_preclip_hint
763 SGIX_ycrcb
764 SGIX_ycrcb_subsample
765 SGIX_ycrcba
781 REND_screen_coordinates

766 SGI_color_matrix
767 SGI_color_table
768 SGI_complex
769 SGI_complex_type
770 SGI_fft
771 SGI_texture_color_table
782 S3_s3tc

772 SUNX_constant_data
783 SGIS_clip_band_hint
784 SGIS_color_range
785 SGIS_detail_texture
786 SGIS_fog_function
787 SGIS_generate_mipmap
788 SGIS_line_texgen
789 SGIS_multisample
790 SGIS_multitexture
791 SGIS_pixel_texture
792 SGIS_point_line_texgen
793 SGIS_shared_multisample
794 SGIS_sharpen_texture
795 SGIS_texture4D
796 SGIS_texture_border_clamp
797 SGIS_texture_edge_clamp
798 SGIS_texture_filter4
799 SGIS_texture_lod
800 SGIS_texture_select

773 SUN_convolution_border_modes
774 SUN_global_alpha
775 SUN_mesh_array
776 SUN_read_video_pixels
777 SUN_slice_accum
778 SUN_triangle_list
779 SUN_vertex
801 SGIX_async
802 SGIX_async_histogram
803 SGIX_async_pixel
804 SGIX_bali_g_instruments
805 SGIX_bali_r_instruments
806 SGIX_bali_timer_instruments
807 SGIX_blend_alpha_minmax
808 SGIX_blend_cadd
809 SGIX_blend_cmultiply
810 SGIX_calligraphic_fragment
811 SGIX_clipmap
812 SGIX_color_matrix_accuracy
813 SGIX_color_table_index_mode
814 SGIX_complex_polar
815 SGIX_convolution_accuracy
816 SGIX_cube_map
817 SGIX_cylinder_texgen
818 SGIX_datapipe
819 SGIX_decimation
820 SGIX_depth_pass_instrument
821 SGIX_depth_texture
822 SGIX_dvc
823 SGIX_flush_raster
824 SGIX_fog_blend
825 SGIX_fog_factor_to_alpha
826 SGIX_fog_layers
827 SGIX_fog_offset
828 SGIX_fog_patchy
829 SGIX_fog_scale
830 SGIX_fog_texture
831 SGIX_fragment_lighting_space
832 SGIX_fragment_specular_lighting
833 SGIX_fragments_instrument
834 SGIX_framezoom
835 SGIX_icc_texture
836 SGIX_igloo_interface
837 SGIX_image_compression
838 SGIX_impact_pixel_texture
839 SGIX_instrument_error
840 SGIX_interlace
841 SGIX_ir_instrument1
842 SGIX_line_quality_hint
843 SGIX_list_priority
844 SGIX_mpeg1
845 SGIX_mpeg2
846 SGIX_nonlinear_lighting_pervertex
847 SGIX_nurbs_eval
848 SGIX_occlusion_instrument
849 SGIX_packed_6bytes
850 SGIX_pixel_texture
851 SGIX_pixel_texture_bits
852 SGIX_pixel_texture_lod
853 SGIX_pixel_tiles
854 SGIX_polynomial_ffd
855 SGIX_quad_mesh
856 SGIX_reference_plane
857 SGIX_resample
858 SGIX_scalebias_hint
859 SGIX_shadow
860 SGIX_shadow_ambient
861 SGIX_slim
862 SGIX_spotlight_cutoff
863 SGIX_sprite
864 SGIX_subdiv_patch
865 SGIX_subsample
866 SGIX_tag_sample_buffer
867 SGIX_texture_add_env
868 SGIX_texture_coordinate_clamp
869 SGIX_texture_lod_bias
870 SGIX_texture_mipmap_anisotropic
871 SGIX_texture_multi_buffer
872 SGIX_texture_phase
873 SGIX_texture_range
874 SGIX_texture_scale_bias
875 SGIX_texture_supersample
876 SGIX_vector_ops
877 SGIX_vertex_array_object
878 SGIX_vertex_preclip
879 SGIX_vertex_preclip_hint
880 SGIX_ycrcb
881 SGIX_ycrcb_subsample
882 SGIX_ycrcba

780 WIN_phong_shading
781 WIN_scene_markerXXX
782 WIN_specular_fog
783 WIN_swap_hint
883 SGI_color_matrix
884 SGI_color_table
885 SGI_complex
886 SGI_complex_type
887 SGI_fft
888 SGI_texture_color_table

889 SUNX_constant_data

890 SUN_convolution_border_modes
891 SUN_global_alpha
892 SUN_mesh_array
893 SUN_read_video_pixels
894 SUN_slice_accum
895 SUN_triangle_list
896 SUN_vertex

897 VIV_shader_binary

898 WIN_phong_shading
899 WIN_scene_markerXXX
900 WIN_specular_fog
901 WIN_swap_hint
diff --git a/doc/glxew.html b/doc/glxew.html index d1ee00c..ab68754 100644 --- a/doc/glxew.html +++ b/doc/glxew.html @@ -99,86 +99,87 @@ THE POSSIBILITY OF SUCH DAMAGE.

Supported GLX Extensions

- + - - - - - - - + + + + + + + - - - - + + + + - + - - - - - - - - - + + + + + + + + + + - + - - - - - - - + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - + + - - - - + + + + - - - - - - - + + + + + + + - - - - + + + + - - + +
1 3DFX_multisample
1 3DFX_multisample

2 AMD_gpu_association

3 ARB_context_flush_control
4 ARB_create_context
5 ARB_create_context_no_error
6 ARB_create_context_profile
7 ARB_create_context_robustness
8 ARB_fbconfig_float
9 ARB_framebuffer_sRGB
3 ARB_context_flush_control
4 ARB_create_context
5 ARB_create_context_no_error
6 ARB_create_context_profile
7 ARB_create_context_robustness
8 ARB_fbconfig_float
9 ARB_framebuffer_sRGB
10 ARB_get_proc_address
11 ARB_multisample
12 ARB_robustness_application_isolation
13 ARB_robustness_share_group_isolation
14 ARB_vertex_buffer_object
11 ARB_multisample
12 ARB_robustness_application_isolation
13 ARB_robustness_share_group_isolation
14 ARB_vertex_buffer_object

15 ATI_pixel_format_float
16 ATI_render_texture

17 EXT_buffer_age
17 EXT_buffer_age
18 EXT_create_context_es2_profile
19 EXT_create_context_es_profile
20 EXT_fbconfig_packed_float
21 EXT_framebuffer_sRGB
22 EXT_import_context
23 EXT_libglvnd
24 EXT_scene_marker
25 EXT_stereo_tree
26 EXT_swap_control
27 EXT_swap_control_tear
28 EXT_texture_from_pixmap
29 EXT_visual_info
30 EXT_visual_rating
22 EXT_import_context
23 EXT_libglvnd
24 EXT_no_config_context
25 EXT_scene_marker
26 EXT_stereo_tree
27 EXT_swap_control
28 EXT_swap_control_tear
29 EXT_texture_from_pixmap
30 EXT_visual_info
31 EXT_visual_rating

31 INTEL_swap_event
32 INTEL_swap_event

32 MESA_agp_offset
33 MESA_copy_sub_buffer
34 MESA_pixmap_colormap
35 MESA_query_renderer
36 MESA_release_buffers
37 MESA_set_3dfx_mode
38 MESA_swap_control
33 MESA_agp_offset
34 MESA_copy_sub_buffer
35 MESA_pixmap_colormap
36 MESA_query_renderer
37 MESA_release_buffers
38 MESA_set_3dfx_mode
39 MESA_swap_control

39 NV_copy_buffer
40 NV_copy_image
41 NV_delay_before_swap
42 NV_float_buffer
43 NV_multisample_coverage
44 NV_present_video
45 NV_robustness_video_memory_purge
46 NV_swap_group
47 NV_vertex_array_range
48 NV_video_capture
49 NV_video_out
40 NV_copy_buffer
41 NV_copy_image
42 NV_delay_before_swap
43 NV_float_buffer
44 NV_multisample_coverage
45 NV_present_video
46 NV_robustness_video_memory_purge
47 NV_swap_group
48 NV_vertex_array_range
49 NV_video_capture
50 NV_video_out

50 OML_swap_method
51 OML_sync_control
51 OML_swap_method
52 OML_sync_control

52 SGIS_blended_overlay
53 SGIS_color_range
54 SGIS_multisample
55 SGIS_shared_multisample
53 SGIS_blended_overlay
54 SGIS_color_range
55 SGIS_multisample
56 SGIS_shared_multisample

56 SGIX_fbconfig
57 SGIX_hyperpipe
58 SGIX_pbuffer
59 SGIX_swap_barrier
60 SGIX_swap_group
61 SGIX_video_resize
62 SGIX_visual_select_group
57 SGIX_fbconfig
58 SGIX_hyperpipe
59 SGIX_pbuffer
60 SGIX_swap_barrier
61 SGIX_swap_group
62 SGIX_video_resize
63 SGIX_visual_select_group

63 SGI_cushion
64 SGI_make_current_read
65 SGI_swap_control
66 SGI_video_sync
64 SGI_cushion
65 SGI_make_current_read
66 SGI_swap_control
67 SGI_video_sync

67 SUN_get_transparent_index
68 SUN_video_resize
68 SUN_get_transparent_index
69 SUN_video_resize
diff --git a/doc/wglew.html b/doc/wglew.html index bf5c9da..23857dd 100644 --- a/doc/wglew.html +++ b/doc/wglew.html @@ -99,70 +99,70 @@ THE POSSIBILITY OF SUCH DAMAGE.

Supported WGL Extensions

- + - + - + - - + + - - - - - - - - - - - - - + + + + + + + + + + + + + - + - + - - - + + + - - - - + + + + - - + + - - - - - - + + + + + + - - - - - + + + + + - - - - - + + + + + - - + + - +
1 3DFX_multisample
1 3DFX_multisample

2 3DL_stereo_control
2 3DL_stereo_control

3 AMD_gpu_association
3 AMD_gpu_association

4 ARB_buffer_region
5 ARB_context_flush_control
4 ARB_buffer_region
5 ARB_context_flush_control
6 ARB_create_context
7 ARB_create_context_no_error
8 ARB_create_context_profile
9 ARB_create_context_robustness
10 ARB_extensions_string
11 ARB_framebuffer_sRGB
12 ARB_make_current_read
13 ARB_multisample
14 ARB_pbuffer
15 ARB_pixel_format
16 ARB_pixel_format_float
17 ARB_render_texture
18 ARB_robustness_application_isolation
19 ARB_robustness_share_group_isolation
7 ARB_create_context_no_error
8 ARB_create_context_profile
9 ARB_create_context_robustness
10 ARB_extensions_string
11 ARB_framebuffer_sRGB
12 ARB_make_current_read
13 ARB_multisample
14 ARB_pbuffer
15 ARB_pixel_format
16 ARB_pixel_format_float
17 ARB_render_texture
18 ARB_robustness_application_isolation
19 ARB_robustness_share_group_isolation

20 ATI_pixel_format_float
20 ATI_pixel_format_float
21 ATI_render_texture_rectangle

22 EXT_colorspace
22 EXT_colorspace
23 EXT_create_context_es2_profile
24 EXT_create_context_es_profile
25 EXT_depth_float
26 EXT_display_color_table
27 EXT_extensions_string
25 EXT_depth_float
26 EXT_display_color_table
27 EXT_extensions_string
28 EXT_framebuffer_sRGB
29 EXT_make_current_read
30 EXT_multisample
31 EXT_pbuffer
32 EXT_pixel_format
29 EXT_make_current_read
30 EXT_multisample
31 EXT_pbuffer
32 EXT_pixel_format
33 EXT_pixel_format_packed_float
34 EXT_swap_control
35 EXT_swap_control_tear
34 EXT_swap_control
35 EXT_swap_control_tear

36 I3D_digital_video_control
37 I3D_gamma
38 I3D_genlock
39 I3D_image_buffer
40 I3D_swap_frame_lock
41 I3D_swap_frame_usage
36 I3D_digital_video_control
37 I3D_gamma
38 I3D_genlock
39 I3D_image_buffer
40 I3D_swap_frame_lock
41 I3D_swap_frame_usage

42 NV_DX_interop
43 NV_DX_interop2
44 NV_copy_image
45 NV_delay_before_swap
46 NV_float_buffer
42 NV_DX_interop
43 NV_DX_interop2
44 NV_copy_image
45 NV_delay_before_swap
46 NV_float_buffer
47 NV_gpu_affinity
48 NV_multisample_coverage
49 NV_present_video
50 NV_render_depth_texture
51 NV_render_texture_rectangle
52 NV_swap_group
48 NV_multisample_coverage
49 NV_present_video
50 NV_render_depth_texture
51 NV_render_texture_rectangle
52 NV_swap_group
53 NV_vertex_array_range
54 NV_video_capture
55 NV_video_output
54 NV_video_capture
55 NV_video_output

56 OML_sync_control
56 OML_sync_control
diff --git a/include/GL/eglew.h b/include/GL/eglew.h index 4670147..d63b2e3 100644 --- a/include/GL/eglew.h +++ b/include/GL/eglew.h @@ -151,6 +151,7 @@ typedef khronos_utime_nanoseconds_t EGLuint64NV; typedef khronos_stime_nanoseconds_t EGLnsecsANDROID; struct EGLClientPixmapHI; +struct AHardwareBuffer; #define EGL_DONT_CARE ((EGLint)-1) @@ -529,6 +530,54 @@ typedef EGLClientBuffer ( * PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC) (const E #endif /* EGL_ANDROID_front_buffer_auto_refresh */ +/* -------------------- EGL_ANDROID_get_frame_timestamps ------------------- */ + +#ifndef EGL_ANDROID_get_frame_timestamps +#define EGL_ANDROID_get_frame_timestamps 1 + +#define EGL_TIMESTAMPS_ANDROID 0x3430 +#define EGL_COMPOSITE_DEADLINE_ANDROID 0x3431 +#define EGL_COMPOSITE_INTERVAL_ANDROID 0x3432 +#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3433 +#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3434 +#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3435 +#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3436 +#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3437 +#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3438 +#define EGL_FIRST_COMPOSITION_GPU_FINISHED_TIME_ANDROID 0x3439 +#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x343A +#define EGL_DEQUEUE_READY_TIME_ANDROID 0x343B +#define EGL_READS_DONE_TIME_ANDROID 0x343C + +typedef EGLBoolean ( * PFNEGLGETCOMPOSITORTIMINGANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint * names, EGLnsecsANDROID * values); +typedef EGLBoolean ( * PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint name); +typedef EGLBoolean ( * PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp); +typedef EGLBoolean ( * PFNEGLGETFRAMETIMESTAMPSANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint * timestamps, EGLnsecsANDROID * values); +typedef EGLBoolean ( * PFNEGLGETNEXTFRAMEIDANDROIDPROC) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR * frameId); + +#define eglGetCompositorTimingANDROID EGLEW_GET_FUN(__eglewGetCompositorTimingANDROID) +#define eglGetCompositorTimingSupportedANDROID EGLEW_GET_FUN(__eglewGetCompositorTimingSupportedANDROID) +#define eglGetFrameTimestampSupportedANDROID EGLEW_GET_FUN(__eglewGetFrameTimestampSupportedANDROID) +#define eglGetFrameTimestampsANDROID EGLEW_GET_FUN(__eglewGetFrameTimestampsANDROID) +#define eglGetNextFrameIdANDROID EGLEW_GET_FUN(__eglewGetNextFrameIdANDROID) + +#define EGLEW_ANDROID_get_frame_timestamps EGLEW_GET_VAR(__EGLEW_ANDROID_get_frame_timestamps) + +#endif /* EGL_ANDROID_get_frame_timestamps */ + +/* ------------------ EGL_ANDROID_get_native_client_buffer ----------------- */ + +#ifndef EGL_ANDROID_get_native_client_buffer +#define EGL_ANDROID_get_native_client_buffer 1 + +typedef EGLClientBuffer ( * PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC) (const struct AHardwareBuffer * buffer); + +#define eglGetNativeClientBufferANDROID EGLEW_GET_FUN(__eglewGetNativeClientBufferANDROID) + +#define EGLEW_ANDROID_get_native_client_buffer EGLEW_GET_VAR(__EGLEW_ANDROID_get_native_client_buffer) + +#endif /* EGL_ANDROID_get_native_client_buffer */ + /* -------------------- EGL_ANDROID_image_native_buffer -------------------- */ #ifndef EGL_ANDROID_image_native_buffer @@ -661,6 +710,17 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EG #endif /* EGL_ARM_pixmap_multisample_discard */ +/* ------------------------- EGL_EXT_bind_to_front ------------------------- */ + +#ifndef EGL_EXT_bind_to_front +#define EGL_EXT_bind_to_front 1 + +#define EGL_FRONT_BUFFER_EXT 0x3464 + +#define EGLEW_EXT_bind_to_front EGLEW_GET_VAR(__EGLEW_EXT_bind_to_front) + +#endif /* EGL_EXT_bind_to_front */ + /* --------------------------- EGL_EXT_buffer_age -------------------------- */ #ifndef EGL_EXT_buffer_age @@ -681,6 +741,52 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EG #endif /* EGL_EXT_client_extensions */ +/* -------------------------- EGL_EXT_client_sync -------------------------- */ + +#ifndef EGL_EXT_client_sync +#define EGL_EXT_client_sync 1 + +#define EGL_SYNC_CLIENT_EXT 0x3364 +#define EGL_SYNC_CLIENT_SIGNAL_EXT 0x3365 + +typedef EGLBoolean ( * PFNEGLCLIENTSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib * attrib_list); + +#define eglClientSignalSyncEXT EGLEW_GET_FUN(__eglewClientSignalSyncEXT) + +#define EGLEW_EXT_client_sync EGLEW_GET_VAR(__EGLEW_EXT_client_sync) + +#endif /* EGL_EXT_client_sync */ + +/* --------------------------- EGL_EXT_compositor -------------------------- */ + +#ifndef EGL_EXT_compositor +#define EGL_EXT_compositor 1 + +#define EGL_PRIMARY_COMPOSITOR_CONTEXT_EXT 0x3460 +#define EGL_EXTERNAL_REF_ID_EXT 0x3461 +#define EGL_COMPOSITOR_DROP_NEWEST_FRAME_EXT 0x3462 +#define EGL_COMPOSITOR_KEEP_NEWEST_FRAME_EXT 0x3463 + +typedef EGLBoolean ( * PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC) (EGLint external_win_id); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC) (EGLint external_ref_id, const EGLint * context_attributes, EGLint num_entries); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC) (const EGLint * external_ref_ids, EGLint num_entries); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSETSIZEEXTPROC) (EGLint external_win_id, EGLint width, EGLint height); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC) (EGLint external_win_id, const EGLint * window_attributes, EGLint num_entries); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC) (EGLint external_ref_id, const EGLint * external_win_ids, EGLint num_entries); +typedef EGLBoolean ( * PFNEGLCOMPOSITORSWAPPOLICYEXTPROC) (EGLint external_win_id, EGLint policy); + +#define eglCompositorBindTexWindowEXT EGLEW_GET_FUN(__eglewCompositorBindTexWindowEXT) +#define eglCompositorSetContextAttributesEXT EGLEW_GET_FUN(__eglewCompositorSetContextAttributesEXT) +#define eglCompositorSetContextListEXT EGLEW_GET_FUN(__eglewCompositorSetContextListEXT) +#define eglCompositorSetSizeEXT EGLEW_GET_FUN(__eglewCompositorSetSizeEXT) +#define eglCompositorSetWindowAttributesEXT EGLEW_GET_FUN(__eglewCompositorSetWindowAttributesEXT) +#define eglCompositorSetWindowListEXT EGLEW_GET_FUN(__eglewCompositorSetWindowListEXT) +#define eglCompositorSwapPolicyEXT EGLEW_GET_FUN(__eglewCompositorSwapPolicyEXT) + +#define EGLEW_EXT_compositor EGLEW_GET_VAR(__EGLEW_EXT_compositor) + +#endif /* EGL_EXT_compositor */ + /* ------------------- EGL_EXT_create_context_robustness ------------------- */ #ifndef EGL_EXT_create_context_robustness @@ -713,6 +819,7 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EG #define EGL_EXT_device_drm 1 #define EGL_DRM_DEVICE_FILE_EXT 0x3233 +#define EGL_DRM_MASTER_FD_EXT 0x333C #define EGLEW_EXT_device_drm EGLEW_GET_VAR(__EGLEW_EXT_device_drm) @@ -784,6 +891,39 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLin #endif /* EGL_EXT_gl_colorspace_bt2020_pq */ +/* -------------------- EGL_EXT_gl_colorspace_display_p3 ------------------- */ + +#ifndef EGL_EXT_gl_colorspace_display_p3 +#define EGL_EXT_gl_colorspace_display_p3 1 + +#define EGL_GL_COLORSPACE_DISPLAY_P3_EXT 0x3363 + +#define EGLEW_EXT_gl_colorspace_display_p3 EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_display_p3) + +#endif /* EGL_EXT_gl_colorspace_display_p3 */ + +/* ---------------- EGL_EXT_gl_colorspace_display_p3_linear ---------------- */ + +#ifndef EGL_EXT_gl_colorspace_display_p3_linear +#define EGL_EXT_gl_colorspace_display_p3_linear 1 + +#define EGL_GL_COLORSPACE_DISPLAY_P3_LINEAR_EXT 0x3362 + +#define EGLEW_EXT_gl_colorspace_display_p3_linear EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_display_p3_linear) + +#endif /* EGL_EXT_gl_colorspace_display_p3_linear */ + +/* ---------------------- EGL_EXT_gl_colorspace_scrgb ---------------------- */ + +#ifndef EGL_EXT_gl_colorspace_scrgb +#define EGL_EXT_gl_colorspace_scrgb 1 + +#define EGL_GL_COLORSPACE_SCRGB_EXT 0x3351 + +#define EGLEW_EXT_gl_colorspace_scrgb EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_scrgb) + +#endif /* EGL_EXT_gl_colorspace_scrgb */ + /* ------------------- EGL_EXT_gl_colorspace_scrgb_linear ------------------ */ #ifndef EGL_EXT_gl_colorspace_scrgb_linear @@ -844,8 +984,8 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLin #define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449 #define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A -typedef EGLBoolean ( * PFNEGLQUERYDMABUFFORMATSEXTPROC) (EGLDisplay dpy, EGLint max_formats, EGLint *formats, EGLint *num_formats); -typedef EGLBoolean ( * PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR *modifiers, EGLBoolean *external_only, EGLint *num_modifiers); +typedef EGLBoolean ( * PFNEGLQUERYDMABUFFORMATSEXTPROC) (EGLDisplay dpy, EGLint max_formats, EGLint * formats, EGLint * num_formats); +typedef EGLBoolean ( * PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR * modifiers, EGLBoolean * external_only, EGLint * num_modifiers); #define eglQueryDmaBufFormatsEXT EGLEW_GET_FUN(__eglewQueryDmaBufFormatsEXT) #define eglQueryDmaBufModifiersEXT EGLEW_GET_FUN(__eglewQueryDmaBufModifiersEXT) @@ -854,6 +994,31 @@ typedef EGLBoolean ( * PFNEGLQUERYDMABUFMODIFIERSEXTPROC) (EGLDisplay dpy, EGL #endif /* EGL_EXT_image_dma_buf_import_modifiers */ +/* ---------------------- EGL_EXT_image_gl_colorspace ---------------------- */ + +#ifndef EGL_EXT_image_gl_colorspace +#define EGL_EXT_image_gl_colorspace 1 + +#define EGL_GL_COLORSPACE 0x309D +#define EGL_GL_COLORSPACE_DEFAULT_EXT 0x314D + +#define EGLEW_EXT_image_gl_colorspace EGLEW_GET_VAR(__EGLEW_EXT_image_gl_colorspace) + +#endif /* EGL_EXT_image_gl_colorspace */ + +/* ------------------ EGL_EXT_image_implicit_sync_control ------------------ */ + +#ifndef EGL_EXT_image_implicit_sync_control +#define EGL_EXT_image_implicit_sync_control 1 + +#define EGL_IMPORT_SYNC_TYPE_EXT 0x3470 +#define EGL_IMPORT_IMPLICIT_SYNC_EXT 0x3471 +#define EGL_IMPORT_EXPLICIT_SYNC_EXT 0x3472 + +#define EGLEW_EXT_image_implicit_sync_control EGLEW_GET_VAR(__EGLEW_EXT_image_implicit_sync_control) + +#endif /* EGL_EXT_image_implicit_sync_control */ + /* ------------------------ EGL_EXT_multiview_window ----------------------- */ #ifndef EGL_EXT_multiview_window @@ -1020,6 +1185,18 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGL #endif /* EGL_EXT_stream_consumer_egloutput */ +/* ------------------- EGL_EXT_surface_CTA861_3_metadata ------------------- */ + +#ifndef EGL_EXT_surface_CTA861_3_metadata +#define EGL_EXT_surface_CTA861_3_metadata 1 + +#define EGL_CTA861_3_MAX_CONTENT_LIGHT_LEVEL_EXT 0x3360 +#define EGL_CTA861_3_MAX_FRAME_AVERAGE_LEVEL_EXT 0x3361 + +#define EGLEW_EXT_surface_CTA861_3_metadata EGLEW_GET_VAR(__EGLEW_EXT_surface_CTA861_3_metadata) + +#endif /* EGL_EXT_surface_CTA861_3_metadata */ + /* ------------------- EGL_EXT_surface_SMPTE2086_metadata ------------------ */ #ifndef EGL_EXT_surface_SMPTE2086_metadata @@ -1035,6 +1212,7 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGL #define EGL_SMPTE2086_WHITE_POINT_Y_EXT 0x3348 #define EGL_SMPTE2086_MAX_LUMINANCE_EXT 0x3349 #define EGL_SMPTE2086_MIN_LUMINANCE_EXT 0x334A +#define EGL_METADATA_SCALING_EXT 50000 #define EGLEW_EXT_surface_SMPTE2086_metadata EGLEW_GET_VAR(__EGLEW_EXT_surface_SMPTE2086_metadata) @@ -1053,6 +1231,19 @@ typedef EGLBoolean ( * PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC) (EGLDisplay dpy, EG #endif /* EGL_EXT_swap_buffers_with_damage */ +/* --------------------------- EGL_EXT_sync_reuse -------------------------- */ + +#ifndef EGL_EXT_sync_reuse +#define EGL_EXT_sync_reuse 1 + +typedef EGLBoolean ( * PFNEGLUNSIGNALSYNCEXTPROC) (EGLDisplay dpy, EGLSync sync, const EGLAttrib * attrib_list); + +#define eglUnsignalSyncEXT EGLEW_GET_FUN(__eglewUnsignalSyncEXT) + +#define EGLEW_EXT_sync_reuse EGLEW_GET_VAR(__EGLEW_EXT_sync_reuse) + +#endif /* EGL_EXT_sync_reuse */ + /* -------------------------- EGL_EXT_yuv_surface -------------------------- */ #ifndef EGL_EXT_yuv_surface @@ -1273,6 +1464,21 @@ typedef EGLBoolean ( * PFNEGLQUERYDEBUGKHRPROC) (EGLint attribute, EGLAttrib * #endif /* EGL_KHR_debug */ +/* ----------------------- EGL_KHR_display_reference ----------------------- */ + +#ifndef EGL_KHR_display_reference +#define EGL_KHR_display_reference 1 + +#define EGL_TRACK_REFERENCES_KHR 0x3352 + +typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBKHRPROC) (EGLDisplay dpy, EGLint name, EGLAttrib * value); + +#define eglQueryDisplayAttribKHR EGLEW_GET_FUN(__eglewQueryDisplayAttribKHR) + +#define EGLEW_KHR_display_reference EGLEW_GET_VAR(__EGLEW_KHR_display_reference) + +#endif /* EGL_KHR_display_reference */ + /* --------------------------- EGL_KHR_fence_sync -------------------------- */ #ifndef EGL_KHR_fence_sync @@ -1782,6 +1988,7 @@ typedef EGLint ( * PFNEGLWAITSYNCKHRPROC) (EGLDisplay dpy, EGLSyncKHR sync, E #define EGL_DRM_BUFFER_USE_SCANOUT_MESA 0x00000001 #define EGL_DRM_BUFFER_USE_SHARE_MESA 0x00000002 +#define EGL_DRM_BUFFER_USE_CURSOR_MESA 0x00000004 #define EGL_DRM_BUFFER_FORMAT_MESA 0x31D0 #define EGL_DRM_BUFFER_USE_MESA 0x31D1 #define EGL_DRM_BUFFER_FORMAT_ARGB32_MESA 0x31D2 @@ -1883,6 +2090,17 @@ typedef EGLBoolean ( * PFNEGLSWAPBUFFERSREGION2NOKPROC) (EGLDisplay dpy, EGLSu #endif /* EGL_NV_3dvision_surface */ +/* -------------------- EGL_NV_context_priority_realtime ------------------- */ + +#ifndef EGL_NV_context_priority_realtime +#define EGL_NV_context_priority_realtime 1 + +#define EGL_CONTEXT_PRIORITY_REALTIME_NV 0x3357 + +#define EGLEW_NV_context_priority_realtime EGLEW_GET_VAR(__EGLEW_NV_context_priority_realtime) + +#endif /* EGL_NV_context_priority_realtime */ + /* ------------------------- EGL_NV_coverage_sample ------------------------ */ #ifndef EGL_NV_coverage_sample @@ -2008,7 +2226,7 @@ typedef EGLBoolean ( * PFNEGLPOSTSUBBUFFERNVPROC) (EGLDisplay dpy, EGLSurface #define EGL_YUV_PLANE1_TEXTURE_UNIT_NV 0x332D #define EGL_YUV_PLANE2_TEXTURE_UNIT_NV 0x332E -typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLAttrib *attrib_list); +typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib * attrib_list); #define eglStreamConsumerGLTextureExternalAttribsNV EGLEW_GET_FUN(__eglewStreamConsumerGLTextureExternalAttribsNV) @@ -2094,6 +2312,19 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGL #endif /* EGL_NV_stream_fifo_synchronous */ +/* -------------------------- EGL_NV_stream_flush -------------------------- */ + +#ifndef EGL_NV_stream_flush +#define EGL_NV_stream_flush 1 + +typedef EGLBoolean ( * PFNEGLSTREAMFLUSHNVPROC) (EGLDisplay dpy, EGLStreamKHR stream); + +#define eglStreamFlushNV EGLEW_GET_FUN(__eglewStreamFlushNV) + +#define EGLEW_NV_stream_flush EGLEW_GET_VAR(__EGLEW_NV_stream_flush) + +#endif /* EGL_NV_stream_flush */ + /* ----------------------- EGL_NV_stream_frame_limits ---------------------- */ #ifndef EGL_NV_stream_frame_limits @@ -2353,12 +2584,30 @@ EGLEW_FUN_EXPORT PFNEGLSETBLOBCACHEFUNCSANDROIDPROC __eglewSetBlobCacheFuncsANDR EGLEW_FUN_EXPORT PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC __eglewCreateNativeClientBufferANDROID; +EGLEW_FUN_EXPORT PFNEGLGETCOMPOSITORTIMINGANDROIDPROC __eglewGetCompositorTimingANDROID; +EGLEW_FUN_EXPORT PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC __eglewGetCompositorTimingSupportedANDROID; +EGLEW_FUN_EXPORT PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC __eglewGetFrameTimestampSupportedANDROID; +EGLEW_FUN_EXPORT PFNEGLGETFRAMETIMESTAMPSANDROIDPROC __eglewGetFrameTimestampsANDROID; +EGLEW_FUN_EXPORT PFNEGLGETNEXTFRAMEIDANDROIDPROC __eglewGetNextFrameIdANDROID; + +EGLEW_FUN_EXPORT PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC __eglewGetNativeClientBufferANDROID; + EGLEW_FUN_EXPORT PFNEGLDUPNATIVEFENCEFDANDROIDPROC __eglewDupNativeFenceFDANDROID; EGLEW_FUN_EXPORT PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROID; EGLEW_FUN_EXPORT PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE; +EGLEW_FUN_EXPORT PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT; + +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC __eglewCompositorSetContextAttributesEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC __eglewCompositorSetContextListEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSETSIZEEXTPROC __eglewCompositorSetSizeEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC __eglewCompositorSetWindowAttributesEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC __eglewCompositorSetWindowListEXT; +EGLEW_FUN_EXPORT PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEXT; + EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT; @@ -2385,6 +2634,8 @@ EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEX EGLEW_FUN_EXPORT PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT; +EGLEW_FUN_EXPORT PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT; + EGLEW_FUN_EXPORT PFNEGLCREATEPIXMAPSURFACEHIPROC __eglewCreatePixmapSurfaceHI; EGLEW_FUN_EXPORT PFNEGLCREATESYNC64KHRPROC __eglewCreateSync64KHR; @@ -2393,6 +2644,8 @@ EGLEW_FUN_EXPORT PFNEGLDEBUGMESSAGECONTROLKHRPROC __eglewDebugMessageControlKHR; EGLEW_FUN_EXPORT PFNEGLLABELOBJECTKHRPROC __eglewLabelObjectKHR; EGLEW_FUN_EXPORT PFNEGLQUERYDEBUGKHRPROC __eglewQueryDebugKHR; +EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBKHRPROC __eglewQueryDisplayAttribKHR; + EGLEW_FUN_EXPORT PFNEGLCREATEIMAGEKHRPROC __eglewCreateImageKHR; EGLEW_FUN_EXPORT PFNEGLDESTROYIMAGEKHRPROC __eglewDestroyImageKHR; @@ -2454,6 +2707,8 @@ EGLEW_FUN_EXPORT PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV; EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV; +EGLEW_FUN_EXPORT PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV; + EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBNVPROC __eglewQueryDisplayAttribNV; EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMMETADATANVPROC __eglewQueryStreamMetadataNV; EGLEW_FUN_EXPORT PFNEGLSETSTREAMMETADATANVPROC __eglewSetStreamMetadataNV; @@ -2481,6 +2736,8 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_blob_cache; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_create_native_client_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_framebuffer_target; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_front_buffer_auto_refresh; +EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_get_frame_timestamps; +EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_get_native_client_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_image_native_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_native_fence_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANDROID_presentation_time; @@ -2492,8 +2749,11 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_window_fixed_size; EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_implicit_external_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_ARM_pixmap_multisample_discard; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_bind_to_front; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_buffer_age; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_extensions; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_sync; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_compositor; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_create_context_robustness; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm; @@ -2502,9 +2762,14 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_openwf; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_query; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_display_p3; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_display_p3_linear; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_scrgb; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_gl_colorspace_scrgb_linear; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_image_dma_buf_import; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_image_dma_buf_import_modifiers; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_image_gl_colorspace; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_image_implicit_sync_control; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_multiview_window; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_output_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_output_drm; @@ -2517,8 +2782,10 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_x11; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_content; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_protected_surface; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_stream_consumer_egloutput; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_CTA861_3_metadata; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_swap_buffers_with_damage; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_sync_reuse; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_yuv_surface; EGLEW_VAR_EXPORT GLboolean __EGLEW_HI_clientpixmap; EGLEW_VAR_EXPORT GLboolean __EGLEW_HI_colorformats; @@ -2532,6 +2799,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_context_flush_control; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_create_context; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_create_context_no_error; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_debug; +EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_display_reference; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_fence_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_get_all_proc_addresses; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_gl_colorspace; @@ -2572,6 +2840,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NOK_swap_region; EGLEW_VAR_EXPORT GLboolean __EGLEW_NOK_swap_region2; EGLEW_VAR_EXPORT GLboolean __EGLEW_NOK_texture_from_pixmap; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_3dvision_surface; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_context_priority_realtime; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_coverage_sample; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_coverage_sample_resolve; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_cuda_event; @@ -2589,6 +2858,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_process; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_system; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_fifo_next; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_fifo_synchronous; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_flush; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_frame_limits; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_metadata; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_remote; diff --git a/include/GL/glew.h b/include/GL/glew.h index b5b6987..2c75e0e 100644 --- a/include/GL/glew.h +++ b/include/GL/glew.h @@ -310,6 +310,8 @@ typedef struct __GLsync *GLsync; typedef char GLchar; +typedef void *GLeglImageOES; /* GL_EXT_EGL_image_storage */ + #define GL_ZERO 0 #define GL_FALSE 0 #define GL_LOGIC_OP 0x0BF1 @@ -2688,6 +2690,28 @@ typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GL #endif /* GL_AMD_draw_buffers_blend */ +/* ---------------- GL_AMD_framebuffer_multisample_advanced ---------------- */ + +#ifndef GL_AMD_framebuffer_multisample_advanced +#define GL_AMD_framebuffer_multisample_advanced 1 + +#define GL_RENDERBUFFER_STORAGE_SAMPLES_AMD 0x91B2 +#define GL_MAX_COLOR_FRAMEBUFFER_SAMPLES_AMD 0x91B3 +#define GL_MAX_COLOR_FRAMEBUFFER_STORAGE_SAMPLES_AMD 0x91B4 +#define GL_MAX_DEPTH_STENCIL_FRAMEBUFFER_SAMPLES_AMD 0x91B5 +#define GL_NUM_SUPPORTED_MULTISAMPLE_MODES_AMD 0x91B6 +#define GL_SUPPORTED_MULTISAMPLE_MODES_AMD 0x91B7 + +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC) (GLuint renderbuffer, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC) (GLenum target, GLsizei samples, GLsizei storageSamples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glNamedRenderbufferStorageMultisampleAdvancedAMD GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleAdvancedAMD) +#define glRenderbufferStorageMultisampleAdvancedAMD GLEW_GET_FUN(__glewRenderbufferStorageMultisampleAdvancedAMD) + +#define GLEW_AMD_framebuffer_multisample_advanced GLEW_GET_VAR(__GLEW_AMD_framebuffer_multisample_advanced) + +#endif /* GL_AMD_framebuffer_multisample_advanced */ + /* ------------------ GL_AMD_framebuffer_sample_positions ------------------ */ #ifndef GL_AMD_framebuffer_sample_positions @@ -2744,6 +2768,45 @@ typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC) (GLuin #endif /* GL_AMD_gpu_shader_half_float */ +/* ------------------- GL_AMD_gpu_shader_half_float_fetch ------------------ */ + +#ifndef GL_AMD_gpu_shader_half_float_fetch +#define GL_AMD_gpu_shader_half_float_fetch 1 + +#define GL_FLOAT16_SAMPLER_1D_AMD 0x91CE +#define GL_FLOAT16_SAMPLER_2D_AMD 0x91CF +#define GL_FLOAT16_SAMPLER_3D_AMD 0x91D0 +#define GL_FLOAT16_SAMPLER_CUBE_AMD 0x91D1 +#define GL_FLOAT16_SAMPLER_2D_RECT_AMD 0x91D2 +#define GL_FLOAT16_SAMPLER_1D_ARRAY_AMD 0x91D3 +#define GL_FLOAT16_SAMPLER_2D_ARRAY_AMD 0x91D4 +#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_AMD 0x91D5 +#define GL_FLOAT16_SAMPLER_BUFFER_AMD 0x91D6 +#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_AMD 0x91D7 +#define GL_FLOAT16_SAMPLER_2D_MULTISAMPLE_ARRAY_AMD 0x91D8 +#define GL_FLOAT16_SAMPLER_1D_SHADOW_AMD 0x91D9 +#define GL_FLOAT16_SAMPLER_2D_SHADOW_AMD 0x91DA +#define GL_FLOAT16_SAMPLER_2D_RECT_SHADOW_AMD 0x91DB +#define GL_FLOAT16_SAMPLER_1D_ARRAY_SHADOW_AMD 0x91DC +#define GL_FLOAT16_SAMPLER_2D_ARRAY_SHADOW_AMD 0x91DD +#define GL_FLOAT16_SAMPLER_CUBE_SHADOW_AMD 0x91DE +#define GL_FLOAT16_SAMPLER_CUBE_MAP_ARRAY_SHADOW_AMD 0x91DF +#define GL_FLOAT16_IMAGE_1D_AMD 0x91E0 +#define GL_FLOAT16_IMAGE_2D_AMD 0x91E1 +#define GL_FLOAT16_IMAGE_3D_AMD 0x91E2 +#define GL_FLOAT16_IMAGE_2D_RECT_AMD 0x91E3 +#define GL_FLOAT16_IMAGE_CUBE_AMD 0x91E4 +#define GL_FLOAT16_IMAGE_1D_ARRAY_AMD 0x91E5 +#define GL_FLOAT16_IMAGE_2D_ARRAY_AMD 0x91E6 +#define GL_FLOAT16_IMAGE_CUBE_MAP_ARRAY_AMD 0x91E7 +#define GL_FLOAT16_IMAGE_BUFFER_AMD 0x91E8 +#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_AMD 0x91E9 +#define GL_FLOAT16_IMAGE_2D_MULTISAMPLE_ARRAY_AMD 0x91EA + +#define GLEW_AMD_gpu_shader_half_float_fetch GLEW_GET_VAR(__GLEW_AMD_gpu_shader_half_float_fetch) + +#endif /* GL_AMD_gpu_shader_half_float_fetch */ + /* ------------------------ GL_AMD_gpu_shader_int16 ------------------------ */ #ifndef GL_AMD_gpu_shader_int16 @@ -2972,6 +3035,15 @@ typedef void (GLAPIENTRY * PFNGLSETMULTISAMPLEFVAMDPROC) (GLenum pname, GLuint i #endif /* GL_AMD_shader_explicit_vertex_parameter */ +/* ------------------- GL_AMD_shader_image_load_store_lod ------------------ */ + +#ifndef GL_AMD_shader_image_load_store_lod +#define GL_AMD_shader_image_load_store_lod 1 + +#define GLEW_AMD_shader_image_load_store_lod GLEW_GET_VAR(__GLEW_AMD_shader_image_load_store_lod) + +#endif /* GL_AMD_shader_image_load_store_lod */ + /* ---------------------- GL_AMD_shader_stencil_export --------------------- */ #ifndef GL_AMD_shader_stencil_export @@ -9042,26 +9114,29 @@ typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GL #endif /* GL_ATI_vertex_streams */ -/* -------------------- GL_EGL_KHR_context_flush_control ------------------- */ +/* ------------------------- GL_DMP_program_binary ------------------------- */ -#ifndef GL_EGL_KHR_context_flush_control -#define GL_EGL_KHR_context_flush_control 1 +#ifndef GL_DMP_program_binary +#define GL_DMP_program_binary 1 -#define GLEW_EGL_KHR_context_flush_control GLEW_GET_VAR(__GLEW_EGL_KHR_context_flush_control) +#define GL_SMAPHS30_PROGRAM_BINARY_DMP 0x9251 +#define GL_SMAPHS_PROGRAM_BINARY_DMP 0x9252 +#define GL_DMP_PROGRAM_BINARY_DMP 0x9253 -#endif /* GL_EGL_KHR_context_flush_control */ +#define GLEW_DMP_program_binary GLEW_GET_VAR(__GLEW_DMP_program_binary) -/* ---------------- GL_EGL_NV_robustness_video_memory_purge ---------------- */ +#endif /* GL_DMP_program_binary */ -#ifndef GL_EGL_NV_robustness_video_memory_purge -#define GL_EGL_NV_robustness_video_memory_purge 1 +/* -------------------------- GL_DMP_shader_binary ------------------------- */ -#define GL_EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C -#define GL_PURGED_CONTEXT_RESET_NV 0x92BB +#ifndef GL_DMP_shader_binary +#define GL_DMP_shader_binary 1 -#define GLEW_EGL_NV_robustness_video_memory_purge GLEW_GET_VAR(__GLEW_EGL_NV_robustness_video_memory_purge) +#define GL_SHADER_BINARY_DMP 0x9250 -#endif /* GL_EGL_NV_robustness_video_memory_purge */ +#define GLEW_DMP_shader_binary GLEW_GET_VAR(__GLEW_DMP_shader_binary) + +#endif /* GL_DMP_shader_binary */ /* --------------------------- GL_EXT_422_pixels --------------------------- */ @@ -9098,6 +9173,30 @@ typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GL #endif /* GL_EXT_EGL_image_array */ +/* ------------------ GL_EXT_EGL_image_external_wrap_modes ----------------- */ + +#ifndef GL_EXT_EGL_image_external_wrap_modes +#define GL_EXT_EGL_image_external_wrap_modes 1 + +#define GLEW_EXT_EGL_image_external_wrap_modes GLEW_GET_VAR(__GLEW_EXT_EGL_image_external_wrap_modes) + +#endif /* GL_EXT_EGL_image_external_wrap_modes */ + +/* ------------------------ GL_EXT_EGL_image_storage ----------------------- */ + +#ifndef GL_EXT_EGL_image_storage +#define GL_EXT_EGL_image_storage 1 + +typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC) (GLenum target, GLeglImageOES image, const GLint* attrib_list); +typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC) (GLuint texture, GLeglImageOES image, const GLint* attrib_list); + +#define glEGLImageTargetTexStorageEXT GLEW_GET_FUN(__glewEGLImageTargetTexStorageEXT) +#define glEGLImageTargetTextureStorageEXT GLEW_GET_FUN(__glewEGLImageTargetTextureStorageEXT) + +#define GLEW_EXT_EGL_image_storage GLEW_GET_VAR(__GLEW_EXT_EGL_image_storage) + +#endif /* GL_EXT_EGL_image_storage */ + /* --------------------------- GL_EXT_YUV_target --------------------------- */ #ifndef GL_EXT_YUV_target @@ -9330,6 +9429,26 @@ typedef void (GLAPIENTRY * PFNGLCLEARTEXSUBIMAGEEXTPROC) (GLuint texture, GLint #endif /* GL_EXT_clear_texture */ +/* -------------------------- GL_EXT_clip_control -------------------------- */ + +#ifndef GL_EXT_clip_control +#define GL_EXT_clip_control 1 + +#define GL_LOWER_LEFT_EXT 0x8CA1 +#define GL_UPPER_LEFT_EXT 0x8CA2 +#define GL_CLIP_ORIGIN_EXT 0x935C +#define GL_CLIP_DEPTH_MODE_EXT 0x935D +#define GL_NEGATIVE_ONE_TO_ONE_EXT 0x935E +#define GL_ZERO_TO_ONE_EXT 0x935F + +typedef void (GLAPIENTRY * PFNGLCLIPCONTROLEXTPROC) (GLenum origin, GLenum depth); + +#define glClipControlEXT GLEW_GET_FUN(__glewClipControlEXT) + +#define GLEW_EXT_clip_control GLEW_GET_VAR(__GLEW_EXT_clip_control) + +#endif /* GL_EXT_clip_control */ + /* ----------------------- GL_EXT_clip_cull_distance ----------------------- */ #ifndef GL_EXT_clip_cull_distance @@ -10108,6 +10227,43 @@ typedef void (GLAPIENTRY * PFNGLDISCARDFRAMEBUFFEREXTPROC) (GLenum target, GLsiz #endif /* GL_EXT_discard_framebuffer */ +/* ---------------------- GL_EXT_disjoint_timer_query ---------------------- */ + +#ifndef GL_EXT_disjoint_timer_query +#define GL_EXT_disjoint_timer_query 1 + +#define GL_QUERY_COUNTER_BITS_EXT 0x8864 +#define GL_CURRENT_QUERY_EXT 0x8865 +#define GL_QUERY_RESULT_EXT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_EXT 0x8867 +#define GL_TIME_ELAPSED_EXT 0x88BF +#define GL_TIMESTAMP_EXT 0x8E28 +#define GL_GPU_DISJOINT_EXT 0x8FBB + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYEXTPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESEXTPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDQUERYEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENQUERIESEXTPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVEXTPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVEXTPROC) (GLuint id, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYEXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLQUERYCOUNTEREXTPROC) (GLuint id, GLenum target); + +#define glBeginQueryEXT GLEW_GET_FUN(__glewBeginQueryEXT) +#define glDeleteQueriesEXT GLEW_GET_FUN(__glewDeleteQueriesEXT) +#define glEndQueryEXT GLEW_GET_FUN(__glewEndQueryEXT) +#define glGenQueriesEXT GLEW_GET_FUN(__glewGenQueriesEXT) +#define glGetQueryObjectivEXT GLEW_GET_FUN(__glewGetQueryObjectivEXT) +#define glGetQueryObjectuivEXT GLEW_GET_FUN(__glewGetQueryObjectuivEXT) +#define glGetQueryivEXT GLEW_GET_FUN(__glewGetQueryivEXT) +#define glIsQueryEXT GLEW_GET_FUN(__glewIsQueryEXT) +#define glQueryCounterEXT GLEW_GET_FUN(__glewQueryCounterEXT) + +#define GLEW_EXT_disjoint_timer_query GLEW_GET_VAR(__GLEW_EXT_disjoint_timer_query) + +#endif /* GL_EXT_disjoint_timer_query */ + /* -------------------------- GL_EXT_draw_buffers -------------------------- */ #ifndef GL_EXT_draw_buffers @@ -10256,6 +10412,21 @@ typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint s #endif /* GL_EXT_draw_range_elements */ +/* --------------------- GL_EXT_draw_transform_feedback -------------------- */ + +#ifndef GL_EXT_draw_transform_feedback +#define GL_EXT_draw_transform_feedback 1 + +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKEXTPROC) (GLenum mode, GLuint id); +typedef void (GLAPIENTRY * PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC) (GLenum mode, GLuint id, GLsizei instancecount); + +#define glDrawTransformFeedbackEXT GLEW_GET_FUN(__glewDrawTransformFeedbackEXT) +#define glDrawTransformFeedbackInstancedEXT GLEW_GET_FUN(__glewDrawTransformFeedbackInstancedEXT) + +#define GLEW_EXT_draw_transform_feedback GLEW_GET_VAR(__GLEW_EXT_draw_transform_feedback) + +#endif /* GL_EXT_draw_transform_feedback */ + /* ------------------------- GL_EXT_external_buffer ------------------------ */ #ifndef GL_EXT_external_buffer @@ -11199,6 +11370,21 @@ typedef void (GLAPIENTRY * PFNGLREADBUFFERINDEXEDEXTPROC) (GLenum src, GLint ind #endif /* GL_EXT_multiview_draw_buffers */ +/* --------------------- GL_EXT_occlusion_query_boolean -------------------- */ + +#ifndef GL_EXT_occlusion_query_boolean +#define GL_EXT_occlusion_query_boolean 1 + +#define GL_CURRENT_QUERY_EXT 0x8865 +#define GL_QUERY_RESULT_EXT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_EXT 0x8867 +#define GL_ANY_SAMPLES_PASSED_EXT 0x8C2F +#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT 0x8D6A + +#define GLEW_EXT_occlusion_query_boolean GLEW_GET_VAR(__GLEW_EXT_occlusion_query_boolean) + +#endif /* GL_EXT_occlusion_query_boolean */ + /* ---------------------- GL_EXT_packed_depth_stencil ---------------------- */ #ifndef GL_EXT_packed_depth_stencil @@ -11399,6 +11585,18 @@ typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETCLAMPEXTPROC) (GLfloat factor, GLfl #endif /* GL_EXT_post_depth_coverage */ +/* ----------------------- GL_EXT_protected_textures ----------------------- */ + +#ifndef GL_EXT_protected_textures +#define GL_EXT_protected_textures 1 + +#define GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT 0x00000010 +#define GL_TEXTURE_PROTECTED_EXT 0x8BFA + +#define GLEW_EXT_protected_textures GLEW_GET_VAR(__GLEW_EXT_protected_textures) + +#endif /* GL_EXT_protected_textures */ + /* ------------------------ GL_EXT_provoking_vertex ------------------------ */ #ifndef GL_EXT_provoking_vertex @@ -11507,6 +11705,31 @@ typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean #endif /* GL_EXT_rescale_normal */ +/* --------------------------- GL_EXT_robustness --------------------------- */ + +#ifndef GL_EXT_robustness +#define GL_EXT_robustness 1 + +#define GL_LOSE_CONTEXT_ON_RESET_EXT 0x8252 +#define GL_GUILTY_CONTEXT_RESET_EXT 0x8253 +#define GL_INNOCENT_CONTEXT_RESET_EXT 0x8254 +#define GL_UNKNOWN_CONTEXT_RESET_EXT 0x8255 +#define GL_RESET_NOTIFICATION_STRATEGY_EXT 0x8256 +#define GL_NO_RESET_NOTIFICATION_EXT 0x8261 +#define GL_CONTEXT_ROBUST_ACCESS_EXT 0x90F3 + +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMFVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETNUNIFORMIVEXTPROC) (GLuint program, GLint location, GLsizei bufSize, GLint* params); +typedef void (GLAPIENTRY * PFNGLREADNPIXELSEXTPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data); + +#define glGetnUniformfvEXT GLEW_GET_FUN(__glewGetnUniformfvEXT) +#define glGetnUniformivEXT GLEW_GET_FUN(__glewGetnUniformivEXT) +#define glReadnPixelsEXT GLEW_GET_FUN(__glewReadnPixelsEXT) + +#define GLEW_EXT_robustness GLEW_GET_VAR(__GLEW_EXT_robustness) + +#endif /* GL_EXT_robustness */ + /* ------------------------------ GL_EXT_sRGB ------------------------------ */ #ifndef GL_EXT_sRGB @@ -11692,10 +11915,25 @@ typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint pr #define GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT 0x8A52 +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC) (void); + +#define glFramebufferFetchBarrierEXT GLEW_GET_FUN(__glewFramebufferFetchBarrierEXT) + #define GLEW_EXT_shader_framebuffer_fetch GLEW_GET_VAR(__GLEW_EXT_shader_framebuffer_fetch) #endif /* GL_EXT_shader_framebuffer_fetch */ +/* -------------- GL_EXT_shader_framebuffer_fetch_non_coherent ------------- */ + +#ifndef GL_EXT_shader_framebuffer_fetch_non_coherent +#define GL_EXT_shader_framebuffer_fetch_non_coherent 1 + +#define GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT 0x8A52 + +#define GLEW_EXT_shader_framebuffer_fetch_non_coherent GLEW_GET_VAR(__GLEW_EXT_shader_framebuffer_fetch_non_coherent) + +#endif /* GL_EXT_shader_framebuffer_fetch_non_coherent */ + /* ------------------------ GL_EXT_shader_group_vote ----------------------- */ #ifndef GL_EXT_shader_group_vote @@ -11939,6 +12177,15 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, G #endif /* GL_EXT_sparse_texture2 */ +/* ----------------------- GL_EXT_static_vertex_array ---------------------- */ + +#ifndef GL_EXT_static_vertex_array +#define GL_EXT_static_vertex_array 1 + +#define GLEW_EXT_static_vertex_array GLEW_GET_VAR(__GLEW_EXT_static_vertex_array) + +#endif /* GL_EXT_static_vertex_array */ + /* ------------------------ GL_EXT_stencil_clear_tag ----------------------- */ #ifndef GL_EXT_stencil_clear_tag @@ -11996,6 +12243,116 @@ typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint leve #endif /* GL_EXT_subtexture */ +/* --------------------- GL_EXT_tessellation_point_size -------------------- */ + +#ifndef GL_EXT_tessellation_point_size +#define GL_EXT_tessellation_point_size 1 + +#define GL_QUADS_EXT 0x0007 +#define GL_TESS_CONTROL_SHADER_BIT_EXT 0x00000008 +#define GL_PATCHES_EXT 0xE +#define GL_TESS_EVALUATION_SHADER_BIT_EXT 0x00000010 +#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221 +#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT 0x886C +#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT 0x886D +#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT 0x8E1E +#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT 0x8E1F +#define GL_PATCH_VERTICES_EXT 0x8E72 +#define GL_TESS_CONTROL_OUTPUT_VERTICES_EXT 0x8E75 +#define GL_TESS_GEN_MODE_EXT 0x8E76 +#define GL_TESS_GEN_SPACING_EXT 0x8E77 +#define GL_TESS_GEN_VERTEX_ORDER_EXT 0x8E78 +#define GL_TESS_GEN_POINT_MODE_EXT 0x8E79 +#define GL_ISOLINES_EXT 0x8E7A +#define GL_FRACTIONAL_ODD_EXT 0x8E7B +#define GL_FRACTIONAL_EVEN_EXT 0x8E7C +#define GL_MAX_PATCH_VERTICES_EXT 0x8E7D +#define GL_MAX_TESS_GEN_LEVEL_EXT 0x8E7E +#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT 0x8E7F +#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT 0x8E80 +#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT 0x8E81 +#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT 0x8E82 +#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT 0x8E83 +#define GL_MAX_TESS_PATCH_COMPONENTS_EXT 0x8E84 +#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT 0x8E85 +#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT 0x8E86 +#define GL_TESS_EVALUATION_SHADER_EXT 0x8E87 +#define GL_TESS_CONTROL_SHADER_EXT 0x8E88 +#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT 0x8E89 +#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT 0x8E8A +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT 0x90CC +#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT 0x90D8 +#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT 0x90D9 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT 0x92CE +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT 0x92D4 +#define GL_IS_PER_PATCH_EXT 0x92E7 +#define GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT 0x9307 +#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT 0x9308 + +typedef void (GLAPIENTRY * PFNGLPATCHPARAMETERIEXTPROC) (GLenum pname, GLint value); + +#define glPatchParameteriEXT GLEW_GET_FUN(__glewPatchParameteriEXT) + +#define GLEW_EXT_tessellation_point_size GLEW_GET_VAR(__GLEW_EXT_tessellation_point_size) + +#endif /* GL_EXT_tessellation_point_size */ + +/* ----------------------- GL_EXT_tessellation_shader ---------------------- */ + +#ifndef GL_EXT_tessellation_shader +#define GL_EXT_tessellation_shader 1 + +#define GL_QUADS_EXT 0x0007 +#define GL_TESS_CONTROL_SHADER_BIT_EXT 0x00000008 +#define GL_PATCHES_EXT 0xE +#define GL_TESS_EVALUATION_SHADER_BIT_EXT 0x00000010 +#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED 0x8221 +#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT 0x886C +#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT 0x886D +#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT 0x8E1E +#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT 0x8E1F +#define GL_PATCH_VERTICES_EXT 0x8E72 +#define GL_TESS_CONTROL_OUTPUT_VERTICES_EXT 0x8E75 +#define GL_TESS_GEN_MODE_EXT 0x8E76 +#define GL_TESS_GEN_SPACING_EXT 0x8E77 +#define GL_TESS_GEN_VERTEX_ORDER_EXT 0x8E78 +#define GL_TESS_GEN_POINT_MODE_EXT 0x8E79 +#define GL_ISOLINES_EXT 0x8E7A +#define GL_FRACTIONAL_ODD_EXT 0x8E7B +#define GL_FRACTIONAL_EVEN_EXT 0x8E7C +#define GL_MAX_PATCH_VERTICES_EXT 0x8E7D +#define GL_MAX_TESS_GEN_LEVEL_EXT 0x8E7E +#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT 0x8E7F +#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT 0x8E80 +#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT 0x8E81 +#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT 0x8E82 +#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT 0x8E83 +#define GL_MAX_TESS_PATCH_COMPONENTS_EXT 0x8E84 +#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT 0x8E85 +#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT 0x8E86 +#define GL_TESS_EVALUATION_SHADER_EXT 0x8E87 +#define GL_TESS_CONTROL_SHADER_EXT 0x8E88 +#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT 0x8E89 +#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT 0x8E8A +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT 0x90CC +#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT 0x90D8 +#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT 0x90D9 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT 0x92CE +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT 0x92D4 +#define GL_IS_PER_PATCH_EXT 0x92E7 +#define GL_REFERENCED_BY_TESS_CONTROL_SHADER_EXT 0x9307 +#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT 0x9308 + +#define GLEW_EXT_tessellation_shader GLEW_GET_VAR(__GLEW_EXT_tessellation_shader) + +#endif /* GL_EXT_tessellation_shader */ + /* ----------------------------- GL_EXT_texture ---------------------------- */ #ifndef GL_EXT_texture @@ -12093,6 +12450,52 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, #endif /* GL_EXT_texture_array */ +/* ---------------------- GL_EXT_texture_border_clamp ---------------------- */ + +#ifndef GL_EXT_texture_border_clamp +#define GL_EXT_texture_border_clamp 1 + +#define GL_TEXTURE_BORDER_COLOR_EXT 0x1004 +#define GL_CLAMP_TO_BORDER_EXT 0x812D + +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIIVEXTPROC) (GLuint sampler, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIUIVEXTPROC) (GLuint sampler, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIIVEXTPROC) (GLuint sampler, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIUIVEXTPROC) (GLuint sampler, GLenum pname, const GLuint* params); + +#define glGetSamplerParameterIivEXT GLEW_GET_FUN(__glewGetSamplerParameterIivEXT) +#define glGetSamplerParameterIuivEXT GLEW_GET_FUN(__glewGetSamplerParameterIuivEXT) +#define glSamplerParameterIivEXT GLEW_GET_FUN(__glewSamplerParameterIivEXT) +#define glSamplerParameterIuivEXT GLEW_GET_FUN(__glewSamplerParameterIuivEXT) + +#define GLEW_EXT_texture_border_clamp GLEW_GET_VAR(__GLEW_EXT_texture_border_clamp) + +#endif /* GL_EXT_texture_border_clamp */ + +/* ------------------------- GL_EXT_texture_buffer ------------------------- */ + +#ifndef GL_EXT_texture_buffer +#define GL_EXT_texture_buffer 1 + +#define GL_TEXTURE_BUFFER_BINDING_EXT 0x8C2A +#define GL_TEXTURE_BUFFER_EXT 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D +#define GL_SAMPLER_BUFFER_EXT 0x8DC2 +#define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8 +#define GL_IMAGE_BUFFER_EXT 0x9051 +#define GL_INT_IMAGE_BUFFER_EXT 0x905C +#define GL_UNSIGNED_INT_IMAGE_BUFFER_EXT 0x9067 +#define GL_TEXTURE_BUFFER_OFFSET_EXT 0x919D +#define GL_TEXTURE_BUFFER_SIZE_EXT 0x919E +#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT 0x919F + +#define GLEW_EXT_texture_buffer GLEW_GET_VAR(__GLEW_EXT_texture_buffer) + +#endif /* GL_EXT_texture_buffer */ + /* ---------------------- GL_EXT_texture_buffer_object --------------------- */ #ifndef GL_EXT_texture_buffer_object @@ -12199,6 +12602,20 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #endif /* GL_EXT_texture_compression_s3tc */ +/* ------------------ GL_EXT_texture_compression_s3tc_srgb ----------------- */ + +#ifndef GL_EXT_texture_compression_s3tc_srgb +#define GL_EXT_texture_compression_s3tc_srgb 1 + +#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F + +#define GLEW_EXT_texture_compression_s3tc_srgb GLEW_GET_VAR(__GLEW_EXT_texture_compression_s3tc_srgb) + +#endif /* GL_EXT_texture_compression_s3tc_srgb */ + /* ------------------------ GL_EXT_texture_cube_map ------------------------ */ #ifndef GL_EXT_texture_cube_map @@ -12347,6 +12764,17 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #endif /* GL_EXT_texture_format_BGRA8888 */ +/* ------------------ GL_EXT_texture_format_sRGB_override ------------------ */ + +#ifndef GL_EXT_texture_format_sRGB_override +#define GL_EXT_texture_format_sRGB_override 1 + +#define GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT 0x8FBF + +#define GLEW_EXT_texture_format_sRGB_override GLEW_GET_VAR(__GLEW_EXT_texture_format_sRGB_override) + +#endif /* GL_EXT_texture_format_sRGB_override */ + /* ------------------------- GL_EXT_texture_integer ------------------------ */ #ifndef GL_EXT_texture_integer @@ -12444,6 +12872,17 @@ typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum #endif /* GL_EXT_texture_mirror_clamp */ +/* ------------------ GL_EXT_texture_mirror_clamp_to_edge ------------------ */ + +#ifndef GL_EXT_texture_mirror_clamp_to_edge +#define GL_EXT_texture_mirror_clamp_to_edge 1 + +#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 + +#define GLEW_EXT_texture_mirror_clamp_to_edge GLEW_GET_VAR(__GLEW_EXT_texture_mirror_clamp_to_edge) + +#endif /* GL_EXT_texture_mirror_clamp_to_edge */ + /* ------------------------- GL_EXT_texture_norm16 ------------------------- */ #ifndef GL_EXT_texture_norm16 @@ -13230,6 +13669,76 @@ typedef GLsync (GLAPIENTRY * PFNGLIMPORTSYNCEXTPROC) (GLenum external_sync_type, #endif /* GL_EXT_x11_sync_object */ +/* ----------------------- GL_FJ_shader_binary_GCCSO ----------------------- */ + +#ifndef GL_FJ_shader_binary_GCCSO +#define GL_FJ_shader_binary_GCCSO 1 + +#define GL_GCCSO_SHADER_BINARY_FJ 0x9260 + +#define GLEW_FJ_shader_binary_GCCSO GLEW_GET_VAR(__GLEW_FJ_shader_binary_GCCSO) + +#endif /* GL_FJ_shader_binary_GCCSO */ + +/* ---------------------- GL_GLU_EXT_nurbs_tessellator --------------------- */ + +#ifndef GL_GLU_EXT_nurbs_tessellator +#define GL_GLU_EXT_nurbs_tessellator 1 + +#define GL_GLU_NURBS_MODE_EXT 100160 +#define GL_GLU_NURBS_TESSELLATOR_EXT 100161 +#define GL_GLU_NURBS_RENDERER_EXT 100162 +#define GL_GLU_NURBS_BEGIN_EXT 100164 +#define GL_GLU_NURBS_VERTEX_EXT 100165 +#define GL_GLU_NURBS_NORMAL_EXT 100166 +#define GL_GLU_NURBS_COLOR_EXT 100167 +#define GL_GLU_NURBS_TEXTURE_COORD_EXT 100168 +#define GL_GLU_NURBS_END_EXT 100169 +#define GL_GLU_NURBS_BEGIN_DATA_EXT 100170 +#define GL_GLU_NURBS_VERTEX_DATA_EXT 100171 +#define GL_GLU_NURBS_NORMAL_DATA_EXT 100172 +#define GL_GLU_NURBS_COLOR_DATA_EXT 100173 +#define GL_GLU_NURBS_TEXTURE_COORD_DATA_EXT 100174 +#define GL_GLU_NURBS_END_DATA_EXT 100175 + +#define GLEW_GLU_EXT_nurbs_tessellator GLEW_GET_VAR(__GLEW_GLU_EXT_nurbs_tessellator) + +#endif /* GL_GLU_EXT_nurbs_tessellator */ + +/* ---------------------- GL_GLU_EXT_object_space_tess --------------------- */ + +#ifndef GL_GLU_EXT_object_space_tess +#define GL_GLU_EXT_object_space_tess 1 + +#define GL_OBJECT_PARAMETRIC_ERROR_EXT 100208 +#define GL_OBJECT_PATH_LENGTH_EXT 100209 + +#define GLEW_GLU_EXT_object_space_tess GLEW_GET_VAR(__GLEW_GLU_EXT_object_space_tess) + +#endif /* GL_GLU_EXT_object_space_tess */ + +/* ------------------------ GL_GLU_SGIX_icc_compress ----------------------- */ + +#ifndef GL_GLU_SGIX_icc_compress +#define GL_GLU_SGIX_icc_compress 1 + +#define GLEW_GLU_SGIX_icc_compress GLEW_GET_VAR(__GLEW_GLU_SGIX_icc_compress) + +#endif /* GL_GLU_SGIX_icc_compress */ + +/* --------------------- GL_GLU_SGI_filter4_parameters --------------------- */ + +#ifndef GL_GLU_SGI_filter4_parameters +#define GL_GLU_SGI_filter4_parameters 1 + +typedef GLint (GLAPIENTRY * PFNGLUTEXFILTERFUNCSGIPROC) (GLenum target, GLenum filtertype, const GLfloat* parms, GLint n, GLfloat *weights); + +#define gluTexFilterFuncSGI GLEW_GET_FUN(__glewuTexFilterFuncSGI) + +#define GLEW_GLU_SGI_filter4_parameters GLEW_GET_VAR(__GLEW_GLU_SGI_filter4_parameters) + +#endif /* GL_GLU_SGI_filter4_parameters */ + /* ---------------------- GL_GREMEDY_frame_terminator ---------------------- */ #ifndef GL_GREMEDY_frame_terminator @@ -13410,6 +13919,159 @@ typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum ty #endif /* GL_IBM_vertex_array_lists */ +/* ------------------------ GL_IMG_bindless_texture ------------------------ */ + +#ifndef GL_IMG_bindless_texture +#define GL_IMG_bindless_texture 1 + +typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTUREHANDLEIMGPROC) (GLuint texture); +typedef GLuint64 (GLAPIENTRY * PFNGLGETTEXTURESAMPLERHANDLEIMGPROC) (GLuint texture, GLuint sampler); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64IMGPROC) (GLuint program, GLint location, GLuint64 value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMHANDLEUI64VIMGPROC) (GLuint program, GLint location, GLsizei count, const GLuint64* values); +typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64IMGPROC) (GLint location, GLuint64 value); +typedef void (GLAPIENTRY * PFNGLUNIFORMHANDLEUI64VIMGPROC) (GLint location, GLsizei count, const GLuint64* value); + +#define glGetTextureHandleIMG GLEW_GET_FUN(__glewGetTextureHandleIMG) +#define glGetTextureSamplerHandleIMG GLEW_GET_FUN(__glewGetTextureSamplerHandleIMG) +#define glProgramUniformHandleui64IMG GLEW_GET_FUN(__glewProgramUniformHandleui64IMG) +#define glProgramUniformHandleui64vIMG GLEW_GET_FUN(__glewProgramUniformHandleui64vIMG) +#define glUniformHandleui64IMG GLEW_GET_FUN(__glewUniformHandleui64IMG) +#define glUniformHandleui64vIMG GLEW_GET_FUN(__glewUniformHandleui64vIMG) + +#define GLEW_IMG_bindless_texture GLEW_GET_VAR(__GLEW_IMG_bindless_texture) + +#endif /* GL_IMG_bindless_texture */ + +/* --------------------- GL_IMG_framebuffer_downsample --------------------- */ + +#ifndef GL_IMG_framebuffer_downsample +#define GL_IMG_framebuffer_downsample 1 + +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_AND_DOWNSAMPLE_IMG 0x913C +#define GL_NUM_DOWNSAMPLE_SCALES_IMG 0x913D +#define GL_DOWNSAMPLE_SCALES_IMG 0x913E +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SCALE_IMG 0x913F + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint xscale, GLint yscale); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer, GLint xscale, GLint yscale); + +#define glFramebufferTexture2DDownsampleIMG GLEW_GET_FUN(__glewFramebufferTexture2DDownsampleIMG) +#define glFramebufferTextureLayerDownsampleIMG GLEW_GET_FUN(__glewFramebufferTextureLayerDownsampleIMG) + +#define GLEW_IMG_framebuffer_downsample GLEW_GET_VAR(__GLEW_IMG_framebuffer_downsample) + +#endif /* GL_IMG_framebuffer_downsample */ + +/* ----------------- GL_IMG_multisampled_render_to_texture ----------------- */ + +#ifndef GL_IMG_multisampled_render_to_texture +#define GL_IMG_multisampled_render_to_texture 1 + +#define GL_RENDERBUFFER_SAMPLES_IMG 0x9133 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG 0x9134 +#define GL_MAX_SAMPLES_IMG 0x9135 +#define GL_TEXTURE_SAMPLES_IMG 0x9136 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glFramebufferTexture2DMultisampleIMG GLEW_GET_FUN(__glewFramebufferTexture2DMultisampleIMG) +#define glRenderbufferStorageMultisampleIMG GLEW_GET_FUN(__glewRenderbufferStorageMultisampleIMG) + +#define GLEW_IMG_multisampled_render_to_texture GLEW_GET_VAR(__GLEW_IMG_multisampled_render_to_texture) + +#endif /* GL_IMG_multisampled_render_to_texture */ + +/* ------------------------- GL_IMG_program_binary ------------------------- */ + +#ifndef GL_IMG_program_binary +#define GL_IMG_program_binary 1 + +#define GL_SGX_PROGRAM_BINARY_IMG 0x9130 + +#define GLEW_IMG_program_binary GLEW_GET_VAR(__GLEW_IMG_program_binary) + +#endif /* GL_IMG_program_binary */ + +/* --------------------------- GL_IMG_read_format -------------------------- */ + +#ifndef GL_IMG_read_format +#define GL_IMG_read_format 1 + +#define GL_BGRA_IMG 0x80E1 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV_IMG 0x8365 + +#define GLEW_IMG_read_format GLEW_GET_VAR(__GLEW_IMG_read_format) + +#endif /* GL_IMG_read_format */ + +/* -------------------------- GL_IMG_shader_binary ------------------------- */ + +#ifndef GL_IMG_shader_binary +#define GL_IMG_shader_binary 1 + +#define GL_SGX_BINARY_IMG 0x8C0A + +#define GLEW_IMG_shader_binary GLEW_GET_VAR(__GLEW_IMG_shader_binary) + +#endif /* GL_IMG_shader_binary */ + +/* -------------------- GL_IMG_texture_compression_pvrtc ------------------- */ + +#ifndef GL_IMG_texture_compression_pvrtc +#define GL_IMG_texture_compression_pvrtc 1 + +#define GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 +#define GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG 0x8C01 +#define GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 +#define GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG 0x8C03 + +#define GLEW_IMG_texture_compression_pvrtc GLEW_GET_VAR(__GLEW_IMG_texture_compression_pvrtc) + +#endif /* GL_IMG_texture_compression_pvrtc */ + +/* ------------------- GL_IMG_texture_compression_pvrtc2 ------------------- */ + +#ifndef GL_IMG_texture_compression_pvrtc2 +#define GL_IMG_texture_compression_pvrtc2 1 + +#define GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG 0x9137 +#define GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG 0x9138 + +#define GLEW_IMG_texture_compression_pvrtc2 GLEW_GET_VAR(__GLEW_IMG_texture_compression_pvrtc2) + +#endif /* GL_IMG_texture_compression_pvrtc2 */ + +/* --------------- GL_IMG_texture_env_enhanced_fixed_function -------------- */ + +#ifndef GL_IMG_texture_env_enhanced_fixed_function +#define GL_IMG_texture_env_enhanced_fixed_function 1 + +#define GL_DOT3_RGBA_IMG 0x86AF +#define GL_MODULATE_COLOR_IMG 0x8C04 +#define GL_RECIP_ADD_SIGNED_ALPHA_IMG 0x8C05 +#define GL_TEXTURE_ALPHA_MODULATE_IMG 0x8C06 +#define GL_FACTOR_ALPHA_MODULATE_IMG 0x8C07 +#define GL_FRAGMENT_ALPHA_MODULATE_IMG 0x8C08 +#define GL_ADD_BLEND_IMG 0x8C09 + +#define GLEW_IMG_texture_env_enhanced_fixed_function GLEW_GET_VAR(__GLEW_IMG_texture_env_enhanced_fixed_function) + +#endif /* GL_IMG_texture_env_enhanced_fixed_function */ + +/* ---------------------- GL_IMG_texture_filter_cubic ---------------------- */ + +#ifndef GL_IMG_texture_filter_cubic +#define GL_IMG_texture_filter_cubic 1 + +#define GL_CUBIC_IMG 0x9139 +#define GL_CUBIC_MIPMAP_NEAREST_IMG 0x913A +#define GL_CUBIC_MIPMAP_LINEAR_IMG 0x913B + +#define GLEW_IMG_texture_filter_cubic GLEW_GET_VAR(__GLEW_IMG_texture_filter_cubic) + +#endif /* GL_IMG_texture_filter_cubic */ + /* -------------------------- GL_INGR_color_clamp -------------------------- */ #ifndef GL_INGR_color_clamp @@ -13439,6 +14101,17 @@ typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum ty #endif /* GL_INGR_interlace_read */ +/* ----------------------- GL_INTEL_blackhole_render ----------------------- */ + +#ifndef GL_INTEL_blackhole_render +#define GL_INTEL_blackhole_render 1 + +#define GL_BLACKHOLE_RENDER_INTEL 0x83FC + +#define GLEW_INTEL_blackhole_render GLEW_GET_VAR(__GLEW_INTEL_blackhole_render) + +#endif /* GL_INTEL_blackhole_render */ + /* ------------------ GL_INTEL_conservative_rasterization ------------------ */ #ifndef GL_INTEL_conservative_rasterization @@ -13626,6 +14299,9 @@ typedef void (GLAPIENTRY * PFNGLBLENDBARRIERKHRPROC) (void); #ifndef GL_KHR_context_flush_control #define GL_KHR_context_flush_control 1 +#define GL_CONTEXT_RELEASE_BEHAVIOR 0x82FB +#define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82FC + #define GLEW_KHR_context_flush_control GLEW_GET_VAR(__GLEW_KHR_context_flush_control) #endif /* GL_KHR_context_flush_control */ @@ -13787,6 +14463,16 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSPROC) (GLint x, GLint y, GLsizei widt #define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB #define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC #define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD +#define GL_COMPRESSED_RGBA_ASTC_3x3x3_OES 0x93C0 +#define GL_COMPRESSED_RGBA_ASTC_4x3x3_OES 0x93C1 +#define GL_COMPRESSED_RGBA_ASTC_4x4x3_OES 0x93C2 +#define GL_COMPRESSED_RGBA_ASTC_4x4x4_OES 0x93C3 +#define GL_COMPRESSED_RGBA_ASTC_5x4x4_OES 0x93C4 +#define GL_COMPRESSED_RGBA_ASTC_5x5x4_OES 0x93C5 +#define GL_COMPRESSED_RGBA_ASTC_5x5x5_OES 0x93C6 +#define GL_COMPRESSED_RGBA_ASTC_6x5x5_OES 0x93C7 +#define GL_COMPRESSED_RGBA_ASTC_6x6x5_OES 0x93C8 +#define GL_COMPRESSED_RGBA_ASTC_6x6x6_OES 0x93C9 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 @@ -13801,6 +14487,16 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSPROC) (GLint x, GLint y, GLsizei widt #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES 0x93E0 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES 0x93E1 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES 0x93E2 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES 0x93E3 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES 0x93E4 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES 0x93E5 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES 0x93E6 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES 0x93E7 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES 0x93E8 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES 0x93E9 #define GLEW_KHR_texture_compression_astc_hdr GLEW_GET_VAR(__GLEW_KHR_texture_compression_astc_hdr) @@ -13825,6 +14521,16 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSPROC) (GLint x, GLint y, GLsizei widt #define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB #define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC #define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD +#define GL_COMPRESSED_RGBA_ASTC_3x3x3_OES 0x93C0 +#define GL_COMPRESSED_RGBA_ASTC_4x3x3_OES 0x93C1 +#define GL_COMPRESSED_RGBA_ASTC_4x4x3_OES 0x93C2 +#define GL_COMPRESSED_RGBA_ASTC_4x4x4_OES 0x93C3 +#define GL_COMPRESSED_RGBA_ASTC_5x4x4_OES 0x93C4 +#define GL_COMPRESSED_RGBA_ASTC_5x5x4_OES 0x93C5 +#define GL_COMPRESSED_RGBA_ASTC_5x5x5_OES 0x93C6 +#define GL_COMPRESSED_RGBA_ASTC_6x5x5_OES 0x93C7 +#define GL_COMPRESSED_RGBA_ASTC_6x6x5_OES 0x93C8 +#define GL_COMPRESSED_RGBA_ASTC_6x6x6_OES 0x93C9 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 @@ -13839,6 +14545,16 @@ typedef void (GLAPIENTRY * PFNGLREADNPIXELSPROC) (GLint x, GLint y, GLsizei widt #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES 0x93E0 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES 0x93E1 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES 0x93E2 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES 0x93E3 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES 0x93E4 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES 0x93E5 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES 0x93E6 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES 0x93E7 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES 0x93E8 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES 0x93E9 #define GLEW_KHR_texture_compression_astc_ldr GLEW_GET_VAR(__GLEW_KHR_texture_compression_astc_ldr) @@ -13895,6 +14611,17 @@ typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, G #endif /* GL_MESAX_texture_stack */ +/* ----------------------- GL_MESA_framebuffer_flip_y ---------------------- */ + +#ifndef GL_MESA_framebuffer_flip_y +#define GL_MESA_framebuffer_flip_y 1 + +#define GL_FRAMEBUFFER_FLIP_Y_MESA 0x8BBB + +#define GLEW_MESA_framebuffer_flip_y GLEW_GET_VAR(__GLEW_MESA_framebuffer_flip_y) + +#endif /* GL_MESA_framebuffer_flip_y */ + /* -------------------------- GL_MESA_pack_invert -------------------------- */ #ifndef GL_MESA_pack_invert @@ -13906,6 +14633,17 @@ typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONPROC) (GLuint region, GLint x, G #endif /* GL_MESA_pack_invert */ +/* --------------------- GL_MESA_program_binary_formats -------------------- */ + +#ifndef GL_MESA_program_binary_formats +#define GL_MESA_program_binary_formats 1 + +#define GL_PROGRAM_BINARY_FORMAT_MESA 0x875F + +#define GLEW_MESA_program_binary_formats GLEW_GET_VAR(__GLEW_MESA_program_binary_formats) + +#endif /* GL_MESA_program_binary_formats */ + /* ------------------------- GL_MESA_resize_buffers ------------------------ */ #ifndef GL_MESA_resize_buffers @@ -13928,6 +14666,15 @@ typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void); #endif /* GL_MESA_shader_integer_functions */ +/* ----------------------- GL_MESA_tile_raster_order ----------------------- */ + +#ifndef GL_MESA_tile_raster_order +#define GL_MESA_tile_raster_order 1 + +#define GLEW_MESA_tile_raster_order GLEW_GET_VAR(__GLEW_MESA_tile_raster_order) + +#endif /* GL_MESA_tile_raster_order */ + /* --------------------------- GL_MESA_window_pos -------------------------- */ #ifndef GL_MESA_window_pos @@ -14378,6 +15125,15 @@ typedef void (GLAPIENTRY * PFNGLSTATECAPTURENVPROC) (GLuint state, GLenum mode); #endif /* GL_NV_compute_program5 */ +/* -------------------- GL_NV_compute_shader_derivatives ------------------- */ + +#ifndef GL_NV_compute_shader_derivatives +#define GL_NV_compute_shader_derivatives 1 + +#define GLEW_NV_compute_shader_derivatives GLEW_GET_VAR(__GLEW_NV_compute_shader_derivatives) + +#endif /* GL_NV_compute_shader_derivatives */ + /* ------------------------ GL_NV_conditional_render ----------------------- */ #ifndef GL_NV_conditional_render @@ -14433,6 +15189,17 @@ typedef void (GLAPIENTRY * PFNGLCONSERVATIVERASTERPARAMETERFNVPROC) (GLenum pnam #endif /* GL_NV_conservative_raster_dilate */ +/* ------------------- GL_NV_conservative_raster_pre_snap ------------------ */ + +#ifndef GL_NV_conservative_raster_pre_snap +#define GL_NV_conservative_raster_pre_snap 1 + +#define GL_CONSERVATIVE_RASTER_MODE_PRE_SNAP_NV 0x9550 + +#define GLEW_NV_conservative_raster_pre_snap GLEW_GET_VAR(__GLEW_NV_conservative_raster_pre_snap) + +#endif /* GL_NV_conservative_raster_pre_snap */ + /* -------------- GL_NV_conservative_raster_pre_snap_triangles ------------- */ #ifndef GL_NV_conservative_raster_pre_snap_triangles @@ -14450,6 +15217,15 @@ typedef void (GLAPIENTRY * PFNGLCONSERVATIVERASTERPARAMETERINVPROC) (GLenum pnam #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +/* --------------- GL_NV_conservative_raster_underestimation --------------- */ + +#ifndef GL_NV_conservative_raster_underestimation +#define GL_NV_conservative_raster_underestimation 1 + +#define GLEW_NV_conservative_raster_underestimation GLEW_GET_VAR(__GLEW_NV_conservative_raster_underestimation) + +#endif /* GL_NV_conservative_raster_underestimation */ + /* --------------------------- GL_NV_copy_buffer --------------------------- */ #ifndef GL_NV_copy_buffer @@ -14536,6 +15312,17 @@ typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFa #endif /* GL_NV_depth_clamp */ +/* ------------------------- GL_NV_depth_nonlinear ------------------------- */ + +#ifndef GL_NV_depth_nonlinear +#define GL_NV_depth_nonlinear 1 + +#define GL_DEPTH_COMPONENT16_NONLINEAR_NV 0x8E2C + +#define GLEW_NV_depth_nonlinear GLEW_GET_VAR(__GLEW_NV_depth_nonlinear) + +#endif /* GL_NV_depth_nonlinear */ + /* ---------------------- GL_NV_depth_range_unclamped ---------------------- */ #ifndef GL_NV_depth_range_unclamped @@ -14924,6 +15711,15 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsi #endif /* GL_NV_fragment_program_option */ +/* ------------------- GL_NV_fragment_shader_barycentric ------------------- */ + +#ifndef GL_NV_fragment_shader_barycentric +#define GL_NV_fragment_shader_barycentric 1 + +#define GLEW_NV_fragment_shader_barycentric GLEW_GET_VAR(__GLEW_NV_fragment_shader_barycentric) + +#endif /* GL_NV_fragment_shader_barycentric */ + /* -------------------- GL_NV_fragment_shader_interlock -------------------- */ #ifndef GL_NV_fragment_shader_interlock @@ -15442,6 +16238,108 @@ typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATSAMPLEIVNVPROC) (GLenum target, #endif /* GL_NV_light_max_exponent */ +/* ------------------------ GL_NV_memory_attachment ------------------------ */ + +#ifndef GL_NV_memory_attachment +#define GL_NV_memory_attachment 1 + +#define GL_ATTACHED_MEMORY_OBJECT_NV 0x95A4 +#define GL_ATTACHED_MEMORY_OFFSET_NV 0x95A5 +#define GL_MEMORY_ATTACHABLE_ALIGNMENT_NV 0x95A6 +#define GL_MEMORY_ATTACHABLE_SIZE_NV 0x95A7 +#define GL_MEMORY_ATTACHABLE_NV 0x95A8 +#define GL_DETACHED_MEMORY_INCARNATION_NV 0x95A9 +#define GL_DETACHED_TEXTURES_NV 0x95AA +#define GL_DETACHED_BUFFERS_NV 0x95AB +#define GL_MAX_DETACHED_TEXTURES_NV 0x95AC +#define GL_MAX_DETACHED_BUFFERS_NV 0x95AD + +typedef void (GLAPIENTRY * PFNGLBUFFERATTACHMEMORYNVPROC) (GLenum target, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC) (GLuint memory, GLenum pname, GLint first, GLsizei count, GLuint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERATTACHMEMORYNVPROC) (GLuint buffer, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLRESETMEMORYOBJECTPARAMETERNVPROC) (GLuint memory, GLenum pname); +typedef void (GLAPIENTRY * PFNGLTEXATTACHMEMORYNVPROC) (GLenum target, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTUREATTACHMEMORYNVPROC) (GLuint texture, GLuint memory, GLuint64 offset); + +#define glBufferAttachMemoryNV GLEW_GET_FUN(__glewBufferAttachMemoryNV) +#define glGetMemoryObjectDetachedResourcesuivNV GLEW_GET_FUN(__glewGetMemoryObjectDetachedResourcesuivNV) +#define glNamedBufferAttachMemoryNV GLEW_GET_FUN(__glewNamedBufferAttachMemoryNV) +#define glResetMemoryObjectParameterNV GLEW_GET_FUN(__glewResetMemoryObjectParameterNV) +#define glTexAttachMemoryNV GLEW_GET_FUN(__glewTexAttachMemoryNV) +#define glTextureAttachMemoryNV GLEW_GET_FUN(__glewTextureAttachMemoryNV) + +#define GLEW_NV_memory_attachment GLEW_GET_VAR(__GLEW_NV_memory_attachment) + +#endif /* GL_NV_memory_attachment */ + +/* --------------------------- GL_NV_mesh_shader --------------------------- */ + +#ifndef GL_NV_mesh_shader +#define GL_NV_mesh_shader 1 + +#define GL_MESH_SHADER_BIT_NV 0x00000040 +#define GL_TASK_SHADER_BIT_NV 0x00000080 +#define GL_MAX_MESH_UNIFORM_BLOCKS_NV 0x8E60 +#define GL_MAX_MESH_TEXTURE_IMAGE_UNITS_NV 0x8E61 +#define GL_MAX_MESH_IMAGE_UNIFORMS_NV 0x8E62 +#define GL_MAX_MESH_UNIFORM_COMPONENTS_NV 0x8E63 +#define GL_MAX_MESH_ATOMIC_COUNTER_BUFFERS_NV 0x8E64 +#define GL_MAX_MESH_ATOMIC_COUNTERS_NV 0x8E65 +#define GL_MAX_MESH_SHADER_STORAGE_BLOCKS_NV 0x8E66 +#define GL_MAX_COMBINED_MESH_UNIFORM_COMPONENTS_NV 0x8E67 +#define GL_MAX_TASK_UNIFORM_BLOCKS_NV 0x8E68 +#define GL_MAX_TASK_TEXTURE_IMAGE_UNITS_NV 0x8E69 +#define GL_MAX_TASK_IMAGE_UNIFORMS_NV 0x8E6A +#define GL_MAX_TASK_UNIFORM_COMPONENTS_NV 0x8E6B +#define GL_MAX_TASK_ATOMIC_COUNTER_BUFFERS_NV 0x8E6C +#define GL_MAX_TASK_ATOMIC_COUNTERS_NV 0x8E6D +#define GL_MAX_TASK_SHADER_STORAGE_BLOCKS_NV 0x8E6E +#define GL_MAX_COMBINED_TASK_UNIFORM_COMPONENTS_NV 0x8E6F +#define GL_MESH_OUTPUT_PER_VERTEX_GRANULARITY_NV 0x92DF +#define GL_MAX_MESH_TOTAL_MEMORY_SIZE_NV 0x9536 +#define GL_MAX_TASK_TOTAL_MEMORY_SIZE_NV 0x9537 +#define GL_MAX_MESH_OUTPUT_VERTICES_NV 0x9538 +#define GL_MAX_MESH_OUTPUT_PRIMITIVES_NV 0x9539 +#define GL_MAX_TASK_OUTPUT_COUNT_NV 0x953A +#define GL_MAX_MESH_WORK_GROUP_SIZE_NV 0x953B +#define GL_MAX_TASK_WORK_GROUP_SIZE_NV 0x953C +#define GL_MAX_DRAW_MESH_TASKS_COUNT_NV 0x953D +#define GL_MESH_WORK_GROUP_SIZE_NV 0x953E +#define GL_TASK_WORK_GROUP_SIZE_NV 0x953F +#define GL_MESH_OUTPUT_PER_PRIMITIVE_GRANULARITY_NV 0x9543 +#define GL_MAX_MESH_VIEWS_NV 0x9557 +#define GL_MESH_SHADER_NV 0x9559 +#define GL_TASK_SHADER_NV 0x955A +#define GL_MESH_VERTICES_OUT_NV 0x9579 +#define GL_MESH_PRIMITIVES_OUT_NV 0x957A +#define GL_MESH_OUTPUT_TYPE_NV 0x957B +#define GL_MESH_SUBROUTINE_NV 0x957C +#define GL_TASK_SUBROUTINE_NV 0x957D +#define GL_MESH_SUBROUTINE_UNIFORM_NV 0x957E +#define GL_TASK_SUBROUTINE_UNIFORM_NV 0x957F +#define GL_UNIFORM_BLOCK_REFERENCED_BY_MESH_SHADER_NV 0x959C +#define GL_UNIFORM_BLOCK_REFERENCED_BY_TASK_SHADER_NV 0x959D +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_MESH_SHADER_NV 0x959E +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TASK_SHADER_NV 0x959F +#define GL_REFERENCED_BY_MESH_SHADER_NV 0x95A0 +#define GL_REFERENCED_BY_TASK_SHADER_NV 0x95A1 +#define GL_MAX_MESH_WORK_GROUP_INVOCATIONS_NV 0x95A2 +#define GL_MAX_TASK_WORK_GROUP_INVOCATIONS_NV 0x95A3 + +typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSINDIRECTNVPROC) (GLintptr indirect); +typedef void (GLAPIENTRY * PFNGLDRAWMESHTASKSNVPROC) (GLuint first, GLuint count); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC) (GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWMESHTASKSINDIRECTNVPROC) (GLintptr indirect, GLsizei drawcount, GLsizei stride); + +#define glDrawMeshTasksIndirectNV GLEW_GET_FUN(__glewDrawMeshTasksIndirectNV) +#define glDrawMeshTasksNV GLEW_GET_FUN(__glewDrawMeshTasksNV) +#define glMultiDrawMeshTasksIndirectCountNV GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectCountNV) +#define glMultiDrawMeshTasksIndirectNV GLEW_GET_FUN(__glewMultiDrawMeshTasksIndirectNV) + +#define GLEW_NV_mesh_shader GLEW_GET_VAR(__GLEW_NV_mesh_shader) + +#endif /* GL_NV_mesh_shader */ + /* ----------------------- GL_NV_multisample_coverage ---------------------- */ #ifndef GL_NV_multisample_coverage @@ -16039,6 +16937,41 @@ typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); #endif /* GL_NV_primitive_restart */ +/* ------------------------ GL_NV_query_resource_tag ----------------------- */ + +#ifndef GL_NV_query_resource_tag +#define GL_NV_query_resource_tag 1 + +#define GLEW_NV_query_resource_tag GLEW_GET_VAR(__GLEW_NV_query_resource_tag) + +#endif /* GL_NV_query_resource_tag */ + +/* --------------------------- GL_NV_read_buffer --------------------------- */ + +#ifndef GL_NV_read_buffer +#define GL_NV_read_buffer 1 + +#define GL_READ_BUFFER_NV 0x0C02 + +typedef void (GLAPIENTRY * PFNGLREADBUFFERNVPROC) (GLenum mode); + +#define glReadBufferNV GLEW_GET_FUN(__glewReadBufferNV) + +#define GLEW_NV_read_buffer GLEW_GET_VAR(__GLEW_NV_read_buffer) + +#endif /* GL_NV_read_buffer */ + +/* ------------------------ GL_NV_read_buffer_front ------------------------ */ + +#ifndef GL_NV_read_buffer_front +#define GL_NV_read_buffer_front 1 + +#define GL_READ_BUFFER_NV 0x0C02 + +#define GLEW_NV_read_buffer_front GLEW_GET_VAR(__GLEW_NV_read_buffer_front) + +#endif /* GL_NV_read_buffer_front */ + /* ---------------------------- GL_NV_read_depth --------------------------- */ #ifndef GL_NV_read_depth @@ -16172,12 +17105,22 @@ typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage #endif /* GL_NV_register_combiners2 */ +/* ------------------- GL_NV_representative_fragment_test ------------------ */ + +#ifndef GL_NV_representative_fragment_test +#define GL_NV_representative_fragment_test 1 + +#define GL_REPRESENTATIVE_FRAGMENT_TEST_NV 0x937F + +#define GLEW_NV_representative_fragment_test GLEW_GET_VAR(__GLEW_NV_representative_fragment_test) + +#endif /* GL_NV_representative_fragment_test */ + /* ------------------ GL_NV_robustness_video_memory_purge ------------------ */ #ifndef GL_NV_robustness_video_memory_purge #define GL_NV_robustness_video_memory_purge 1 -#define GL_EGL_GENERATE_RESET_ON_VIDEO_MEMORY_PURGE_NV 0x334C #define GL_PURGED_CONTEXT_RESET_NV 0x92BB #define GLEW_NV_robustness_video_memory_purge GLEW_GET_VAR(__GLEW_NV_robustness_video_memory_purge) @@ -16220,9 +17163,11 @@ typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLenum target, GLuint start, GLsizei count, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLRESOLVEDEPTHVALUESNVPROC) (void); #define glFramebufferSampleLocationsfvNV GLEW_GET_FUN(__glewFramebufferSampleLocationsfvNV) #define glNamedFramebufferSampleLocationsfvNV GLEW_GET_FUN(__glewNamedFramebufferSampleLocationsfvNV) +#define glResolveDepthValuesNV GLEW_GET_FUN(__glewResolveDepthValuesNV) #define GLEW_NV_sample_locations GLEW_GET_VAR(__GLEW_NV_sample_locations) @@ -16237,6 +17182,24 @@ typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLuint #endif /* GL_NV_sample_mask_override_coverage */ +/* ------------------------ GL_NV_scissor_exclusive ------------------------ */ + +#ifndef GL_NV_scissor_exclusive +#define GL_NV_scissor_exclusive 1 + +#define GL_SCISSOR_TEST_EXCLUSIVE_NV 0x9555 +#define GL_SCISSOR_BOX_EXCLUSIVE_NV 0x9556 + +typedef void (GLAPIENTRY * PFNGLSCISSOREXCLUSIVEARRAYVNVPROC) (GLuint first, GLsizei count, const GLint* v); +typedef void (GLAPIENTRY * PFNGLSCISSOREXCLUSIVENVPROC) (GLint x, GLint y, GLsizei width, GLsizei height); + +#define glScissorExclusiveArrayvNV GLEW_GET_FUN(__glewScissorExclusiveArrayvNV) +#define glScissorExclusiveNV GLEW_GET_FUN(__glewScissorExclusiveNV) + +#define GLEW_NV_scissor_exclusive GLEW_GET_VAR(__GLEW_NV_scissor_exclusive) + +#endif /* GL_NV_scissor_exclusive */ + /* ---------------------- GL_NV_shader_atomic_counters --------------------- */ #ifndef GL_NV_shader_atomic_counters @@ -16341,6 +17304,15 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou #endif /* GL_NV_shader_storage_buffer_object */ +/* --------------------- GL_NV_shader_texture_footprint -------------------- */ + +#ifndef GL_NV_shader_texture_footprint +#define GL_NV_shader_texture_footprint 1 + +#define GLEW_NV_shader_texture_footprint GLEW_GET_VAR(__GLEW_NV_shader_texture_footprint) + +#endif /* GL_NV_shader_texture_footprint */ + /* ----------------------- GL_NV_shader_thread_group ----------------------- */ #ifndef GL_NV_shader_thread_group @@ -16363,6 +17335,51 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou #endif /* GL_NV_shader_thread_shuffle */ +/* ------------------------ GL_NV_shading_rate_image ----------------------- */ + +#ifndef GL_NV_shading_rate_image +#define GL_NV_shading_rate_image 1 + +#define GL_SHADING_RATE_IMAGE_BINDING_NV 0x955B +#define GL_SHADING_RATE_IMAGE_TEXEL_WIDTH_NV 0x955C +#define GL_SHADING_RATE_IMAGE_TEXEL_HEIGHT_NV 0x955D +#define GL_SHADING_RATE_IMAGE_PALETTE_SIZE_NV 0x955E +#define GL_MAX_COARSE_FRAGMENT_SAMPLES_NV 0x955F +#define GL_SHADING_RATE_IMAGE_NV 0x9563 +#define GL_SHADING_RATE_NO_INVOCATIONS_NV 0x9564 +#define GL_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV 0x9565 +#define GL_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV 0x9566 +#define GL_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV 0x9567 +#define GL_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV 0x9568 +#define GL_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV 0x9569 +#define GL_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV 0x956A +#define GL_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV 0x956B +#define GL_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV 0x956C +#define GL_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV 0x956D +#define GL_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV 0x956E +#define GL_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV 0x956F +#define GL_SHADING_RATE_SAMPLE_ORDER_DEFAULT_NV 0x95AE +#define GL_SHADING_RATE_SAMPLE_ORDER_PIXEL_MAJOR_NV 0x95AF +#define GL_SHADING_RATE_SAMPLE_ORDER_SAMPLE_MAJOR_NV 0x95B0 + +typedef void (GLAPIENTRY * PFNGLBINDSHADINGRATEIMAGENVPROC) (GLuint texture); +typedef void (GLAPIENTRY * PFNGLGETSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint entry, GLenum* rate); +typedef void (GLAPIENTRY * PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC) (GLenum rate, GLuint samples, GLuint index, GLint* location); +typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEBARRIERNVPROC) (GLenum order); +typedef void (GLAPIENTRY * PFNGLSHADINGRATEIMAGEPALETTENVPROC) (GLuint viewport, GLuint first, GLsizei count, const GLenum* rates); +typedef void (GLAPIENTRY * PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC) (GLenum rate, GLuint samples, const GLint* locations); + +#define glBindShadingRateImageNV GLEW_GET_FUN(__glewBindShadingRateImageNV) +#define glGetShadingRateImagePaletteNV GLEW_GET_FUN(__glewGetShadingRateImagePaletteNV) +#define glGetShadingRateSampleLocationivNV GLEW_GET_FUN(__glewGetShadingRateSampleLocationivNV) +#define glShadingRateImageBarrierNV GLEW_GET_FUN(__glewShadingRateImageBarrierNV) +#define glShadingRateImagePaletteNV GLEW_GET_FUN(__glewShadingRateImagePaletteNV) +#define glShadingRateSampleOrderCustomNV GLEW_GET_FUN(__glewShadingRateSampleOrderCustomNV) + +#define GLEW_NV_shading_rate_image GLEW_GET_VAR(__GLEW_NV_shading_rate_image) + +#endif /* GL_NV_shading_rate_image */ + /* ---------------------- GL_NV_shadow_samplers_array ---------------------- */ #ifndef GL_NV_shadow_samplers_array @@ -17472,6 +18489,96 @@ typedef void (GLAPIENTRY * PFNGLVIEWPORTSWIZZLENVPROC) (GLuint index, GLenum swi #endif /* GL_NV_viewport_swizzle */ +/* ---------------------------- GL_OES_EGL_image --------------------------- */ + +#ifndef GL_OES_EGL_image +#define GL_OES_EGL_image 1 + +typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC) (GLenum target, GLeglImageOES image); +typedef void (GLAPIENTRY * PFNGLEGLIMAGETARGETTEXTURE2DOESPROC) (GLenum target, GLeglImageOES image); + +#define glEGLImageTargetRenderbufferStorageOES GLEW_GET_FUN(__glewEGLImageTargetRenderbufferStorageOES) +#define glEGLImageTargetTexture2DOES GLEW_GET_FUN(__glewEGLImageTargetTexture2DOES) + +#define GLEW_OES_EGL_image GLEW_GET_VAR(__GLEW_OES_EGL_image) + +#endif /* GL_OES_EGL_image */ + +/* ----------------------- GL_OES_EGL_image_external ----------------------- */ + +#ifndef GL_OES_EGL_image_external +#define GL_OES_EGL_image_external 1 + +#define GL_TEXTURE_EXTERNAL_OES 0x8D65 +#define GL_SAMPLER_EXTERNAL_OES 0x8D66 +#define GL_TEXTURE_BINDING_EXTERNAL_OES 0x8D67 +#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES 0x8D68 + +#define GLEW_OES_EGL_image_external GLEW_GET_VAR(__GLEW_OES_EGL_image_external) + +#endif /* GL_OES_EGL_image_external */ + +/* -------------------- GL_OES_EGL_image_external_essl3 -------------------- */ + +#ifndef GL_OES_EGL_image_external_essl3 +#define GL_OES_EGL_image_external_essl3 1 + +#define GLEW_OES_EGL_image_external_essl3 GLEW_GET_VAR(__GLEW_OES_EGL_image_external_essl3) + +#endif /* GL_OES_EGL_image_external_essl3 */ + +/* --------------------- GL_OES_blend_equation_separate -------------------- */ + +#ifndef GL_OES_blend_equation_separate +#define GL_OES_blend_equation_separate 1 + +#define GL_BLEND_EQUATION_RGB_OES 0x8009 +#define GL_BLEND_EQUATION_ALPHA_OES 0x883D + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEOESPROC) (GLenum modeRGB, GLenum modeAlpha); + +#define glBlendEquationSeparateOES GLEW_GET_FUN(__glewBlendEquationSeparateOES) + +#define GLEW_OES_blend_equation_separate GLEW_GET_VAR(__GLEW_OES_blend_equation_separate) + +#endif /* GL_OES_blend_equation_separate */ + +/* ----------------------- GL_OES_blend_func_separate ---------------------- */ + +#ifndef GL_OES_blend_func_separate +#define GL_OES_blend_func_separate 1 + +#define GL_BLEND_DST_RGB_OES 0x80C8 +#define GL_BLEND_SRC_RGB_OES 0x80C9 +#define GL_BLEND_DST_ALPHA_OES 0x80CA +#define GL_BLEND_SRC_ALPHA_OES 0x80CB + +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEOESPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +#define glBlendFuncSeparateOES GLEW_GET_FUN(__glewBlendFuncSeparateOES) + +#define GLEW_OES_blend_func_separate GLEW_GET_VAR(__GLEW_OES_blend_func_separate) + +#endif /* GL_OES_blend_func_separate */ + +/* ------------------------- GL_OES_blend_subtract ------------------------- */ + +#ifndef GL_OES_blend_subtract +#define GL_OES_blend_subtract 1 + +#define GL_FUNC_ADD_OES 0x8006 +#define GL_BLEND_EQUATION_OES 0x8009 +#define GL_FUNC_SUBTRACT_OES 0x800A +#define GL_FUNC_REVERSE_SUBTRACT_OES 0x800B + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONOESPROC) (GLenum mode); + +#define glBlendEquationOES GLEW_GET_FUN(__glewBlendEquationOES) + +#define GLEW_OES_blend_subtract GLEW_GET_VAR(__GLEW_OES_blend_subtract) + +#endif /* GL_OES_blend_subtract */ + /* ------------------------ GL_OES_byte_coordinates ------------------------ */ #ifndef GL_OES_byte_coordinates @@ -17481,6 +18588,1100 @@ typedef void (GLAPIENTRY * PFNGLVIEWPORTSWIZZLENVPROC) (GLuint index, GLenum swi #endif /* GL_OES_byte_coordinates */ +/* ------------------ GL_OES_compressed_ETC1_RGB8_texture ------------------ */ + +#ifndef GL_OES_compressed_ETC1_RGB8_texture +#define GL_OES_compressed_ETC1_RGB8_texture 1 + +#define GL_ETC1_RGB8_OES 0x8D64 + +#define GLEW_OES_compressed_ETC1_RGB8_texture GLEW_GET_VAR(__GLEW_OES_compressed_ETC1_RGB8_texture) + +#endif /* GL_OES_compressed_ETC1_RGB8_texture */ + +/* ------------------- GL_OES_compressed_paletted_texture ------------------ */ + +#ifndef GL_OES_compressed_paletted_texture +#define GL_OES_compressed_paletted_texture 1 + +#define GL_PALETTE4_RGB8_OES 0x8B90 +#define GL_PALETTE4_RGBA8_OES 0x8B91 +#define GL_PALETTE4_R5_G6_B5_OES 0x8B92 +#define GL_PALETTE4_RGBA4_OES 0x8B93 +#define GL_PALETTE4_RGB5_A1_OES 0x8B94 +#define GL_PALETTE8_RGB8_OES 0x8B95 +#define GL_PALETTE8_RGBA8_OES 0x8B96 +#define GL_PALETTE8_R5_G6_B5_OES 0x8B97 +#define GL_PALETTE8_RGBA4_OES 0x8B98 +#define GL_PALETTE8_RGB5_A1_OES 0x8B99 + +#define GLEW_OES_compressed_paletted_texture GLEW_GET_VAR(__GLEW_OES_compressed_paletted_texture) + +#endif /* GL_OES_compressed_paletted_texture */ + +/* --------------------------- GL_OES_copy_image --------------------------- */ + +#ifndef GL_OES_copy_image +#define GL_OES_copy_image 1 + +typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATAOESPROC) (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); + +#define glCopyImageSubDataOES GLEW_GET_FUN(__glewCopyImageSubDataOES) + +#define GLEW_OES_copy_image GLEW_GET_VAR(__GLEW_OES_copy_image) + +#endif /* GL_OES_copy_image */ + +/* ----------------------------- GL_OES_depth24 ---------------------------- */ + +#ifndef GL_OES_depth24 +#define GL_OES_depth24 1 + +#define GL_DEPTH_COMPONENT24_OES 0x81A6 + +#define GLEW_OES_depth24 GLEW_GET_VAR(__GLEW_OES_depth24) + +#endif /* GL_OES_depth24 */ + +/* ----------------------------- GL_OES_depth32 ---------------------------- */ + +#ifndef GL_OES_depth32 +#define GL_OES_depth32 1 + +#define GL_DEPTH_COMPONENT32_OES 0x81A7 + +#define GLEW_OES_depth32 GLEW_GET_VAR(__GLEW_OES_depth32) + +#endif /* GL_OES_depth32 */ + +/* -------------------------- GL_OES_depth_texture ------------------------- */ + +#ifndef GL_OES_depth_texture +#define GL_OES_depth_texture 1 + +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_UNSIGNED_INT 0x1405 +#define GL_DEPTH_COMPONENT 0x1902 + +#define GLEW_OES_depth_texture GLEW_GET_VAR(__GLEW_OES_depth_texture) + +#endif /* GL_OES_depth_texture */ + +/* --------------------- GL_OES_depth_texture_cube_map --------------------- */ + +#ifndef GL_OES_depth_texture_cube_map +#define GL_OES_depth_texture_cube_map 1 + +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_UNSIGNED_INT 0x1405 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_DEPTH_STENCIL_OES 0x84F9 +#define GL_DEPTH24_STENCIL8_OES 0x88F0 + +#define GLEW_OES_depth_texture_cube_map GLEW_GET_VAR(__GLEW_OES_depth_texture_cube_map) + +#endif /* GL_OES_depth_texture_cube_map */ + +/* ---------------------- GL_OES_draw_buffers_indexed ---------------------- */ + +#ifndef GL_OES_draw_buffers_indexed +#define GL_OES_draw_buffers_indexed 1 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIOESPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIOESPROC) (GLuint buf, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIOESPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCIOESPROC) (GLuint buf, GLenum src, GLenum dst); +typedef void (GLAPIENTRY * PFNGLCOLORMASKIOESPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLDISABLEIOESPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEIOESPROC) (GLenum target, GLuint index); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIOESPROC) (GLenum target, GLuint index); + +#define glBlendEquationSeparateiOES GLEW_GET_FUN(__glewBlendEquationSeparateiOES) +#define glBlendEquationiOES GLEW_GET_FUN(__glewBlendEquationiOES) +#define glBlendFuncSeparateiOES GLEW_GET_FUN(__glewBlendFuncSeparateiOES) +#define glBlendFunciOES GLEW_GET_FUN(__glewBlendFunciOES) +#define glColorMaskiOES GLEW_GET_FUN(__glewColorMaskiOES) +#define glDisableiOES GLEW_GET_FUN(__glewDisableiOES) +#define glEnableiOES GLEW_GET_FUN(__glewEnableiOES) +#define glIsEnablediOES GLEW_GET_FUN(__glewIsEnablediOES) + +#define GLEW_OES_draw_buffers_indexed GLEW_GET_VAR(__GLEW_OES_draw_buffers_indexed) + +#endif /* GL_OES_draw_buffers_indexed */ + +/* -------------------------- GL_OES_draw_texture -------------------------- */ + +#ifndef GL_OES_draw_texture +#define GL_OES_draw_texture 1 + +#define GL_TEXTURE_CROP_RECT_OES 0x8B9D + +#define GLEW_OES_draw_texture GLEW_GET_VAR(__GLEW_OES_draw_texture) + +#endif /* GL_OES_draw_texture */ + +/* ----------------------- GL_OES_element_index_uint ----------------------- */ + +#ifndef GL_OES_element_index_uint +#define GL_OES_element_index_uint 1 + +#define GL_UNSIGNED_INT 0x1405 + +#define GLEW_OES_element_index_uint GLEW_GET_VAR(__GLEW_OES_element_index_uint) + +#endif /* GL_OES_element_index_uint */ + +/* --------------------- GL_OES_extended_matrix_palette -------------------- */ + +#ifndef GL_OES_extended_matrix_palette +#define GL_OES_extended_matrix_palette 1 + +#define GLEW_OES_extended_matrix_palette GLEW_GET_VAR(__GLEW_OES_extended_matrix_palette) + +#endif /* GL_OES_extended_matrix_palette */ + +/* ------------------------ GL_OES_fbo_render_mipmap ----------------------- */ + +#ifndef GL_OES_fbo_render_mipmap +#define GL_OES_fbo_render_mipmap 1 + +#define GLEW_OES_fbo_render_mipmap GLEW_GET_VAR(__GLEW_OES_fbo_render_mipmap) + +#endif /* GL_OES_fbo_render_mipmap */ + +/* --------------------- GL_OES_fragment_precision_high -------------------- */ + +#ifndef GL_OES_fragment_precision_high +#define GL_OES_fragment_precision_high 1 + +#define GLEW_OES_fragment_precision_high GLEW_GET_VAR(__GLEW_OES_fragment_precision_high) + +#endif /* GL_OES_fragment_precision_high */ + +/* ----------------------- GL_OES_framebuffer_object ----------------------- */ + +#ifndef GL_OES_framebuffer_object +#define GL_OES_framebuffer_object 1 + +#define GL_NONE_OES 0 +#define GL_INVALID_FRAMEBUFFER_OPERATION_OES 0x0506 +#define GL_RGBA4_OES 0x8056 +#define GL_RGB5_A1_OES 0x8057 +#define GL_DEPTH_COMPONENT16_OES 0x81A5 +#define GL_MAX_RENDERBUFFER_SIZE_OES 0x84E8 +#define GL_FRAMEBUFFER_BINDING_OES 0x8CA6 +#define GL_RENDERBUFFER_BINDING_OES 0x8CA7 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE_OES 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES 0x8CDA +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED_OES 0x8CDD +#define GL_COLOR_ATTACHMENT0_OES 0x8CE0 +#define GL_DEPTH_ATTACHMENT_OES 0x8D00 +#define GL_STENCIL_ATTACHMENT_OES 0x8D20 +#define GL_FRAMEBUFFER_OES 0x8D40 +#define GL_RENDERBUFFER_OES 0x8D41 +#define GL_RENDERBUFFER_WIDTH_OES 0x8D42 +#define GL_RENDERBUFFER_HEIGHT_OES 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT_OES 0x8D44 +#define GL_STENCIL_INDEX1_OES 0x8D46 +#define GL_STENCIL_INDEX4_OES 0x8D47 +#define GL_STENCIL_INDEX8_OES 0x8D48 +#define GL_RENDERBUFFER_RED_SIZE_OES 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE_OES 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE_OES 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE_OES 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE_OES 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE_OES 0x8D55 +#define GL_RGB565_OES 0x8D62 + +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFEROESPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFEROESPROC) (GLenum target, GLuint renderbuffer); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSOESPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSOESPROC) (GLsizei n, const GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSOESPROC) (GLsizei n, const GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFEROESPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DOESPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSOESPROC) (GLsizei n, GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSOESPROC) (GLsizei n, GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPOESPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVOESPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFEROESPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFEROESPROC) (GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEOESPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + +#define glBindFramebufferOES GLEW_GET_FUN(__glewBindFramebufferOES) +#define glBindRenderbufferOES GLEW_GET_FUN(__glewBindRenderbufferOES) +#define glCheckFramebufferStatusOES GLEW_GET_FUN(__glewCheckFramebufferStatusOES) +#define glDeleteFramebuffersOES GLEW_GET_FUN(__glewDeleteFramebuffersOES) +#define glDeleteRenderbuffersOES GLEW_GET_FUN(__glewDeleteRenderbuffersOES) +#define glFramebufferRenderbufferOES GLEW_GET_FUN(__glewFramebufferRenderbufferOES) +#define glFramebufferTexture2DOES GLEW_GET_FUN(__glewFramebufferTexture2DOES) +#define glGenFramebuffersOES GLEW_GET_FUN(__glewGenFramebuffersOES) +#define glGenRenderbuffersOES GLEW_GET_FUN(__glewGenRenderbuffersOES) +#define glGenerateMipmapOES GLEW_GET_FUN(__glewGenerateMipmapOES) +#define glGetFramebufferAttachmentParameterivOES GLEW_GET_FUN(__glewGetFramebufferAttachmentParameterivOES) +#define glGetRenderbufferParameterivOES GLEW_GET_FUN(__glewGetRenderbufferParameterivOES) +#define glIsFramebufferOES GLEW_GET_FUN(__glewIsFramebufferOES) +#define glIsRenderbufferOES GLEW_GET_FUN(__glewIsRenderbufferOES) +#define glRenderbufferStorageOES GLEW_GET_FUN(__glewRenderbufferStorageOES) + +#define GLEW_OES_framebuffer_object GLEW_GET_VAR(__GLEW_OES_framebuffer_object) + +#endif /* GL_OES_framebuffer_object */ + +/* ----------------------- GL_OES_geometry_point_size ---------------------- */ + +#ifndef GL_OES_geometry_point_size +#define GL_OES_geometry_point_size 1 + +#define GL_GEOMETRY_SHADER_BIT_OES 0x00000004 +#define GL_LINES_ADJACENCY_OES 0xA +#define GL_LINE_STRIP_ADJACENCY_OES 0xB +#define GL_TRIANGLES_ADJACENCY_OES 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_OES 0xD +#define GL_LAYER_PROVOKING_VERTEX_OES 0x825E +#define GL_UNDEFINED_VERTEX_OES 0x8260 +#define GL_GEOMETRY_SHADER_INVOCATIONS_OES 0x887F +#define GL_GEOMETRY_LINKED_VERTICES_OUT_OES 0x8916 +#define GL_GEOMETRY_LINKED_INPUT_TYPE_OES 0x8917 +#define GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES 0x8A2C +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES 0x8A32 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES 0x8C29 +#define GL_PRIMITIVES_GENERATED_OES 0x8C87 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES 0x8DA8 +#define GL_GEOMETRY_SHADER_OES 0x8DD9 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES 0x8DE1 +#define GL_FIRST_VERTEX_CONVENTION_OES 0x8E4D +#define GL_LAST_VERTEX_CONVENTION_OES 0x8E4E +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES 0x8E5A +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES 0x90CD +#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES 0x90D7 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES 0x9124 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES 0x92CF +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES 0x92D5 +#define GL_REFERENCED_BY_GEOMETRY_SHADER_OES 0x9309 +#define GL_FRAMEBUFFER_DEFAULT_LAYERS_OES 0x9312 +#define GL_MAX_FRAMEBUFFER_LAYERS_OES 0x9317 + +#define GLEW_OES_geometry_point_size GLEW_GET_VAR(__GLEW_OES_geometry_point_size) + +#endif /* GL_OES_geometry_point_size */ + +/* ------------------------- GL_OES_geometry_shader ------------------------ */ + +#ifndef GL_OES_geometry_shader +#define GL_OES_geometry_shader 1 + +#define GL_GEOMETRY_SHADER_BIT_OES 0x00000004 +#define GL_LINES_ADJACENCY_OES 0xA +#define GL_LINE_STRIP_ADJACENCY_OES 0xB +#define GL_TRIANGLES_ADJACENCY_OES 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_OES 0xD +#define GL_LAYER_PROVOKING_VERTEX_OES 0x825E +#define GL_UNDEFINED_VERTEX_OES 0x8260 +#define GL_GEOMETRY_SHADER_INVOCATIONS_OES 0x887F +#define GL_GEOMETRY_LINKED_VERTICES_OUT_OES 0x8916 +#define GL_GEOMETRY_LINKED_INPUT_TYPE_OES 0x8917 +#define GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES 0x8A2C +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES 0x8A32 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES 0x8C29 +#define GL_PRIMITIVES_GENERATED_OES 0x8C87 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES 0x8DA8 +#define GL_GEOMETRY_SHADER_OES 0x8DD9 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES 0x8DE1 +#define GL_FIRST_VERTEX_CONVENTION_OES 0x8E4D +#define GL_LAST_VERTEX_CONVENTION_OES 0x8E4E +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES 0x8E5A +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES 0x90CD +#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES 0x90D7 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES 0x9124 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES 0x92CF +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES 0x92D5 +#define GL_REFERENCED_BY_GEOMETRY_SHADER_OES 0x9309 +#define GL_FRAMEBUFFER_DEFAULT_LAYERS_OES 0x9312 +#define GL_MAX_FRAMEBUFFER_LAYERS_OES 0x9317 + +#define GLEW_OES_geometry_shader GLEW_GET_VAR(__GLEW_OES_geometry_shader) + +#endif /* GL_OES_geometry_shader */ + +/* ----------------------- GL_OES_get_program_binary ----------------------- */ + +#ifndef GL_OES_get_program_binary +#define GL_OES_get_program_binary 1 + +#define GL_PROGRAM_BINARY_LENGTH_OES 0x8741 +#define GL_NUM_PROGRAM_BINARY_FORMATS_OES 0x87FE +#define GL_PROGRAM_BINARY_FORMATS_OES 0x87FF + +typedef void (GLAPIENTRY * PFNGLGETPROGRAMBINARYOESPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLenum *binaryFormat, void*binary); +typedef void (GLAPIENTRY * PFNGLPROGRAMBINARYOESPROC) (GLuint program, GLenum binaryFormat, const void *binary, GLint length); + +#define glGetProgramBinaryOES GLEW_GET_FUN(__glewGetProgramBinaryOES) +#define glProgramBinaryOES GLEW_GET_FUN(__glewProgramBinaryOES) + +#define GLEW_OES_get_program_binary GLEW_GET_VAR(__GLEW_OES_get_program_binary) + +#endif /* GL_OES_get_program_binary */ + +/* --------------------------- GL_OES_gpu_shader5 -------------------------- */ + +#ifndef GL_OES_gpu_shader5 +#define GL_OES_gpu_shader5 1 + +#define GLEW_OES_gpu_shader5 GLEW_GET_VAR(__GLEW_OES_gpu_shader5) + +#endif /* GL_OES_gpu_shader5 */ + +/* ---------------------------- GL_OES_mapbuffer --------------------------- */ + +#ifndef GL_OES_mapbuffer +#define GL_OES_mapbuffer 1 + +#define GL_WRITE_ONLY_OES 0x88B9 +#define GL_BUFFER_ACCESS_OES 0x88BB +#define GL_BUFFER_MAPPED_OES 0x88BC +#define GL_BUFFER_MAP_POINTER_OES 0x88BD + +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVOESPROC) (GLenum target, GLenum pname, void** params); +typedef void * (GLAPIENTRY * PFNGLMAPBUFFEROESPROC) (GLenum target, GLenum access); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFEROESPROC) (GLenum target); + +#define glGetBufferPointervOES GLEW_GET_FUN(__glewGetBufferPointervOES) +#define glMapBufferOES GLEW_GET_FUN(__glewMapBufferOES) +#define glUnmapBufferOES GLEW_GET_FUN(__glewUnmapBufferOES) + +#define GLEW_OES_mapbuffer GLEW_GET_VAR(__GLEW_OES_mapbuffer) + +#endif /* GL_OES_mapbuffer */ + +/* --------------------------- GL_OES_matrix_get --------------------------- */ + +#ifndef GL_OES_matrix_get +#define GL_OES_matrix_get 1 + +#define GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES 0x898d +#define GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES 0x898e +#define GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES 0x898f + +#define GLEW_OES_matrix_get GLEW_GET_VAR(__GLEW_OES_matrix_get) + +#endif /* GL_OES_matrix_get */ + +/* ------------------------- GL_OES_matrix_palette ------------------------- */ + +#ifndef GL_OES_matrix_palette +#define GL_OES_matrix_palette 1 + +#define GL_MAX_VERTEX_UNITS_OES 0x86A4 +#define GL_WEIGHT_ARRAY_TYPE_OES 0x86A9 +#define GL_WEIGHT_ARRAY_STRIDE_OES 0x86AA +#define GL_WEIGHT_ARRAY_SIZE_OES 0x86AB +#define GL_WEIGHT_ARRAY_POINTER_OES 0x86AC +#define GL_WEIGHT_ARRAY_OES 0x86AD +#define GL_MATRIX_PALETTE_OES 0x8840 +#define GL_MAX_PALETTE_MATRICES_OES 0x8842 +#define GL_CURRENT_PALETTE_MATRIX_OES 0x8843 +#define GL_MATRIX_INDEX_ARRAY_OES 0x8844 +#define GL_MATRIX_INDEX_ARRAY_SIZE_OES 0x8846 +#define GL_MATRIX_INDEX_ARRAY_TYPE_OES 0x8847 +#define GL_MATRIX_INDEX_ARRAY_STRIDE_OES 0x8848 +#define GL_MATRIX_INDEX_ARRAY_POINTER_OES 0x8849 +#define GL_WEIGHT_ARRAY_BUFFER_BINDING_OES 0x889E +#define GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES 0x8B9E + +typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXOESPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); +typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTEROESPROC) (GLint size, GLenum type, GLsizei stride, void *pointer); + +#define glCurrentPaletteMatrixOES GLEW_GET_FUN(__glewCurrentPaletteMatrixOES) +#define glMatrixIndexPointerOES GLEW_GET_FUN(__glewMatrixIndexPointerOES) +#define glWeightPointerOES GLEW_GET_FUN(__glewWeightPointerOES) + +#define GLEW_OES_matrix_palette GLEW_GET_VAR(__GLEW_OES_matrix_palette) + +#endif /* GL_OES_matrix_palette */ + +/* ---------------------- GL_OES_packed_depth_stencil ---------------------- */ + +#ifndef GL_OES_packed_depth_stencil +#define GL_OES_packed_depth_stencil 1 + +#define GL_DEPTH_STENCIL_OES 0x84F9 +#define GL_UNSIGNED_INT_24_8_OES 0x84FA +#define GL_DEPTH24_STENCIL8_OES 0x88F0 + +#define GLEW_OES_packed_depth_stencil GLEW_GET_VAR(__GLEW_OES_packed_depth_stencil) + +#endif /* GL_OES_packed_depth_stencil */ + +/* ------------------------ GL_OES_point_size_array ------------------------ */ + +#ifndef GL_OES_point_size_array +#define GL_OES_point_size_array 1 + +#define GL_POINT_SIZE_ARRAY_TYPE_OES 0x898A +#define GL_POINT_SIZE_ARRAY_STRIDE_OES 0x898B +#define GL_POINT_SIZE_ARRAY_POINTER_OES 0x898C +#define GL_POINT_SIZE_ARRAY_OES 0x8B9C +#define GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES 0x8B9F + +#define GLEW_OES_point_size_array GLEW_GET_VAR(__GLEW_OES_point_size_array) + +#endif /* GL_OES_point_size_array */ + +/* -------------------------- GL_OES_point_sprite -------------------------- */ + +#ifndef GL_OES_point_sprite +#define GL_OES_point_sprite 1 + +#define GL_POINT_SPRITE_OES 0x8861 +#define GL_COORD_REPLACE_OES 0x8862 + +#define GLEW_OES_point_sprite GLEW_GET_VAR(__GLEW_OES_point_sprite) + +#endif /* GL_OES_point_sprite */ + +/* --------------------------- GL_OES_read_format -------------------------- */ + +#ifndef GL_OES_read_format +#define GL_OES_read_format 1 + +#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B + +#define GLEW_OES_read_format GLEW_GET_VAR(__GLEW_OES_read_format) + +#endif /* GL_OES_read_format */ + +/* --------------------- GL_OES_required_internalformat -------------------- */ + +#ifndef GL_OES_required_internalformat +#define GL_OES_required_internalformat 1 + +#define GL_ALPHA8_OES 0x803C +#define GL_LUMINANCE8_OES 0x8040 +#define GL_LUMINANCE4_ALPHA4_OES 0x8043 +#define GL_LUMINANCE8_ALPHA8_OES 0x8045 +#define GL_RGB8_OES 0x8051 +#define GL_RGB10_EXT 0x8052 +#define GL_RGBA4_OES 0x8056 +#define GL_RGB5_A1_OES 0x8057 +#define GL_RGBA8_OES 0x8058 +#define GL_RGB10_A2_EXT 0x8059 +#define GL_DEPTH_COMPONENT16_OES 0x81A5 +#define GL_DEPTH_COMPONENT24_OES 0x81A6 +#define GL_DEPTH_COMPONENT32_OES 0x81A7 +#define GL_DEPTH24_STENCIL8_OES 0x88F0 +#define GL_RGB565_OES 0x8D62 + +#define GLEW_OES_required_internalformat GLEW_GET_VAR(__GLEW_OES_required_internalformat) + +#endif /* GL_OES_required_internalformat */ + +/* --------------------------- GL_OES_rgb8_rgba8 --------------------------- */ + +#ifndef GL_OES_rgb8_rgba8 +#define GL_OES_rgb8_rgba8 1 + +#define GL_RGB8_OES 0x8051 +#define GL_RGBA8_OES 0x8058 + +#define GLEW_OES_rgb8_rgba8 GLEW_GET_VAR(__GLEW_OES_rgb8_rgba8) + +#endif /* GL_OES_rgb8_rgba8 */ + +/* ------------------------- GL_OES_sample_shading ------------------------- */ + +#ifndef GL_OES_sample_shading +#define GL_OES_sample_shading 1 + +#define GL_SAMPLE_SHADING_OES 0x8C36 +#define GL_MIN_SAMPLE_SHADING_VALUE_OES 0x8C37 + +typedef void (GLAPIENTRY * PFNGLMINSAMPLESHADINGOESPROC) (GLfloat value); + +#define glMinSampleShadingOES GLEW_GET_FUN(__glewMinSampleShadingOES) + +#define GLEW_OES_sample_shading GLEW_GET_VAR(__GLEW_OES_sample_shading) + +#endif /* GL_OES_sample_shading */ + +/* ------------------------ GL_OES_sample_variables ------------------------ */ + +#ifndef GL_OES_sample_variables +#define GL_OES_sample_variables 1 + +#define GLEW_OES_sample_variables GLEW_GET_VAR(__GLEW_OES_sample_variables) + +#endif /* GL_OES_sample_variables */ + +/* ----------------------- GL_OES_shader_image_atomic ---------------------- */ + +#ifndef GL_OES_shader_image_atomic +#define GL_OES_shader_image_atomic 1 + +#define GLEW_OES_shader_image_atomic GLEW_GET_VAR(__GLEW_OES_shader_image_atomic) + +#endif /* GL_OES_shader_image_atomic */ + +/* ------------------------ GL_OES_shader_io_blocks ------------------------ */ + +#ifndef GL_OES_shader_io_blocks +#define GL_OES_shader_io_blocks 1 + +#define GLEW_OES_shader_io_blocks GLEW_GET_VAR(__GLEW_OES_shader_io_blocks) + +#endif /* GL_OES_shader_io_blocks */ + +/* ---------------- GL_OES_shader_multisample_interpolation ---------------- */ + +#ifndef GL_OES_shader_multisample_interpolation +#define GL_OES_shader_multisample_interpolation 1 + +#define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES 0x8E5B +#define GL_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES 0x8E5C +#define GL_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES 0x8E5D + +#define GLEW_OES_shader_multisample_interpolation GLEW_GET_VAR(__GLEW_OES_shader_multisample_interpolation) + +#endif /* GL_OES_shader_multisample_interpolation */ + +/* ------------------------ GL_OES_single_precision ------------------------ */ + +#ifndef GL_OES_single_precision +#define GL_OES_single_precision 1 + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFOESPROC) (GLclampf depth); +typedef void (GLAPIENTRY * PFNGLCLIPPLANEFOESPROC) (GLenum plane, const GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFOESPROC) (GLclampf n, GLclampf f); +typedef void (GLAPIENTRY * PFNGLFRUSTUMFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); +typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEFOESPROC) (GLenum plane, GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLORTHOFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); + +#define glClearDepthfOES GLEW_GET_FUN(__glewClearDepthfOES) +#define glClipPlanefOES GLEW_GET_FUN(__glewClipPlanefOES) +#define glDepthRangefOES GLEW_GET_FUN(__glewDepthRangefOES) +#define glFrustumfOES GLEW_GET_FUN(__glewFrustumfOES) +#define glGetClipPlanefOES GLEW_GET_FUN(__glewGetClipPlanefOES) +#define glOrthofOES GLEW_GET_FUN(__glewOrthofOES) + +#define GLEW_OES_single_precision GLEW_GET_VAR(__GLEW_OES_single_precision) + +#endif /* GL_OES_single_precision */ + +/* ---------------------- GL_OES_standard_derivatives ---------------------- */ + +#ifndef GL_OES_standard_derivatives +#define GL_OES_standard_derivatives 1 + +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES 0x8B8B + +#define GLEW_OES_standard_derivatives GLEW_GET_VAR(__GLEW_OES_standard_derivatives) + +#endif /* GL_OES_standard_derivatives */ + +/* ---------------------------- GL_OES_stencil1 ---------------------------- */ + +#ifndef GL_OES_stencil1 +#define GL_OES_stencil1 1 + +#define GL_STENCIL_INDEX1_OES 0x8D46 + +#define GLEW_OES_stencil1 GLEW_GET_VAR(__GLEW_OES_stencil1) + +#endif /* GL_OES_stencil1 */ + +/* ---------------------------- GL_OES_stencil4 ---------------------------- */ + +#ifndef GL_OES_stencil4 +#define GL_OES_stencil4 1 + +#define GL_STENCIL_INDEX4_OES 0x8D47 + +#define GLEW_OES_stencil4 GLEW_GET_VAR(__GLEW_OES_stencil4) + +#endif /* GL_OES_stencil4 */ + +/* ---------------------------- GL_OES_stencil8 ---------------------------- */ + +#ifndef GL_OES_stencil8 +#define GL_OES_stencil8 1 + +#define GL_STENCIL_INDEX8_OES 0x8D48 + +#define GLEW_OES_stencil8 GLEW_GET_VAR(__GLEW_OES_stencil8) + +#endif /* GL_OES_stencil8 */ + +/* ----------------------- GL_OES_surfaceless_context ---------------------- */ + +#ifndef GL_OES_surfaceless_context +#define GL_OES_surfaceless_context 1 + +#define GL_FRAMEBUFFER_UNDEFINED_OES 0x8219 + +#define GLEW_OES_surfaceless_context GLEW_GET_VAR(__GLEW_OES_surfaceless_context) + +#endif /* GL_OES_surfaceless_context */ + +/* --------------------- GL_OES_tessellation_point_size -------------------- */ + +#ifndef GL_OES_tessellation_point_size +#define GL_OES_tessellation_point_size 1 + +#define GL_QUADS_OES 0x0007 +#define GL_TESS_CONTROL_SHADER_BIT_OES 0x00000008 +#define GL_PATCHES_OES 0xE +#define GL_TESS_EVALUATION_SHADER_BIT_OES 0x00000010 +#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES 0x8221 +#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES 0x886C +#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES 0x886D +#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES 0x8E1E +#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES 0x8E1F +#define GL_PATCH_VERTICES_OES 0x8E72 +#define GL_TESS_CONTROL_OUTPUT_VERTICES_OES 0x8E75 +#define GL_TESS_GEN_MODE_OES 0x8E76 +#define GL_TESS_GEN_SPACING_OES 0x8E77 +#define GL_TESS_GEN_VERTEX_ORDER_OES 0x8E78 +#define GL_TESS_GEN_POINT_MODE_OES 0x8E79 +#define GL_ISOLINES_OES 0x8E7A +#define GL_FRACTIONAL_ODD_OES 0x8E7B +#define GL_FRACTIONAL_EVEN_OES 0x8E7C +#define GL_MAX_PATCH_VERTICES_OES 0x8E7D +#define GL_MAX_TESS_GEN_LEVEL_OES 0x8E7E +#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES 0x8E7F +#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES 0x8E80 +#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES 0x8E81 +#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES 0x8E82 +#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES 0x8E83 +#define GL_MAX_TESS_PATCH_COMPONENTS_OES 0x8E84 +#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES 0x8E85 +#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES 0x8E86 +#define GL_TESS_EVALUATION_SHADER_OES 0x8E87 +#define GL_TESS_CONTROL_SHADER_OES 0x8E88 +#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES 0x8E89 +#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES 0x8E8A +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES 0x90CC +#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES 0x90D8 +#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES 0x90D9 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES 0x92CE +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES 0x92D4 +#define GL_IS_PER_PATCH_OES 0x92E7 +#define GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES 0x9307 +#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES 0x9308 + +#define GLEW_OES_tessellation_point_size GLEW_GET_VAR(__GLEW_OES_tessellation_point_size) + +#endif /* GL_OES_tessellation_point_size */ + +/* ----------------------- GL_OES_tessellation_shader ---------------------- */ + +#ifndef GL_OES_tessellation_shader +#define GL_OES_tessellation_shader 1 + +#define GL_QUADS_OES 0x0007 +#define GL_TESS_CONTROL_SHADER_BIT_OES 0x00000008 +#define GL_PATCHES_OES 0xE +#define GL_TESS_EVALUATION_SHADER_BIT_OES 0x00000010 +#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES 0x8221 +#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES 0x886C +#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES 0x886D +#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES 0x8E1E +#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES 0x8E1F +#define GL_PATCH_VERTICES_OES 0x8E72 +#define GL_TESS_CONTROL_OUTPUT_VERTICES_OES 0x8E75 +#define GL_TESS_GEN_MODE_OES 0x8E76 +#define GL_TESS_GEN_SPACING_OES 0x8E77 +#define GL_TESS_GEN_VERTEX_ORDER_OES 0x8E78 +#define GL_TESS_GEN_POINT_MODE_OES 0x8E79 +#define GL_ISOLINES_OES 0x8E7A +#define GL_FRACTIONAL_ODD_OES 0x8E7B +#define GL_FRACTIONAL_EVEN_OES 0x8E7C +#define GL_MAX_PATCH_VERTICES_OES 0x8E7D +#define GL_MAX_TESS_GEN_LEVEL_OES 0x8E7E +#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES 0x8E7F +#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES 0x8E80 +#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES 0x8E81 +#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES 0x8E82 +#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES 0x8E83 +#define GL_MAX_TESS_PATCH_COMPONENTS_OES 0x8E84 +#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES 0x8E85 +#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES 0x8E86 +#define GL_TESS_EVALUATION_SHADER_OES 0x8E87 +#define GL_TESS_CONTROL_SHADER_OES 0x8E88 +#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES 0x8E89 +#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES 0x8E8A +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES 0x90CC +#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES 0x90D8 +#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES 0x90D9 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES 0x92CE +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES 0x92D4 +#define GL_IS_PER_PATCH_OES 0x92E7 +#define GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES 0x9307 +#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES 0x9308 + +#define GLEW_OES_tessellation_shader GLEW_GET_VAR(__GLEW_OES_tessellation_shader) + +#endif /* GL_OES_tessellation_shader */ + +/* --------------------------- GL_OES_texture_3D --------------------------- */ + +#ifndef GL_OES_texture_3D +#define GL_OES_texture_3D 1 + +#define GL_TEXTURE_BINDING_3D_OES 0x806A +#define GL_TEXTURE_3D_OES 0x806F +#define GL_TEXTURE_WRAP_R_OES 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE_OES 0x8073 + +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DOESPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DOESPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DOESPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DOESPROC) (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DOESPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); + +#define glCompressedTexImage3DOES GLEW_GET_FUN(__glewCompressedTexImage3DOES) +#define glCompressedTexSubImage3DOES GLEW_GET_FUN(__glewCompressedTexSubImage3DOES) +#define glCopyTexSubImage3DOES GLEW_GET_FUN(__glewCopyTexSubImage3DOES) +#define glFramebufferTexture3DOES GLEW_GET_FUN(__glewFramebufferTexture3DOES) +#define glTexImage3DOES GLEW_GET_FUN(__glewTexImage3DOES) +#define glTexSubImage3DOES GLEW_GET_FUN(__glewTexSubImage3DOES) + +#define GLEW_OES_texture_3D GLEW_GET_VAR(__GLEW_OES_texture_3D) + +#endif /* GL_OES_texture_3D */ + +/* ---------------------- GL_OES_texture_border_clamp ---------------------- */ + +#ifndef GL_OES_texture_border_clamp +#define GL_OES_texture_border_clamp 1 + +#define GL_TEXTURE_BORDER_COLOR_OES 0x1004 +#define GL_CLAMP_TO_BORDER_OES 0x812D + +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIIVOESPROC) (GLuint sampler, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSAMPLERPARAMETERIUIVOESPROC) (GLuint sampler, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVOESPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVOESPROC) (GLenum target, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIIVOESPROC) (GLuint sampler, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLSAMPLERPARAMETERIUIVOESPROC) (GLuint sampler, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVOESPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVOESPROC) (GLenum target, GLenum pname, const GLuint* params); + +#define glGetSamplerParameterIivOES GLEW_GET_FUN(__glewGetSamplerParameterIivOES) +#define glGetSamplerParameterIuivOES GLEW_GET_FUN(__glewGetSamplerParameterIuivOES) +#define glGetTexParameterIivOES GLEW_GET_FUN(__glewGetTexParameterIivOES) +#define glGetTexParameterIuivOES GLEW_GET_FUN(__glewGetTexParameterIuivOES) +#define glSamplerParameterIivOES GLEW_GET_FUN(__glewSamplerParameterIivOES) +#define glSamplerParameterIuivOES GLEW_GET_FUN(__glewSamplerParameterIuivOES) +#define glTexParameterIivOES GLEW_GET_FUN(__glewTexParameterIivOES) +#define glTexParameterIuivOES GLEW_GET_FUN(__glewTexParameterIuivOES) + +#define GLEW_OES_texture_border_clamp GLEW_GET_VAR(__GLEW_OES_texture_border_clamp) + +#endif /* GL_OES_texture_border_clamp */ + +/* ------------------------- GL_OES_texture_buffer ------------------------- */ + +#ifndef GL_OES_texture_buffer +#define GL_OES_texture_buffer 1 + +#define GL_TEXTURE_BUFFER_BINDING_OES 0x8C2A +#define GL_TEXTURE_BUFFER_OES 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_OES 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_OES 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES 0x8C2D +#define GL_SAMPLER_BUFFER_OES 0x8DC2 +#define GL_INT_SAMPLER_BUFFER_OES 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER_OES 0x8DD8 +#define GL_IMAGE_BUFFER_OES 0x9051 +#define GL_INT_IMAGE_BUFFER_OES 0x905C +#define GL_UNSIGNED_INT_IMAGE_BUFFER_OES 0x9067 +#define GL_TEXTURE_BUFFER_OFFSET_OES 0x919D +#define GL_TEXTURE_BUFFER_SIZE_OES 0x919E +#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES 0x919F + +typedef void (GLAPIENTRY * PFNGLTEXBUFFEROESPROC) (GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXBUFFERRANGEOESPROC) (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size); + +#define glTexBufferOES GLEW_GET_FUN(__glewTexBufferOES) +#define glTexBufferRangeOES GLEW_GET_FUN(__glewTexBufferRangeOES) + +#define GLEW_OES_texture_buffer GLEW_GET_VAR(__GLEW_OES_texture_buffer) + +#endif /* GL_OES_texture_buffer */ + +/* -------------------- GL_OES_texture_compression_astc -------------------- */ + +#ifndef GL_OES_texture_compression_astc +#define GL_OES_texture_compression_astc 1 + +#define GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0 +#define GL_COMPRESSED_RGBA_ASTC_5x4_KHR 0x93B1 +#define GL_COMPRESSED_RGBA_ASTC_5x5_KHR 0x93B2 +#define GL_COMPRESSED_RGBA_ASTC_6x5_KHR 0x93B3 +#define GL_COMPRESSED_RGBA_ASTC_6x6_KHR 0x93B4 +#define GL_COMPRESSED_RGBA_ASTC_8x5_KHR 0x93B5 +#define GL_COMPRESSED_RGBA_ASTC_8x6_KHR 0x93B6 +#define GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93B7 +#define GL_COMPRESSED_RGBA_ASTC_10x5_KHR 0x93B8 +#define GL_COMPRESSED_RGBA_ASTC_10x6_KHR 0x93B9 +#define GL_COMPRESSED_RGBA_ASTC_10x8_KHR 0x93BA +#define GL_COMPRESSED_RGBA_ASTC_10x10_KHR 0x93BB +#define GL_COMPRESSED_RGBA_ASTC_12x10_KHR 0x93BC +#define GL_COMPRESSED_RGBA_ASTC_12x12_KHR 0x93BD +#define GL_COMPRESSED_RGBA_ASTC_3x3x3_OES 0x93C0 +#define GL_COMPRESSED_RGBA_ASTC_4x3x3_OES 0x93C1 +#define GL_COMPRESSED_RGBA_ASTC_4x4x3_OES 0x93C2 +#define GL_COMPRESSED_RGBA_ASTC_4x4x4_OES 0x93C3 +#define GL_COMPRESSED_RGBA_ASTC_5x4x4_OES 0x93C4 +#define GL_COMPRESSED_RGBA_ASTC_5x5x4_OES 0x93C5 +#define GL_COMPRESSED_RGBA_ASTC_5x5x5_OES 0x93C6 +#define GL_COMPRESSED_RGBA_ASTC_6x5x5_OES 0x93C7 +#define GL_COMPRESSED_RGBA_ASTC_6x6x5_OES 0x93C8 +#define GL_COMPRESSED_RGBA_ASTC_6x6x6_OES 0x93C9 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR 0x93D0 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR 0x93D1 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR 0x93D2 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR 0x93D3 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR 0x93D4 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR 0x93D5 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR 0x93D6 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR 0x93D7 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR 0x93D8 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR 0x93D9 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR 0x93DA +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR 0x93DB +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR 0x93DC +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR 0x93DD +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES 0x93E0 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES 0x93E1 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES 0x93E2 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES 0x93E3 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES 0x93E4 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES 0x93E5 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES 0x93E6 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES 0x93E7 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES 0x93E8 +#define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES 0x93E9 + +#define GLEW_OES_texture_compression_astc GLEW_GET_VAR(__GLEW_OES_texture_compression_astc) + +#endif /* GL_OES_texture_compression_astc */ + +/* ------------------------ GL_OES_texture_cube_map ------------------------ */ + +#ifndef GL_OES_texture_cube_map +#define GL_OES_texture_cube_map 1 + +#define GL_TEXTURE_GEN_MODE_OES 0x2500 +#define GL_NORMAL_MAP_OES 0x8511 +#define GL_REFLECTION_MAP_OES 0x8512 +#define GL_TEXTURE_CUBE_MAP_OES 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_OES 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES 0x851A +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_OES 0x851C +#define GL_TEXTURE_GEN_STR_OES 0x8D60 + +typedef void (GLAPIENTRY * PFNGLGETTEXGENFVOESPROC) (GLenum coord, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETTEXGENIVOESPROC) (GLenum coord, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXGENXVOESPROC) (GLenum coord, GLenum pname, GLfixed* params); +typedef void (GLAPIENTRY * PFNGLTEXGENFOESPROC) (GLenum coord, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLTEXGENFVOESPROC) (GLenum coord, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLTEXGENIOESPROC) (GLenum coord, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLTEXGENIVOESPROC) (GLenum coord, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLTEXGENXOESPROC) (GLenum coord, GLenum pname, GLfixed param); +typedef void (GLAPIENTRY * PFNGLTEXGENXVOESPROC) (GLenum coord, GLenum pname, const GLfixed* params); + +#define glGetTexGenfvOES GLEW_GET_FUN(__glewGetTexGenfvOES) +#define glGetTexGenivOES GLEW_GET_FUN(__glewGetTexGenivOES) +#define glGetTexGenxvOES GLEW_GET_FUN(__glewGetTexGenxvOES) +#define glTexGenfOES GLEW_GET_FUN(__glewTexGenfOES) +#define glTexGenfvOES GLEW_GET_FUN(__glewTexGenfvOES) +#define glTexGeniOES GLEW_GET_FUN(__glewTexGeniOES) +#define glTexGenivOES GLEW_GET_FUN(__glewTexGenivOES) +#define glTexGenxOES GLEW_GET_FUN(__glewTexGenxOES) +#define glTexGenxvOES GLEW_GET_FUN(__glewTexGenxvOES) + +#define GLEW_OES_texture_cube_map GLEW_GET_VAR(__GLEW_OES_texture_cube_map) + +#endif /* GL_OES_texture_cube_map */ + +/* --------------------- GL_OES_texture_cube_map_array --------------------- */ + +#ifndef GL_OES_texture_cube_map_array +#define GL_OES_texture_cube_map_array 1 + +#define GL_TEXTURE_CUBE_MAP_ARRAY_OES 0x9009 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES 0x900A +#define GL_SAMPLER_CUBE_MAP_ARRAY_OES 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES 0x900D +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES 0x900E +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES 0x900F +#define GL_IMAGE_CUBE_MAP_ARRAY_OES 0x9054 +#define GL_INT_IMAGE_CUBE_MAP_ARRAY_OES 0x905F +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES 0x906A + +#define GLEW_OES_texture_cube_map_array GLEW_GET_VAR(__GLEW_OES_texture_cube_map_array) + +#endif /* GL_OES_texture_cube_map_array */ + +/* ---------------------- GL_OES_texture_env_crossbar ---------------------- */ + +#ifndef GL_OES_texture_env_crossbar +#define GL_OES_texture_env_crossbar 1 + +#define GLEW_OES_texture_env_crossbar GLEW_GET_VAR(__GLEW_OES_texture_env_crossbar) + +#endif /* GL_OES_texture_env_crossbar */ + +/* --------------------- GL_OES_texture_mirrored_repeat -------------------- */ + +#ifndef GL_OES_texture_mirrored_repeat +#define GL_OES_texture_mirrored_repeat 1 + +#define GL_MIRRORED_REPEAT 0x8370 + +#define GLEW_OES_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_OES_texture_mirrored_repeat) + +#endif /* GL_OES_texture_mirrored_repeat */ + +/* -------------------------- GL_OES_texture_npot -------------------------- */ + +#ifndef GL_OES_texture_npot +#define GL_OES_texture_npot 1 + +#define GLEW_OES_texture_npot GLEW_GET_VAR(__GLEW_OES_texture_npot) + +#endif /* GL_OES_texture_npot */ + +/* ------------------------ GL_OES_texture_stencil8 ------------------------ */ + +#ifndef GL_OES_texture_stencil8 +#define GL_OES_texture_stencil8 1 + +#define GL_STENCIL_INDEX 0x1901 +#define GL_STENCIL_INDEX8 0x8D48 + +#define GLEW_OES_texture_stencil8 GLEW_GET_VAR(__GLEW_OES_texture_stencil8) + +#endif /* GL_OES_texture_stencil8 */ + +/* -------------- GL_OES_texture_storage_multisample_2d_array -------------- */ + +#ifndef GL_OES_texture_storage_multisample_2d_array +#define GL_OES_texture_storage_multisample_2d_array 1 + +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES 0x9102 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES 0x9105 +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY_OES 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES 0x910D + +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC) (GLenum target, GLsizei samples, GLenum sizedinternalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); + +#define glTexStorage3DMultisampleOES GLEW_GET_FUN(__glewTexStorage3DMultisampleOES) + +#define GLEW_OES_texture_storage_multisample_2d_array GLEW_GET_VAR(__GLEW_OES_texture_storage_multisample_2d_array) + +#endif /* GL_OES_texture_storage_multisample_2d_array */ + +/* -------------------------- GL_OES_texture_view -------------------------- */ + +#ifndef GL_OES_texture_view +#define GL_OES_texture_view 1 + +#define GL_TEXTURE_VIEW_MIN_LEVEL_OES 0x82DB +#define GL_TEXTURE_VIEW_NUM_LEVELS_OES 0x82DC +#define GL_TEXTURE_VIEW_MIN_LAYER_OES 0x82DD +#define GL_TEXTURE_VIEW_NUM_LAYERS_OES 0x82DE +#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF + +typedef void (GLAPIENTRY * PFNGLTEXTUREVIEWOESPROC) (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); + +#define glTextureViewOES GLEW_GET_FUN(__glewTextureViewOES) + +#define GLEW_OES_texture_view GLEW_GET_VAR(__GLEW_OES_texture_view) + +#endif /* GL_OES_texture_view */ + +/* ----------------------- GL_OES_vertex_array_object ---------------------- */ + +#ifndef GL_OES_vertex_array_object +#define GL_OES_vertex_array_object 1 + +#define GL_VERTEX_ARRAY_BINDING_OES 0x85B5 + +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYOESPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSOESPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSOESPROC) (GLsizei n, GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYOESPROC) (GLuint array); + +#define glBindVertexArrayOES GLEW_GET_FUN(__glewBindVertexArrayOES) +#define glDeleteVertexArraysOES GLEW_GET_FUN(__glewDeleteVertexArraysOES) +#define glGenVertexArraysOES GLEW_GET_FUN(__glewGenVertexArraysOES) +#define glIsVertexArrayOES GLEW_GET_FUN(__glewIsVertexArrayOES) + +#define GLEW_OES_vertex_array_object GLEW_GET_VAR(__GLEW_OES_vertex_array_object) + +#endif /* GL_OES_vertex_array_object */ + +/* ------------------------ GL_OES_vertex_half_float ----------------------- */ + +#ifndef GL_OES_vertex_half_float +#define GL_OES_vertex_half_float 1 + +#define GL_HALF_FLOAT_OES 0x8D61 + +#define GLEW_OES_vertex_half_float GLEW_GET_VAR(__GLEW_OES_vertex_half_float) + +#endif /* GL_OES_vertex_half_float */ + +/* --------------------- GL_OES_vertex_type_10_10_10_2 --------------------- */ + +#ifndef GL_OES_vertex_type_10_10_10_2 +#define GL_OES_vertex_type_10_10_10_2 1 + +#define GL_UNSIGNED_INT_10_10_10_2_OES 0x8DF6 +#define GL_INT_10_10_10_2_OES 0x8DF7 + +#define GLEW_OES_vertex_type_10_10_10_2 GLEW_GET_VAR(__GLEW_OES_vertex_type_10_10_10_2) + +#endif /* GL_OES_vertex_type_10_10_10_2 */ + /* ---------------------------- GL_OML_interlace --------------------------- */ #ifndef GL_OML_interlace @@ -17532,8 +19733,10 @@ typedef void (GLAPIENTRY * PFNGLVIEWPORTSWIZZLENVPROC) (GLuint index, GLenum swi #define GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR 0x9633 typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews); #define glFramebufferTextureMultiviewOVR GLEW_GET_FUN(__glewFramebufferTextureMultiviewOVR) +#define glNamedFramebufferTextureMultiviewOVR GLEW_GET_FUN(__glewNamedFramebufferTextureMultiviewOVR) #define GLEW_OVR_multiview GLEW_GET_VAR(__GLEW_OVR_multiview) @@ -17776,6 +19979,48 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC) (void); #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +/* ----------------- GL_QCOM_shader_framebuffer_fetch_rate ----------------- */ + +#ifndef GL_QCOM_shader_framebuffer_fetch_rate +#define GL_QCOM_shader_framebuffer_fetch_rate 1 + +#define GLEW_QCOM_shader_framebuffer_fetch_rate GLEW_GET_VAR(__GLEW_QCOM_shader_framebuffer_fetch_rate) + +#endif /* GL_QCOM_shader_framebuffer_fetch_rate */ + +/* ------------------------ GL_QCOM_texture_foveated ----------------------- */ + +#ifndef GL_QCOM_texture_foveated +#define GL_QCOM_texture_foveated 1 + +#define GL_FOVEATION_ENABLE_BIT_QCOM 0x1 +#define GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM 0x2 +#define GL_TEXTURE_FOVEATED_FEATURE_BITS_QCOM 0x8BFB +#define GL_TEXTURE_FOVEATED_MIN_PIXEL_DENSITY_QCOM 0x8BFC +#define GL_TEXTURE_FOVEATED_FEATURE_QUERY_QCOM 0x8BFD +#define GL_TEXTURE_FOVEATED_NUM_FOCAL_POINTS_QUERY_QCOM 0x8BFE +#define GL_FRAMEBUFFER_INCOMPLETE_FOVEATION_QCOM 0x8BFF + +typedef void (GLAPIENTRY * PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC) (GLuint texture, GLuint layer, GLuint focalPoint, GLfloat focalX, GLfloat focalY, GLfloat gainX, GLfloat gainY, GLfloat foveaArea); + +#define glTextureFoveationParametersQCOM GLEW_GET_FUN(__glewTextureFoveationParametersQCOM) + +#define GLEW_QCOM_texture_foveated GLEW_GET_VAR(__GLEW_QCOM_texture_foveated) + +#endif /* GL_QCOM_texture_foveated */ + +/* --------------- GL_QCOM_texture_foveated_subsampled_layout -------------- */ + +#ifndef GL_QCOM_texture_foveated_subsampled_layout +#define GL_QCOM_texture_foveated_subsampled_layout 1 + +#define GL_FOVEATION_SUBSAMPLED_LAYOUT_METHOD_BIT_QCOM 0x4 +#define GL_MAX_SHADER_SUBSAMPLED_IMAGE_UNITS_QCOM 0x8FA1 + +#define GLEW_QCOM_texture_foveated_subsampled_layout GLEW_GET_VAR(__GLEW_QCOM_texture_foveated_subsampled_layout) + +#endif /* GL_QCOM_texture_foveated_subsampled_layout */ + /* ------------------------ GL_QCOM_tiled_rendering ------------------------ */ #ifndef GL_QCOM_tiled_rendering @@ -19808,6 +22053,17 @@ typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat* tc, #endif /* GL_SUN_vertex */ +/* -------------------------- GL_VIV_shader_binary ------------------------- */ + +#ifndef GL_VIV_shader_binary +#define GL_VIV_shader_binary 1 + +#define GL_SHADER_BINARY_VIV 0x8FC4 + +#define GLEW_VIV_shader_binary GLEW_GET_VAR(__GLEW_VIV_shader_binary) + +#endif /* GL_VIV_shader_binary */ + /* -------------------------- GL_WIN_phong_shading ------------------------- */ #ifndef GL_WIN_phong_shading @@ -20172,6 +22428,9 @@ GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSepa GLEW_FUN_EXPORT PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC __glewNamedRenderbufferStorageMultisampleAdvancedAMD; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC __glewRenderbufferStorageMultisampleAdvancedAMD; + GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewFramebufferSamplePositionsfvAMD; GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC __glewGetFramebufferParameterfvAMD; GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC __glewGetNamedFramebufferParameterfvAMD; @@ -21223,6 +23482,9 @@ GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI; +GLEW_FUN_EXPORT PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC __glewEGLImageTargetTexStorageEXT; +GLEW_FUN_EXPORT PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC __glewEGLImageTargetTextureStorageEXT; + GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __glewDrawArraysInstancedBaseInstanceEXT; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseInstanceEXT; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseVertexBaseInstanceEXT; @@ -21249,6 +23511,8 @@ GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT; GLEW_FUN_EXPORT PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT; GLEW_FUN_EXPORT PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT; +GLEW_FUN_EXPORT PFNGLCLIPCONTROLEXTPROC __glewClipControlEXT; + GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT; GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT; @@ -21509,6 +23773,16 @@ GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffse GLEW_FUN_EXPORT PFNGLDISCARDFRAMEBUFFEREXTPROC __glewDiscardFramebufferEXT; +GLEW_FUN_EXPORT PFNGLBEGINQUERYEXTPROC __glewBeginQueryEXT; +GLEW_FUN_EXPORT PFNGLDELETEQUERIESEXTPROC __glewDeleteQueriesEXT; +GLEW_FUN_EXPORT PFNGLENDQUERYEXTPROC __glewEndQueryEXT; +GLEW_FUN_EXPORT PFNGLGENQUERIESEXTPROC __glewGenQueriesEXT; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVEXTPROC __glewGetQueryObjectivEXT; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVEXTPROC __glewGetQueryObjectuivEXT; +GLEW_FUN_EXPORT PFNGLGETQUERYIVEXTPROC __glewGetQueryivEXT; +GLEW_FUN_EXPORT PFNGLISQUERYEXTPROC __glewIsQueryEXT; +GLEW_FUN_EXPORT PFNGLQUERYCOUNTEREXTPROC __glewQueryCounterEXT; + GLEW_FUN_EXPORT PFNGLDRAWBUFFERSEXTPROC __glewDrawBuffersEXT; GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT; @@ -21537,6 +23811,9 @@ GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKEXTPROC __glewDrawTransformFeedbackEXT; +GLEW_FUN_EXPORT PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC __glewDrawTransformFeedbackInstancedEXT; + GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEEXTERNALEXTPROC __glewBufferStorageExternalEXT; GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC __glewNamedBufferStorageExternalEXT; @@ -21719,6 +23996,10 @@ GLEW_FUN_EXPORT PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTable GLEW_FUN_EXPORT PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV; GLEW_FUN_EXPORT PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT; +GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT; +GLEW_FUN_EXPORT PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT; + GLEW_FUN_EXPORT PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT; GLEW_FUN_EXPORT PFNGLENDSCENEEXTPROC __glewEndSceneEXT; @@ -21757,6 +24038,8 @@ GLEW_FUN_EXPORT PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT; GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT; GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC __glewFramebufferFetchBarrierEXT; + GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT; GLEW_FUN_EXPORT PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT; @@ -21773,10 +24056,17 @@ GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLPATCHPARAMETERIEXTPROC __glewPatchParameteriEXT; + GLEW_FUN_EXPORT PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIIVEXTPROC __glewGetSamplerParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIUIVEXTPROC __glewGetSamplerParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIIVEXTPROC __glewSamplerParameterIivEXT; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIUIVEXTPROC __glewSamplerParameterIuivEXT; + GLEW_FUN_EXPORT PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT; GLEW_FUN_EXPORT PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT; @@ -21894,6 +24184,8 @@ GLEW_FUN_EXPORT PFNGLWINDOWRECTANGLESEXTPROC __glewWindowRectanglesEXT; GLEW_FUN_EXPORT PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT; +GLEW_FUN_EXPORT PFNGLUTEXFILTERFUNCSGIPROC __glewuTexFilterFuncSGI; + GLEW_FUN_EXPORT PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY; GLEW_FUN_EXPORT PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY; @@ -21917,6 +24209,19 @@ GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointe GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM; GLEW_FUN_EXPORT PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM; +GLEW_FUN_EXPORT PFNGLGETTEXTUREHANDLEIMGPROC __glewGetTextureHandleIMG; +GLEW_FUN_EXPORT PFNGLGETTEXTURESAMPLERHANDLEIMGPROC __glewGetTextureSamplerHandleIMG; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64IMGPROC __glewProgramUniformHandleui64IMG; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMHANDLEUI64VIMGPROC __glewProgramUniformHandleui64vIMG; +GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64IMGPROC __glewUniformHandleui64IMG; +GLEW_FUN_EXPORT PFNGLUNIFORMHANDLEUI64VIMGPROC __glewUniformHandleui64vIMG; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC __glewFramebufferTexture2DDownsampleIMG; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferTextureLayerDownsampleIMG; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG; + GLEW_FUN_EXPORT PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL; GLEW_FUN_EXPORT PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL; GLEW_FUN_EXPORT PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL; @@ -22227,6 +24532,18 @@ GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORNVPROC __glewVertexAttribDivisorNV; GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV; +GLEW_FUN_EXPORT PFNGLBUFFERATTACHMEMORYNVPROC __glewBufferAttachMemoryNV; +GLEW_FUN_EXPORT PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC __glewGetMemoryObjectDetachedResourcesuivNV; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERATTACHMEMORYNVPROC __glewNamedBufferAttachMemoryNV; +GLEW_FUN_EXPORT PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectParameterNV; +GLEW_FUN_EXPORT PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV; +GLEW_FUN_EXPORT PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV; + +GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV; +GLEW_FUN_EXPORT PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV; +GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV; +GLEW_FUN_EXPORT PFNGLMULTIDRAWMESHTASKSINDIRECTNVPROC __glewMultiDrawMeshTasksIndirectNV; + GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3FVNVPROC __glewUniformMatrix2x3fvNV; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4FVNVPROC __glewUniformMatrix2x4fvNV; GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2FVNVPROC __glewUniformMatrix3x2fvNV; @@ -22329,6 +24646,8 @@ GLEW_FUN_EXPORT PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV; GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV; GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV; +GLEW_FUN_EXPORT PFNGLREADBUFFERNVPROC __glewReadBufferNV; + GLEW_FUN_EXPORT PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV; GLEW_FUN_EXPORT PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV; GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV; @@ -22348,6 +24667,10 @@ GLEW_FUN_EXPORT PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStagePar GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewFramebufferSampleLocationsfvNV; GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewNamedFramebufferSampleLocationsfvNV; +GLEW_FUN_EXPORT PFNGLRESOLVEDEPTHVALUESNVPROC __glewResolveDepthValuesNV; + +GLEW_FUN_EXPORT PFNGLSCISSOREXCLUSIVEARRAYVNVPROC __glewScissorExclusiveArrayvNV; +GLEW_FUN_EXPORT PFNGLSCISSOREXCLUSIVENVPROC __glewScissorExclusiveNV; GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV; GLEW_FUN_EXPORT PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV; @@ -22363,6 +24686,13 @@ GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64NVPROC __glewUniformui64NV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV; +GLEW_FUN_EXPORT PFNGLBINDSHADINGRATEIMAGENVPROC __glewBindShadingRateImageNV; +GLEW_FUN_EXPORT PFNGLGETSHADINGRATEIMAGEPALETTENVPROC __glewGetShadingRateImagePaletteNV; +GLEW_FUN_EXPORT PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSampleLocationivNV; +GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV; +GLEW_FUN_EXPORT PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV; +GLEW_FUN_EXPORT PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV; + GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV; GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV; GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DNVPROC __glewCopyTexSubImage3DNV; @@ -22539,7 +24869,102 @@ GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFVNVPROC __glewViewportIndexedfvNV; GLEW_FUN_EXPORT PFNGLVIEWPORTSWIZZLENVPROC __glewViewportSwizzleNV; +GLEW_FUN_EXPORT PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC __glewEGLImageTargetRenderbufferStorageOES; +GLEW_FUN_EXPORT PFNGLEGLIMAGETARGETTEXTURE2DOESPROC __glewEGLImageTargetTexture2DOES; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEOESPROC __glewBlendEquationSeparateOES; + +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEOESPROC __glewBlendFuncSeparateOES; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONOESPROC __glewBlendEquationOES; + +GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATAOESPROC __glewCopyImageSubDataOES; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIOESPROC __glewBlendEquationSeparateiOES; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIOESPROC __glewBlendEquationiOES; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIOESPROC __glewBlendFuncSeparateiOES; +GLEW_FUN_EXPORT PFNGLBLENDFUNCIOESPROC __glewBlendFunciOES; +GLEW_FUN_EXPORT PFNGLCOLORMASKIOESPROC __glewColorMaskiOES; +GLEW_FUN_EXPORT PFNGLDISABLEIOESPROC __glewDisableiOES; +GLEW_FUN_EXPORT PFNGLENABLEIOESPROC __glewEnableiOES; +GLEW_FUN_EXPORT PFNGLISENABLEDIOESPROC __glewIsEnablediOES; + +GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEROESPROC __glewBindFramebufferOES; +GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFEROESPROC __glewBindRenderbufferOES; +GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSOESPROC __glewCheckFramebufferStatusOES; +GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSOESPROC __glewDeleteFramebuffersOES; +GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSOESPROC __glewDeleteRenderbuffersOES; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFEROESPROC __glewFramebufferRenderbufferOES; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DOESPROC __glewFramebufferTexture2DOES; +GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSOESPROC __glewGenFramebuffersOES; +GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSOESPROC __glewGenRenderbuffersOES; +GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPOESPROC __glewGenerateMipmapOES; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC __glewGetFramebufferAttachmentParameterivOES; +GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVOESPROC __glewGetRenderbufferParameterivOES; +GLEW_FUN_EXPORT PFNGLISFRAMEBUFFEROESPROC __glewIsFramebufferOES; +GLEW_FUN_EXPORT PFNGLISRENDERBUFFEROESPROC __glewIsRenderbufferOES; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEOESPROC __glewRenderbufferStorageOES; + +GLEW_FUN_EXPORT PFNGLGETPROGRAMBINARYOESPROC __glewGetProgramBinaryOES; +GLEW_FUN_EXPORT PFNGLPROGRAMBINARYOESPROC __glewProgramBinaryOES; + +GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVOESPROC __glewGetBufferPointervOES; +GLEW_FUN_EXPORT PFNGLMAPBUFFEROESPROC __glewMapBufferOES; +GLEW_FUN_EXPORT PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES; + +GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES; +GLEW_FUN_EXPORT PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES; + +GLEW_FUN_EXPORT PFNGLMINSAMPLESHADINGOESPROC __glewMinSampleShadingOES; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES; +GLEW_FUN_EXPORT PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES; +GLEW_FUN_EXPORT PFNGLFRUSTUMFOESPROC __glewFrustumfOES; +GLEW_FUN_EXPORT PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES; +GLEW_FUN_EXPORT PFNGLORTHOFOESPROC __glewOrthofOES; + +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DOESPROC __glewCompressedTexImage3DOES; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC __glewCompressedTexSubImage3DOES; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DOESPROC __glewCopyTexSubImage3DOES; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DOESPROC __glewFramebufferTexture3DOES; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DOESPROC __glewTexImage3DOES; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DOESPROC __glewTexSubImage3DOES; + +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIIVOESPROC __glewGetSamplerParameterIivOES; +GLEW_FUN_EXPORT PFNGLGETSAMPLERPARAMETERIUIVOESPROC __glewGetSamplerParameterIuivOES; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVOESPROC __glewGetTexParameterIivOES; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVOESPROC __glewGetTexParameterIuivOES; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIIVOESPROC __glewSamplerParameterIivOES; +GLEW_FUN_EXPORT PFNGLSAMPLERPARAMETERIUIVOESPROC __glewSamplerParameterIuivOES; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVOESPROC __glewTexParameterIivOES; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVOESPROC __glewTexParameterIuivOES; + +GLEW_FUN_EXPORT PFNGLTEXBUFFEROESPROC __glewTexBufferOES; +GLEW_FUN_EXPORT PFNGLTEXBUFFERRANGEOESPROC __glewTexBufferRangeOES; + +GLEW_FUN_EXPORT PFNGLGETTEXGENFVOESPROC __glewGetTexGenfvOES; +GLEW_FUN_EXPORT PFNGLGETTEXGENIVOESPROC __glewGetTexGenivOES; +GLEW_FUN_EXPORT PFNGLGETTEXGENXVOESPROC __glewGetTexGenxvOES; +GLEW_FUN_EXPORT PFNGLTEXGENFOESPROC __glewTexGenfOES; +GLEW_FUN_EXPORT PFNGLTEXGENFVOESPROC __glewTexGenfvOES; +GLEW_FUN_EXPORT PFNGLTEXGENIOESPROC __glewTexGeniOES; +GLEW_FUN_EXPORT PFNGLTEXGENIVOESPROC __glewTexGenivOES; +GLEW_FUN_EXPORT PFNGLTEXGENXOESPROC __glewTexGenxOES; +GLEW_FUN_EXPORT PFNGLTEXGENXVOESPROC __glewTexGenxvOES; + +GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC __glewTexStorage3DMultisampleOES; + +GLEW_FUN_EXPORT PFNGLTEXTUREVIEWOESPROC __glewTextureViewOES; + +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYOESPROC __glewBindVertexArrayOES; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSOESPROC __glewDeleteVertexArraysOES; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSOESPROC __glewGenVertexArraysOES; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYOESPROC __glewIsVertexArrayOES; + GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewNamedFramebufferTextureMultiviewOVR; GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __glewFramebufferTextureMultisampleMultiviewOVR; @@ -22569,6 +24994,8 @@ GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFov GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM; +GLEW_FUN_EXPORT PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM; + GLEW_FUN_EXPORT PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM; GLEW_FUN_EXPORT PFNGLSTARTTILINGQCOMPROC __glewStartTilingQCOM; @@ -22843,9 +25270,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_AMD_conservative_depth; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_debug_output; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_depth_clamp_separate; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_draw_buffers_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_framebuffer_multisample_advanced; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_framebuffer_sample_positions; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gcn_shader; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_half_float; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_half_float_fetch; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_int16; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_int64; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_interleaved_elements; @@ -22861,6 +25290,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_AMD_seamless_cubemap_per_texture; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_atomic_counter_ops; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_ballot; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_explicit_vertex_parameter; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_image_load_store_lod; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_value_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_trinary_minmax; @@ -23110,11 +25540,13 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_mirror_once; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_attrib_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_streams; -GLEW_VAR_EXPORT GLboolean __GLEW_EGL_KHR_context_flush_control; -GLEW_VAR_EXPORT GLboolean __GLEW_EGL_NV_robustness_video_memory_purge; +GLEW_VAR_EXPORT GLboolean __GLEW_DMP_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_DMP_shader_binary; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_422_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_external_wrap_modes; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_EGL_image_storage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_YUV_target; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_base_instance; @@ -23129,6 +25561,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_subtract; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_buffer_storage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clear_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_control; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_cull_distance; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_volume_hint; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cmyka; @@ -23148,12 +25581,14 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_debug_marker; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_depth_bounds_test; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_direct_state_access; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_discard_framebuffer; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_disjoint_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers2; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers_indexed; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_elements_base_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_instanced; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_range_elements; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_transform_feedback; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_external_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_float_blend; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; @@ -23190,6 +25625,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisample_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisampled_render_to_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisampled_render_to_texture2; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multiview_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_occlusion_query_boolean; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_float; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_pixels; @@ -23201,12 +25637,14 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_point_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_post_depth_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_protected_textures; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_provoking_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pvrtc_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_raster_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_read_format_bgra; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_render_snorm; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_rescale_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_robustness; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sRGB_write_control; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker; @@ -23217,6 +25655,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_win32; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_shader_objects; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_group_vote; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_formatted; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_store; @@ -23232,13 +25671,18 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_samplers; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sparse_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sparse_texture2; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_static_vertex_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_clear_tag; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_two_side; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_wrap; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_subtexture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_tessellation_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_tessellation_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture3D; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_astc_decode_mode; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5; @@ -23247,6 +25691,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_dxt1; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_latc; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_rgtc; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_s3tc_srgb; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_edge_clamp; @@ -23257,9 +25702,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_dot3; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_anisotropic; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_format_BGRA8888; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_format_sRGB_override; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_integer; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_lod_bias; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_mirror_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_mirror_clamp_to_edge; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_norm16; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal; @@ -23287,6 +25734,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_weighting; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_win32_keyed_mutex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_window_rectangles; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_x11_sync_object; +GLEW_VAR_EXPORT GLboolean __GLEW_FJ_shader_binary_GCCSO; +GLEW_VAR_EXPORT GLboolean __GLEW_GLU_EXT_nurbs_tessellator; +GLEW_VAR_EXPORT GLboolean __GLEW_GLU_EXT_object_space_tess; +GLEW_VAR_EXPORT GLboolean __GLEW_GLU_SGIX_icc_compress; +GLEW_VAR_EXPORT GLboolean __GLEW_GLU_SGI_filter4_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_frame_terminator; GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_string_marker; GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes; @@ -23299,8 +25751,19 @@ GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_static_data; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_texture_mirrored_repeat; GLEW_VAR_EXPORT GLboolean __GLEW_IBM_vertex_array_lists; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_bindless_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_framebuffer_downsample; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_multisampled_render_to_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_read_format; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_shader_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_compression_pvrtc2; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function; +GLEW_VAR_EXPORT GLboolean __GLEW_IMG_texture_filter_cubic; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read; +GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_blackhole_render; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_conservative_rasterization; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_fragment_shader_ordering; GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_framebuffer_CMAA; @@ -23321,9 +25784,12 @@ GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_ldr; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d; GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region; GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_framebuffer_flip_y; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_program_binary_formats; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_shader_integer_functions; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_tile_raster_order; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos; GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_blend_equation_advanced_multi_draw_buffers; @@ -23344,16 +25810,20 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_square; GLEW_VAR_EXPORT GLboolean __GLEW_NV_clip_space_w_scaling; GLEW_VAR_EXPORT GLboolean __GLEW_NV_command_list; GLEW_VAR_EXPORT GLboolean __GLEW_NV_compute_program5; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_compute_shader_derivatives; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conditional_render; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster_dilate; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster_pre_snap; GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster_pre_snap_triangles; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_conservative_raster_underestimation; GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_depth_to_color; GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_image; GLEW_VAR_EXPORT GLboolean __GLEW_NV_deep_texture3D; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_buffer_float; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_nonlinear; GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_range_unclamped; GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_instanced; @@ -23372,6 +25842,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program_option; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_shader_barycentric; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_shader_interlock; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_mixed_samples; @@ -23392,6 +25863,8 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_image_formats; GLEW_VAR_EXPORT GLboolean __GLEW_NV_instanced_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_NV_internalformat_sample_query; GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_memory_attachment; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_mesh_shader; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; GLEW_VAR_EXPORT GLboolean __GLEW_NV_non_square_matrices; @@ -23411,15 +25884,20 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite; GLEW_VAR_EXPORT GLboolean __GLEW_NV_polygon_mode; GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video; GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_query_resource_tag; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_buffer_front; GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_depth; GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_NV_read_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners; GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_representative_fragment_test; GLEW_VAR_EXPORT GLboolean __GLEW_NV_robustness_video_memory_purge; GLEW_VAR_EXPORT GLboolean __GLEW_NV_sRGB_formats; GLEW_VAR_EXPORT GLboolean __GLEW_NV_sample_locations; GLEW_VAR_EXPORT GLboolean __GLEW_NV_sample_mask_override_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_scissor_exclusive; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_counters; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_float; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_float64; @@ -23428,8 +25906,10 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_int64; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_buffer_load; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_noperspective_interpolation; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_storage_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_texture_footprint; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_thread_group; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_thread_shuffle; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_shading_rate_image; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shadow_samplers_array; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shadow_samplers_cube; GLEW_VAR_EXPORT GLboolean __GLEW_NV_stereo_view_rendering; @@ -23470,7 +25950,68 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_video_capture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_viewport_array; GLEW_VAR_EXPORT GLboolean __GLEW_NV_viewport_array2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_viewport_swizzle; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_EGL_image; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_EGL_image_external; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_EGL_image_external_essl3; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_blend_equation_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_blend_func_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_blend_subtract; GLEW_VAR_EXPORT GLboolean __GLEW_OES_byte_coordinates; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_ETC1_RGB8_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_paletted_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_copy_image; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_depth24; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_depth32; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_depth_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_draw_buffers_indexed; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_draw_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_element_index_uint; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_extended_matrix_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_fbo_render_mipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_fragment_precision_high; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_framebuffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_geometry_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_geometry_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_get_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_gpu_shader5; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_mapbuffer; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_matrix_get; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_matrix_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_point_size_array; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_read_format; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_required_internalformat; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_rgb8_rgba8; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_sample_shading; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_sample_variables; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_shader_image_atomic; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_shader_io_blocks; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_shader_multisample_interpolation; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_single_precision; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_standard_derivatives; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_stencil1; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_stencil4; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_stencil8; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_surfaceless_context; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_tessellation_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_tessellation_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_3D; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_compression_astc; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_cube_map_array; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_env_crossbar; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_mirrored_repeat; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_npot; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_stencil8; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_storage_multisample_2d_array; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_texture_view; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_vertex_half_float; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_vertex_type_10_10_10_2; GLEW_VAR_EXPORT GLboolean __GLEW_OML_interlace; GLEW_VAR_EXPORT GLboolean __GLEW_OML_resample; GLEW_VAR_EXPORT GLboolean __GLEW_OML_subsample; @@ -23487,6 +26028,9 @@ GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get2; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_framebuffer_foveated; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_perfmon_global_mode; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_tiled_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_writeonly_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_0_compatibility; @@ -23612,6 +26156,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_SUN_read_video_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_slice_accum; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_triangle_list; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_VIV_shader_binary; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_phong_shading; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_scene_markerXXX; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_specular_fog; @@ -23637,9 +26182,9 @@ GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; /* GLEW version info */ /* -VERSION 2.1.0 +VERSION 2.2.0 VERSION_MAJOR 2 -VERSION_MINOR 1 +VERSION_MINOR 2 VERSION_MICRO 0 */ diff --git a/include/GL/glxew.h b/include/GL/glxew.h index 7e39c2f..0ac521e 100644 --- a/include/GL/glxew.h +++ b/include/GL/glxew.h @@ -392,6 +392,10 @@ typedef Bool ( * PFNGLXMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (GLXContext ctx); #ifndef GLX_ARB_context_flush_control #define GLX_ARB_context_flush_control 1 +#define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0x0000 +#define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097 +#define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098 + #define GLXEW_ARB_context_flush_control GLXEW_GET_VAR(__GLXEW_ARB_context_flush_control) #endif /* GLX_ARB_context_flush_control */ @@ -686,6 +690,15 @@ typedef int ( * PFNGLXQUERYCONTEXTINFOEXTPROC) (Display* dpy, GLXContext context #endif /* GLX_EXT_libglvnd */ +/* ----------------------- GLX_EXT_no_config_context ----------------------- */ + +#ifndef GLX_EXT_no_config_context +#define GLX_EXT_no_config_context 1 + +#define GLXEW_EXT_no_config_context GLXEW_GET_VAR(__GLXEW_EXT_no_config_context) + +#endif /* GLX_EXT_no_config_context */ + /* -------------------------- GLX_EXT_scene_marker ------------------------- */ #ifndef GLX_EXT_scene_marker @@ -1708,6 +1721,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_fbconfig_packed_float; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_framebuffer_sRGB; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_import_context; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_libglvnd; +GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_no_config_context; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_scene_marker; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_stereo_tree; GLXEW_VAR_EXPORT GLboolean __GLXEW_EXT_swap_control; diff --git a/include/GL/wglew.h b/include/GL/wglew.h index 2097c0f..a1be437 100644 --- a/include/GL/wglew.h +++ b/include/GL/wglew.h @@ -188,6 +188,10 @@ typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, in #ifndef WGL_ARB_context_flush_control #define WGL_ARB_context_flush_control 1 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB 0x0000 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB 0x2097 +#define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098 + #define WGLEW_ARB_context_flush_control WGLEW_GET_VAR(__WGLEW_ARB_context_flush_control) #endif /* WGL_ARB_context_flush_control */ diff --git a/src/glew.c b/src/glew.c index 03d4da6..1bfa7ab 100644 --- a/src/glew.c +++ b/src/glew.c @@ -635,6 +635,9 @@ PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL; PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC __glewNamedRenderbufferStorageMultisampleAdvancedAMD = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC __glewRenderbufferStorageMultisampleAdvancedAMD = NULL; + PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewFramebufferSamplePositionsfvAMD = NULL; PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC __glewGetFramebufferParameterfvAMD = NULL; PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC __glewGetNamedFramebufferParameterfvAMD = NULL; @@ -1686,6 +1689,9 @@ PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL; PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL; PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL; +PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC __glewEGLImageTargetTexStorageEXT = NULL; +PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC __glewEGLImageTargetTextureStorageEXT = NULL; + PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __glewDrawArraysInstancedBaseInstanceEXT = NULL; PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseInstanceEXT = NULL; PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseVertexBaseInstanceEXT = NULL; @@ -1712,6 +1718,8 @@ PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL; PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT = NULL; PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT = NULL; +PFNGLCLIPCONTROLEXTPROC __glewClipControlEXT = NULL; + PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL; PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL; @@ -1972,6 +1980,16 @@ PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL; PFNGLDISCARDFRAMEBUFFEREXTPROC __glewDiscardFramebufferEXT = NULL; +PFNGLBEGINQUERYEXTPROC __glewBeginQueryEXT = NULL; +PFNGLDELETEQUERIESEXTPROC __glewDeleteQueriesEXT = NULL; +PFNGLENDQUERYEXTPROC __glewEndQueryEXT = NULL; +PFNGLGENQUERIESEXTPROC __glewGenQueriesEXT = NULL; +PFNGLGETQUERYOBJECTIVEXTPROC __glewGetQueryObjectivEXT = NULL; +PFNGLGETQUERYOBJECTUIVEXTPROC __glewGetQueryObjectuivEXT = NULL; +PFNGLGETQUERYIVEXTPROC __glewGetQueryivEXT = NULL; +PFNGLISQUERYEXTPROC __glewIsQueryEXT = NULL; +PFNGLQUERYCOUNTEREXTPROC __glewQueryCounterEXT = NULL; + PFNGLDRAWBUFFERSEXTPROC __glewDrawBuffersEXT = NULL; PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL; @@ -2000,6 +2018,9 @@ PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL; PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL; +PFNGLDRAWTRANSFORMFEEDBACKEXTPROC __glewDrawTransformFeedbackEXT = NULL; +PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC __glewDrawTransformFeedbackInstancedEXT = NULL; + PFNGLBUFFERSTORAGEEXTERNALEXTPROC __glewBufferStorageExternalEXT = NULL; PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC __glewNamedBufferStorageExternalEXT = NULL; @@ -2182,6 +2203,10 @@ PFNGLCOVERAGEMODULATIONTABLENVPROC __glewCoverageModulationTableNV = NULL; PFNGLGETCOVERAGEMODULATIONTABLENVPROC __glewGetCoverageModulationTableNV = NULL; PFNGLRASTERSAMPLESEXTPROC __glewRasterSamplesEXT = NULL; +PFNGLGETNUNIFORMFVEXTPROC __glewGetnUniformfvEXT = NULL; +PFNGLGETNUNIFORMIVEXTPROC __glewGetnUniformivEXT = NULL; +PFNGLREADNPIXELSEXTPROC __glewReadnPixelsEXT = NULL; + PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL; PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL; @@ -2220,6 +2245,8 @@ PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL; PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL; PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL; +PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC __glewFramebufferFetchBarrierEXT = NULL; + PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL; PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL; @@ -2236,10 +2263,17 @@ PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL; PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL; PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL; +PFNGLPATCHPARAMETERIEXTPROC __glewPatchParameteriEXT = NULL; + PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL; PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL; +PFNGLGETSAMPLERPARAMETERIIVEXTPROC __glewGetSamplerParameterIivEXT = NULL; +PFNGLGETSAMPLERPARAMETERIUIVEXTPROC __glewGetSamplerParameterIuivEXT = NULL; +PFNGLSAMPLERPARAMETERIIVEXTPROC __glewSamplerParameterIivEXT = NULL; +PFNGLSAMPLERPARAMETERIUIVEXTPROC __glewSamplerParameterIuivEXT = NULL; + PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL; PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL; @@ -2357,6 +2391,8 @@ PFNGLWINDOWRECTANGLESEXTPROC __glewWindowRectanglesEXT = NULL; PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL; +PFNGLUTEXFILTERFUNCSGIPROC __glewuTexFilterFuncSGI = NULL; + PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL; PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL; @@ -2380,6 +2416,19 @@ PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL; PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL; PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL; +PFNGLGETTEXTUREHANDLEIMGPROC __glewGetTextureHandleIMG = NULL; +PFNGLGETTEXTURESAMPLERHANDLEIMGPROC __glewGetTextureSamplerHandleIMG = NULL; +PFNGLPROGRAMUNIFORMHANDLEUI64IMGPROC __glewProgramUniformHandleui64IMG = NULL; +PFNGLPROGRAMUNIFORMHANDLEUI64VIMGPROC __glewProgramUniformHandleui64vIMG = NULL; +PFNGLUNIFORMHANDLEUI64IMGPROC __glewUniformHandleui64IMG = NULL; +PFNGLUNIFORMHANDLEUI64VIMGPROC __glewUniformHandleui64vIMG = NULL; + +PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC __glewFramebufferTexture2DDownsampleIMG = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC __glewFramebufferTextureLayerDownsampleIMG = NULL; + +PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC __glewFramebufferTexture2DMultisampleIMG = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC __glewRenderbufferStorageMultisampleIMG = NULL; + PFNGLMAPTEXTURE2DINTELPROC __glewMapTexture2DINTEL = NULL; PFNGLSYNCTEXTUREINTELPROC __glewSyncTextureINTEL = NULL; PFNGLUNMAPTEXTURE2DINTELPROC __glewUnmapTexture2DINTEL = NULL; @@ -2690,6 +2739,18 @@ PFNGLVERTEXATTRIBDIVISORNVPROC __glewVertexAttribDivisorNV = NULL; PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV = NULL; +PFNGLBUFFERATTACHMEMORYNVPROC __glewBufferAttachMemoryNV = NULL; +PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC __glewGetMemoryObjectDetachedResourcesuivNV = NULL; +PFNGLNAMEDBUFFERATTACHMEMORYNVPROC __glewNamedBufferAttachMemoryNV = NULL; +PFNGLRESETMEMORYOBJECTPARAMETERNVPROC __glewResetMemoryObjectParameterNV = NULL; +PFNGLTEXATTACHMEMORYNVPROC __glewTexAttachMemoryNV = NULL; +PFNGLTEXTUREATTACHMEMORYNVPROC __glewTextureAttachMemoryNV = NULL; + +PFNGLDRAWMESHTASKSINDIRECTNVPROC __glewDrawMeshTasksIndirectNV = NULL; +PFNGLDRAWMESHTASKSNVPROC __glewDrawMeshTasksNV = NULL; +PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC __glewMultiDrawMeshTasksIndirectCountNV = NULL; +PFNGLMULTIDRAWMESHTASKSINDIRECTNVPROC __glewMultiDrawMeshTasksIndirectNV = NULL; + PFNGLUNIFORMMATRIX2X3FVNVPROC __glewUniformMatrix2x3fvNV = NULL; PFNGLUNIFORMMATRIX2X4FVNVPROC __glewUniformMatrix2x4fvNV = NULL; PFNGLUNIFORMMATRIX3X2FVNVPROC __glewUniformMatrix3x2fvNV = NULL; @@ -2792,6 +2853,8 @@ PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL; PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL; PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL; +PFNGLREADBUFFERNVPROC __glewReadBufferNV = NULL; + PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL; PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL; PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL; @@ -2811,6 +2874,10 @@ PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NUL PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewFramebufferSampleLocationsfvNV = NULL; PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC __glewNamedFramebufferSampleLocationsfvNV = NULL; +PFNGLRESOLVEDEPTHVALUESNVPROC __glewResolveDepthValuesNV = NULL; + +PFNGLSCISSOREXCLUSIVEARRAYVNVPROC __glewScissorExclusiveArrayvNV = NULL; +PFNGLSCISSOREXCLUSIVENVPROC __glewScissorExclusiveNV = NULL; PFNGLGETBUFFERPARAMETERUI64VNVPROC __glewGetBufferParameterui64vNV = NULL; PFNGLGETINTEGERUI64VNVPROC __glewGetIntegerui64vNV = NULL; @@ -2826,6 +2893,13 @@ PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL; PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL; PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL; +PFNGLBINDSHADINGRATEIMAGENVPROC __glewBindShadingRateImageNV = NULL; +PFNGLGETSHADINGRATEIMAGEPALETTENVPROC __glewGetShadingRateImagePaletteNV = NULL; +PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC __glewGetShadingRateSampleLocationivNV = NULL; +PFNGLSHADINGRATEIMAGEBARRIERNVPROC __glewShadingRateImageBarrierNV = NULL; +PFNGLSHADINGRATEIMAGEPALETTENVPROC __glewShadingRateImagePaletteNV = NULL; +PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC __glewShadingRateSampleOrderCustomNV = NULL; + PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV = NULL; PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV = NULL; PFNGLCOPYTEXSUBIMAGE3DNVPROC __glewCopyTexSubImage3DNV = NULL; @@ -3002,7 +3076,102 @@ PFNGLVIEWPORTINDEXEDFVNVPROC __glewViewportIndexedfvNV = NULL; PFNGLVIEWPORTSWIZZLENVPROC __glewViewportSwizzleNV = NULL; +PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC __glewEGLImageTargetRenderbufferStorageOES = NULL; +PFNGLEGLIMAGETARGETTEXTURE2DOESPROC __glewEGLImageTargetTexture2DOES = NULL; + +PFNGLBLENDEQUATIONSEPARATEOESPROC __glewBlendEquationSeparateOES = NULL; + +PFNGLBLENDFUNCSEPARATEOESPROC __glewBlendFuncSeparateOES = NULL; + +PFNGLBLENDEQUATIONOESPROC __glewBlendEquationOES = NULL; + +PFNGLCOPYIMAGESUBDATAOESPROC __glewCopyImageSubDataOES = NULL; + +PFNGLBLENDEQUATIONSEPARATEIOESPROC __glewBlendEquationSeparateiOES = NULL; +PFNGLBLENDEQUATIONIOESPROC __glewBlendEquationiOES = NULL; +PFNGLBLENDFUNCSEPARATEIOESPROC __glewBlendFuncSeparateiOES = NULL; +PFNGLBLENDFUNCIOESPROC __glewBlendFunciOES = NULL; +PFNGLCOLORMASKIOESPROC __glewColorMaskiOES = NULL; +PFNGLDISABLEIOESPROC __glewDisableiOES = NULL; +PFNGLENABLEIOESPROC __glewEnableiOES = NULL; +PFNGLISENABLEDIOESPROC __glewIsEnablediOES = NULL; + +PFNGLBINDFRAMEBUFFEROESPROC __glewBindFramebufferOES = NULL; +PFNGLBINDRENDERBUFFEROESPROC __glewBindRenderbufferOES = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSOESPROC __glewCheckFramebufferStatusOES = NULL; +PFNGLDELETEFRAMEBUFFERSOESPROC __glewDeleteFramebuffersOES = NULL; +PFNGLDELETERENDERBUFFERSOESPROC __glewDeleteRenderbuffersOES = NULL; +PFNGLFRAMEBUFFERRENDERBUFFEROESPROC __glewFramebufferRenderbufferOES = NULL; +PFNGLFRAMEBUFFERTEXTURE2DOESPROC __glewFramebufferTexture2DOES = NULL; +PFNGLGENFRAMEBUFFERSOESPROC __glewGenFramebuffersOES = NULL; +PFNGLGENRENDERBUFFERSOESPROC __glewGenRenderbuffersOES = NULL; +PFNGLGENERATEMIPMAPOESPROC __glewGenerateMipmapOES = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC __glewGetFramebufferAttachmentParameterivOES = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVOESPROC __glewGetRenderbufferParameterivOES = NULL; +PFNGLISFRAMEBUFFEROESPROC __glewIsFramebufferOES = NULL; +PFNGLISRENDERBUFFEROESPROC __glewIsRenderbufferOES = NULL; +PFNGLRENDERBUFFERSTORAGEOESPROC __glewRenderbufferStorageOES = NULL; + +PFNGLGETPROGRAMBINARYOESPROC __glewGetProgramBinaryOES = NULL; +PFNGLPROGRAMBINARYOESPROC __glewProgramBinaryOES = NULL; + +PFNGLGETBUFFERPOINTERVOESPROC __glewGetBufferPointervOES = NULL; +PFNGLMAPBUFFEROESPROC __glewMapBufferOES = NULL; +PFNGLUNMAPBUFFEROESPROC __glewUnmapBufferOES = NULL; + +PFNGLCURRENTPALETTEMATRIXOESPROC __glewCurrentPaletteMatrixOES = NULL; +PFNGLMATRIXINDEXPOINTEROESPROC __glewMatrixIndexPointerOES = NULL; +PFNGLWEIGHTPOINTEROESPROC __glewWeightPointerOES = NULL; + +PFNGLMINSAMPLESHADINGOESPROC __glewMinSampleShadingOES = NULL; + +PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL; +PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL; +PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL; +PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL; +PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL; +PFNGLORTHOFOESPROC __glewOrthofOES = NULL; + +PFNGLCOMPRESSEDTEXIMAGE3DOESPROC __glewCompressedTexImage3DOES = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC __glewCompressedTexSubImage3DOES = NULL; +PFNGLCOPYTEXSUBIMAGE3DOESPROC __glewCopyTexSubImage3DOES = NULL; +PFNGLFRAMEBUFFERTEXTURE3DOESPROC __glewFramebufferTexture3DOES = NULL; +PFNGLTEXIMAGE3DOESPROC __glewTexImage3DOES = NULL; +PFNGLTEXSUBIMAGE3DOESPROC __glewTexSubImage3DOES = NULL; + +PFNGLGETSAMPLERPARAMETERIIVOESPROC __glewGetSamplerParameterIivOES = NULL; +PFNGLGETSAMPLERPARAMETERIUIVOESPROC __glewGetSamplerParameterIuivOES = NULL; +PFNGLGETTEXPARAMETERIIVOESPROC __glewGetTexParameterIivOES = NULL; +PFNGLGETTEXPARAMETERIUIVOESPROC __glewGetTexParameterIuivOES = NULL; +PFNGLSAMPLERPARAMETERIIVOESPROC __glewSamplerParameterIivOES = NULL; +PFNGLSAMPLERPARAMETERIUIVOESPROC __glewSamplerParameterIuivOES = NULL; +PFNGLTEXPARAMETERIIVOESPROC __glewTexParameterIivOES = NULL; +PFNGLTEXPARAMETERIUIVOESPROC __glewTexParameterIuivOES = NULL; + +PFNGLTEXBUFFEROESPROC __glewTexBufferOES = NULL; +PFNGLTEXBUFFERRANGEOESPROC __glewTexBufferRangeOES = NULL; + +PFNGLGETTEXGENFVOESPROC __glewGetTexGenfvOES = NULL; +PFNGLGETTEXGENIVOESPROC __glewGetTexGenivOES = NULL; +PFNGLGETTEXGENXVOESPROC __glewGetTexGenxvOES = NULL; +PFNGLTEXGENFOESPROC __glewTexGenfOES = NULL; +PFNGLTEXGENFVOESPROC __glewTexGenfvOES = NULL; +PFNGLTEXGENIOESPROC __glewTexGeniOES = NULL; +PFNGLTEXGENIVOESPROC __glewTexGenivOES = NULL; +PFNGLTEXGENXOESPROC __glewTexGenxOES = NULL; +PFNGLTEXGENXVOESPROC __glewTexGenxvOES = NULL; + +PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC __glewTexStorage3DMultisampleOES = NULL; + +PFNGLTEXTUREVIEWOESPROC __glewTextureViewOES = NULL; + +PFNGLBINDVERTEXARRAYOESPROC __glewBindVertexArrayOES = NULL; +PFNGLDELETEVERTEXARRAYSOESPROC __glewDeleteVertexArraysOES = NULL; +PFNGLGENVERTEXARRAYSOESPROC __glewGenVertexArraysOES = NULL; +PFNGLISVERTEXARRAYOESPROC __glewIsVertexArrayOES = NULL; + PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewNamedFramebufferTextureMultiviewOVR = NULL; PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __glewFramebufferTextureMultisampleMultiviewOVR = NULL; @@ -3032,6 +3201,8 @@ PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParameters PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM = NULL; +PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC __glewTextureFoveationParametersQCOM = NULL; + PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM = NULL; PFNGLSTARTTILINGQCOMPROC __glewStartTilingQCOM = NULL; @@ -3307,9 +3478,11 @@ GLboolean __GLEW_AMD_conservative_depth = GL_FALSE; GLboolean __GLEW_AMD_debug_output = GL_FALSE; GLboolean __GLEW_AMD_depth_clamp_separate = GL_FALSE; GLboolean __GLEW_AMD_draw_buffers_blend = GL_FALSE; +GLboolean __GLEW_AMD_framebuffer_multisample_advanced = GL_FALSE; GLboolean __GLEW_AMD_framebuffer_sample_positions = GL_FALSE; GLboolean __GLEW_AMD_gcn_shader = GL_FALSE; GLboolean __GLEW_AMD_gpu_shader_half_float = GL_FALSE; +GLboolean __GLEW_AMD_gpu_shader_half_float_fetch = GL_FALSE; GLboolean __GLEW_AMD_gpu_shader_int16 = GL_FALSE; GLboolean __GLEW_AMD_gpu_shader_int64 = GL_FALSE; GLboolean __GLEW_AMD_interleaved_elements = GL_FALSE; @@ -3325,6 +3498,7 @@ GLboolean __GLEW_AMD_seamless_cubemap_per_texture = GL_FALSE; GLboolean __GLEW_AMD_shader_atomic_counter_ops = GL_FALSE; GLboolean __GLEW_AMD_shader_ballot = GL_FALSE; GLboolean __GLEW_AMD_shader_explicit_vertex_parameter = GL_FALSE; +GLboolean __GLEW_AMD_shader_image_load_store_lod = GL_FALSE; GLboolean __GLEW_AMD_shader_stencil_export = GL_FALSE; GLboolean __GLEW_AMD_shader_stencil_value_export = GL_FALSE; GLboolean __GLEW_AMD_shader_trinary_minmax = GL_FALSE; @@ -3574,11 +3748,13 @@ GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE; GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE; GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE; GLboolean __GLEW_ATI_vertex_streams = GL_FALSE; -GLboolean __GLEW_EGL_KHR_context_flush_control = GL_FALSE; -GLboolean __GLEW_EGL_NV_robustness_video_memory_purge = GL_FALSE; +GLboolean __GLEW_DMP_program_binary = GL_FALSE; +GLboolean __GLEW_DMP_shader_binary = GL_FALSE; GLboolean __GLEW_EXT_422_pixels = GL_FALSE; GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; GLboolean __GLEW_EXT_EGL_image_array = GL_FALSE; +GLboolean __GLEW_EXT_EGL_image_external_wrap_modes = GL_FALSE; +GLboolean __GLEW_EXT_EGL_image_storage = GL_FALSE; GLboolean __GLEW_EXT_YUV_target = GL_FALSE; GLboolean __GLEW_EXT_abgr = GL_FALSE; GLboolean __GLEW_EXT_base_instance = GL_FALSE; @@ -3593,6 +3769,7 @@ GLboolean __GLEW_EXT_blend_minmax = GL_FALSE; GLboolean __GLEW_EXT_blend_subtract = GL_FALSE; GLboolean __GLEW_EXT_buffer_storage = GL_FALSE; GLboolean __GLEW_EXT_clear_texture = GL_FALSE; +GLboolean __GLEW_EXT_clip_control = GL_FALSE; GLboolean __GLEW_EXT_clip_cull_distance = GL_FALSE; GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE; GLboolean __GLEW_EXT_cmyka = GL_FALSE; @@ -3612,12 +3789,14 @@ GLboolean __GLEW_EXT_debug_marker = GL_FALSE; GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE; GLboolean __GLEW_EXT_direct_state_access = GL_FALSE; GLboolean __GLEW_EXT_discard_framebuffer = GL_FALSE; +GLboolean __GLEW_EXT_disjoint_timer_query = GL_FALSE; GLboolean __GLEW_EXT_draw_buffers = GL_FALSE; GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE; GLboolean __GLEW_EXT_draw_buffers_indexed = GL_FALSE; GLboolean __GLEW_EXT_draw_elements_base_vertex = GL_FALSE; GLboolean __GLEW_EXT_draw_instanced = GL_FALSE; GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE; +GLboolean __GLEW_EXT_draw_transform_feedback = GL_FALSE; GLboolean __GLEW_EXT_external_buffer = GL_FALSE; GLboolean __GLEW_EXT_float_blend = GL_FALSE; GLboolean __GLEW_EXT_fog_coord = GL_FALSE; @@ -3654,6 +3833,7 @@ GLboolean __GLEW_EXT_multisample_compatibility = GL_FALSE; GLboolean __GLEW_EXT_multisampled_render_to_texture = GL_FALSE; GLboolean __GLEW_EXT_multisampled_render_to_texture2 = GL_FALSE; GLboolean __GLEW_EXT_multiview_draw_buffers = GL_FALSE; +GLboolean __GLEW_EXT_occlusion_query_boolean = GL_FALSE; GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE; GLboolean __GLEW_EXT_packed_float = GL_FALSE; GLboolean __GLEW_EXT_packed_pixels = GL_FALSE; @@ -3665,12 +3845,14 @@ GLboolean __GLEW_EXT_point_parameters = GL_FALSE; GLboolean __GLEW_EXT_polygon_offset = GL_FALSE; GLboolean __GLEW_EXT_polygon_offset_clamp = GL_FALSE; GLboolean __GLEW_EXT_post_depth_coverage = GL_FALSE; +GLboolean __GLEW_EXT_protected_textures = GL_FALSE; GLboolean __GLEW_EXT_provoking_vertex = GL_FALSE; GLboolean __GLEW_EXT_pvrtc_sRGB = GL_FALSE; GLboolean __GLEW_EXT_raster_multisample = GL_FALSE; GLboolean __GLEW_EXT_read_format_bgra = GL_FALSE; GLboolean __GLEW_EXT_render_snorm = GL_FALSE; GLboolean __GLEW_EXT_rescale_normal = GL_FALSE; +GLboolean __GLEW_EXT_robustness = GL_FALSE; GLboolean __GLEW_EXT_sRGB = GL_FALSE; GLboolean __GLEW_EXT_sRGB_write_control = GL_FALSE; GLboolean __GLEW_EXT_scene_marker = GL_FALSE; @@ -3681,6 +3863,7 @@ GLboolean __GLEW_EXT_semaphore_win32 = GL_FALSE; GLboolean __GLEW_EXT_separate_shader_objects = GL_FALSE; GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE; GLboolean __GLEW_EXT_shader_framebuffer_fetch = GL_FALSE; +GLboolean __GLEW_EXT_shader_framebuffer_fetch_non_coherent = GL_FALSE; GLboolean __GLEW_EXT_shader_group_vote = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_formatted = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE; @@ -3696,13 +3879,18 @@ GLboolean __GLEW_EXT_shadow_samplers = GL_FALSE; GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE; GLboolean __GLEW_EXT_sparse_texture = GL_FALSE; GLboolean __GLEW_EXT_sparse_texture2 = GL_FALSE; +GLboolean __GLEW_EXT_static_vertex_array = GL_FALSE; GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE; GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE; GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE; GLboolean __GLEW_EXT_subtexture = GL_FALSE; +GLboolean __GLEW_EXT_tessellation_point_size = GL_FALSE; +GLboolean __GLEW_EXT_tessellation_shader = GL_FALSE; GLboolean __GLEW_EXT_texture = GL_FALSE; GLboolean __GLEW_EXT_texture3D = GL_FALSE; GLboolean __GLEW_EXT_texture_array = GL_FALSE; +GLboolean __GLEW_EXT_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_buffer = GL_FALSE; GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_astc_decode_mode = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5 = GL_FALSE; @@ -3711,6 +3899,7 @@ GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE; GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_s3tc_srgb = GL_FALSE; GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE; GLboolean __GLEW_EXT_texture_cube_map_array = GL_FALSE; GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE; @@ -3721,9 +3910,11 @@ GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE; GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE; GLboolean __GLEW_EXT_texture_filter_minmax = GL_FALSE; GLboolean __GLEW_EXT_texture_format_BGRA8888 = GL_FALSE; +GLboolean __GLEW_EXT_texture_format_sRGB_override = GL_FALSE; GLboolean __GLEW_EXT_texture_integer = GL_FALSE; GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE; GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_mirror_clamp_to_edge = GL_FALSE; GLboolean __GLEW_EXT_texture_norm16 = GL_FALSE; GLboolean __GLEW_EXT_texture_object = GL_FALSE; GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE; @@ -3751,6 +3942,11 @@ GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE; GLboolean __GLEW_EXT_win32_keyed_mutex = GL_FALSE; GLboolean __GLEW_EXT_window_rectangles = GL_FALSE; GLboolean __GLEW_EXT_x11_sync_object = GL_FALSE; +GLboolean __GLEW_FJ_shader_binary_GCCSO = GL_FALSE; +GLboolean __GLEW_GLU_EXT_nurbs_tessellator = GL_FALSE; +GLboolean __GLEW_GLU_EXT_object_space_tess = GL_FALSE; +GLboolean __GLEW_GLU_SGIX_icc_compress = GL_FALSE; +GLboolean __GLEW_GLU_SGI_filter4_parameters = GL_FALSE; GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE; GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE; GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE; @@ -3763,8 +3959,19 @@ GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE; GLboolean __GLEW_IBM_static_data = GL_FALSE; GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE; GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE; +GLboolean __GLEW_IMG_bindless_texture = GL_FALSE; +GLboolean __GLEW_IMG_framebuffer_downsample = GL_FALSE; +GLboolean __GLEW_IMG_multisampled_render_to_texture = GL_FALSE; +GLboolean __GLEW_IMG_program_binary = GL_FALSE; +GLboolean __GLEW_IMG_read_format = GL_FALSE; +GLboolean __GLEW_IMG_shader_binary = GL_FALSE; +GLboolean __GLEW_IMG_texture_compression_pvrtc = GL_FALSE; +GLboolean __GLEW_IMG_texture_compression_pvrtc2 = GL_FALSE; +GLboolean __GLEW_IMG_texture_env_enhanced_fixed_function = GL_FALSE; +GLboolean __GLEW_IMG_texture_filter_cubic = GL_FALSE; GLboolean __GLEW_INGR_color_clamp = GL_FALSE; GLboolean __GLEW_INGR_interlace_read = GL_FALSE; +GLboolean __GLEW_INTEL_blackhole_render = GL_FALSE; GLboolean __GLEW_INTEL_conservative_rasterization = GL_FALSE; GLboolean __GLEW_INTEL_fragment_shader_ordering = GL_FALSE; GLboolean __GLEW_INTEL_framebuffer_CMAA = GL_FALSE; @@ -3785,9 +3992,12 @@ GLboolean __GLEW_KHR_texture_compression_astc_ldr = GL_FALSE; GLboolean __GLEW_KHR_texture_compression_astc_sliced_3d = GL_FALSE; GLboolean __GLEW_KTX_buffer_region = GL_FALSE; GLboolean __GLEW_MESAX_texture_stack = GL_FALSE; +GLboolean __GLEW_MESA_framebuffer_flip_y = GL_FALSE; GLboolean __GLEW_MESA_pack_invert = GL_FALSE; +GLboolean __GLEW_MESA_program_binary_formats = GL_FALSE; GLboolean __GLEW_MESA_resize_buffers = GL_FALSE; GLboolean __GLEW_MESA_shader_integer_functions = GL_FALSE; +GLboolean __GLEW_MESA_tile_raster_order = GL_FALSE; GLboolean __GLEW_MESA_window_pos = GL_FALSE; GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE; GLboolean __GLEW_NVX_blend_equation_advanced_multi_draw_buffers = GL_FALSE; @@ -3808,16 +4018,20 @@ GLboolean __GLEW_NV_blend_square = GL_FALSE; GLboolean __GLEW_NV_clip_space_w_scaling = GL_FALSE; GLboolean __GLEW_NV_command_list = GL_FALSE; GLboolean __GLEW_NV_compute_program5 = GL_FALSE; +GLboolean __GLEW_NV_compute_shader_derivatives = GL_FALSE; GLboolean __GLEW_NV_conditional_render = GL_FALSE; GLboolean __GLEW_NV_conservative_raster = GL_FALSE; GLboolean __GLEW_NV_conservative_raster_dilate = GL_FALSE; +GLboolean __GLEW_NV_conservative_raster_pre_snap = GL_FALSE; GLboolean __GLEW_NV_conservative_raster_pre_snap_triangles = GL_FALSE; +GLboolean __GLEW_NV_conservative_raster_underestimation = GL_FALSE; GLboolean __GLEW_NV_copy_buffer = GL_FALSE; GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE; GLboolean __GLEW_NV_copy_image = GL_FALSE; GLboolean __GLEW_NV_deep_texture3D = GL_FALSE; GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE; GLboolean __GLEW_NV_depth_clamp = GL_FALSE; +GLboolean __GLEW_NV_depth_nonlinear = GL_FALSE; GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE; GLboolean __GLEW_NV_draw_buffers = GL_FALSE; GLboolean __GLEW_NV_draw_instanced = GL_FALSE; @@ -3836,6 +4050,7 @@ GLboolean __GLEW_NV_fragment_program = GL_FALSE; GLboolean __GLEW_NV_fragment_program2 = GL_FALSE; GLboolean __GLEW_NV_fragment_program4 = GL_FALSE; GLboolean __GLEW_NV_fragment_program_option = GL_FALSE; +GLboolean __GLEW_NV_fragment_shader_barycentric = GL_FALSE; GLboolean __GLEW_NV_fragment_shader_interlock = GL_FALSE; GLboolean __GLEW_NV_framebuffer_blit = GL_FALSE; GLboolean __GLEW_NV_framebuffer_mixed_samples = GL_FALSE; @@ -3856,6 +4071,8 @@ GLboolean __GLEW_NV_image_formats = GL_FALSE; GLboolean __GLEW_NV_instanced_arrays = GL_FALSE; GLboolean __GLEW_NV_internalformat_sample_query = GL_FALSE; GLboolean __GLEW_NV_light_max_exponent = GL_FALSE; +GLboolean __GLEW_NV_memory_attachment = GL_FALSE; +GLboolean __GLEW_NV_mesh_shader = GL_FALSE; GLboolean __GLEW_NV_multisample_coverage = GL_FALSE; GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; GLboolean __GLEW_NV_non_square_matrices = GL_FALSE; @@ -3875,15 +4092,20 @@ GLboolean __GLEW_NV_point_sprite = GL_FALSE; GLboolean __GLEW_NV_polygon_mode = GL_FALSE; GLboolean __GLEW_NV_present_video = GL_FALSE; GLboolean __GLEW_NV_primitive_restart = GL_FALSE; +GLboolean __GLEW_NV_query_resource_tag = GL_FALSE; +GLboolean __GLEW_NV_read_buffer = GL_FALSE; +GLboolean __GLEW_NV_read_buffer_front = GL_FALSE; GLboolean __GLEW_NV_read_depth = GL_FALSE; GLboolean __GLEW_NV_read_depth_stencil = GL_FALSE; GLboolean __GLEW_NV_read_stencil = GL_FALSE; GLboolean __GLEW_NV_register_combiners = GL_FALSE; GLboolean __GLEW_NV_register_combiners2 = GL_FALSE; +GLboolean __GLEW_NV_representative_fragment_test = GL_FALSE; GLboolean __GLEW_NV_robustness_video_memory_purge = GL_FALSE; GLboolean __GLEW_NV_sRGB_formats = GL_FALSE; GLboolean __GLEW_NV_sample_locations = GL_FALSE; GLboolean __GLEW_NV_sample_mask_override_coverage = GL_FALSE; +GLboolean __GLEW_NV_scissor_exclusive = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_counters = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_float = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_float64 = GL_FALSE; @@ -3892,8 +4114,10 @@ GLboolean __GLEW_NV_shader_atomic_int64 = GL_FALSE; GLboolean __GLEW_NV_shader_buffer_load = GL_FALSE; GLboolean __GLEW_NV_shader_noperspective_interpolation = GL_FALSE; GLboolean __GLEW_NV_shader_storage_buffer_object = GL_FALSE; +GLboolean __GLEW_NV_shader_texture_footprint = GL_FALSE; GLboolean __GLEW_NV_shader_thread_group = GL_FALSE; GLboolean __GLEW_NV_shader_thread_shuffle = GL_FALSE; +GLboolean __GLEW_NV_shading_rate_image = GL_FALSE; GLboolean __GLEW_NV_shadow_samplers_array = GL_FALSE; GLboolean __GLEW_NV_shadow_samplers_cube = GL_FALSE; GLboolean __GLEW_NV_stereo_view_rendering = GL_FALSE; @@ -3934,7 +4158,68 @@ GLboolean __GLEW_NV_video_capture = GL_FALSE; GLboolean __GLEW_NV_viewport_array = GL_FALSE; GLboolean __GLEW_NV_viewport_array2 = GL_FALSE; GLboolean __GLEW_NV_viewport_swizzle = GL_FALSE; +GLboolean __GLEW_OES_EGL_image = GL_FALSE; +GLboolean __GLEW_OES_EGL_image_external = GL_FALSE; +GLboolean __GLEW_OES_EGL_image_external_essl3 = GL_FALSE; +GLboolean __GLEW_OES_blend_equation_separate = GL_FALSE; +GLboolean __GLEW_OES_blend_func_separate = GL_FALSE; +GLboolean __GLEW_OES_blend_subtract = GL_FALSE; GLboolean __GLEW_OES_byte_coordinates = GL_FALSE; +GLboolean __GLEW_OES_compressed_ETC1_RGB8_texture = GL_FALSE; +GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE; +GLboolean __GLEW_OES_copy_image = GL_FALSE; +GLboolean __GLEW_OES_depth24 = GL_FALSE; +GLboolean __GLEW_OES_depth32 = GL_FALSE; +GLboolean __GLEW_OES_depth_texture = GL_FALSE; +GLboolean __GLEW_OES_depth_texture_cube_map = GL_FALSE; +GLboolean __GLEW_OES_draw_buffers_indexed = GL_FALSE; +GLboolean __GLEW_OES_draw_texture = GL_FALSE; +GLboolean __GLEW_OES_element_index_uint = GL_FALSE; +GLboolean __GLEW_OES_extended_matrix_palette = GL_FALSE; +GLboolean __GLEW_OES_fbo_render_mipmap = GL_FALSE; +GLboolean __GLEW_OES_fragment_precision_high = GL_FALSE; +GLboolean __GLEW_OES_framebuffer_object = GL_FALSE; +GLboolean __GLEW_OES_geometry_point_size = GL_FALSE; +GLboolean __GLEW_OES_geometry_shader = GL_FALSE; +GLboolean __GLEW_OES_get_program_binary = GL_FALSE; +GLboolean __GLEW_OES_gpu_shader5 = GL_FALSE; +GLboolean __GLEW_OES_mapbuffer = GL_FALSE; +GLboolean __GLEW_OES_matrix_get = GL_FALSE; +GLboolean __GLEW_OES_matrix_palette = GL_FALSE; +GLboolean __GLEW_OES_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_OES_point_size_array = GL_FALSE; +GLboolean __GLEW_OES_point_sprite = GL_FALSE; +GLboolean __GLEW_OES_read_format = GL_FALSE; +GLboolean __GLEW_OES_required_internalformat = GL_FALSE; +GLboolean __GLEW_OES_rgb8_rgba8 = GL_FALSE; +GLboolean __GLEW_OES_sample_shading = GL_FALSE; +GLboolean __GLEW_OES_sample_variables = GL_FALSE; +GLboolean __GLEW_OES_shader_image_atomic = GL_FALSE; +GLboolean __GLEW_OES_shader_io_blocks = GL_FALSE; +GLboolean __GLEW_OES_shader_multisample_interpolation = GL_FALSE; +GLboolean __GLEW_OES_single_precision = GL_FALSE; +GLboolean __GLEW_OES_standard_derivatives = GL_FALSE; +GLboolean __GLEW_OES_stencil1 = GL_FALSE; +GLboolean __GLEW_OES_stencil4 = GL_FALSE; +GLboolean __GLEW_OES_stencil8 = GL_FALSE; +GLboolean __GLEW_OES_surfaceless_context = GL_FALSE; +GLboolean __GLEW_OES_tessellation_point_size = GL_FALSE; +GLboolean __GLEW_OES_tessellation_shader = GL_FALSE; +GLboolean __GLEW_OES_texture_3D = GL_FALSE; +GLboolean __GLEW_OES_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_OES_texture_buffer = GL_FALSE; +GLboolean __GLEW_OES_texture_compression_astc = GL_FALSE; +GLboolean __GLEW_OES_texture_cube_map = GL_FALSE; +GLboolean __GLEW_OES_texture_cube_map_array = GL_FALSE; +GLboolean __GLEW_OES_texture_env_crossbar = GL_FALSE; +GLboolean __GLEW_OES_texture_mirrored_repeat = GL_FALSE; +GLboolean __GLEW_OES_texture_npot = GL_FALSE; +GLboolean __GLEW_OES_texture_stencil8 = GL_FALSE; +GLboolean __GLEW_OES_texture_storage_multisample_2d_array = GL_FALSE; +GLboolean __GLEW_OES_texture_view = GL_FALSE; +GLboolean __GLEW_OES_vertex_array_object = GL_FALSE; +GLboolean __GLEW_OES_vertex_half_float = GL_FALSE; +GLboolean __GLEW_OES_vertex_type_10_10_10_2 = GL_FALSE; GLboolean __GLEW_OML_interlace = GL_FALSE; GLboolean __GLEW_OML_resample = GL_FALSE; GLboolean __GLEW_OML_subsample = GL_FALSE; @@ -3951,6 +4236,9 @@ GLboolean __GLEW_QCOM_extended_get2 = GL_FALSE; GLboolean __GLEW_QCOM_framebuffer_foveated = GL_FALSE; GLboolean __GLEW_QCOM_perfmon_global_mode = GL_FALSE; GLboolean __GLEW_QCOM_shader_framebuffer_fetch_noncoherent = GL_FALSE; +GLboolean __GLEW_QCOM_shader_framebuffer_fetch_rate = GL_FALSE; +GLboolean __GLEW_QCOM_texture_foveated = GL_FALSE; +GLboolean __GLEW_QCOM_texture_foveated_subsampled_layout = GL_FALSE; GLboolean __GLEW_QCOM_tiled_rendering = GL_FALSE; GLboolean __GLEW_QCOM_writeonly_rendering = GL_FALSE; GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE; @@ -4076,66 +4364,13 @@ GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE; GLboolean __GLEW_SUN_slice_accum = GL_FALSE; GLboolean __GLEW_SUN_triangle_list = GL_FALSE; GLboolean __GLEW_SUN_vertex = GL_FALSE; +GLboolean __GLEW_VIV_shader_binary = GL_FALSE; GLboolean __GLEW_WIN_phong_shading = GL_FALSE; GLboolean __GLEW_WIN_scene_markerXXX = GL_FALSE; GLboolean __GLEW_WIN_specular_fog = GL_FALSE; GLboolean __GLEW_WIN_swap_hint = GL_FALSE; static const char * _glewExtensionLookup[] = { -#ifdef GL_VERSION_1_2 - "GL_VERSION_1_2", -#endif -#ifdef GL_VERSION_1_2_1 - "GL_VERSION_1_2_1", -#endif -#ifdef GL_VERSION_1_3 - "GL_VERSION_1_3", -#endif -#ifdef GL_VERSION_1_4 - "GL_VERSION_1_4", -#endif -#ifdef GL_VERSION_1_5 - "GL_VERSION_1_5", -#endif -#ifdef GL_VERSION_2_0 - "GL_VERSION_2_0", -#endif -#ifdef GL_VERSION_2_1 - "GL_VERSION_2_1", -#endif -#ifdef GL_VERSION_3_0 - "GL_VERSION_3_0", -#endif -#ifdef GL_VERSION_3_1 - "GL_VERSION_3_1", -#endif -#ifdef GL_VERSION_3_2 - "GL_VERSION_3_2", -#endif -#ifdef GL_VERSION_3_3 - "GL_VERSION_3_3", -#endif -#ifdef GL_VERSION_4_0 - "GL_VERSION_4_0", -#endif -#ifdef GL_VERSION_4_1 - "GL_VERSION_4_1", -#endif -#ifdef GL_VERSION_4_2 - "GL_VERSION_4_2", -#endif -#ifdef GL_VERSION_4_3 - "GL_VERSION_4_3", -#endif -#ifdef GL_VERSION_4_4 - "GL_VERSION_4_4", -#endif -#ifdef GL_VERSION_4_5 - "GL_VERSION_4_5", -#endif -#ifdef GL_VERSION_4_6 - "GL_VERSION_4_6", -#endif #ifdef GL_3DFX_multisample "GL_3DFX_multisample", #endif @@ -4166,6 +4401,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_draw_buffers_blend "GL_AMD_draw_buffers_blend", #endif +#ifdef GL_AMD_framebuffer_multisample_advanced + "GL_AMD_framebuffer_multisample_advanced", +#endif #ifdef GL_AMD_framebuffer_sample_positions "GL_AMD_framebuffer_sample_positions", #endif @@ -4175,6 +4413,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_gpu_shader_half_float "GL_AMD_gpu_shader_half_float", #endif +#ifdef GL_AMD_gpu_shader_half_float_fetch + "GL_AMD_gpu_shader_half_float_fetch", +#endif #ifdef GL_AMD_gpu_shader_int16 "GL_AMD_gpu_shader_int16", #endif @@ -4220,6 +4461,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_shader_explicit_vertex_parameter "GL_AMD_shader_explicit_vertex_parameter", #endif +#ifdef GL_AMD_shader_image_load_store_lod + "GL_AMD_shader_image_load_store_lod", +#endif #ifdef GL_AMD_shader_stencil_export "GL_AMD_shader_stencil_export", #endif @@ -4967,11 +5211,11 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ATI_vertex_streams "GL_ATI_vertex_streams", #endif -#ifdef GL_EGL_KHR_context_flush_control - "GL_EGL_KHR_context_flush_control", +#ifdef GL_DMP_program_binary + "GL_DMP_program_binary", #endif -#ifdef GL_EGL_NV_robustness_video_memory_purge - "GL_EGL_NV_robustness_video_memory_purge", +#ifdef GL_DMP_shader_binary + "GL_DMP_shader_binary", #endif #ifdef GL_EXT_422_pixels "GL_EXT_422_pixels", @@ -4982,6 +5226,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_EGL_image_array "GL_EXT_EGL_image_array", #endif +#ifdef GL_EXT_EGL_image_external_wrap_modes + "GL_EXT_EGL_image_external_wrap_modes", +#endif +#ifdef GL_EXT_EGL_image_storage + "GL_EXT_EGL_image_storage", +#endif #ifdef GL_EXT_YUV_target "GL_EXT_YUV_target", #endif @@ -5024,6 +5274,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_clear_texture "GL_EXT_clear_texture", #endif +#ifdef GL_EXT_clip_control + "GL_EXT_clip_control", +#endif #ifdef GL_EXT_clip_cull_distance "GL_EXT_clip_cull_distance", #endif @@ -5081,6 +5334,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_discard_framebuffer "GL_EXT_discard_framebuffer", #endif +#ifdef GL_EXT_disjoint_timer_query + "GL_EXT_disjoint_timer_query", +#endif #ifdef GL_EXT_draw_buffers "GL_EXT_draw_buffers", #endif @@ -5099,6 +5355,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_draw_range_elements "GL_EXT_draw_range_elements", #endif +#ifdef GL_EXT_draw_transform_feedback + "GL_EXT_draw_transform_feedback", +#endif #ifdef GL_EXT_external_buffer "GL_EXT_external_buffer", #endif @@ -5207,6 +5466,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_multiview_draw_buffers "GL_EXT_multiview_draw_buffers", #endif +#ifdef GL_EXT_occlusion_query_boolean + "GL_EXT_occlusion_query_boolean", +#endif #ifdef GL_EXT_packed_depth_stencil "GL_EXT_packed_depth_stencil", #endif @@ -5240,6 +5502,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_post_depth_coverage "GL_EXT_post_depth_coverage", #endif +#ifdef GL_EXT_protected_textures + "GL_EXT_protected_textures", +#endif #ifdef GL_EXT_provoking_vertex "GL_EXT_provoking_vertex", #endif @@ -5258,6 +5523,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_rescale_normal "GL_EXT_rescale_normal", #endif +#ifdef GL_EXT_robustness + "GL_EXT_robustness", +#endif #ifdef GL_EXT_sRGB "GL_EXT_sRGB", #endif @@ -5288,6 +5556,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_shader_framebuffer_fetch "GL_EXT_shader_framebuffer_fetch", #endif +#ifdef GL_EXT_shader_framebuffer_fetch_non_coherent + "GL_EXT_shader_framebuffer_fetch_non_coherent", +#endif #ifdef GL_EXT_shader_group_vote "GL_EXT_shader_group_vote", #endif @@ -5333,6 +5604,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_sparse_texture2 "GL_EXT_sparse_texture2", #endif +#ifdef GL_EXT_static_vertex_array + "GL_EXT_static_vertex_array", +#endif #ifdef GL_EXT_stencil_clear_tag "GL_EXT_stencil_clear_tag", #endif @@ -5345,6 +5619,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_subtexture "GL_EXT_subtexture", #endif +#ifdef GL_EXT_tessellation_point_size + "GL_EXT_tessellation_point_size", +#endif +#ifdef GL_EXT_tessellation_shader + "GL_EXT_tessellation_shader", +#endif #ifdef GL_EXT_texture "GL_EXT_texture", #endif @@ -5354,6 +5634,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_array "GL_EXT_texture_array", #endif +#ifdef GL_EXT_texture_border_clamp + "GL_EXT_texture_border_clamp", +#endif +#ifdef GL_EXT_texture_buffer + "GL_EXT_texture_buffer", +#endif #ifdef GL_EXT_texture_buffer_object "GL_EXT_texture_buffer_object", #endif @@ -5378,6 +5664,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_compression_s3tc "GL_EXT_texture_compression_s3tc", #endif +#ifdef GL_EXT_texture_compression_s3tc_srgb + "GL_EXT_texture_compression_s3tc_srgb", +#endif #ifdef GL_EXT_texture_cube_map "GL_EXT_texture_cube_map", #endif @@ -5408,6 +5697,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_format_BGRA8888 "GL_EXT_texture_format_BGRA8888", #endif +#ifdef GL_EXT_texture_format_sRGB_override + "GL_EXT_texture_format_sRGB_override", +#endif #ifdef GL_EXT_texture_integer "GL_EXT_texture_integer", #endif @@ -5417,6 +5709,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_mirror_clamp "GL_EXT_texture_mirror_clamp", #endif +#ifdef GL_EXT_texture_mirror_clamp_to_edge + "GL_EXT_texture_mirror_clamp_to_edge", +#endif #ifdef GL_EXT_texture_norm16 "GL_EXT_texture_norm16", #endif @@ -5498,6 +5793,21 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_x11_sync_object "GL_EXT_x11_sync_object", #endif +#ifdef GL_FJ_shader_binary_GCCSO + "GL_FJ_shader_binary_GCCSO", +#endif +#ifdef GL_GLU_EXT_nurbs_tessellator + "GL_GLU_EXT_nurbs_tessellator", +#endif +#ifdef GL_GLU_EXT_object_space_tess + "GL_GLU_EXT_object_space_tess", +#endif +#ifdef GL_GLU_SGIX_icc_compress + "GL_GLU_SGIX_icc_compress", +#endif +#ifdef GL_GLU_SGI_filter4_parameters + "GL_GLU_SGI_filter4_parameters", +#endif #ifdef GL_GREMEDY_frame_terminator "GL_GREMEDY_frame_terminator", #endif @@ -5534,12 +5844,45 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_IBM_vertex_array_lists "GL_IBM_vertex_array_lists", #endif +#ifdef GL_IMG_bindless_texture + "GL_IMG_bindless_texture", +#endif +#ifdef GL_IMG_framebuffer_downsample + "GL_IMG_framebuffer_downsample", +#endif +#ifdef GL_IMG_multisampled_render_to_texture + "GL_IMG_multisampled_render_to_texture", +#endif +#ifdef GL_IMG_program_binary + "GL_IMG_program_binary", +#endif +#ifdef GL_IMG_read_format + "GL_IMG_read_format", +#endif +#ifdef GL_IMG_shader_binary + "GL_IMG_shader_binary", +#endif +#ifdef GL_IMG_texture_compression_pvrtc + "GL_IMG_texture_compression_pvrtc", +#endif +#ifdef GL_IMG_texture_compression_pvrtc2 + "GL_IMG_texture_compression_pvrtc2", +#endif +#ifdef GL_IMG_texture_env_enhanced_fixed_function + "GL_IMG_texture_env_enhanced_fixed_function", +#endif +#ifdef GL_IMG_texture_filter_cubic + "GL_IMG_texture_filter_cubic", +#endif #ifdef GL_INGR_color_clamp "GL_INGR_color_clamp", #endif #ifdef GL_INGR_interlace_read "GL_INGR_interlace_read", #endif +#ifdef GL_INTEL_blackhole_render + "GL_INTEL_blackhole_render", +#endif #ifdef GL_INTEL_conservative_rasterization "GL_INTEL_conservative_rasterization", #endif @@ -5600,15 +5943,24 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_MESAX_texture_stack "GL_MESAX_texture_stack", #endif +#ifdef GL_MESA_framebuffer_flip_y + "GL_MESA_framebuffer_flip_y", +#endif #ifdef GL_MESA_pack_invert "GL_MESA_pack_invert", #endif +#ifdef GL_MESA_program_binary_formats + "GL_MESA_program_binary_formats", +#endif #ifdef GL_MESA_resize_buffers "GL_MESA_resize_buffers", #endif #ifdef GL_MESA_shader_integer_functions "GL_MESA_shader_integer_functions", #endif +#ifdef GL_MESA_tile_raster_order + "GL_MESA_tile_raster_order", +#endif #ifdef GL_MESA_window_pos "GL_MESA_window_pos", #endif @@ -5669,6 +6021,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_compute_program5 "GL_NV_compute_program5", #endif +#ifdef GL_NV_compute_shader_derivatives + "GL_NV_compute_shader_derivatives", +#endif #ifdef GL_NV_conditional_render "GL_NV_conditional_render", #endif @@ -5678,9 +6033,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_conservative_raster_dilate "GL_NV_conservative_raster_dilate", #endif +#ifdef GL_NV_conservative_raster_pre_snap + "GL_NV_conservative_raster_pre_snap", +#endif #ifdef GL_NV_conservative_raster_pre_snap_triangles "GL_NV_conservative_raster_pre_snap_triangles", #endif +#ifdef GL_NV_conservative_raster_underestimation + "GL_NV_conservative_raster_underestimation", +#endif #ifdef GL_NV_copy_buffer "GL_NV_copy_buffer", #endif @@ -5699,6 +6060,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_depth_clamp "GL_NV_depth_clamp", #endif +#ifdef GL_NV_depth_nonlinear + "GL_NV_depth_nonlinear", +#endif #ifdef GL_NV_depth_range_unclamped "GL_NV_depth_range_unclamped", #endif @@ -5753,6 +6117,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_fragment_program_option "GL_NV_fragment_program_option", #endif +#ifdef GL_NV_fragment_shader_barycentric + "GL_NV_fragment_shader_barycentric", +#endif #ifdef GL_NV_fragment_shader_interlock "GL_NV_fragment_shader_interlock", #endif @@ -5813,6 +6180,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_light_max_exponent "GL_NV_light_max_exponent", #endif +#ifdef GL_NV_memory_attachment + "GL_NV_memory_attachment", +#endif +#ifdef GL_NV_mesh_shader + "GL_NV_mesh_shader", +#endif #ifdef GL_NV_multisample_coverage "GL_NV_multisample_coverage", #endif @@ -5870,6 +6243,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_primitive_restart "GL_NV_primitive_restart", #endif +#ifdef GL_NV_query_resource_tag + "GL_NV_query_resource_tag", +#endif +#ifdef GL_NV_read_buffer + "GL_NV_read_buffer", +#endif +#ifdef GL_NV_read_buffer_front + "GL_NV_read_buffer_front", +#endif #ifdef GL_NV_read_depth "GL_NV_read_depth", #endif @@ -5885,6 +6267,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_register_combiners2 "GL_NV_register_combiners2", #endif +#ifdef GL_NV_representative_fragment_test + "GL_NV_representative_fragment_test", +#endif #ifdef GL_NV_robustness_video_memory_purge "GL_NV_robustness_video_memory_purge", #endif @@ -5897,6 +6282,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_sample_mask_override_coverage "GL_NV_sample_mask_override_coverage", #endif +#ifdef GL_NV_scissor_exclusive + "GL_NV_scissor_exclusive", +#endif #ifdef GL_NV_shader_atomic_counters "GL_NV_shader_atomic_counters", #endif @@ -5921,12 +6309,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_shader_storage_buffer_object "GL_NV_shader_storage_buffer_object", #endif +#ifdef GL_NV_shader_texture_footprint + "GL_NV_shader_texture_footprint", +#endif #ifdef GL_NV_shader_thread_group "GL_NV_shader_thread_group", #endif #ifdef GL_NV_shader_thread_shuffle "GL_NV_shader_thread_shuffle", #endif +#ifdef GL_NV_shading_rate_image + "GL_NV_shading_rate_image", +#endif #ifdef GL_NV_shadow_samplers_array "GL_NV_shadow_samplers_array", #endif @@ -6047,9 +6441,192 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_viewport_swizzle "GL_NV_viewport_swizzle", #endif +#ifdef GL_OES_EGL_image + "GL_OES_EGL_image", +#endif +#ifdef GL_OES_EGL_image_external + "GL_OES_EGL_image_external", +#endif +#ifdef GL_OES_EGL_image_external_essl3 + "GL_OES_EGL_image_external_essl3", +#endif +#ifdef GL_OES_blend_equation_separate + "GL_OES_blend_equation_separate", +#endif +#ifdef GL_OES_blend_func_separate + "GL_OES_blend_func_separate", +#endif +#ifdef GL_OES_blend_subtract + "GL_OES_blend_subtract", +#endif #ifdef GL_OES_byte_coordinates "GL_OES_byte_coordinates", #endif +#ifdef GL_OES_compressed_ETC1_RGB8_texture + "GL_OES_compressed_ETC1_RGB8_texture", +#endif +#ifdef GL_OES_compressed_paletted_texture + "GL_OES_compressed_paletted_texture", +#endif +#ifdef GL_OES_copy_image + "GL_OES_copy_image", +#endif +#ifdef GL_OES_depth24 + "GL_OES_depth24", +#endif +#ifdef GL_OES_depth32 + "GL_OES_depth32", +#endif +#ifdef GL_OES_depth_texture + "GL_OES_depth_texture", +#endif +#ifdef GL_OES_depth_texture_cube_map + "GL_OES_depth_texture_cube_map", +#endif +#ifdef GL_OES_draw_buffers_indexed + "GL_OES_draw_buffers_indexed", +#endif +#ifdef GL_OES_draw_texture + "GL_OES_draw_texture", +#endif +#ifdef GL_OES_element_index_uint + "GL_OES_element_index_uint", +#endif +#ifdef GL_OES_extended_matrix_palette + "GL_OES_extended_matrix_palette", +#endif +#ifdef GL_OES_fbo_render_mipmap + "GL_OES_fbo_render_mipmap", +#endif +#ifdef GL_OES_fragment_precision_high + "GL_OES_fragment_precision_high", +#endif +#ifdef GL_OES_framebuffer_object + "GL_OES_framebuffer_object", +#endif +#ifdef GL_OES_geometry_point_size + "GL_OES_geometry_point_size", +#endif +#ifdef GL_OES_geometry_shader + "GL_OES_geometry_shader", +#endif +#ifdef GL_OES_get_program_binary + "GL_OES_get_program_binary", +#endif +#ifdef GL_OES_gpu_shader5 + "GL_OES_gpu_shader5", +#endif +#ifdef GL_OES_mapbuffer + "GL_OES_mapbuffer", +#endif +#ifdef GL_OES_matrix_get + "GL_OES_matrix_get", +#endif +#ifdef GL_OES_matrix_palette + "GL_OES_matrix_palette", +#endif +#ifdef GL_OES_packed_depth_stencil + "GL_OES_packed_depth_stencil", +#endif +#ifdef GL_OES_point_size_array + "GL_OES_point_size_array", +#endif +#ifdef GL_OES_point_sprite + "GL_OES_point_sprite", +#endif +#ifdef GL_OES_read_format + "GL_OES_read_format", +#endif +#ifdef GL_OES_required_internalformat + "GL_OES_required_internalformat", +#endif +#ifdef GL_OES_rgb8_rgba8 + "GL_OES_rgb8_rgba8", +#endif +#ifdef GL_OES_sample_shading + "GL_OES_sample_shading", +#endif +#ifdef GL_OES_sample_variables + "GL_OES_sample_variables", +#endif +#ifdef GL_OES_shader_image_atomic + "GL_OES_shader_image_atomic", +#endif +#ifdef GL_OES_shader_io_blocks + "GL_OES_shader_io_blocks", +#endif +#ifdef GL_OES_shader_multisample_interpolation + "GL_OES_shader_multisample_interpolation", +#endif +#ifdef GL_OES_single_precision + "GL_OES_single_precision", +#endif +#ifdef GL_OES_standard_derivatives + "GL_OES_standard_derivatives", +#endif +#ifdef GL_OES_stencil1 + "GL_OES_stencil1", +#endif +#ifdef GL_OES_stencil4 + "GL_OES_stencil4", +#endif +#ifdef GL_OES_stencil8 + "GL_OES_stencil8", +#endif +#ifdef GL_OES_surfaceless_context + "GL_OES_surfaceless_context", +#endif +#ifdef GL_OES_tessellation_point_size + "GL_OES_tessellation_point_size", +#endif +#ifdef GL_OES_tessellation_shader + "GL_OES_tessellation_shader", +#endif +#ifdef GL_OES_texture_3D + "GL_OES_texture_3D", +#endif +#ifdef GL_OES_texture_border_clamp + "GL_OES_texture_border_clamp", +#endif +#ifdef GL_OES_texture_buffer + "GL_OES_texture_buffer", +#endif +#ifdef GL_OES_texture_compression_astc + "GL_OES_texture_compression_astc", +#endif +#ifdef GL_OES_texture_cube_map + "GL_OES_texture_cube_map", +#endif +#ifdef GL_OES_texture_cube_map_array + "GL_OES_texture_cube_map_array", +#endif +#ifdef GL_OES_texture_env_crossbar + "GL_OES_texture_env_crossbar", +#endif +#ifdef GL_OES_texture_mirrored_repeat + "GL_OES_texture_mirrored_repeat", +#endif +#ifdef GL_OES_texture_npot + "GL_OES_texture_npot", +#endif +#ifdef GL_OES_texture_stencil8 + "GL_OES_texture_stencil8", +#endif +#ifdef GL_OES_texture_storage_multisample_2d_array + "GL_OES_texture_storage_multisample_2d_array", +#endif +#ifdef GL_OES_texture_view + "GL_OES_texture_view", +#endif +#ifdef GL_OES_vertex_array_object + "GL_OES_vertex_array_object", +#endif +#ifdef GL_OES_vertex_half_float + "GL_OES_vertex_half_float", +#endif +#ifdef GL_OES_vertex_type_10_10_10_2 + "GL_OES_vertex_type_10_10_10_2", +#endif #ifdef GL_OML_interlace "GL_OML_interlace", #endif @@ -6098,6 +6675,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent "GL_QCOM_shader_framebuffer_fetch_noncoherent", #endif +#ifdef GL_QCOM_shader_framebuffer_fetch_rate + "GL_QCOM_shader_framebuffer_fetch_rate", +#endif +#ifdef GL_QCOM_texture_foveated + "GL_QCOM_texture_foveated", +#endif +#ifdef GL_QCOM_texture_foveated_subsampled_layout + "GL_QCOM_texture_foveated_subsampled_layout", +#endif #ifdef GL_QCOM_tiled_rendering "GL_QCOM_tiled_rendering", #endif @@ -6473,6 +7059,63 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_SUN_vertex "GL_SUN_vertex", #endif +#ifdef GL_VERSION_1_2 + "GL_VERSION_1_2", +#endif +#ifdef GL_VERSION_1_2_1 + "GL_VERSION_1_2_1", +#endif +#ifdef GL_VERSION_1_3 + "GL_VERSION_1_3", +#endif +#ifdef GL_VERSION_1_4 + "GL_VERSION_1_4", +#endif +#ifdef GL_VERSION_1_5 + "GL_VERSION_1_5", +#endif +#ifdef GL_VERSION_2_0 + "GL_VERSION_2_0", +#endif +#ifdef GL_VERSION_2_1 + "GL_VERSION_2_1", +#endif +#ifdef GL_VERSION_3_0 + "GL_VERSION_3_0", +#endif +#ifdef GL_VERSION_3_1 + "GL_VERSION_3_1", +#endif +#ifdef GL_VERSION_3_2 + "GL_VERSION_3_2", +#endif +#ifdef GL_VERSION_3_3 + "GL_VERSION_3_3", +#endif +#ifdef GL_VERSION_4_0 + "GL_VERSION_4_0", +#endif +#ifdef GL_VERSION_4_1 + "GL_VERSION_4_1", +#endif +#ifdef GL_VERSION_4_2 + "GL_VERSION_4_2", +#endif +#ifdef GL_VERSION_4_3 + "GL_VERSION_4_3", +#endif +#ifdef GL_VERSION_4_4 + "GL_VERSION_4_4", +#endif +#ifdef GL_VERSION_4_5 + "GL_VERSION_4_5", +#endif +#ifdef GL_VERSION_4_6 + "GL_VERSION_4_6", +#endif +#ifdef GL_VIV_shader_binary + "GL_VIV_shader_binary", +#endif #ifdef GL_WIN_phong_shading "GL_WIN_phong_shading", #endif @@ -6488,64 +7131,11 @@ static const char * _glewExtensionLookup[] = { NULL }; + /* Detected in the extension string or strings */ -static GLboolean _glewExtensionString[801]; +static GLboolean _glewExtensionString[919]; /* Detected via extension string or experimental mode */ static GLboolean* _glewExtensionEnabled[] = { -#ifdef GL_VERSION_1_2 - &__GLEW_VERSION_1_2, -#endif -#ifdef GL_VERSION_1_2_1 - &__GLEW_VERSION_1_2_1, -#endif -#ifdef GL_VERSION_1_3 - &__GLEW_VERSION_1_3, -#endif -#ifdef GL_VERSION_1_4 - &__GLEW_VERSION_1_4, -#endif -#ifdef GL_VERSION_1_5 - &__GLEW_VERSION_1_5, -#endif -#ifdef GL_VERSION_2_0 - &__GLEW_VERSION_2_0, -#endif -#ifdef GL_VERSION_2_1 - &__GLEW_VERSION_2_1, -#endif -#ifdef GL_VERSION_3_0 - &__GLEW_VERSION_3_0, -#endif -#ifdef GL_VERSION_3_1 - &__GLEW_VERSION_3_1, -#endif -#ifdef GL_VERSION_3_2 - &__GLEW_VERSION_3_2, -#endif -#ifdef GL_VERSION_3_3 - &__GLEW_VERSION_3_3, -#endif -#ifdef GL_VERSION_4_0 - &__GLEW_VERSION_4_0, -#endif -#ifdef GL_VERSION_4_1 - &__GLEW_VERSION_4_1, -#endif -#ifdef GL_VERSION_4_2 - &__GLEW_VERSION_4_2, -#endif -#ifdef GL_VERSION_4_3 - &__GLEW_VERSION_4_3, -#endif -#ifdef GL_VERSION_4_4 - &__GLEW_VERSION_4_4, -#endif -#ifdef GL_VERSION_4_5 - &__GLEW_VERSION_4_5, -#endif -#ifdef GL_VERSION_4_6 - &__GLEW_VERSION_4_6, -#endif #ifdef GL_3DFX_multisample &__GLEW_3DFX_multisample, #endif @@ -6576,6 +7166,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_draw_buffers_blend &__GLEW_AMD_draw_buffers_blend, #endif +#ifdef GL_AMD_framebuffer_multisample_advanced + &__GLEW_AMD_framebuffer_multisample_advanced, +#endif #ifdef GL_AMD_framebuffer_sample_positions &__GLEW_AMD_framebuffer_sample_positions, #endif @@ -6585,6 +7178,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_gpu_shader_half_float &__GLEW_AMD_gpu_shader_half_float, #endif +#ifdef GL_AMD_gpu_shader_half_float_fetch + &__GLEW_AMD_gpu_shader_half_float_fetch, +#endif #ifdef GL_AMD_gpu_shader_int16 &__GLEW_AMD_gpu_shader_int16, #endif @@ -6630,6 +7226,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_shader_explicit_vertex_parameter &__GLEW_AMD_shader_explicit_vertex_parameter, #endif +#ifdef GL_AMD_shader_image_load_store_lod + &__GLEW_AMD_shader_image_load_store_lod, +#endif #ifdef GL_AMD_shader_stencil_export &__GLEW_AMD_shader_stencil_export, #endif @@ -7377,11 +7976,11 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ATI_vertex_streams &__GLEW_ATI_vertex_streams, #endif -#ifdef GL_EGL_KHR_context_flush_control - &__GLEW_EGL_KHR_context_flush_control, +#ifdef GL_DMP_program_binary + &__GLEW_DMP_program_binary, #endif -#ifdef GL_EGL_NV_robustness_video_memory_purge - &__GLEW_EGL_NV_robustness_video_memory_purge, +#ifdef GL_DMP_shader_binary + &__GLEW_DMP_shader_binary, #endif #ifdef GL_EXT_422_pixels &__GLEW_EXT_422_pixels, @@ -7392,6 +7991,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_EGL_image_array &__GLEW_EXT_EGL_image_array, #endif +#ifdef GL_EXT_EGL_image_external_wrap_modes + &__GLEW_EXT_EGL_image_external_wrap_modes, +#endif +#ifdef GL_EXT_EGL_image_storage + &__GLEW_EXT_EGL_image_storage, +#endif #ifdef GL_EXT_YUV_target &__GLEW_EXT_YUV_target, #endif @@ -7434,6 +8039,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_clear_texture &__GLEW_EXT_clear_texture, #endif +#ifdef GL_EXT_clip_control + &__GLEW_EXT_clip_control, +#endif #ifdef GL_EXT_clip_cull_distance &__GLEW_EXT_clip_cull_distance, #endif @@ -7491,6 +8099,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_discard_framebuffer &__GLEW_EXT_discard_framebuffer, #endif +#ifdef GL_EXT_disjoint_timer_query + &__GLEW_EXT_disjoint_timer_query, +#endif #ifdef GL_EXT_draw_buffers &__GLEW_EXT_draw_buffers, #endif @@ -7509,6 +8120,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_draw_range_elements &__GLEW_EXT_draw_range_elements, #endif +#ifdef GL_EXT_draw_transform_feedback + &__GLEW_EXT_draw_transform_feedback, +#endif #ifdef GL_EXT_external_buffer &__GLEW_EXT_external_buffer, #endif @@ -7617,6 +8231,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_multiview_draw_buffers &__GLEW_EXT_multiview_draw_buffers, #endif +#ifdef GL_EXT_occlusion_query_boolean + &__GLEW_EXT_occlusion_query_boolean, +#endif #ifdef GL_EXT_packed_depth_stencil &__GLEW_EXT_packed_depth_stencil, #endif @@ -7650,6 +8267,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_post_depth_coverage &__GLEW_EXT_post_depth_coverage, #endif +#ifdef GL_EXT_protected_textures + &__GLEW_EXT_protected_textures, +#endif #ifdef GL_EXT_provoking_vertex &__GLEW_EXT_provoking_vertex, #endif @@ -7668,6 +8288,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_rescale_normal &__GLEW_EXT_rescale_normal, #endif +#ifdef GL_EXT_robustness + &__GLEW_EXT_robustness, +#endif #ifdef GL_EXT_sRGB &__GLEW_EXT_sRGB, #endif @@ -7698,6 +8321,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_shader_framebuffer_fetch &__GLEW_EXT_shader_framebuffer_fetch, #endif +#ifdef GL_EXT_shader_framebuffer_fetch_non_coherent + &__GLEW_EXT_shader_framebuffer_fetch_non_coherent, +#endif #ifdef GL_EXT_shader_group_vote &__GLEW_EXT_shader_group_vote, #endif @@ -7743,6 +8369,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_sparse_texture2 &__GLEW_EXT_sparse_texture2, #endif +#ifdef GL_EXT_static_vertex_array + &__GLEW_EXT_static_vertex_array, +#endif #ifdef GL_EXT_stencil_clear_tag &__GLEW_EXT_stencil_clear_tag, #endif @@ -7755,6 +8384,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_subtexture &__GLEW_EXT_subtexture, #endif +#ifdef GL_EXT_tessellation_point_size + &__GLEW_EXT_tessellation_point_size, +#endif +#ifdef GL_EXT_tessellation_shader + &__GLEW_EXT_tessellation_shader, +#endif #ifdef GL_EXT_texture &__GLEW_EXT_texture, #endif @@ -7764,6 +8399,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_array &__GLEW_EXT_texture_array, #endif +#ifdef GL_EXT_texture_border_clamp + &__GLEW_EXT_texture_border_clamp, +#endif +#ifdef GL_EXT_texture_buffer + &__GLEW_EXT_texture_buffer, +#endif #ifdef GL_EXT_texture_buffer_object &__GLEW_EXT_texture_buffer_object, #endif @@ -7788,6 +8429,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_compression_s3tc &__GLEW_EXT_texture_compression_s3tc, #endif +#ifdef GL_EXT_texture_compression_s3tc_srgb + &__GLEW_EXT_texture_compression_s3tc_srgb, +#endif #ifdef GL_EXT_texture_cube_map &__GLEW_EXT_texture_cube_map, #endif @@ -7818,6 +8462,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_format_BGRA8888 &__GLEW_EXT_texture_format_BGRA8888, #endif +#ifdef GL_EXT_texture_format_sRGB_override + &__GLEW_EXT_texture_format_sRGB_override, +#endif #ifdef GL_EXT_texture_integer &__GLEW_EXT_texture_integer, #endif @@ -7827,6 +8474,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_mirror_clamp &__GLEW_EXT_texture_mirror_clamp, #endif +#ifdef GL_EXT_texture_mirror_clamp_to_edge + &__GLEW_EXT_texture_mirror_clamp_to_edge, +#endif #ifdef GL_EXT_texture_norm16 &__GLEW_EXT_texture_norm16, #endif @@ -7908,6 +8558,21 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_x11_sync_object &__GLEW_EXT_x11_sync_object, #endif +#ifdef GL_FJ_shader_binary_GCCSO + &__GLEW_FJ_shader_binary_GCCSO, +#endif +#ifdef GL_GLU_EXT_nurbs_tessellator + &__GLEW_GLU_EXT_nurbs_tessellator, +#endif +#ifdef GL_GLU_EXT_object_space_tess + &__GLEW_GLU_EXT_object_space_tess, +#endif +#ifdef GL_GLU_SGIX_icc_compress + &__GLEW_GLU_SGIX_icc_compress, +#endif +#ifdef GL_GLU_SGI_filter4_parameters + &__GLEW_GLU_SGI_filter4_parameters, +#endif #ifdef GL_GREMEDY_frame_terminator &__GLEW_GREMEDY_frame_terminator, #endif @@ -7944,12 +8609,45 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_IBM_vertex_array_lists &__GLEW_IBM_vertex_array_lists, #endif +#ifdef GL_IMG_bindless_texture + &__GLEW_IMG_bindless_texture, +#endif +#ifdef GL_IMG_framebuffer_downsample + &__GLEW_IMG_framebuffer_downsample, +#endif +#ifdef GL_IMG_multisampled_render_to_texture + &__GLEW_IMG_multisampled_render_to_texture, +#endif +#ifdef GL_IMG_program_binary + &__GLEW_IMG_program_binary, +#endif +#ifdef GL_IMG_read_format + &__GLEW_IMG_read_format, +#endif +#ifdef GL_IMG_shader_binary + &__GLEW_IMG_shader_binary, +#endif +#ifdef GL_IMG_texture_compression_pvrtc + &__GLEW_IMG_texture_compression_pvrtc, +#endif +#ifdef GL_IMG_texture_compression_pvrtc2 + &__GLEW_IMG_texture_compression_pvrtc2, +#endif +#ifdef GL_IMG_texture_env_enhanced_fixed_function + &__GLEW_IMG_texture_env_enhanced_fixed_function, +#endif +#ifdef GL_IMG_texture_filter_cubic + &__GLEW_IMG_texture_filter_cubic, +#endif #ifdef GL_INGR_color_clamp &__GLEW_INGR_color_clamp, #endif #ifdef GL_INGR_interlace_read &__GLEW_INGR_interlace_read, #endif +#ifdef GL_INTEL_blackhole_render + &__GLEW_INTEL_blackhole_render, +#endif #ifdef GL_INTEL_conservative_rasterization &__GLEW_INTEL_conservative_rasterization, #endif @@ -8010,15 +8708,24 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_MESAX_texture_stack &__GLEW_MESAX_texture_stack, #endif +#ifdef GL_MESA_framebuffer_flip_y + &__GLEW_MESA_framebuffer_flip_y, +#endif #ifdef GL_MESA_pack_invert &__GLEW_MESA_pack_invert, #endif +#ifdef GL_MESA_program_binary_formats + &__GLEW_MESA_program_binary_formats, +#endif #ifdef GL_MESA_resize_buffers &__GLEW_MESA_resize_buffers, #endif #ifdef GL_MESA_shader_integer_functions &__GLEW_MESA_shader_integer_functions, #endif +#ifdef GL_MESA_tile_raster_order + &__GLEW_MESA_tile_raster_order, +#endif #ifdef GL_MESA_window_pos &__GLEW_MESA_window_pos, #endif @@ -8079,6 +8786,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_compute_program5 &__GLEW_NV_compute_program5, #endif +#ifdef GL_NV_compute_shader_derivatives + &__GLEW_NV_compute_shader_derivatives, +#endif #ifdef GL_NV_conditional_render &__GLEW_NV_conditional_render, #endif @@ -8088,9 +8798,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_conservative_raster_dilate &__GLEW_NV_conservative_raster_dilate, #endif +#ifdef GL_NV_conservative_raster_pre_snap + &__GLEW_NV_conservative_raster_pre_snap, +#endif #ifdef GL_NV_conservative_raster_pre_snap_triangles &__GLEW_NV_conservative_raster_pre_snap_triangles, #endif +#ifdef GL_NV_conservative_raster_underestimation + &__GLEW_NV_conservative_raster_underestimation, +#endif #ifdef GL_NV_copy_buffer &__GLEW_NV_copy_buffer, #endif @@ -8109,6 +8825,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_depth_clamp &__GLEW_NV_depth_clamp, #endif +#ifdef GL_NV_depth_nonlinear + &__GLEW_NV_depth_nonlinear, +#endif #ifdef GL_NV_depth_range_unclamped &__GLEW_NV_depth_range_unclamped, #endif @@ -8163,6 +8882,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_fragment_program_option &__GLEW_NV_fragment_program_option, #endif +#ifdef GL_NV_fragment_shader_barycentric + &__GLEW_NV_fragment_shader_barycentric, +#endif #ifdef GL_NV_fragment_shader_interlock &__GLEW_NV_fragment_shader_interlock, #endif @@ -8223,6 +8945,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_light_max_exponent &__GLEW_NV_light_max_exponent, #endif +#ifdef GL_NV_memory_attachment + &__GLEW_NV_memory_attachment, +#endif +#ifdef GL_NV_mesh_shader + &__GLEW_NV_mesh_shader, +#endif #ifdef GL_NV_multisample_coverage &__GLEW_NV_multisample_coverage, #endif @@ -8280,6 +9008,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_primitive_restart &__GLEW_NV_primitive_restart, #endif +#ifdef GL_NV_query_resource_tag + &__GLEW_NV_query_resource_tag, +#endif +#ifdef GL_NV_read_buffer + &__GLEW_NV_read_buffer, +#endif +#ifdef GL_NV_read_buffer_front + &__GLEW_NV_read_buffer_front, +#endif #ifdef GL_NV_read_depth &__GLEW_NV_read_depth, #endif @@ -8295,6 +9032,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_register_combiners2 &__GLEW_NV_register_combiners2, #endif +#ifdef GL_NV_representative_fragment_test + &__GLEW_NV_representative_fragment_test, +#endif #ifdef GL_NV_robustness_video_memory_purge &__GLEW_NV_robustness_video_memory_purge, #endif @@ -8307,6 +9047,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_sample_mask_override_coverage &__GLEW_NV_sample_mask_override_coverage, #endif +#ifdef GL_NV_scissor_exclusive + &__GLEW_NV_scissor_exclusive, +#endif #ifdef GL_NV_shader_atomic_counters &__GLEW_NV_shader_atomic_counters, #endif @@ -8331,12 +9074,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_shader_storage_buffer_object &__GLEW_NV_shader_storage_buffer_object, #endif +#ifdef GL_NV_shader_texture_footprint + &__GLEW_NV_shader_texture_footprint, +#endif #ifdef GL_NV_shader_thread_group &__GLEW_NV_shader_thread_group, #endif #ifdef GL_NV_shader_thread_shuffle &__GLEW_NV_shader_thread_shuffle, #endif +#ifdef GL_NV_shading_rate_image + &__GLEW_NV_shading_rate_image, +#endif #ifdef GL_NV_shadow_samplers_array &__GLEW_NV_shadow_samplers_array, #endif @@ -8457,9 +9206,192 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_viewport_swizzle &__GLEW_NV_viewport_swizzle, #endif +#ifdef GL_OES_EGL_image + &__GLEW_OES_EGL_image, +#endif +#ifdef GL_OES_EGL_image_external + &__GLEW_OES_EGL_image_external, +#endif +#ifdef GL_OES_EGL_image_external_essl3 + &__GLEW_OES_EGL_image_external_essl3, +#endif +#ifdef GL_OES_blend_equation_separate + &__GLEW_OES_blend_equation_separate, +#endif +#ifdef GL_OES_blend_func_separate + &__GLEW_OES_blend_func_separate, +#endif +#ifdef GL_OES_blend_subtract + &__GLEW_OES_blend_subtract, +#endif #ifdef GL_OES_byte_coordinates &__GLEW_OES_byte_coordinates, #endif +#ifdef GL_OES_compressed_ETC1_RGB8_texture + &__GLEW_OES_compressed_ETC1_RGB8_texture, +#endif +#ifdef GL_OES_compressed_paletted_texture + &__GLEW_OES_compressed_paletted_texture, +#endif +#ifdef GL_OES_copy_image + &__GLEW_OES_copy_image, +#endif +#ifdef GL_OES_depth24 + &__GLEW_OES_depth24, +#endif +#ifdef GL_OES_depth32 + &__GLEW_OES_depth32, +#endif +#ifdef GL_OES_depth_texture + &__GLEW_OES_depth_texture, +#endif +#ifdef GL_OES_depth_texture_cube_map + &__GLEW_OES_depth_texture_cube_map, +#endif +#ifdef GL_OES_draw_buffers_indexed + &__GLEW_OES_draw_buffers_indexed, +#endif +#ifdef GL_OES_draw_texture + &__GLEW_OES_draw_texture, +#endif +#ifdef GL_OES_element_index_uint + &__GLEW_OES_element_index_uint, +#endif +#ifdef GL_OES_extended_matrix_palette + &__GLEW_OES_extended_matrix_palette, +#endif +#ifdef GL_OES_fbo_render_mipmap + &__GLEW_OES_fbo_render_mipmap, +#endif +#ifdef GL_OES_fragment_precision_high + &__GLEW_OES_fragment_precision_high, +#endif +#ifdef GL_OES_framebuffer_object + &__GLEW_OES_framebuffer_object, +#endif +#ifdef GL_OES_geometry_point_size + &__GLEW_OES_geometry_point_size, +#endif +#ifdef GL_OES_geometry_shader + &__GLEW_OES_geometry_shader, +#endif +#ifdef GL_OES_get_program_binary + &__GLEW_OES_get_program_binary, +#endif +#ifdef GL_OES_gpu_shader5 + &__GLEW_OES_gpu_shader5, +#endif +#ifdef GL_OES_mapbuffer + &__GLEW_OES_mapbuffer, +#endif +#ifdef GL_OES_matrix_get + &__GLEW_OES_matrix_get, +#endif +#ifdef GL_OES_matrix_palette + &__GLEW_OES_matrix_palette, +#endif +#ifdef GL_OES_packed_depth_stencil + &__GLEW_OES_packed_depth_stencil, +#endif +#ifdef GL_OES_point_size_array + &__GLEW_OES_point_size_array, +#endif +#ifdef GL_OES_point_sprite + &__GLEW_OES_point_sprite, +#endif +#ifdef GL_OES_read_format + &__GLEW_OES_read_format, +#endif +#ifdef GL_OES_required_internalformat + &__GLEW_OES_required_internalformat, +#endif +#ifdef GL_OES_rgb8_rgba8 + &__GLEW_OES_rgb8_rgba8, +#endif +#ifdef GL_OES_sample_shading + &__GLEW_OES_sample_shading, +#endif +#ifdef GL_OES_sample_variables + &__GLEW_OES_sample_variables, +#endif +#ifdef GL_OES_shader_image_atomic + &__GLEW_OES_shader_image_atomic, +#endif +#ifdef GL_OES_shader_io_blocks + &__GLEW_OES_shader_io_blocks, +#endif +#ifdef GL_OES_shader_multisample_interpolation + &__GLEW_OES_shader_multisample_interpolation, +#endif +#ifdef GL_OES_single_precision + &__GLEW_OES_single_precision, +#endif +#ifdef GL_OES_standard_derivatives + &__GLEW_OES_standard_derivatives, +#endif +#ifdef GL_OES_stencil1 + &__GLEW_OES_stencil1, +#endif +#ifdef GL_OES_stencil4 + &__GLEW_OES_stencil4, +#endif +#ifdef GL_OES_stencil8 + &__GLEW_OES_stencil8, +#endif +#ifdef GL_OES_surfaceless_context + &__GLEW_OES_surfaceless_context, +#endif +#ifdef GL_OES_tessellation_point_size + &__GLEW_OES_tessellation_point_size, +#endif +#ifdef GL_OES_tessellation_shader + &__GLEW_OES_tessellation_shader, +#endif +#ifdef GL_OES_texture_3D + &__GLEW_OES_texture_3D, +#endif +#ifdef GL_OES_texture_border_clamp + &__GLEW_OES_texture_border_clamp, +#endif +#ifdef GL_OES_texture_buffer + &__GLEW_OES_texture_buffer, +#endif +#ifdef GL_OES_texture_compression_astc + &__GLEW_OES_texture_compression_astc, +#endif +#ifdef GL_OES_texture_cube_map + &__GLEW_OES_texture_cube_map, +#endif +#ifdef GL_OES_texture_cube_map_array + &__GLEW_OES_texture_cube_map_array, +#endif +#ifdef GL_OES_texture_env_crossbar + &__GLEW_OES_texture_env_crossbar, +#endif +#ifdef GL_OES_texture_mirrored_repeat + &__GLEW_OES_texture_mirrored_repeat, +#endif +#ifdef GL_OES_texture_npot + &__GLEW_OES_texture_npot, +#endif +#ifdef GL_OES_texture_stencil8 + &__GLEW_OES_texture_stencil8, +#endif +#ifdef GL_OES_texture_storage_multisample_2d_array + &__GLEW_OES_texture_storage_multisample_2d_array, +#endif +#ifdef GL_OES_texture_view + &__GLEW_OES_texture_view, +#endif +#ifdef GL_OES_vertex_array_object + &__GLEW_OES_vertex_array_object, +#endif +#ifdef GL_OES_vertex_half_float + &__GLEW_OES_vertex_half_float, +#endif +#ifdef GL_OES_vertex_type_10_10_10_2 + &__GLEW_OES_vertex_type_10_10_10_2, +#endif #ifdef GL_OML_interlace &__GLEW_OML_interlace, #endif @@ -8508,6 +9440,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent &__GLEW_QCOM_shader_framebuffer_fetch_noncoherent, #endif +#ifdef GL_QCOM_shader_framebuffer_fetch_rate + &__GLEW_QCOM_shader_framebuffer_fetch_rate, +#endif +#ifdef GL_QCOM_texture_foveated + &__GLEW_QCOM_texture_foveated, +#endif +#ifdef GL_QCOM_texture_foveated_subsampled_layout + &__GLEW_QCOM_texture_foveated_subsampled_layout, +#endif #ifdef GL_QCOM_tiled_rendering &__GLEW_QCOM_tiled_rendering, #endif @@ -8883,6 +9824,63 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_SUN_vertex &__GLEW_SUN_vertex, #endif +#ifdef GL_VERSION_1_2 + &__GLEW_VERSION_1_2, +#endif +#ifdef GL_VERSION_1_2_1 + &__GLEW_VERSION_1_2_1, +#endif +#ifdef GL_VERSION_1_3 + &__GLEW_VERSION_1_3, +#endif +#ifdef GL_VERSION_1_4 + &__GLEW_VERSION_1_4, +#endif +#ifdef GL_VERSION_1_5 + &__GLEW_VERSION_1_5, +#endif +#ifdef GL_VERSION_2_0 + &__GLEW_VERSION_2_0, +#endif +#ifdef GL_VERSION_2_1 + &__GLEW_VERSION_2_1, +#endif +#ifdef GL_VERSION_3_0 + &__GLEW_VERSION_3_0, +#endif +#ifdef GL_VERSION_3_1 + &__GLEW_VERSION_3_1, +#endif +#ifdef GL_VERSION_3_2 + &__GLEW_VERSION_3_2, +#endif +#ifdef GL_VERSION_3_3 + &__GLEW_VERSION_3_3, +#endif +#ifdef GL_VERSION_4_0 + &__GLEW_VERSION_4_0, +#endif +#ifdef GL_VERSION_4_1 + &__GLEW_VERSION_4_1, +#endif +#ifdef GL_VERSION_4_2 + &__GLEW_VERSION_4_2, +#endif +#ifdef GL_VERSION_4_3 + &__GLEW_VERSION_4_3, +#endif +#ifdef GL_VERSION_4_4 + &__GLEW_VERSION_4_4, +#endif +#ifdef GL_VERSION_4_5 + &__GLEW_VERSION_4_5, +#endif +#ifdef GL_VERSION_4_6 + &__GLEW_VERSION_4_6, +#endif +#ifdef GL_VIV_shader_binary + &__GLEW_VIV_shader_binary, +#endif #ifdef GL_WIN_phong_shading &__GLEW_WIN_phong_shading, #endif @@ -8897,6 +9895,7 @@ static GLboolean* _glewExtensionEnabled[] = { #endif NULL }; + static GLboolean _glewInit_GL_VERSION_1_2 (); static GLboolean _glewInit_GL_VERSION_1_3 (); static GLboolean _glewInit_GL_VERSION_1_4 (); @@ -8913,6 +9912,7 @@ static GLboolean _glewInit_GL_VERSION_4_6 (); static GLboolean _glewInit_GL_3DFX_tbuffer (); static GLboolean _glewInit_GL_AMD_debug_output (); static GLboolean _glewInit_GL_AMD_draw_buffers_blend (); +static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced (); static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions (); static GLboolean _glewInit_GL_AMD_interleaved_elements (); static GLboolean _glewInit_GL_AMD_multi_draw_indirect (); @@ -9036,6 +10036,7 @@ static GLboolean _glewInit_GL_ATI_separate_stencil (); static GLboolean _glewInit_GL_ATI_vertex_array_object (); static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (); static GLboolean _glewInit_GL_ATI_vertex_streams (); +static GLboolean _glewInit_GL_EXT_EGL_image_storage (); static GLboolean _glewInit_GL_EXT_base_instance (); static GLboolean _glewInit_GL_EXT_bindable_uniform (); static GLboolean _glewInit_GL_EXT_blend_color (); @@ -9045,6 +10046,7 @@ static GLboolean _glewInit_GL_EXT_blend_func_separate (); static GLboolean _glewInit_GL_EXT_blend_minmax (); static GLboolean _glewInit_GL_EXT_buffer_storage (); static GLboolean _glewInit_GL_EXT_clear_texture (); +static GLboolean _glewInit_GL_EXT_clip_control (); static GLboolean _glewInit_GL_EXT_color_subtable (); static GLboolean _glewInit_GL_EXT_compiled_vertex_array (); static GLboolean _glewInit_GL_EXT_convolution (); @@ -9057,12 +10059,14 @@ static GLboolean _glewInit_GL_EXT_debug_marker (); static GLboolean _glewInit_GL_EXT_depth_bounds_test (); static GLboolean _glewInit_GL_EXT_direct_state_access (); static GLboolean _glewInit_GL_EXT_discard_framebuffer (); +static GLboolean _glewInit_GL_EXT_disjoint_timer_query (); static GLboolean _glewInit_GL_EXT_draw_buffers (); static GLboolean _glewInit_GL_EXT_draw_buffers2 (); static GLboolean _glewInit_GL_EXT_draw_buffers_indexed (); static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex (); static GLboolean _glewInit_GL_EXT_draw_instanced (); static GLboolean _glewInit_GL_EXT_draw_range_elements (); +static GLboolean _glewInit_GL_EXT_draw_transform_feedback (); static GLboolean _glewInit_GL_EXT_external_buffer (); static GLboolean _glewInit_GL_EXT_fog_coord (); static GLboolean _glewInit_GL_EXT_fragment_lighting (); @@ -9093,19 +10097,23 @@ static GLboolean _glewInit_GL_EXT_polygon_offset (); static GLboolean _glewInit_GL_EXT_polygon_offset_clamp (); static GLboolean _glewInit_GL_EXT_provoking_vertex (); static GLboolean _glewInit_GL_EXT_raster_multisample (); +static GLboolean _glewInit_GL_EXT_robustness (); static GLboolean _glewInit_GL_EXT_scene_marker (); static GLboolean _glewInit_GL_EXT_secondary_color (); static GLboolean _glewInit_GL_EXT_semaphore (); static GLboolean _glewInit_GL_EXT_semaphore_fd (); static GLboolean _glewInit_GL_EXT_semaphore_win32 (); static GLboolean _glewInit_GL_EXT_separate_shader_objects (); +static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch (); static GLboolean _glewInit_GL_EXT_shader_image_load_store (); static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 (); static GLboolean _glewInit_GL_EXT_sparse_texture (); static GLboolean _glewInit_GL_EXT_stencil_two_side (); static GLboolean _glewInit_GL_EXT_subtexture (); +static GLboolean _glewInit_GL_EXT_tessellation_point_size (); static GLboolean _glewInit_GL_EXT_texture3D (); static GLboolean _glewInit_GL_EXT_texture_array (); +static GLboolean _glewInit_GL_EXT_texture_border_clamp (); static GLboolean _glewInit_GL_EXT_texture_buffer_object (); static GLboolean _glewInit_GL_EXT_texture_integer (); static GLboolean _glewInit_GL_EXT_texture_object (); @@ -9122,11 +10130,15 @@ static GLboolean _glewInit_GL_EXT_vertex_weighting (); static GLboolean _glewInit_GL_EXT_win32_keyed_mutex (); static GLboolean _glewInit_GL_EXT_window_rectangles (); static GLboolean _glewInit_GL_EXT_x11_sync_object (); +static GLboolean _glewInit_GL_GLU_SGI_filter4_parameters (); static GLboolean _glewInit_GL_GREMEDY_frame_terminator (); static GLboolean _glewInit_GL_GREMEDY_string_marker (); static GLboolean _glewInit_GL_HP_image_transform (); static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (); static GLboolean _glewInit_GL_IBM_vertex_array_lists (); +static GLboolean _glewInit_GL_IMG_bindless_texture (); +static GLboolean _glewInit_GL_IMG_framebuffer_downsample (); +static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture (); static GLboolean _glewInit_GL_INTEL_map_texture (); static GLboolean _glewInit_GL_INTEL_parallel_arrays (); static GLboolean _glewInit_GL_INTEL_performance_query (); @@ -9173,6 +10185,8 @@ static GLboolean _glewInit_GL_NV_gpu_shader5 (); static GLboolean _glewInit_GL_NV_half_float (); static GLboolean _glewInit_GL_NV_instanced_arrays (); static GLboolean _glewInit_GL_NV_internalformat_sample_query (); +static GLboolean _glewInit_GL_NV_memory_attachment (); +static GLboolean _glewInit_GL_NV_mesh_shader (); static GLboolean _glewInit_GL_NV_non_square_matrices (); static GLboolean _glewInit_GL_NV_occlusion_query (); static GLboolean _glewInit_GL_NV_parameter_buffer_object (); @@ -9182,10 +10196,13 @@ static GLboolean _glewInit_GL_NV_point_sprite (); static GLboolean _glewInit_GL_NV_polygon_mode (); static GLboolean _glewInit_GL_NV_present_video (); static GLboolean _glewInit_GL_NV_primitive_restart (); +static GLboolean _glewInit_GL_NV_read_buffer (); static GLboolean _glewInit_GL_NV_register_combiners (); static GLboolean _glewInit_GL_NV_register_combiners2 (); static GLboolean _glewInit_GL_NV_sample_locations (); +static GLboolean _glewInit_GL_NV_scissor_exclusive (); static GLboolean _glewInit_GL_NV_shader_buffer_load (); +static GLboolean _glewInit_GL_NV_shading_rate_image (); static GLboolean _glewInit_GL_NV_texture_array (); static GLboolean _glewInit_GL_NV_texture_barrier (); static GLboolean _glewInit_GL_NV_texture_multisample (); @@ -9199,6 +10216,25 @@ static GLboolean _glewInit_GL_NV_vertex_program (); static GLboolean _glewInit_GL_NV_video_capture (); static GLboolean _glewInit_GL_NV_viewport_array (); static GLboolean _glewInit_GL_NV_viewport_swizzle (); +static GLboolean _glewInit_GL_OES_EGL_image (); +static GLboolean _glewInit_GL_OES_blend_equation_separate (); +static GLboolean _glewInit_GL_OES_blend_func_separate (); +static GLboolean _glewInit_GL_OES_blend_subtract (); +static GLboolean _glewInit_GL_OES_copy_image (); +static GLboolean _glewInit_GL_OES_draw_buffers_indexed (); +static GLboolean _glewInit_GL_OES_framebuffer_object (); +static GLboolean _glewInit_GL_OES_get_program_binary (); +static GLboolean _glewInit_GL_OES_mapbuffer (); +static GLboolean _glewInit_GL_OES_matrix_palette (); +static GLboolean _glewInit_GL_OES_sample_shading (); +static GLboolean _glewInit_GL_OES_single_precision (); +static GLboolean _glewInit_GL_OES_texture_3D (); +static GLboolean _glewInit_GL_OES_texture_border_clamp (); +static GLboolean _glewInit_GL_OES_texture_buffer (); +static GLboolean _glewInit_GL_OES_texture_cube_map (); +static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array (); +static GLboolean _glewInit_GL_OES_texture_view (); +static GLboolean _glewInit_GL_OES_vertex_array_object (); static GLboolean _glewInit_GL_OVR_multiview (); static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (); static GLboolean _glewInit_GL_QCOM_alpha_test (); @@ -9207,6 +10243,7 @@ static GLboolean _glewInit_GL_QCOM_extended_get (); static GLboolean _glewInit_GL_QCOM_extended_get2 (); static GLboolean _glewInit_GL_QCOM_framebuffer_foveated (); static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent (); +static GLboolean _glewInit_GL_QCOM_texture_foveated (); static GLboolean _glewInit_GL_QCOM_tiled_rendering (); static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (); static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (); @@ -9752,6 +10789,20 @@ static GLboolean _glewInit_GL_AMD_draw_buffers_blend () #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_multisample_advanced + +static GLboolean _glewInit_GL_AMD_framebuffer_multisample_advanced () +{ + GLboolean r = GL_FALSE; + + r = ((glNamedRenderbufferStorageMultisampleAdvancedAMD = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleAdvancedAMD")) == NULL) || r; + r = ((glRenderbufferStorageMultisampleAdvancedAMD = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEADVANCEDAMDPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleAdvancedAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_framebuffer_multisample_advanced */ + #ifdef GL_AMD_framebuffer_sample_positions static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions () @@ -12157,6 +13208,20 @@ static GLboolean _glewInit_GL_ATI_vertex_streams () #endif /* GL_ATI_vertex_streams */ +#ifdef GL_EXT_EGL_image_storage + +static GLboolean _glewInit_GL_EXT_EGL_image_storage () +{ + GLboolean r = GL_FALSE; + + r = ((glEGLImageTargetTexStorageEXT = (PFNGLEGLIMAGETARGETTEXSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glEGLImageTargetTexStorageEXT")) == NULL) || r; + r = ((glEGLImageTargetTextureStorageEXT = (PFNGLEGLIMAGETARGETTEXTURESTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glEGLImageTargetTextureStorageEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_EGL_image_storage */ + #ifdef GL_EXT_base_instance static GLboolean _glewInit_GL_EXT_base_instance () @@ -12282,6 +13347,19 @@ static GLboolean _glewInit_GL_EXT_clear_texture () #endif /* GL_EXT_clear_texture */ +#ifdef GL_EXT_clip_control + +static GLboolean _glewInit_GL_EXT_clip_control () +{ + GLboolean r = GL_FALSE; + + r = ((glClipControlEXT = (PFNGLCLIPCONTROLEXTPROC)glewGetProcAddress((const GLubyte*)"glClipControlEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_clip_control */ + #ifdef GL_EXT_color_subtable static GLboolean _glewInit_GL_EXT_color_subtable () @@ -12674,6 +13752,27 @@ static GLboolean _glewInit_GL_EXT_discard_framebuffer () #endif /* GL_EXT_discard_framebuffer */ +#ifdef GL_EXT_disjoint_timer_query + +static GLboolean _glewInit_GL_EXT_disjoint_timer_query () +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQueryEXT = (PFNGLBEGINQUERYEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryEXT")) == NULL) || r; + r = ((glDeleteQueriesEXT = (PFNGLDELETEQUERIESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesEXT")) == NULL) || r; + r = ((glEndQueryEXT = (PFNGLENDQUERYEXTPROC)glewGetProcAddress((const GLubyte*)"glEndQueryEXT")) == NULL) || r; + r = ((glGenQueriesEXT = (PFNGLGENQUERIESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesEXT")) == NULL) || r; + r = ((glGetQueryObjectivEXT = (PFNGLGETQUERYOBJECTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivEXT")) == NULL) || r; + r = ((glGetQueryObjectuivEXT = (PFNGLGETQUERYOBJECTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivEXT")) == NULL) || r; + r = ((glGetQueryivEXT = (PFNGLGETQUERYIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivEXT")) == NULL) || r; + r = ((glIsQueryEXT = (PFNGLISQUERYEXTPROC)glewGetProcAddress((const GLubyte*)"glIsQueryEXT")) == NULL) || r; + r = ((glQueryCounterEXT = (PFNGLQUERYCOUNTEREXTPROC)glewGetProcAddress((const GLubyte*)"glQueryCounterEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_disjoint_timer_query */ + #ifdef GL_EXT_draw_buffers static GLboolean _glewInit_GL_EXT_draw_buffers () @@ -12768,6 +13867,20 @@ static GLboolean _glewInit_GL_EXT_draw_range_elements () #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_draw_transform_feedback + +static GLboolean _glewInit_GL_EXT_draw_transform_feedback () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawTransformFeedbackEXT = (PFNGLDRAWTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackEXT")) == NULL) || r; + r = ((glDrawTransformFeedbackInstancedEXT = (PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawTransformFeedbackInstancedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_transform_feedback */ + #ifdef GL_EXT_external_buffer static GLboolean _glewInit_GL_EXT_external_buffer () @@ -13280,6 +14393,21 @@ static GLboolean _glewInit_GL_EXT_raster_multisample () #endif /* GL_EXT_raster_multisample */ +#ifdef GL_EXT_robustness + +static GLboolean _glewInit_GL_EXT_robustness () +{ + GLboolean r = GL_FALSE; + + r = ((glGetnUniformfvEXT = (PFNGLGETNUNIFORMFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformfvEXT")) == NULL) || r; + r = ((glGetnUniformivEXT = (PFNGLGETNUNIFORMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetnUniformivEXT")) == NULL) || r; + r = ((glReadnPixelsEXT = (PFNGLREADNPIXELSEXTPROC)glewGetProcAddress((const GLubyte*)"glReadnPixelsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_robustness */ + #ifdef GL_EXT_scene_marker static GLboolean _glewInit_GL_EXT_scene_marker () @@ -13384,6 +14512,19 @@ static GLboolean _glewInit_GL_EXT_separate_shader_objects () #endif /* GL_EXT_separate_shader_objects */ +#ifdef GL_EXT_shader_framebuffer_fetch + +static GLboolean _glewInit_GL_EXT_shader_framebuffer_fetch () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferFetchBarrierEXT = (PFNGLFRAMEBUFFERFETCHBARRIEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFetchBarrierEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_shader_framebuffer_fetch */ + #ifdef GL_EXT_shader_image_load_store static GLboolean _glewInit_GL_EXT_shader_image_load_store () @@ -13455,6 +14596,19 @@ static GLboolean _glewInit_GL_EXT_subtexture () #endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_tessellation_point_size + +static GLboolean _glewInit_GL_EXT_tessellation_point_size () +{ + GLboolean r = GL_FALSE; + + r = ((glPatchParameteriEXT = (PFNGLPATCHPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPatchParameteriEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_tessellation_point_size */ + #ifdef GL_EXT_texture3D static GLboolean _glewInit_GL_EXT_texture3D () @@ -13481,6 +14635,22 @@ static GLboolean _glewInit_GL_EXT_texture_array () #endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_border_clamp + +static GLboolean _glewInit_GL_EXT_texture_border_clamp () +{ + GLboolean r = GL_FALSE; + + r = ((glGetSamplerParameterIivEXT = (PFNGLGETSAMPLERPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIivEXT")) == NULL) || r; + r = ((glGetSamplerParameterIuivEXT = (PFNGLGETSAMPLERPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuivEXT")) == NULL) || r; + r = ((glSamplerParameterIivEXT = (PFNGLSAMPLERPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIivEXT")) == NULL) || r; + r = ((glSamplerParameterIuivEXT = (PFNGLSAMPLERPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_border_clamp */ + #ifdef GL_EXT_texture_buffer_object static GLboolean _glewInit_GL_EXT_texture_buffer_object () @@ -13774,6 +14944,19 @@ static GLboolean _glewInit_GL_EXT_x11_sync_object () #endif /* GL_EXT_x11_sync_object */ +#ifdef GL_GLU_SGI_filter4_parameters + +static GLboolean _glewInit_GL_GLU_SGI_filter4_parameters () +{ + GLboolean r = GL_FALSE; + + r = ((gluTexFilterFuncSGI = (PFNGLUTEXFILTERFUNCSGIPROC)glewGetProcAddress((const GLubyte*)"gluTexFilterFuncSGI")) == NULL) || r; + + return r; +} + +#endif /* GL_GLU_SGI_filter4_parameters */ + #ifdef GL_GREMEDY_frame_terminator static GLboolean _glewInit_GL_GREMEDY_frame_terminator () @@ -13852,6 +15035,52 @@ static GLboolean _glewInit_GL_IBM_vertex_array_lists () #endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_IMG_bindless_texture + +static GLboolean _glewInit_GL_IMG_bindless_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glGetTextureHandleIMG = (PFNGLGETTEXTUREHANDLEIMGPROC)glewGetProcAddress((const GLubyte*)"glGetTextureHandleIMG")) == NULL) || r; + r = ((glGetTextureSamplerHandleIMG = (PFNGLGETTEXTURESAMPLERHANDLEIMGPROC)glewGetProcAddress((const GLubyte*)"glGetTextureSamplerHandleIMG")) == NULL) || r; + r = ((glProgramUniformHandleui64IMG = (PFNGLPROGRAMUNIFORMHANDLEUI64IMGPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64IMG")) == NULL) || r; + r = ((glProgramUniformHandleui64vIMG = (PFNGLPROGRAMUNIFORMHANDLEUI64VIMGPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformHandleui64vIMG")) == NULL) || r; + r = ((glUniformHandleui64IMG = (PFNGLUNIFORMHANDLEUI64IMGPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64IMG")) == NULL) || r; + r = ((glUniformHandleui64vIMG = (PFNGLUNIFORMHANDLEUI64VIMGPROC)glewGetProcAddress((const GLubyte*)"glUniformHandleui64vIMG")) == NULL) || r; + + return r; +} + +#endif /* GL_IMG_bindless_texture */ + +#ifdef GL_IMG_framebuffer_downsample + +static GLboolean _glewInit_GL_IMG_framebuffer_downsample () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTexture2DDownsampleIMG = (PFNGLFRAMEBUFFERTEXTURE2DDOWNSAMPLEIMGPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DDownsampleIMG")) == NULL) || r; + r = ((glFramebufferTextureLayerDownsampleIMG = (PFNGLFRAMEBUFFERTEXTURELAYERDOWNSAMPLEIMGPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerDownsampleIMG")) == NULL) || r; + + return r; +} + +#endif /* GL_IMG_framebuffer_downsample */ + +#ifdef GL_IMG_multisampled_render_to_texture + +static GLboolean _glewInit_GL_IMG_multisampled_render_to_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTexture2DMultisampleIMG = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMGPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DMultisampleIMG")) == NULL) || r; + r = ((glRenderbufferStorageMultisampleIMG = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMGPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleIMG")) == NULL) || r; + + return r; +} + +#endif /* GL_IMG_multisampled_render_to_texture */ + #ifdef GL_INTEL_map_texture static GLboolean _glewInit_GL_INTEL_map_texture () @@ -14668,6 +15897,40 @@ static GLboolean _glewInit_GL_NV_internalformat_sample_query () #endif /* GL_NV_internalformat_sample_query */ +#ifdef GL_NV_memory_attachment + +static GLboolean _glewInit_GL_NV_memory_attachment () +{ + GLboolean r = GL_FALSE; + + r = ((glBufferAttachMemoryNV = (PFNGLBUFFERATTACHMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glBufferAttachMemoryNV")) == NULL) || r; + r = ((glGetMemoryObjectDetachedResourcesuivNV = (PFNGLGETMEMORYOBJECTDETACHEDRESOURCESUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMemoryObjectDetachedResourcesuivNV")) == NULL) || r; + r = ((glNamedBufferAttachMemoryNV = (PFNGLNAMEDBUFFERATTACHMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferAttachMemoryNV")) == NULL) || r; + r = ((glResetMemoryObjectParameterNV = (PFNGLRESETMEMORYOBJECTPARAMETERNVPROC)glewGetProcAddress((const GLubyte*)"glResetMemoryObjectParameterNV")) == NULL) || r; + r = ((glTexAttachMemoryNV = (PFNGLTEXATTACHMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glTexAttachMemoryNV")) == NULL) || r; + r = ((glTextureAttachMemoryNV = (PFNGLTEXTUREATTACHMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glTextureAttachMemoryNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_memory_attachment */ + +#ifdef GL_NV_mesh_shader + +static GLboolean _glewInit_GL_NV_mesh_shader () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawMeshTasksIndirectNV = (PFNGLDRAWMESHTASKSINDIRECTNVPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksIndirectNV")) == NULL) || r; + r = ((glDrawMeshTasksNV = (PFNGLDRAWMESHTASKSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawMeshTasksNV")) == NULL) || r; + r = ((glMultiDrawMeshTasksIndirectCountNV = (PFNGLMULTIDRAWMESHTASKSINDIRECTCOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectCountNV")) == NULL) || r; + r = ((glMultiDrawMeshTasksIndirectNV = (PFNGLMULTIDRAWMESHTASKSINDIRECTNVPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawMeshTasksIndirectNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_mesh_shader */ + #ifdef GL_NV_non_square_matrices static GLboolean _glewInit_GL_NV_non_square_matrices () @@ -14869,6 +16132,19 @@ static GLboolean _glewInit_GL_NV_primitive_restart () #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_read_buffer + +static GLboolean _glewInit_GL_NV_read_buffer () +{ + GLboolean r = GL_FALSE; + + r = ((glReadBufferNV = (PFNGLREADBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glReadBufferNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_read_buffer */ + #ifdef GL_NV_register_combiners static GLboolean _glewInit_GL_NV_register_combiners () @@ -14916,12 +16192,27 @@ static GLboolean _glewInit_GL_NV_sample_locations () r = ((glFramebufferSampleLocationsfvNV = (PFNGLFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSampleLocationsfvNV")) == NULL) || r; r = ((glNamedFramebufferSampleLocationsfvNV = (PFNGLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNVPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSampleLocationsfvNV")) == NULL) || r; + r = ((glResolveDepthValuesNV = (PFNGLRESOLVEDEPTHVALUESNVPROC)glewGetProcAddress((const GLubyte*)"glResolveDepthValuesNV")) == NULL) || r; return r; } #endif /* GL_NV_sample_locations */ +#ifdef GL_NV_scissor_exclusive + +static GLboolean _glewInit_GL_NV_scissor_exclusive () +{ + GLboolean r = GL_FALSE; + + r = ((glScissorExclusiveArrayvNV = (PFNGLSCISSOREXCLUSIVEARRAYVNVPROC)glewGetProcAddress((const GLubyte*)"glScissorExclusiveArrayvNV")) == NULL) || r; + r = ((glScissorExclusiveNV = (PFNGLSCISSOREXCLUSIVENVPROC)glewGetProcAddress((const GLubyte*)"glScissorExclusiveNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_scissor_exclusive */ + #ifdef GL_NV_shader_buffer_load static GLboolean _glewInit_GL_NV_shader_buffer_load () @@ -14947,6 +16238,24 @@ static GLboolean _glewInit_GL_NV_shader_buffer_load () #endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_shading_rate_image + +static GLboolean _glewInit_GL_NV_shading_rate_image () +{ + GLboolean r = GL_FALSE; + + r = ((glBindShadingRateImageNV = (PFNGLBINDSHADINGRATEIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glBindShadingRateImageNV")) == NULL) || r; + r = ((glGetShadingRateImagePaletteNV = (PFNGLGETSHADINGRATEIMAGEPALETTENVPROC)glewGetProcAddress((const GLubyte*)"glGetShadingRateImagePaletteNV")) == NULL) || r; + r = ((glGetShadingRateSampleLocationivNV = (PFNGLGETSHADINGRATESAMPLELOCATIONIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetShadingRateSampleLocationivNV")) == NULL) || r; + r = ((glShadingRateImageBarrierNV = (PFNGLSHADINGRATEIMAGEBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImageBarrierNV")) == NULL) || r; + r = ((glShadingRateImagePaletteNV = (PFNGLSHADINGRATEIMAGEPALETTENVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateImagePaletteNV")) == NULL) || r; + r = ((glShadingRateSampleOrderCustomNV = (PFNGLSHADINGRATESAMPLEORDERCUSTOMNVPROC)glewGetProcAddress((const GLubyte*)"glShadingRateSampleOrderCustomNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_shading_rate_image */ + #ifdef GL_NV_texture_array static GLboolean _glewInit_GL_NV_texture_array () @@ -15266,6 +16575,309 @@ static GLboolean _glewInit_GL_NV_viewport_swizzle () #endif /* GL_NV_viewport_swizzle */ +#ifdef GL_OES_EGL_image + +static GLboolean _glewInit_GL_OES_EGL_image () +{ + GLboolean r = GL_FALSE; + + r = ((glEGLImageTargetRenderbufferStorageOES = (PFNGLEGLIMAGETARGETRENDERBUFFERSTORAGEOESPROC)glewGetProcAddress((const GLubyte*)"glEGLImageTargetRenderbufferStorageOES")) == NULL) || r; + r = ((glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)glewGetProcAddress((const GLubyte*)"glEGLImageTargetTexture2DOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_EGL_image */ + +#ifdef GL_OES_blend_equation_separate + +static GLboolean _glewInit_GL_OES_blend_equation_separate () +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateOES = (PFNGLBLENDEQUATIONSEPARATEOESPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_blend_equation_separate */ + +#ifdef GL_OES_blend_func_separate + +static GLboolean _glewInit_GL_OES_blend_func_separate () +{ + GLboolean r = GL_FALSE; + + r = ((glBlendFuncSeparateOES = (PFNGLBLENDFUNCSEPARATEOESPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_blend_func_separate */ + +#ifdef GL_OES_blend_subtract + +static GLboolean _glewInit_GL_OES_blend_subtract () +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationOES = (PFNGLBLENDEQUATIONOESPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_blend_subtract */ + +#ifdef GL_OES_copy_image + +static GLboolean _glewInit_GL_OES_copy_image () +{ + GLboolean r = GL_FALSE; + + r = ((glCopyImageSubDataOES = (PFNGLCOPYIMAGESUBDATAOESPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_copy_image */ + +#ifdef GL_OES_draw_buffers_indexed + +static GLboolean _glewInit_GL_OES_draw_buffers_indexed () +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateiOES = (PFNGLBLENDEQUATIONSEPARATEIOESPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiOES")) == NULL) || r; + r = ((glBlendEquationiOES = (PFNGLBLENDEQUATIONIOESPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiOES")) == NULL) || r; + r = ((glBlendFuncSeparateiOES = (PFNGLBLENDFUNCSEPARATEIOESPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiOES")) == NULL) || r; + r = ((glBlendFunciOES = (PFNGLBLENDFUNCIOESPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciOES")) == NULL) || r; + r = ((glColorMaskiOES = (PFNGLCOLORMASKIOESPROC)glewGetProcAddress((const GLubyte*)"glColorMaskiOES")) == NULL) || r; + r = ((glDisableiOES = (PFNGLDISABLEIOESPROC)glewGetProcAddress((const GLubyte*)"glDisableiOES")) == NULL) || r; + r = ((glEnableiOES = (PFNGLENABLEIOESPROC)glewGetProcAddress((const GLubyte*)"glEnableiOES")) == NULL) || r; + r = ((glIsEnablediOES = (PFNGLISENABLEDIOESPROC)glewGetProcAddress((const GLubyte*)"glIsEnablediOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_draw_buffers_indexed */ + +#ifdef GL_OES_framebuffer_object + +static GLboolean _glewInit_GL_OES_framebuffer_object () +{ + GLboolean r = GL_FALSE; + + r = ((glBindFramebufferOES = (PFNGLBINDFRAMEBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferOES")) == NULL) || r; + r = ((glBindRenderbufferOES = (PFNGLBINDRENDERBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferOES")) == NULL) || r; + r = ((glCheckFramebufferStatusOES = (PFNGLCHECKFRAMEBUFFERSTATUSOESPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusOES")) == NULL) || r; + r = ((glDeleteFramebuffersOES = (PFNGLDELETEFRAMEBUFFERSOESPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersOES")) == NULL) || r; + r = ((glDeleteRenderbuffersOES = (PFNGLDELETERENDERBUFFERSOESPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersOES")) == NULL) || r; + r = ((glFramebufferRenderbufferOES = (PFNGLFRAMEBUFFERRENDERBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferOES")) == NULL) || r; + r = ((glFramebufferTexture2DOES = (PFNGLFRAMEBUFFERTEXTURE2DOESPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DOES")) == NULL) || r; + r = ((glGenFramebuffersOES = (PFNGLGENFRAMEBUFFERSOESPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersOES")) == NULL) || r; + r = ((glGenRenderbuffersOES = (PFNGLGENRENDERBUFFERSOESPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersOES")) == NULL) || r; + r = ((glGenerateMipmapOES = (PFNGLGENERATEMIPMAPOESPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapOES")) == NULL) || r; + r = ((glGetFramebufferAttachmentParameterivOES = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivOES")) == NULL) || r; + r = ((glGetRenderbufferParameterivOES = (PFNGLGETRENDERBUFFERPARAMETERIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivOES")) == NULL) || r; + r = ((glIsFramebufferOES = (PFNGLISFRAMEBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferOES")) == NULL) || r; + r = ((glIsRenderbufferOES = (PFNGLISRENDERBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferOES")) == NULL) || r; + r = ((glRenderbufferStorageOES = (PFNGLRENDERBUFFERSTORAGEOESPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_framebuffer_object */ + +#ifdef GL_OES_get_program_binary + +static GLboolean _glewInit_GL_OES_get_program_binary () +{ + GLboolean r = GL_FALSE; + + r = ((glGetProgramBinaryOES = (PFNGLGETPROGRAMBINARYOESPROC)glewGetProcAddress((const GLubyte*)"glGetProgramBinaryOES")) == NULL) || r; + r = ((glProgramBinaryOES = (PFNGLPROGRAMBINARYOESPROC)glewGetProcAddress((const GLubyte*)"glProgramBinaryOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_get_program_binary */ + +#ifdef GL_OES_mapbuffer + +static GLboolean _glewInit_GL_OES_mapbuffer () +{ + GLboolean r = GL_FALSE; + + r = ((glGetBufferPointervOES = (PFNGLGETBUFFERPOINTERVOESPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervOES")) == NULL) || r; + r = ((glMapBufferOES = (PFNGLMAPBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glMapBufferOES")) == NULL) || r; + r = ((glUnmapBufferOES = (PFNGLUNMAPBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_mapbuffer */ + +#ifdef GL_OES_matrix_palette + +static GLboolean _glewInit_GL_OES_matrix_palette () +{ + GLboolean r = GL_FALSE; + + r = ((glCurrentPaletteMatrixOES = (PFNGLCURRENTPALETTEMATRIXOESPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixOES")) == NULL) || r; + r = ((glMatrixIndexPointerOES = (PFNGLMATRIXINDEXPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerOES")) == NULL) || r; + r = ((glWeightPointerOES = (PFNGLWEIGHTPOINTEROESPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_matrix_palette */ + +#ifdef GL_OES_sample_shading + +static GLboolean _glewInit_GL_OES_sample_shading () +{ + GLboolean r = GL_FALSE; + + r = ((glMinSampleShadingOES = (PFNGLMINSAMPLESHADINGOESPROC)glewGetProcAddress((const GLubyte*)"glMinSampleShadingOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_sample_shading */ + +#ifdef GL_OES_single_precision + +static GLboolean _glewInit_GL_OES_single_precision () +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r; + r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r; + r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r; + r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r; + r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r; + r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_single_precision */ + +#ifdef GL_OES_texture_3D + +static GLboolean _glewInit_GL_OES_texture_3D () +{ + GLboolean r = GL_FALSE; + + r = ((glCompressedTexImage3DOES = (PFNGLCOMPRESSEDTEXIMAGE3DOESPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DOES")) == NULL) || r; + r = ((glCompressedTexSubImage3DOES = (PFNGLCOMPRESSEDTEXSUBIMAGE3DOESPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DOES")) == NULL) || r; + r = ((glCopyTexSubImage3DOES = (PFNGLCOPYTEXSUBIMAGE3DOESPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DOES")) == NULL) || r; + r = ((glFramebufferTexture3DOES = (PFNGLFRAMEBUFFERTEXTURE3DOESPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DOES")) == NULL) || r; + r = ((glTexImage3DOES = (PFNGLTEXIMAGE3DOESPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DOES")) == NULL) || r; + r = ((glTexSubImage3DOES = (PFNGLTEXSUBIMAGE3DOESPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_3D */ + +#ifdef GL_OES_texture_border_clamp + +static GLboolean _glewInit_GL_OES_texture_border_clamp () +{ + GLboolean r = GL_FALSE; + + r = ((glGetSamplerParameterIivOES = (PFNGLGETSAMPLERPARAMETERIIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIivOES")) == NULL) || r; + r = ((glGetSamplerParameterIuivOES = (PFNGLGETSAMPLERPARAMETERIUIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetSamplerParameterIuivOES")) == NULL) || r; + r = ((glGetTexParameterIivOES = (PFNGLGETTEXPARAMETERIIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivOES")) == NULL) || r; + r = ((glGetTexParameterIuivOES = (PFNGLGETTEXPARAMETERIUIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivOES")) == NULL) || r; + r = ((glSamplerParameterIivOES = (PFNGLSAMPLERPARAMETERIIVOESPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIivOES")) == NULL) || r; + r = ((glSamplerParameterIuivOES = (PFNGLSAMPLERPARAMETERIUIVOESPROC)glewGetProcAddress((const GLubyte*)"glSamplerParameterIuivOES")) == NULL) || r; + r = ((glTexParameterIivOES = (PFNGLTEXPARAMETERIIVOESPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivOES")) == NULL) || r; + r = ((glTexParameterIuivOES = (PFNGLTEXPARAMETERIUIVOESPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_border_clamp */ + +#ifdef GL_OES_texture_buffer + +static GLboolean _glewInit_GL_OES_texture_buffer () +{ + GLboolean r = GL_FALSE; + + r = ((glTexBufferOES = (PFNGLTEXBUFFEROESPROC)glewGetProcAddress((const GLubyte*)"glTexBufferOES")) == NULL) || r; + r = ((glTexBufferRangeOES = (PFNGLTEXBUFFERRANGEOESPROC)glewGetProcAddress((const GLubyte*)"glTexBufferRangeOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_buffer */ + +#ifdef GL_OES_texture_cube_map + +static GLboolean _glewInit_GL_OES_texture_cube_map () +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexGenfvOES = (PFNGLGETTEXGENFVOESPROC)glewGetProcAddress((const GLubyte*)"glGetTexGenfvOES")) == NULL) || r; + r = ((glGetTexGenivOES = (PFNGLGETTEXGENIVOESPROC)glewGetProcAddress((const GLubyte*)"glGetTexGenivOES")) == NULL) || r; + r = ((glGetTexGenxvOES = (PFNGLGETTEXGENXVOESPROC)glewGetProcAddress((const GLubyte*)"glGetTexGenxvOES")) == NULL) || r; + r = ((glTexGenfOES = (PFNGLTEXGENFOESPROC)glewGetProcAddress((const GLubyte*)"glTexGenfOES")) == NULL) || r; + r = ((glTexGenfvOES = (PFNGLTEXGENFVOESPROC)glewGetProcAddress((const GLubyte*)"glTexGenfvOES")) == NULL) || r; + r = ((glTexGeniOES = (PFNGLTEXGENIOESPROC)glewGetProcAddress((const GLubyte*)"glTexGeniOES")) == NULL) || r; + r = ((glTexGenivOES = (PFNGLTEXGENIVOESPROC)glewGetProcAddress((const GLubyte*)"glTexGenivOES")) == NULL) || r; + r = ((glTexGenxOES = (PFNGLTEXGENXOESPROC)glewGetProcAddress((const GLubyte*)"glTexGenxOES")) == NULL) || r; + r = ((glTexGenxvOES = (PFNGLTEXGENXVOESPROC)glewGetProcAddress((const GLubyte*)"glTexGenxvOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_cube_map */ + +#ifdef GL_OES_texture_storage_multisample_2d_array + +static GLboolean _glewInit_GL_OES_texture_storage_multisample_2d_array () +{ + GLboolean r = GL_FALSE; + + r = ((glTexStorage3DMultisampleOES = (PFNGLTEXSTORAGE3DMULTISAMPLEOESPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DMultisampleOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_storage_multisample_2d_array */ + +#ifdef GL_OES_texture_view + +static GLboolean _glewInit_GL_OES_texture_view () +{ + GLboolean r = GL_FALSE; + + r = ((glTextureViewOES = (PFNGLTEXTUREVIEWOESPROC)glewGetProcAddress((const GLubyte*)"glTextureViewOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_texture_view */ + +#ifdef GL_OES_vertex_array_object + +static GLboolean _glewInit_GL_OES_vertex_array_object () +{ + GLboolean r = GL_FALSE; + + r = ((glBindVertexArrayOES = (PFNGLBINDVERTEXARRAYOESPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayOES")) == NULL) || r; + r = ((glDeleteVertexArraysOES = (PFNGLDELETEVERTEXARRAYSOESPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysOES")) == NULL) || r; + r = ((glGenVertexArraysOES = (PFNGLGENVERTEXARRAYSOESPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysOES")) == NULL) || r; + r = ((glIsVertexArrayOES = (PFNGLISVERTEXARRAYOESPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_vertex_array_object */ + #ifdef GL_OVR_multiview static GLboolean _glewInit_GL_OVR_multiview () @@ -15273,6 +16885,7 @@ static GLboolean _glewInit_GL_OVR_multiview () GLboolean r = GL_FALSE; r = ((glFramebufferTextureMultiviewOVR = (PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureMultiviewOVR")) == NULL) || r; + r = ((glNamedFramebufferTextureMultiviewOVR = (PFNGLNAMEDFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureMultiviewOVR")) == NULL) || r; return r; } @@ -15384,6 +16997,19 @@ static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent () #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_texture_foveated + +static GLboolean _glewInit_GL_QCOM_texture_foveated () +{ + GLboolean r = GL_FALSE; + + r = ((glTextureFoveationParametersQCOM = (PFNGLTEXTUREFOVEATIONPARAMETERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glTextureFoveationParametersQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_texture_foveated */ + #ifdef GL_QCOM_tiled_rendering static GLboolean _glewInit_GL_QCOM_tiled_rendering () @@ -16336,6 +17962,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_AMD_draw_buffers_blend if (glewExperimental || GLEW_AMD_draw_buffers_blend) GLEW_AMD_draw_buffers_blend = !_glewInit_GL_AMD_draw_buffers_blend(); #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_multisample_advanced + if (glewExperimental || GLEW_AMD_framebuffer_multisample_advanced) GLEW_AMD_framebuffer_multisample_advanced = !_glewInit_GL_AMD_framebuffer_multisample_advanced(); +#endif /* GL_AMD_framebuffer_multisample_advanced */ #ifdef GL_AMD_framebuffer_sample_positions if (glewExperimental || GLEW_AMD_framebuffer_sample_positions) GLEW_AMD_framebuffer_sample_positions = !_glewInit_GL_AMD_framebuffer_sample_positions(); #endif /* GL_AMD_framebuffer_sample_positions */ @@ -16705,6 +18334,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_ATI_vertex_streams if (glewExperimental || GLEW_ATI_vertex_streams) GLEW_ATI_vertex_streams = !_glewInit_GL_ATI_vertex_streams(); #endif /* GL_ATI_vertex_streams */ +#ifdef GL_EXT_EGL_image_storage + if (glewExperimental || GLEW_EXT_EGL_image_storage) GLEW_EXT_EGL_image_storage = !_glewInit_GL_EXT_EGL_image_storage(); +#endif /* GL_EXT_EGL_image_storage */ #ifdef GL_EXT_base_instance if (glewExperimental || GLEW_EXT_base_instance) GLEW_EXT_base_instance = !_glewInit_GL_EXT_base_instance(); #endif /* GL_EXT_base_instance */ @@ -16732,6 +18364,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_clear_texture if (glewExperimental || GLEW_EXT_clear_texture) GLEW_EXT_clear_texture = !_glewInit_GL_EXT_clear_texture(); #endif /* GL_EXT_clear_texture */ +#ifdef GL_EXT_clip_control + if (glewExperimental || GLEW_EXT_clip_control) GLEW_EXT_clip_control = !_glewInit_GL_EXT_clip_control(); +#endif /* GL_EXT_clip_control */ #ifdef GL_EXT_color_subtable if (glewExperimental || GLEW_EXT_color_subtable) GLEW_EXT_color_subtable = !_glewInit_GL_EXT_color_subtable(); #endif /* GL_EXT_color_subtable */ @@ -16768,6 +18403,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_discard_framebuffer if (glewExperimental || GLEW_EXT_discard_framebuffer) GLEW_EXT_discard_framebuffer = !_glewInit_GL_EXT_discard_framebuffer(); #endif /* GL_EXT_discard_framebuffer */ +#ifdef GL_EXT_disjoint_timer_query + if (glewExperimental || GLEW_EXT_disjoint_timer_query) GLEW_EXT_disjoint_timer_query = !_glewInit_GL_EXT_disjoint_timer_query(); +#endif /* GL_EXT_disjoint_timer_query */ #ifdef GL_EXT_draw_buffers if (glewExperimental || GLEW_EXT_draw_buffers) GLEW_EXT_draw_buffers = !_glewInit_GL_EXT_draw_buffers(); #endif /* GL_EXT_draw_buffers */ @@ -16786,6 +18424,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_draw_range_elements if (glewExperimental || GLEW_EXT_draw_range_elements) GLEW_EXT_draw_range_elements = !_glewInit_GL_EXT_draw_range_elements(); #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_draw_transform_feedback + if (glewExperimental || GLEW_EXT_draw_transform_feedback) GLEW_EXT_draw_transform_feedback = !_glewInit_GL_EXT_draw_transform_feedback(); +#endif /* GL_EXT_draw_transform_feedback */ #ifdef GL_EXT_external_buffer if (glewExperimental || GLEW_EXT_external_buffer) GLEW_EXT_external_buffer = !_glewInit_GL_EXT_external_buffer(); #endif /* GL_EXT_external_buffer */ @@ -16876,6 +18517,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_raster_multisample if (glewExperimental || GLEW_EXT_raster_multisample) GLEW_EXT_raster_multisample = !_glewInit_GL_EXT_raster_multisample(); #endif /* GL_EXT_raster_multisample */ +#ifdef GL_EXT_robustness + if (glewExperimental || GLEW_EXT_robustness) GLEW_EXT_robustness = !_glewInit_GL_EXT_robustness(); +#endif /* GL_EXT_robustness */ #ifdef GL_EXT_scene_marker if (glewExperimental || GLEW_EXT_scene_marker) GLEW_EXT_scene_marker = !_glewInit_GL_EXT_scene_marker(); #endif /* GL_EXT_scene_marker */ @@ -16894,6 +18538,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_separate_shader_objects if (glewExperimental || GLEW_EXT_separate_shader_objects) GLEW_EXT_separate_shader_objects = !_glewInit_GL_EXT_separate_shader_objects(); #endif /* GL_EXT_separate_shader_objects */ +#ifdef GL_EXT_shader_framebuffer_fetch + if (glewExperimental || GLEW_EXT_shader_framebuffer_fetch) GLEW_EXT_shader_framebuffer_fetch = !_glewInit_GL_EXT_shader_framebuffer_fetch(); +#endif /* GL_EXT_shader_framebuffer_fetch */ #ifdef GL_EXT_shader_image_load_store if (glewExperimental || GLEW_EXT_shader_image_load_store) GLEW_EXT_shader_image_load_store = !_glewInit_GL_EXT_shader_image_load_store(); #endif /* GL_EXT_shader_image_load_store */ @@ -16909,12 +18556,18 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_subtexture if (glewExperimental || GLEW_EXT_subtexture) GLEW_EXT_subtexture = !_glewInit_GL_EXT_subtexture(); #endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_tessellation_point_size + if (glewExperimental || GLEW_EXT_tessellation_point_size) GLEW_EXT_tessellation_point_size = !_glewInit_GL_EXT_tessellation_point_size(); +#endif /* GL_EXT_tessellation_point_size */ #ifdef GL_EXT_texture3D if (glewExperimental || GLEW_EXT_texture3D) GLEW_EXT_texture3D = !_glewInit_GL_EXT_texture3D(); #endif /* GL_EXT_texture3D */ #ifdef GL_EXT_texture_array if (glewExperimental || GLEW_EXT_texture_array) GLEW_EXT_texture_array = !_glewInit_GL_EXT_texture_array(); #endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_border_clamp + if (glewExperimental || GLEW_EXT_texture_border_clamp) GLEW_EXT_texture_border_clamp = !_glewInit_GL_EXT_texture_border_clamp(); +#endif /* GL_EXT_texture_border_clamp */ #ifdef GL_EXT_texture_buffer_object if (glewExperimental || GLEW_EXT_texture_buffer_object) GLEW_EXT_texture_buffer_object = !_glewInit_GL_EXT_texture_buffer_object(); #endif /* GL_EXT_texture_buffer_object */ @@ -16963,6 +18616,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_x11_sync_object if (glewExperimental || GLEW_EXT_x11_sync_object) GLEW_EXT_x11_sync_object = !_glewInit_GL_EXT_x11_sync_object(); #endif /* GL_EXT_x11_sync_object */ +#ifdef GL_GLU_SGI_filter4_parameters + if (glewExperimental || GLEW_GLU_SGI_filter4_parameters) GLEW_GLU_SGI_filter4_parameters = !_glewInit_GL_GLU_SGI_filter4_parameters(); +#endif /* GL_GLU_SGI_filter4_parameters */ #ifdef GL_GREMEDY_frame_terminator if (glewExperimental || GLEW_GREMEDY_frame_terminator) GLEW_GREMEDY_frame_terminator = !_glewInit_GL_GREMEDY_frame_terminator(); #endif /* GL_GREMEDY_frame_terminator */ @@ -16978,6 +18634,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_IBM_vertex_array_lists if (glewExperimental || GLEW_IBM_vertex_array_lists) GLEW_IBM_vertex_array_lists = !_glewInit_GL_IBM_vertex_array_lists(); #endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_IMG_bindless_texture + if (glewExperimental || GLEW_IMG_bindless_texture) GLEW_IMG_bindless_texture = !_glewInit_GL_IMG_bindless_texture(); +#endif /* GL_IMG_bindless_texture */ +#ifdef GL_IMG_framebuffer_downsample + if (glewExperimental || GLEW_IMG_framebuffer_downsample) GLEW_IMG_framebuffer_downsample = !_glewInit_GL_IMG_framebuffer_downsample(); +#endif /* GL_IMG_framebuffer_downsample */ +#ifdef GL_IMG_multisampled_render_to_texture + if (glewExperimental || GLEW_IMG_multisampled_render_to_texture) GLEW_IMG_multisampled_render_to_texture = !_glewInit_GL_IMG_multisampled_render_to_texture(); +#endif /* GL_IMG_multisampled_render_to_texture */ #ifdef GL_INTEL_map_texture if (glewExperimental || GLEW_INTEL_map_texture) GLEW_INTEL_map_texture = !_glewInit_GL_INTEL_map_texture(); #endif /* GL_INTEL_map_texture */ @@ -17116,6 +18781,12 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_internalformat_sample_query if (glewExperimental || GLEW_NV_internalformat_sample_query) GLEW_NV_internalformat_sample_query = !_glewInit_GL_NV_internalformat_sample_query(); #endif /* GL_NV_internalformat_sample_query */ +#ifdef GL_NV_memory_attachment + if (glewExperimental || GLEW_NV_memory_attachment) GLEW_NV_memory_attachment = !_glewInit_GL_NV_memory_attachment(); +#endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_mesh_shader + if (glewExperimental || GLEW_NV_mesh_shader) GLEW_NV_mesh_shader = !_glewInit_GL_NV_mesh_shader(); +#endif /* GL_NV_mesh_shader */ #ifdef GL_NV_non_square_matrices if (glewExperimental || GLEW_NV_non_square_matrices) GLEW_NV_non_square_matrices = !_glewInit_GL_NV_non_square_matrices(); #endif /* GL_NV_non_square_matrices */ @@ -17143,6 +18814,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_primitive_restart if (glewExperimental || GLEW_NV_primitive_restart) GLEW_NV_primitive_restart = !_glewInit_GL_NV_primitive_restart(); #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_read_buffer + if (glewExperimental || GLEW_NV_read_buffer) GLEW_NV_read_buffer = !_glewInit_GL_NV_read_buffer(); +#endif /* GL_NV_read_buffer */ #ifdef GL_NV_register_combiners if (glewExperimental || GLEW_NV_register_combiners) GLEW_NV_register_combiners = !_glewInit_GL_NV_register_combiners(); #endif /* GL_NV_register_combiners */ @@ -17152,9 +18826,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_sample_locations if (glewExperimental || GLEW_NV_sample_locations) GLEW_NV_sample_locations = !_glewInit_GL_NV_sample_locations(); #endif /* GL_NV_sample_locations */ +#ifdef GL_NV_scissor_exclusive + if (glewExperimental || GLEW_NV_scissor_exclusive) GLEW_NV_scissor_exclusive = !_glewInit_GL_NV_scissor_exclusive(); +#endif /* GL_NV_scissor_exclusive */ #ifdef GL_NV_shader_buffer_load if (glewExperimental || GLEW_NV_shader_buffer_load) GLEW_NV_shader_buffer_load = !_glewInit_GL_NV_shader_buffer_load(); #endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_shading_rate_image + if (glewExperimental || GLEW_NV_shading_rate_image) GLEW_NV_shading_rate_image = !_glewInit_GL_NV_shading_rate_image(); +#endif /* GL_NV_shading_rate_image */ #ifdef GL_NV_texture_array if (glewExperimental || GLEW_NV_texture_array) GLEW_NV_texture_array = !_glewInit_GL_NV_texture_array(); #endif /* GL_NV_texture_array */ @@ -17194,6 +18874,63 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_viewport_swizzle if (glewExperimental || GLEW_NV_viewport_swizzle) GLEW_NV_viewport_swizzle = !_glewInit_GL_NV_viewport_swizzle(); #endif /* GL_NV_viewport_swizzle */ +#ifdef GL_OES_EGL_image + if (glewExperimental || GLEW_OES_EGL_image) GLEW_OES_EGL_image = !_glewInit_GL_OES_EGL_image(); +#endif /* GL_OES_EGL_image */ +#ifdef GL_OES_blend_equation_separate + if (glewExperimental || GLEW_OES_blend_equation_separate) GLEW_OES_blend_equation_separate = !_glewInit_GL_OES_blend_equation_separate(); +#endif /* GL_OES_blend_equation_separate */ +#ifdef GL_OES_blend_func_separate + if (glewExperimental || GLEW_OES_blend_func_separate) GLEW_OES_blend_func_separate = !_glewInit_GL_OES_blend_func_separate(); +#endif /* GL_OES_blend_func_separate */ +#ifdef GL_OES_blend_subtract + if (glewExperimental || GLEW_OES_blend_subtract) GLEW_OES_blend_subtract = !_glewInit_GL_OES_blend_subtract(); +#endif /* GL_OES_blend_subtract */ +#ifdef GL_OES_copy_image + if (glewExperimental || GLEW_OES_copy_image) GLEW_OES_copy_image = !_glewInit_GL_OES_copy_image(); +#endif /* GL_OES_copy_image */ +#ifdef GL_OES_draw_buffers_indexed + if (glewExperimental || GLEW_OES_draw_buffers_indexed) GLEW_OES_draw_buffers_indexed = !_glewInit_GL_OES_draw_buffers_indexed(); +#endif /* GL_OES_draw_buffers_indexed */ +#ifdef GL_OES_framebuffer_object + if (glewExperimental || GLEW_OES_framebuffer_object) GLEW_OES_framebuffer_object = !_glewInit_GL_OES_framebuffer_object(); +#endif /* GL_OES_framebuffer_object */ +#ifdef GL_OES_get_program_binary + if (glewExperimental || GLEW_OES_get_program_binary) GLEW_OES_get_program_binary = !_glewInit_GL_OES_get_program_binary(); +#endif /* GL_OES_get_program_binary */ +#ifdef GL_OES_mapbuffer + if (glewExperimental || GLEW_OES_mapbuffer) GLEW_OES_mapbuffer = !_glewInit_GL_OES_mapbuffer(); +#endif /* GL_OES_mapbuffer */ +#ifdef GL_OES_matrix_palette + if (glewExperimental || GLEW_OES_matrix_palette) GLEW_OES_matrix_palette = !_glewInit_GL_OES_matrix_palette(); +#endif /* GL_OES_matrix_palette */ +#ifdef GL_OES_sample_shading + if (glewExperimental || GLEW_OES_sample_shading) GLEW_OES_sample_shading = !_glewInit_GL_OES_sample_shading(); +#endif /* GL_OES_sample_shading */ +#ifdef GL_OES_single_precision + if (glewExperimental || GLEW_OES_single_precision) GLEW_OES_single_precision = !_glewInit_GL_OES_single_precision(); +#endif /* GL_OES_single_precision */ +#ifdef GL_OES_texture_3D + if (glewExperimental || GLEW_OES_texture_3D) GLEW_OES_texture_3D = !_glewInit_GL_OES_texture_3D(); +#endif /* GL_OES_texture_3D */ +#ifdef GL_OES_texture_border_clamp + if (glewExperimental || GLEW_OES_texture_border_clamp) GLEW_OES_texture_border_clamp = !_glewInit_GL_OES_texture_border_clamp(); +#endif /* GL_OES_texture_border_clamp */ +#ifdef GL_OES_texture_buffer + if (glewExperimental || GLEW_OES_texture_buffer) GLEW_OES_texture_buffer = !_glewInit_GL_OES_texture_buffer(); +#endif /* GL_OES_texture_buffer */ +#ifdef GL_OES_texture_cube_map + if (glewExperimental || GLEW_OES_texture_cube_map) GLEW_OES_texture_cube_map = !_glewInit_GL_OES_texture_cube_map(); +#endif /* GL_OES_texture_cube_map */ +#ifdef GL_OES_texture_storage_multisample_2d_array + if (glewExperimental || GLEW_OES_texture_storage_multisample_2d_array) GLEW_OES_texture_storage_multisample_2d_array = !_glewInit_GL_OES_texture_storage_multisample_2d_array(); +#endif /* GL_OES_texture_storage_multisample_2d_array */ +#ifdef GL_OES_texture_view + if (glewExperimental || GLEW_OES_texture_view) GLEW_OES_texture_view = !_glewInit_GL_OES_texture_view(); +#endif /* GL_OES_texture_view */ +#ifdef GL_OES_vertex_array_object + if (glewExperimental || GLEW_OES_vertex_array_object) GLEW_OES_vertex_array_object = !_glewInit_GL_OES_vertex_array_object(); +#endif /* GL_OES_vertex_array_object */ #ifdef GL_OVR_multiview if (glewExperimental || GLEW_OVR_multiview) GLEW_OVR_multiview = !_glewInit_GL_OVR_multiview(); #endif /* GL_OVR_multiview */ @@ -17218,6 +18955,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent if (glewExperimental || GLEW_QCOM_shader_framebuffer_fetch_noncoherent) GLEW_QCOM_shader_framebuffer_fetch_noncoherent = !_glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent(); #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_texture_foveated + if (glewExperimental || GLEW_QCOM_texture_foveated) GLEW_QCOM_texture_foveated = !_glewInit_GL_QCOM_texture_foveated(); +#endif /* GL_QCOM_texture_foveated */ #ifdef GL_QCOM_tiled_rendering if (glewExperimental || GLEW_QCOM_tiled_rendering) GLEW_QCOM_tiled_rendering = !_glewInit_GL_QCOM_tiled_rendering(); #endif /* GL_QCOM_tiled_rendering */ @@ -17414,12 +19154,30 @@ PFNEGLSETBLOBCACHEFUNCSANDROIDPROC __eglewSetBlobCacheFuncsANDROID = NULL; PFNEGLCREATENATIVECLIENTBUFFERANDROIDPROC __eglewCreateNativeClientBufferANDROID = NULL; +PFNEGLGETCOMPOSITORTIMINGANDROIDPROC __eglewGetCompositorTimingANDROID = NULL; +PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC __eglewGetCompositorTimingSupportedANDROID = NULL; +PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC __eglewGetFrameTimestampSupportedANDROID = NULL; +PFNEGLGETFRAMETIMESTAMPSANDROIDPROC __eglewGetFrameTimestampsANDROID = NULL; +PFNEGLGETNEXTFRAMEIDANDROIDPROC __eglewGetNextFrameIdANDROID = NULL; + +PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC __eglewGetNativeClientBufferANDROID = NULL; + PFNEGLDUPNATIVEFENCEFDANDROIDPROC __eglewDupNativeFenceFDANDROID = NULL; PFNEGLPRESENTATIONTIMEANDROIDPROC __eglewPresentationTimeANDROID = NULL; PFNEGLQUERYSURFACEPOINTERANGLEPROC __eglewQuerySurfacePointerANGLE = NULL; +PFNEGLCLIENTSIGNALSYNCEXTPROC __eglewClientSignalSyncEXT = NULL; + +PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC __eglewCompositorBindTexWindowEXT = NULL; +PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC __eglewCompositorSetContextAttributesEXT = NULL; +PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC __eglewCompositorSetContextListEXT = NULL; +PFNEGLCOMPOSITORSETSIZEEXTPROC __eglewCompositorSetSizeEXT = NULL; +PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC __eglewCompositorSetWindowAttributesEXT = NULL; +PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC __eglewCompositorSetWindowListEXT = NULL; +PFNEGLCOMPOSITORSWAPPOLICYEXTPROC __eglewCompositorSwapPolicyEXT = NULL; + PFNEGLQUERYDEVICESEXTPROC __eglewQueryDevicesEXT = NULL; PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT = NULL; @@ -17446,6 +19204,8 @@ PFNEGLSTREAMCONSUMEROUTPUTEXTPROC __eglewStreamConsumerOutputEXT = NULL; PFNEGLSWAPBUFFERSWITHDAMAGEEXTPROC __eglewSwapBuffersWithDamageEXT = NULL; +PFNEGLUNSIGNALSYNCEXTPROC __eglewUnsignalSyncEXT = NULL; + PFNEGLCREATEPIXMAPSURFACEHIPROC __eglewCreatePixmapSurfaceHI = NULL; PFNEGLCREATESYNC64KHRPROC __eglewCreateSync64KHR = NULL; @@ -17454,6 +19214,8 @@ PFNEGLDEBUGMESSAGECONTROLKHRPROC __eglewDebugMessageControlKHR = NULL; PFNEGLLABELOBJECTKHRPROC __eglewLabelObjectKHR = NULL; PFNEGLQUERYDEBUGKHRPROC __eglewQueryDebugKHR = NULL; +PFNEGLQUERYDISPLAYATTRIBKHRPROC __eglewQueryDisplayAttribKHR = NULL; + PFNEGLCREATEIMAGEKHRPROC __eglewCreateImageKHR = NULL; PFNEGLDESTROYIMAGEKHRPROC __eglewDestroyImageKHR = NULL; @@ -17515,6 +19277,8 @@ PFNEGLPOSTSUBBUFFERNVPROC __eglewPostSubBufferNV = NULL; PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC __eglewStreamConsumerGLTextureExternalAttribsNV = NULL; +PFNEGLSTREAMFLUSHNVPROC __eglewStreamFlushNV = NULL; + PFNEGLQUERYDISPLAYATTRIBNVPROC __eglewQueryDisplayAttribNV = NULL; PFNEGLQUERYSTREAMMETADATANVPROC __eglewQueryStreamMetadataNV = NULL; PFNEGLSETSTREAMMETADATANVPROC __eglewSetStreamMetadataNV = NULL; @@ -17542,6 +19306,8 @@ GLboolean __EGLEW_ANDROID_blob_cache = GL_FALSE; GLboolean __EGLEW_ANDROID_create_native_client_buffer = GL_FALSE; GLboolean __EGLEW_ANDROID_framebuffer_target = GL_FALSE; GLboolean __EGLEW_ANDROID_front_buffer_auto_refresh = GL_FALSE; +GLboolean __EGLEW_ANDROID_get_frame_timestamps = GL_FALSE; +GLboolean __EGLEW_ANDROID_get_native_client_buffer = GL_FALSE; GLboolean __EGLEW_ANDROID_image_native_buffer = GL_FALSE; GLboolean __EGLEW_ANDROID_native_fence_sync = GL_FALSE; GLboolean __EGLEW_ANDROID_presentation_time = GL_FALSE; @@ -17553,8 +19319,11 @@ GLboolean __EGLEW_ANGLE_surface_d3d_texture_2d_share_handle = GL_FALSE; GLboolean __EGLEW_ANGLE_window_fixed_size = GL_FALSE; GLboolean __EGLEW_ARM_implicit_external_sync = GL_FALSE; GLboolean __EGLEW_ARM_pixmap_multisample_discard = GL_FALSE; +GLboolean __EGLEW_EXT_bind_to_front = GL_FALSE; GLboolean __EGLEW_EXT_buffer_age = GL_FALSE; GLboolean __EGLEW_EXT_client_extensions = GL_FALSE; +GLboolean __EGLEW_EXT_client_sync = GL_FALSE; +GLboolean __EGLEW_EXT_compositor = GL_FALSE; GLboolean __EGLEW_EXT_create_context_robustness = GL_FALSE; GLboolean __EGLEW_EXT_device_base = GL_FALSE; GLboolean __EGLEW_EXT_device_drm = GL_FALSE; @@ -17563,9 +19332,14 @@ GLboolean __EGLEW_EXT_device_openwf = GL_FALSE; GLboolean __EGLEW_EXT_device_query = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_bt2020_linear = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_bt2020_pq = GL_FALSE; +GLboolean __EGLEW_EXT_gl_colorspace_display_p3 = GL_FALSE; +GLboolean __EGLEW_EXT_gl_colorspace_display_p3_linear = GL_FALSE; +GLboolean __EGLEW_EXT_gl_colorspace_scrgb = GL_FALSE; GLboolean __EGLEW_EXT_gl_colorspace_scrgb_linear = GL_FALSE; GLboolean __EGLEW_EXT_image_dma_buf_import = GL_FALSE; GLboolean __EGLEW_EXT_image_dma_buf_import_modifiers = GL_FALSE; +GLboolean __EGLEW_EXT_image_gl_colorspace = GL_FALSE; +GLboolean __EGLEW_EXT_image_implicit_sync_control = GL_FALSE; GLboolean __EGLEW_EXT_multiview_window = GL_FALSE; GLboolean __EGLEW_EXT_output_base = GL_FALSE; GLboolean __EGLEW_EXT_output_drm = GL_FALSE; @@ -17578,8 +19352,10 @@ GLboolean __EGLEW_EXT_platform_x11 = GL_FALSE; GLboolean __EGLEW_EXT_protected_content = GL_FALSE; GLboolean __EGLEW_EXT_protected_surface = GL_FALSE; GLboolean __EGLEW_EXT_stream_consumer_egloutput = GL_FALSE; +GLboolean __EGLEW_EXT_surface_CTA861_3_metadata = GL_FALSE; GLboolean __EGLEW_EXT_surface_SMPTE2086_metadata = GL_FALSE; GLboolean __EGLEW_EXT_swap_buffers_with_damage = GL_FALSE; +GLboolean __EGLEW_EXT_sync_reuse = GL_FALSE; GLboolean __EGLEW_EXT_yuv_surface = GL_FALSE; GLboolean __EGLEW_HI_clientpixmap = GL_FALSE; GLboolean __EGLEW_HI_colorformats = GL_FALSE; @@ -17593,6 +19369,7 @@ GLboolean __EGLEW_KHR_context_flush_control = GL_FALSE; GLboolean __EGLEW_KHR_create_context = GL_FALSE; GLboolean __EGLEW_KHR_create_context_no_error = GL_FALSE; GLboolean __EGLEW_KHR_debug = GL_FALSE; +GLboolean __EGLEW_KHR_display_reference = GL_FALSE; GLboolean __EGLEW_KHR_fence_sync = GL_FALSE; GLboolean __EGLEW_KHR_get_all_proc_addresses = GL_FALSE; GLboolean __EGLEW_KHR_gl_colorspace = GL_FALSE; @@ -17633,6 +19410,7 @@ GLboolean __EGLEW_NOK_swap_region = GL_FALSE; GLboolean __EGLEW_NOK_swap_region2 = GL_FALSE; GLboolean __EGLEW_NOK_texture_from_pixmap = GL_FALSE; GLboolean __EGLEW_NV_3dvision_surface = GL_FALSE; +GLboolean __EGLEW_NV_context_priority_realtime = GL_FALSE; GLboolean __EGLEW_NV_coverage_sample = GL_FALSE; GLboolean __EGLEW_NV_coverage_sample_resolve = GL_FALSE; GLboolean __EGLEW_NV_cuda_event = GL_FALSE; @@ -17650,6 +19428,7 @@ GLboolean __EGLEW_NV_stream_cross_process = GL_FALSE; GLboolean __EGLEW_NV_stream_cross_system = GL_FALSE; GLboolean __EGLEW_NV_stream_fifo_next = GL_FALSE; GLboolean __EGLEW_NV_stream_fifo_synchronous = GL_FALSE; +GLboolean __EGLEW_NV_stream_flush = GL_FALSE; GLboolean __EGLEW_NV_stream_frame_limits = GL_FALSE; GLboolean __EGLEW_NV_stream_metadata = GL_FALSE; GLboolean __EGLEW_NV_stream_remote = GL_FALSE; @@ -17791,6 +19570,36 @@ static GLboolean _glewInit_EGL_ANDROID_create_native_client_buffer () #endif /* EGL_ANDROID_create_native_client_buffer */ +#ifdef EGL_ANDROID_get_frame_timestamps + +static GLboolean _glewInit_EGL_ANDROID_get_frame_timestamps () +{ + GLboolean r = GL_FALSE; + + r = ((eglGetCompositorTimingANDROID = (PFNEGLGETCOMPOSITORTIMINGANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetCompositorTimingANDROID")) == NULL) || r; + r = ((eglGetCompositorTimingSupportedANDROID = (PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetCompositorTimingSupportedANDROID")) == NULL) || r; + r = ((eglGetFrameTimestampSupportedANDROID = (PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetFrameTimestampSupportedANDROID")) == NULL) || r; + r = ((eglGetFrameTimestampsANDROID = (PFNEGLGETFRAMETIMESTAMPSANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetFrameTimestampsANDROID")) == NULL) || r; + r = ((eglGetNextFrameIdANDROID = (PFNEGLGETNEXTFRAMEIDANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetNextFrameIdANDROID")) == NULL) || r; + + return r; +} + +#endif /* EGL_ANDROID_get_frame_timestamps */ + +#ifdef EGL_ANDROID_get_native_client_buffer + +static GLboolean _glewInit_EGL_ANDROID_get_native_client_buffer () +{ + GLboolean r = GL_FALSE; + + r = ((eglGetNativeClientBufferANDROID = (PFNEGLGETNATIVECLIENTBUFFERANDROIDPROC)glewGetProcAddress((const GLubyte*)"eglGetNativeClientBufferANDROID")) == NULL) || r; + + return r; +} + +#endif /* EGL_ANDROID_get_native_client_buffer */ + #ifdef EGL_ANDROID_native_fence_sync static GLboolean _glewInit_EGL_ANDROID_native_fence_sync () @@ -17830,6 +19639,38 @@ static GLboolean _glewInit_EGL_ANGLE_query_surface_pointer () #endif /* EGL_ANGLE_query_surface_pointer */ +#ifdef EGL_EXT_client_sync + +static GLboolean _glewInit_EGL_EXT_client_sync () +{ + GLboolean r = GL_FALSE; + + r = ((eglClientSignalSyncEXT = (PFNEGLCLIENTSIGNALSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"eglClientSignalSyncEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_client_sync */ + +#ifdef EGL_EXT_compositor + +static GLboolean _glewInit_EGL_EXT_compositor () +{ + GLboolean r = GL_FALSE; + + r = ((eglCompositorBindTexWindowEXT = (PFNEGLCOMPOSITORBINDTEXWINDOWEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorBindTexWindowEXT")) == NULL) || r; + r = ((eglCompositorSetContextAttributesEXT = (PFNEGLCOMPOSITORSETCONTEXTATTRIBUTESEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSetContextAttributesEXT")) == NULL) || r; + r = ((eglCompositorSetContextListEXT = (PFNEGLCOMPOSITORSETCONTEXTLISTEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSetContextListEXT")) == NULL) || r; + r = ((eglCompositorSetSizeEXT = (PFNEGLCOMPOSITORSETSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSetSizeEXT")) == NULL) || r; + r = ((eglCompositorSetWindowAttributesEXT = (PFNEGLCOMPOSITORSETWINDOWATTRIBUTESEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSetWindowAttributesEXT")) == NULL) || r; + r = ((eglCompositorSetWindowListEXT = (PFNEGLCOMPOSITORSETWINDOWLISTEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSetWindowListEXT")) == NULL) || r; + r = ((eglCompositorSwapPolicyEXT = (PFNEGLCOMPOSITORSWAPPOLICYEXTPROC)glewGetProcAddress((const GLubyte*)"eglCompositorSwapPolicyEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_compositor */ + #ifdef EGL_EXT_device_enumeration static GLboolean _glewInit_EGL_EXT_device_enumeration () @@ -17933,6 +19774,19 @@ static GLboolean _glewInit_EGL_EXT_swap_buffers_with_damage () #endif /* EGL_EXT_swap_buffers_with_damage */ +#ifdef EGL_EXT_sync_reuse + +static GLboolean _glewInit_EGL_EXT_sync_reuse () +{ + GLboolean r = GL_FALSE; + + r = ((eglUnsignalSyncEXT = (PFNEGLUNSIGNALSYNCEXTPROC)glewGetProcAddress((const GLubyte*)"eglUnsignalSyncEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_sync_reuse */ + #ifdef EGL_HI_clientpixmap static GLboolean _glewInit_EGL_HI_clientpixmap () @@ -17974,6 +19828,19 @@ static GLboolean _glewInit_EGL_KHR_debug () #endif /* EGL_KHR_debug */ +#ifdef EGL_KHR_display_reference + +static GLboolean _glewInit_EGL_KHR_display_reference () +{ + GLboolean r = GL_FALSE; + + r = ((eglQueryDisplayAttribKHR = (PFNEGLQUERYDISPLAYATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryDisplayAttribKHR")) == NULL) || r; + + return r; +} + +#endif /* EGL_KHR_display_reference */ + #ifdef EGL_KHR_image static GLboolean _glewInit_EGL_KHR_image () @@ -18255,6 +20122,19 @@ static GLboolean _glewInit_EGL_NV_stream_consumer_gltexture_yuv () #endif /* EGL_NV_stream_consumer_gltexture_yuv */ +#ifdef EGL_NV_stream_flush + +static GLboolean _glewInit_EGL_NV_stream_flush () +{ + GLboolean r = GL_FALSE; + + r = ((eglStreamFlushNV = (PFNEGLSTREAMFLUSHNVPROC)glewGetProcAddress((const GLubyte*)"eglStreamFlushNV")) == NULL) || r; + + return r; +} + +#endif /* EGL_NV_stream_flush */ + #ifdef EGL_NV_stream_metadata static GLboolean _glewInit_EGL_NV_stream_metadata () @@ -18402,6 +20282,14 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_ANDROID_front_buffer_auto_refresh EGLEW_ANDROID_front_buffer_auto_refresh = _glewSearchExtension("EGL_ANDROID_front_buffer_auto_refresh", extStart, extEnd); #endif /* EGL_ANDROID_front_buffer_auto_refresh */ +#ifdef EGL_ANDROID_get_frame_timestamps + EGLEW_ANDROID_get_frame_timestamps = _glewSearchExtension("EGL_ANDROID_get_frame_timestamps", extStart, extEnd); + if (glewExperimental || EGLEW_ANDROID_get_frame_timestamps) EGLEW_ANDROID_get_frame_timestamps = !_glewInit_EGL_ANDROID_get_frame_timestamps(); +#endif /* EGL_ANDROID_get_frame_timestamps */ +#ifdef EGL_ANDROID_get_native_client_buffer + EGLEW_ANDROID_get_native_client_buffer = _glewSearchExtension("EGL_ANDROID_get_native_client_buffer", extStart, extEnd); + if (glewExperimental || EGLEW_ANDROID_get_native_client_buffer) EGLEW_ANDROID_get_native_client_buffer = !_glewInit_EGL_ANDROID_get_native_client_buffer(); +#endif /* EGL_ANDROID_get_native_client_buffer */ #ifdef EGL_ANDROID_image_native_buffer EGLEW_ANDROID_image_native_buffer = _glewSearchExtension("EGL_ANDROID_image_native_buffer", extStart, extEnd); #endif /* EGL_ANDROID_image_native_buffer */ @@ -18438,12 +20326,23 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_ARM_pixmap_multisample_discard EGLEW_ARM_pixmap_multisample_discard = _glewSearchExtension("EGL_ARM_pixmap_multisample_discard", extStart, extEnd); #endif /* EGL_ARM_pixmap_multisample_discard */ +#ifdef EGL_EXT_bind_to_front + EGLEW_EXT_bind_to_front = _glewSearchExtension("EGL_EXT_bind_to_front", extStart, extEnd); +#endif /* EGL_EXT_bind_to_front */ #ifdef EGL_EXT_buffer_age EGLEW_EXT_buffer_age = _glewSearchExtension("EGL_EXT_buffer_age", extStart, extEnd); #endif /* EGL_EXT_buffer_age */ #ifdef EGL_EXT_client_extensions EGLEW_EXT_client_extensions = _glewSearchExtension("EGL_EXT_client_extensions", extStart, extEnd); #endif /* EGL_EXT_client_extensions */ +#ifdef EGL_EXT_client_sync + EGLEW_EXT_client_sync = _glewSearchExtension("EGL_EXT_client_sync", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_client_sync) EGLEW_EXT_client_sync = !_glewInit_EGL_EXT_client_sync(); +#endif /* EGL_EXT_client_sync */ +#ifdef EGL_EXT_compositor + EGLEW_EXT_compositor = _glewSearchExtension("EGL_EXT_compositor", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_compositor) EGLEW_EXT_compositor = !_glewInit_EGL_EXT_compositor(); +#endif /* EGL_EXT_compositor */ #ifdef EGL_EXT_create_context_robustness EGLEW_EXT_create_context_robustness = _glewSearchExtension("EGL_EXT_create_context_robustness", extStart, extEnd); #endif /* EGL_EXT_create_context_robustness */ @@ -18470,6 +20369,15 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_gl_colorspace_bt2020_pq EGLEW_EXT_gl_colorspace_bt2020_pq = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_pq", extStart, extEnd); #endif /* EGL_EXT_gl_colorspace_bt2020_pq */ +#ifdef EGL_EXT_gl_colorspace_display_p3 + EGLEW_EXT_gl_colorspace_display_p3 = _glewSearchExtension("EGL_EXT_gl_colorspace_display_p3", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_display_p3 */ +#ifdef EGL_EXT_gl_colorspace_display_p3_linear + EGLEW_EXT_gl_colorspace_display_p3_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_display_p3_linear", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_display_p3_linear */ +#ifdef EGL_EXT_gl_colorspace_scrgb + EGLEW_EXT_gl_colorspace_scrgb = _glewSearchExtension("EGL_EXT_gl_colorspace_scrgb", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_scrgb */ #ifdef EGL_EXT_gl_colorspace_scrgb_linear EGLEW_EXT_gl_colorspace_scrgb_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_scrgb_linear", extStart, extEnd); #endif /* EGL_EXT_gl_colorspace_scrgb_linear */ @@ -18480,6 +20388,12 @@ GLenum eglewInit (EGLDisplay display) EGLEW_EXT_image_dma_buf_import_modifiers = _glewSearchExtension("EGL_EXT_image_dma_buf_import_modifiers", extStart, extEnd); if (glewExperimental || EGLEW_EXT_image_dma_buf_import_modifiers) EGLEW_EXT_image_dma_buf_import_modifiers = !_glewInit_EGL_EXT_image_dma_buf_import_modifiers(); #endif /* EGL_EXT_image_dma_buf_import_modifiers */ +#ifdef EGL_EXT_image_gl_colorspace + EGLEW_EXT_image_gl_colorspace = _glewSearchExtension("EGL_EXT_image_gl_colorspace", extStart, extEnd); +#endif /* EGL_EXT_image_gl_colorspace */ +#ifdef EGL_EXT_image_implicit_sync_control + EGLEW_EXT_image_implicit_sync_control = _glewSearchExtension("EGL_EXT_image_implicit_sync_control", extStart, extEnd); +#endif /* EGL_EXT_image_implicit_sync_control */ #ifdef EGL_EXT_multiview_window EGLEW_EXT_multiview_window = _glewSearchExtension("EGL_EXT_multiview_window", extStart, extEnd); #endif /* EGL_EXT_multiview_window */ @@ -18519,6 +20433,9 @@ GLenum eglewInit (EGLDisplay display) EGLEW_EXT_stream_consumer_egloutput = _glewSearchExtension("EGL_EXT_stream_consumer_egloutput", extStart, extEnd); if (glewExperimental || EGLEW_EXT_stream_consumer_egloutput) EGLEW_EXT_stream_consumer_egloutput = !_glewInit_EGL_EXT_stream_consumer_egloutput(); #endif /* EGL_EXT_stream_consumer_egloutput */ +#ifdef EGL_EXT_surface_CTA861_3_metadata + EGLEW_EXT_surface_CTA861_3_metadata = _glewSearchExtension("EGL_EXT_surface_CTA861_3_metadata", extStart, extEnd); +#endif /* EGL_EXT_surface_CTA861_3_metadata */ #ifdef EGL_EXT_surface_SMPTE2086_metadata EGLEW_EXT_surface_SMPTE2086_metadata = _glewSearchExtension("EGL_EXT_surface_SMPTE2086_metadata", extStart, extEnd); #endif /* EGL_EXT_surface_SMPTE2086_metadata */ @@ -18526,6 +20443,10 @@ GLenum eglewInit (EGLDisplay display) EGLEW_EXT_swap_buffers_with_damage = _glewSearchExtension("EGL_EXT_swap_buffers_with_damage", extStart, extEnd); if (glewExperimental || EGLEW_EXT_swap_buffers_with_damage) EGLEW_EXT_swap_buffers_with_damage = !_glewInit_EGL_EXT_swap_buffers_with_damage(); #endif /* EGL_EXT_swap_buffers_with_damage */ +#ifdef EGL_EXT_sync_reuse + EGLEW_EXT_sync_reuse = _glewSearchExtension("EGL_EXT_sync_reuse", extStart, extEnd); + if (glewExperimental || EGLEW_EXT_sync_reuse) EGLEW_EXT_sync_reuse = !_glewInit_EGL_EXT_sync_reuse(); +#endif /* EGL_EXT_sync_reuse */ #ifdef EGL_EXT_yuv_surface EGLEW_EXT_yuv_surface = _glewSearchExtension("EGL_EXT_yuv_surface", extStart, extEnd); #endif /* EGL_EXT_yuv_surface */ @@ -18568,6 +20489,10 @@ GLenum eglewInit (EGLDisplay display) EGLEW_KHR_debug = _glewSearchExtension("EGL_KHR_debug", extStart, extEnd); if (glewExperimental || EGLEW_KHR_debug) EGLEW_KHR_debug = !_glewInit_EGL_KHR_debug(); #endif /* EGL_KHR_debug */ +#ifdef EGL_KHR_display_reference + EGLEW_KHR_display_reference = _glewSearchExtension("EGL_KHR_display_reference", extStart, extEnd); + if (glewExperimental || EGLEW_KHR_display_reference) EGLEW_KHR_display_reference = !_glewInit_EGL_KHR_display_reference(); +#endif /* EGL_KHR_display_reference */ #ifdef EGL_KHR_fence_sync EGLEW_KHR_fence_sync = _glewSearchExtension("EGL_KHR_fence_sync", extStart, extEnd); #endif /* EGL_KHR_fence_sync */ @@ -18705,6 +20630,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_NV_3dvision_surface EGLEW_NV_3dvision_surface = _glewSearchExtension("EGL_NV_3dvision_surface", extStart, extEnd); #endif /* EGL_NV_3dvision_surface */ +#ifdef EGL_NV_context_priority_realtime + EGLEW_NV_context_priority_realtime = _glewSearchExtension("EGL_NV_context_priority_realtime", extStart, extEnd); +#endif /* EGL_NV_context_priority_realtime */ #ifdef EGL_NV_coverage_sample EGLEW_NV_coverage_sample = _glewSearchExtension("EGL_NV_coverage_sample", extStart, extEnd); #endif /* EGL_NV_coverage_sample */ @@ -18759,6 +20687,10 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_NV_stream_fifo_synchronous EGLEW_NV_stream_fifo_synchronous = _glewSearchExtension("EGL_NV_stream_fifo_synchronous", extStart, extEnd); #endif /* EGL_NV_stream_fifo_synchronous */ +#ifdef EGL_NV_stream_flush + EGLEW_NV_stream_flush = _glewSearchExtension("EGL_NV_stream_flush", extStart, extEnd); + if (glewExperimental || EGLEW_NV_stream_flush) EGLEW_NV_stream_flush = !_glewInit_EGL_NV_stream_flush(); +#endif /* EGL_NV_stream_flush */ #ifdef EGL_NV_stream_frame_limits EGLEW_NV_stream_frame_limits = _glewSearchExtension("EGL_NV_stream_frame_limits", extStart, extEnd); #endif /* EGL_NV_stream_frame_limits */ @@ -19927,6 +21859,7 @@ GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE; GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE; GLboolean __GLXEW_EXT_import_context = GL_FALSE; GLboolean __GLXEW_EXT_libglvnd = GL_FALSE; +GLboolean __GLXEW_EXT_no_config_context = GL_FALSE; GLboolean __GLXEW_EXT_scene_marker = GL_FALSE; GLboolean __GLXEW_EXT_stereo_tree = GL_FALSE; GLboolean __GLXEW_EXT_swap_control = GL_FALSE; @@ -20652,6 +22585,9 @@ GLenum glxewInit () #ifdef GLX_EXT_libglvnd GLXEW_EXT_libglvnd = _glewSearchExtension("GLX_EXT_libglvnd", extStart, extEnd); #endif /* GLX_EXT_libglvnd */ +#ifdef GLX_EXT_no_config_context + GLXEW_EXT_no_config_context = _glewSearchExtension("GLX_EXT_no_config_context", extStart, extEnd); +#endif /* GLX_EXT_no_config_context */ #ifdef GLX_EXT_scene_marker GLXEW_EXT_scene_marker = _glewSearchExtension("GLX_EXT_scene_marker", extStart, extEnd); #endif /* GLX_EXT_scene_marker */ @@ -20844,9 +22780,9 @@ const GLubyte * GLEWAPIENTRY glewGetString (GLenum name) static const GLubyte* _glewString[] = { (const GLubyte*)NULL, - (const GLubyte*)"2.1.0", + (const GLubyte*)"2.2.0", + (const GLubyte*)"2", (const GLubyte*)"2", - (const GLubyte*)"1", (const GLubyte*)"0" }; const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; @@ -21103,6 +23039,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_framebuffer_multisample_advanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_advanced", 32)) + { + ret = GLEW_AMD_framebuffer_multisample_advanced; + continue; + } +#endif #ifdef GL_AMD_framebuffer_sample_positions if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sample_positions", 28)) { @@ -21124,6 +23067,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_gpu_shader_half_float_fetch + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_half_float_fetch", 27)) + { + ret = GLEW_AMD_gpu_shader_half_float_fetch; + continue; + } +#endif #ifdef GL_AMD_gpu_shader_int16 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int16", 16)) { @@ -21229,6 +23179,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_shader_image_load_store_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_store_lod", 27)) + { + ret = GLEW_AMD_shader_image_load_store_lod; + continue; + } +#endif #ifdef GL_AMD_shader_stencil_export if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_stencil_export", 21)) { @@ -22994,19 +24951,19 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } #endif } - if (_glewStrSame2(&pos, &len, (const GLubyte*)"EGL_", 4)) + if (_glewStrSame2(&pos, &len, (const GLubyte*)"DMP_", 4)) { -#ifdef GL_EGL_KHR_context_flush_control - if (_glewStrSame3(&pos, &len, (const GLubyte*)"KHR_context_flush_control", 25)) +#ifdef GL_DMP_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14)) { - ret = GLEW_EGL_KHR_context_flush_control; + ret = GLEW_DMP_program_binary; continue; } #endif -#ifdef GL_EGL_NV_robustness_video_memory_purge - if (_glewStrSame3(&pos, &len, (const GLubyte*)"NV_robustness_video_memory_purge", 32)) +#ifdef GL_DMP_shader_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary", 13)) { - ret = GLEW_EGL_NV_robustness_video_memory_purge; + ret = GLEW_DMP_shader_binary; continue; } #endif @@ -23034,6 +24991,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_EGL_image_external_wrap_modes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_external_wrap_modes", 29)) + { + ret = GLEW_EXT_EGL_image_external_wrap_modes; + continue; + } +#endif +#ifdef GL_EXT_EGL_image_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_storage", 17)) + { + ret = GLEW_EXT_EGL_image_storage; + continue; + } +#endif #ifdef GL_EXT_YUV_target if (_glewStrSame3(&pos, &len, (const GLubyte*)"YUV_target", 10)) { @@ -23132,6 +25103,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_clip_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_control", 12)) + { + ret = GLEW_EXT_clip_control; + continue; + } +#endif #ifdef GL_EXT_clip_cull_distance if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_cull_distance", 18)) { @@ -23265,6 +25243,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_disjoint_timer_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"disjoint_timer_query", 20)) + { + ret = GLEW_EXT_disjoint_timer_query; + continue; + } +#endif #ifdef GL_EXT_draw_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) { @@ -23307,6 +25292,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_draw_transform_feedback + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_transform_feedback", 23)) + { + ret = GLEW_EXT_draw_transform_feedback; + continue; + } +#endif #ifdef GL_EXT_external_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"external_buffer", 15)) { @@ -23559,6 +25551,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_occlusion_query_boolean + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query_boolean", 23)) + { + ret = GLEW_EXT_occlusion_query_boolean; + continue; + } +#endif #ifdef GL_EXT_packed_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) { @@ -23636,6 +25635,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_protected_textures + if (_glewStrSame3(&pos, &len, (const GLubyte*)"protected_textures", 18)) + { + ret = GLEW_EXT_protected_textures; + continue; + } +#endif #ifdef GL_EXT_provoking_vertex if (_glewStrSame3(&pos, &len, (const GLubyte*)"provoking_vertex", 16)) { @@ -23678,6 +25684,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_robustness + if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness", 10)) + { + ret = GLEW_EXT_robustness; + continue; + } +#endif #ifdef GL_EXT_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB", 4)) { @@ -23748,6 +25761,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_framebuffer_fetch_non_coherent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_non_coherent", 37)) + { + ret = GLEW_EXT_shader_framebuffer_fetch_non_coherent; + continue; + } +#endif #ifdef GL_EXT_shader_group_vote if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17)) { @@ -23853,6 +25873,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_static_vertex_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_vertex_array", 19)) + { + ret = GLEW_EXT_static_vertex_array; + continue; + } +#endif #ifdef GL_EXT_stencil_clear_tag if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17)) { @@ -23881,6 +25908,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_tessellation_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_point_size", 23)) + { + ret = GLEW_EXT_tessellation_point_size; + continue; + } +#endif +#ifdef GL_EXT_tessellation_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19)) + { + ret = GLEW_EXT_tessellation_shader; + continue; + } +#endif #ifdef GL_EXT_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7)) { @@ -23902,6 +25943,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_EXT_texture_border_clamp; + continue; + } +#endif +#ifdef GL_EXT_texture_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer", 14)) + { + ret = GLEW_EXT_texture_buffer; + continue; + } +#endif #ifdef GL_EXT_texture_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) { @@ -23958,6 +26013,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_compression_s3tc_srgb + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc_srgb", 29)) + { + ret = GLEW_EXT_texture_compression_s3tc_srgb; + continue; + } +#endif #ifdef GL_EXT_texture_cube_map if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) { @@ -24028,6 +26090,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_format_sRGB_override + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_format_sRGB_override", 28)) + { + ret = GLEW_EXT_texture_format_sRGB_override; + continue; + } +#endif #ifdef GL_EXT_texture_integer if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15)) { @@ -24049,6 +26118,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_mirror_clamp_to_edge + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp_to_edge", 28)) + { + ret = GLEW_EXT_texture_mirror_clamp_to_edge; + continue; + } +#endif #ifdef GL_EXT_texture_norm16 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_norm16", 14)) { @@ -24237,6 +26313,47 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_EXT_x11_sync_object; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"FJ_", 3)) + { +#ifdef GL_FJ_shader_binary_GCCSO + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary_GCCSO", 19)) + { + ret = GLEW_FJ_shader_binary_GCCSO; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"GLU_", 4)) + { +#ifdef GL_GLU_EXT_nurbs_tessellator + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EXT_nurbs_tessellator", 21)) + { + ret = GLEW_GLU_EXT_nurbs_tessellator; + continue; + } +#endif +#ifdef GL_GLU_EXT_object_space_tess + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EXT_object_space_tess", 21)) + { + ret = GLEW_GLU_EXT_object_space_tess; + continue; + } +#endif +#ifdef GL_GLU_SGIX_icc_compress + if (_glewStrSame3(&pos, &len, (const GLubyte*)"SGIX_icc_compress", 17)) + { + ret = GLEW_GLU_SGIX_icc_compress; + continue; + } +#endif +#ifdef GL_GLU_SGI_filter4_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"SGI_filter4_parameters", 22)) + { + ret = GLEW_GLU_SGI_filter4_parameters; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8)) @@ -24330,6 +26447,79 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_IBM_vertex_array_lists; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"IMG_", 4)) + { +#ifdef GL_IMG_bindless_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_texture", 16)) + { + ret = GLEW_IMG_bindless_texture; + continue; + } +#endif +#ifdef GL_IMG_framebuffer_downsample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_downsample", 22)) + { + ret = GLEW_IMG_framebuffer_downsample; + continue; + } +#endif +#ifdef GL_IMG_multisampled_render_to_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisampled_render_to_texture", 30)) + { + ret = GLEW_IMG_multisampled_render_to_texture; + continue; + } +#endif +#ifdef GL_IMG_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary", 14)) + { + ret = GLEW_IMG_program_binary; + continue; + } +#endif +#ifdef GL_IMG_read_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) + { + ret = GLEW_IMG_read_format; + continue; + } +#endif +#ifdef GL_IMG_shader_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary", 13)) + { + ret = GLEW_IMG_shader_binary; + continue; + } +#endif +#ifdef GL_IMG_texture_compression_pvrtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_pvrtc", 25)) + { + ret = GLEW_IMG_texture_compression_pvrtc; + continue; + } +#endif +#ifdef GL_IMG_texture_compression_pvrtc2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_pvrtc2", 26)) + { + ret = GLEW_IMG_texture_compression_pvrtc2; + continue; + } +#endif +#ifdef GL_IMG_texture_env_enhanced_fixed_function + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_enhanced_fixed_function", 35)) + { + ret = GLEW_IMG_texture_env_enhanced_fixed_function; + continue; + } +#endif +#ifdef GL_IMG_texture_filter_cubic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_cubic", 20)) + { + ret = GLEW_IMG_texture_filter_cubic; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5)) @@ -24351,6 +26541,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) { +#ifdef GL_INTEL_blackhole_render + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blackhole_render", 16)) + { + ret = GLEW_INTEL_blackhole_render; + continue; + } +#endif #ifdef GL_INTEL_conservative_rasterization if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_rasterization", 26)) { @@ -24503,6 +26700,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) { +#ifdef GL_MESA_framebuffer_flip_y + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_flip_y", 18)) + { + ret = GLEW_MESA_framebuffer_flip_y; + continue; + } +#endif #ifdef GL_MESA_pack_invert if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11)) { @@ -24510,6 +26714,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_MESA_program_binary_formats + if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary_formats", 22)) + { + ret = GLEW_MESA_program_binary_formats; + continue; + } +#endif #ifdef GL_MESA_resize_buffers if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14)) { @@ -24524,6 +26735,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_MESA_tile_raster_order + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tile_raster_order", 17)) + { + ret = GLEW_MESA_tile_raster_order; + continue; + } +#endif #ifdef GL_MESA_window_pos if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) { @@ -24670,6 +26888,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_compute_shader_derivatives + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compute_shader_derivatives", 26)) + { + ret = GLEW_NV_compute_shader_derivatives; + continue; + } +#endif #ifdef GL_NV_conditional_render if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18)) { @@ -24691,6 +26916,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_conservative_raster_pre_snap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_pre_snap", 28)) + { + ret = GLEW_NV_conservative_raster_pre_snap; + continue; + } +#endif #ifdef GL_NV_conservative_raster_pre_snap_triangles if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_pre_snap_triangles", 38)) { @@ -24698,6 +26930,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_conservative_raster_underestimation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_raster_underestimation", 35)) + { + ret = GLEW_NV_conservative_raster_underestimation; + continue; + } +#endif #ifdef GL_NV_copy_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) { @@ -24740,6 +26979,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_depth_nonlinear + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_nonlinear", 15)) + { + ret = GLEW_NV_depth_nonlinear; + continue; + } +#endif #ifdef GL_NV_depth_range_unclamped if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21)) { @@ -24866,6 +27112,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_fragment_shader_barycentric + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_barycentric", 27)) + { + ret = GLEW_NV_fragment_shader_barycentric; + continue; + } +#endif #ifdef GL_NV_fragment_shader_interlock if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader_interlock", 25)) { @@ -25006,6 +27259,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_memory_attachment + if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_attachment", 17)) + { + ret = GLEW_NV_memory_attachment; + continue; + } +#endif +#ifdef GL_NV_mesh_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_shader", 11)) + { + ret = GLEW_NV_mesh_shader; + continue; + } +#endif #ifdef GL_NV_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_coverage", 20)) { @@ -25139,6 +27406,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_query_resource_tag + if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_resource_tag", 18)) + { + ret = GLEW_NV_query_resource_tag; + continue; + } +#endif +#ifdef GL_NV_read_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_buffer", 11)) + { + ret = GLEW_NV_read_buffer; + continue; + } +#endif +#ifdef GL_NV_read_buffer_front + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_buffer_front", 17)) + { + ret = GLEW_NV_read_buffer_front; + continue; + } +#endif #ifdef GL_NV_read_depth if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_depth", 10)) { @@ -25174,6 +27462,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_representative_fragment_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"representative_fragment_test", 28)) + { + ret = GLEW_NV_representative_fragment_test; + continue; + } +#endif #ifdef GL_NV_robustness_video_memory_purge if (_glewStrSame3(&pos, &len, (const GLubyte*)"robustness_video_memory_purge", 29)) { @@ -25202,6 +27497,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_scissor_exclusive + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scissor_exclusive", 17)) + { + ret = GLEW_NV_scissor_exclusive; + continue; + } +#endif #ifdef GL_NV_shader_atomic_counters if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_atomic_counters", 22)) { @@ -25258,6 +27560,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_shader_texture_footprint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_footprint", 24)) + { + ret = GLEW_NV_shader_texture_footprint; + continue; + } +#endif #ifdef GL_NV_shader_thread_group if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_thread_group", 19)) { @@ -25272,6 +27581,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_shading_rate_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_rate_image", 18)) + { + ret = GLEW_NV_shading_rate_image; + continue; + } +#endif #ifdef GL_NV_shadow_samplers_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers_array", 21)) { @@ -25555,12 +27871,439 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4)) { +#ifdef GL_OES_EGL_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image", 9)) + { + ret = GLEW_OES_EGL_image; + continue; + } +#endif +#ifdef GL_OES_EGL_image_external + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_external", 18)) + { + ret = GLEW_OES_EGL_image_external; + continue; + } +#endif +#ifdef GL_OES_EGL_image_external_essl3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_external_essl3", 24)) + { + ret = GLEW_OES_EGL_image_external_essl3; + continue; + } +#endif +#ifdef GL_OES_blend_equation_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23)) + { + ret = GLEW_OES_blend_equation_separate; + continue; + } +#endif +#ifdef GL_OES_blend_func_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19)) + { + ret = GLEW_OES_blend_func_separate; + continue; + } +#endif +#ifdef GL_OES_blend_subtract + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14)) + { + ret = GLEW_OES_blend_subtract; + continue; + } +#endif #ifdef GL_OES_byte_coordinates if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16)) { ret = GLEW_OES_byte_coordinates; continue; } +#endif +#ifdef GL_OES_compressed_ETC1_RGB8_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_ETC1_RGB8_texture", 28)) + { + ret = GLEW_OES_compressed_ETC1_RGB8_texture; + continue; + } +#endif +#ifdef GL_OES_compressed_paletted_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27)) + { + ret = GLEW_OES_compressed_paletted_texture; + continue; + } +#endif +#ifdef GL_OES_copy_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) + { + ret = GLEW_OES_copy_image; + continue; + } +#endif +#ifdef GL_OES_depth24 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth24", 7)) + { + ret = GLEW_OES_depth24; + continue; + } +#endif +#ifdef GL_OES_depth32 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth32", 7)) + { + ret = GLEW_OES_depth32; + continue; + } +#endif +#ifdef GL_OES_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) + { + ret = GLEW_OES_depth_texture; + continue; + } +#endif +#ifdef GL_OES_depth_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture_cube_map", 22)) + { + ret = GLEW_OES_depth_texture_cube_map; + continue; + } +#endif +#ifdef GL_OES_draw_buffers_indexed + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_indexed", 20)) + { + ret = GLEW_OES_draw_buffers_indexed; + continue; + } +#endif +#ifdef GL_OES_draw_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_texture", 12)) + { + ret = GLEW_OES_draw_texture; + continue; + } +#endif +#ifdef GL_OES_element_index_uint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_index_uint", 18)) + { + ret = GLEW_OES_element_index_uint; + continue; + } +#endif +#ifdef GL_OES_extended_matrix_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extended_matrix_palette", 23)) + { + ret = GLEW_OES_extended_matrix_palette; + continue; + } +#endif +#ifdef GL_OES_fbo_render_mipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbo_render_mipmap", 17)) + { + ret = GLEW_OES_fbo_render_mipmap; + continue; + } +#endif +#ifdef GL_OES_fragment_precision_high + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_precision_high", 23)) + { + ret = GLEW_OES_fragment_precision_high; + continue; + } +#endif +#ifdef GL_OES_framebuffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) + { + ret = GLEW_OES_framebuffer_object; + continue; + } +#endif +#ifdef GL_OES_geometry_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_point_size", 19)) + { + ret = GLEW_OES_geometry_point_size; + continue; + } +#endif +#ifdef GL_OES_geometry_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader", 15)) + { + ret = GLEW_OES_geometry_shader; + continue; + } +#endif +#ifdef GL_OES_get_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_program_binary", 18)) + { + ret = GLEW_OES_get_program_binary; + continue; + } +#endif +#ifdef GL_OES_gpu_shader5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) + { + ret = GLEW_OES_gpu_shader5; + continue; + } +#endif +#ifdef GL_OES_mapbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mapbuffer", 9)) + { + ret = GLEW_OES_mapbuffer; + continue; + } +#endif +#ifdef GL_OES_matrix_get + if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_get", 10)) + { + ret = GLEW_OES_matrix_get; + continue; + } +#endif +#ifdef GL_OES_matrix_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14)) + { + ret = GLEW_OES_matrix_palette; + continue; + } +#endif +#ifdef GL_OES_packed_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) + { + ret = GLEW_OES_packed_depth_stencil; + continue; + } +#endif +#ifdef GL_OES_point_size_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_size_array", 16)) + { + ret = GLEW_OES_point_size_array; + continue; + } +#endif +#ifdef GL_OES_point_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) + { + ret = GLEW_OES_point_sprite; + continue; + } +#endif +#ifdef GL_OES_read_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) + { + ret = GLEW_OES_read_format; + continue; + } +#endif +#ifdef GL_OES_required_internalformat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"required_internalformat", 23)) + { + ret = GLEW_OES_required_internalformat; + continue; + } +#endif +#ifdef GL_OES_rgb8_rgba8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgb8_rgba8", 10)) + { + ret = GLEW_OES_rgb8_rgba8; + continue; + } +#endif +#ifdef GL_OES_sample_shading + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_shading", 14)) + { + ret = GLEW_OES_sample_shading; + continue; + } +#endif +#ifdef GL_OES_sample_variables + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_variables", 16)) + { + ret = GLEW_OES_sample_variables; + continue; + } +#endif +#ifdef GL_OES_shader_image_atomic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_atomic", 19)) + { + ret = GLEW_OES_shader_image_atomic; + continue; + } +#endif +#ifdef GL_OES_shader_io_blocks + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_io_blocks", 16)) + { + ret = GLEW_OES_shader_io_blocks; + continue; + } +#endif +#ifdef GL_OES_shader_multisample_interpolation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_multisample_interpolation", 32)) + { + ret = GLEW_OES_shader_multisample_interpolation; + continue; + } +#endif +#ifdef GL_OES_single_precision + if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16)) + { + ret = GLEW_OES_single_precision; + continue; + } +#endif +#ifdef GL_OES_standard_derivatives + if (_glewStrSame3(&pos, &len, (const GLubyte*)"standard_derivatives", 20)) + { + ret = GLEW_OES_standard_derivatives; + continue; + } +#endif +#ifdef GL_OES_stencil1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil1", 8)) + { + ret = GLEW_OES_stencil1; + continue; + } +#endif +#ifdef GL_OES_stencil4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil4", 8)) + { + ret = GLEW_OES_stencil4; + continue; + } +#endif +#ifdef GL_OES_stencil8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil8", 8)) + { + ret = GLEW_OES_stencil8; + continue; + } +#endif +#ifdef GL_OES_surfaceless_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"surfaceless_context", 19)) + { + ret = GLEW_OES_surfaceless_context; + continue; + } +#endif +#ifdef GL_OES_tessellation_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_point_size", 23)) + { + ret = GLEW_OES_tessellation_point_size; + continue; + } +#endif +#ifdef GL_OES_tessellation_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tessellation_shader", 19)) + { + ret = GLEW_OES_tessellation_shader; + continue; + } +#endif +#ifdef GL_OES_texture_3D + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_3D", 10)) + { + ret = GLEW_OES_texture_3D; + continue; + } +#endif +#ifdef GL_OES_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_OES_texture_border_clamp; + continue; + } +#endif +#ifdef GL_OES_texture_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer", 14)) + { + ret = GLEW_OES_texture_buffer; + continue; + } +#endif +#ifdef GL_OES_texture_compression_astc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc", 24)) + { + ret = GLEW_OES_texture_compression_astc; + continue; + } +#endif +#ifdef GL_OES_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) + { + ret = GLEW_OES_texture_cube_map; + continue; + } +#endif +#ifdef GL_OES_texture_cube_map_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22)) + { + ret = GLEW_OES_texture_cube_map_array; + continue; + } +#endif +#ifdef GL_OES_texture_env_crossbar + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20)) + { + ret = GLEW_OES_texture_env_crossbar; + continue; + } +#endif +#ifdef GL_OES_texture_mirrored_repeat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) + { + ret = GLEW_OES_texture_mirrored_repeat; + continue; + } +#endif +#ifdef GL_OES_texture_npot + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_npot", 12)) + { + ret = GLEW_OES_texture_npot; + continue; + } +#endif +#ifdef GL_OES_texture_stencil8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stencil8", 16)) + { + ret = GLEW_OES_texture_stencil8; + continue; + } +#endif +#ifdef GL_OES_texture_storage_multisample_2d_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage_multisample_2d_array", 36)) + { + ret = GLEW_OES_texture_storage_multisample_2d_array; + continue; + } +#endif +#ifdef GL_OES_texture_view + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12)) + { + ret = GLEW_OES_texture_view; + continue; + } +#endif +#ifdef GL_OES_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_OES_vertex_array_object; + continue; + } +#endif +#ifdef GL_OES_vertex_half_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_half_float", 17)) + { + ret = GLEW_OES_vertex_half_float; + continue; + } +#endif +#ifdef GL_OES_vertex_type_10_10_10_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_type_10_10_10_2", 22)) + { + ret = GLEW_OES_vertex_type_10_10_10_2; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) @@ -25686,6 +28429,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_QCOM_shader_framebuffer_fetch_rate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_rate", 29)) + { + ret = GLEW_QCOM_shader_framebuffer_fetch_rate; + continue; + } +#endif +#ifdef GL_QCOM_texture_foveated + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated", 16)) + { + ret = GLEW_QCOM_texture_foveated; + continue; + } +#endif +#ifdef GL_QCOM_texture_foveated_subsampled_layout + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_foveated_subsampled_layout", 34)) + { + ret = GLEW_QCOM_texture_foveated_subsampled_layout; + continue; + } +#endif #ifdef GL_QCOM_tiled_rendering if (_glewStrSame3(&pos, &len, (const GLubyte*)"tiled_rendering", 15)) { @@ -26584,6 +29348,16 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_SUN_vertex; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"VIV_", 4)) + { +#ifdef GL_VIV_shader_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_binary", 13)) + { + ret = GLEW_VIV_shader_binary; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4)) @@ -27269,6 +30043,13 @@ GLboolean glxewIsSupported (const char* name) continue; } #endif +#ifdef GLX_EXT_no_config_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"no_config_context", 17)) + { + ret = GLXEW_EXT_no_config_context; + continue; + } +#endif #ifdef GLX_EXT_scene_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) { @@ -27701,6 +30482,20 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_ANDROID_get_frame_timestamps + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_frame_timestamps", 20)) + { + ret = EGLEW_ANDROID_get_frame_timestamps; + continue; + } +#endif +#ifdef EGL_ANDROID_get_native_client_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_native_client_buffer", 24)) + { + ret = EGLEW_ANDROID_get_native_client_buffer; + continue; + } +#endif #ifdef EGL_ANDROID_image_native_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_native_buffer", 19)) { @@ -27787,6 +30582,13 @@ GLboolean eglewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) { +#ifdef EGL_EXT_bind_to_front + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bind_to_front", 13)) + { + ret = EGLEW_EXT_bind_to_front; + continue; + } +#endif #ifdef EGL_EXT_buffer_age if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_age", 10)) { @@ -27801,6 +30603,20 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_client_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_sync", 11)) + { + ret = EGLEW_EXT_client_sync; + continue; + } +#endif +#ifdef EGL_EXT_compositor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compositor", 10)) + { + ret = EGLEW_EXT_compositor; + continue; + } +#endif #ifdef EGL_EXT_create_context_robustness if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_robustness", 25)) { @@ -27857,6 +30673,27 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_gl_colorspace_display_p3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_display_p3", 24)) + { + ret = EGLEW_EXT_gl_colorspace_display_p3; + continue; + } +#endif +#ifdef EGL_EXT_gl_colorspace_display_p3_linear + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_display_p3_linear", 31)) + { + ret = EGLEW_EXT_gl_colorspace_display_p3_linear; + continue; + } +#endif +#ifdef EGL_EXT_gl_colorspace_scrgb + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_scrgb", 19)) + { + ret = EGLEW_EXT_gl_colorspace_scrgb; + continue; + } +#endif #ifdef EGL_EXT_gl_colorspace_scrgb_linear if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_scrgb_linear", 26)) { @@ -27878,6 +30715,20 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_image_gl_colorspace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_gl_colorspace", 19)) + { + ret = EGLEW_EXT_image_gl_colorspace; + continue; + } +#endif +#ifdef EGL_EXT_image_implicit_sync_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_implicit_sync_control", 27)) + { + ret = EGLEW_EXT_image_implicit_sync_control; + continue; + } +#endif #ifdef EGL_EXT_multiview_window if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_window", 16)) { @@ -27962,6 +30813,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_surface_CTA861_3_metadata + if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_CTA861_3_metadata", 25)) + { + ret = EGLEW_EXT_surface_CTA861_3_metadata; + continue; + } +#endif #ifdef EGL_EXT_surface_SMPTE2086_metadata if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_SMPTE2086_metadata", 26)) { @@ -27976,6 +30834,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_sync_reuse + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_reuse", 10)) + { + ret = EGLEW_EXT_sync_reuse; + continue; + } +#endif #ifdef EGL_EXT_yuv_surface if (_glewStrSame3(&pos, &len, (const GLubyte*)"yuv_surface", 11)) { @@ -28076,6 +30941,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_KHR_display_reference + if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_reference", 17)) + { + ret = EGLEW_KHR_display_reference; + continue; + } +#endif #ifdef EGL_KHR_fence_sync if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence_sync", 10)) { @@ -28365,6 +31237,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_NV_context_priority_realtime + if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_priority_realtime", 25)) + { + ret = EGLEW_NV_context_priority_realtime; + continue; + } +#endif #ifdef EGL_NV_coverage_sample if (_glewStrSame3(&pos, &len, (const GLubyte*)"coverage_sample", 15)) { @@ -28484,6 +31363,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_NV_stream_flush + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_flush", 12)) + { + ret = EGLEW_NV_stream_flush; + continue; + } +#endif #ifdef EGL_NV_stream_frame_limits if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_frame_limits", 19)) { diff --git a/src/glewinfo.c b/src/glewinfo.c index 882654d..c631594 100644 --- a/src/glewinfo.c +++ b/src/glewinfo.c @@ -686,6 +686,18 @@ static void _glewInfo_GL_AMD_draw_buffers_blend (void) #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_multisample_advanced + +static void _glewInfo_GL_AMD_framebuffer_multisample_advanced (void) +{ + glewPrintExt("GL_AMD_framebuffer_multisample_advanced", GLEW_AMD_framebuffer_multisample_advanced, glewIsSupported("GL_AMD_framebuffer_multisample_advanced"), glewGetExtension("GL_AMD_framebuffer_multisample_advanced")); + + glewInfoFunc("glNamedRenderbufferStorageMultisampleAdvancedAMD", glNamedRenderbufferStorageMultisampleAdvancedAMD == NULL); + glewInfoFunc("glRenderbufferStorageMultisampleAdvancedAMD", glRenderbufferStorageMultisampleAdvancedAMD == NULL); +} + +#endif /* GL_AMD_framebuffer_multisample_advanced */ + #ifdef GL_AMD_framebuffer_sample_positions static void _glewInfo_GL_AMD_framebuffer_sample_positions (void) @@ -718,6 +730,15 @@ static void _glewInfo_GL_AMD_gpu_shader_half_float (void) #endif /* GL_AMD_gpu_shader_half_float */ +#ifdef GL_AMD_gpu_shader_half_float_fetch + +static void _glewInfo_GL_AMD_gpu_shader_half_float_fetch (void) +{ + glewPrintExt("GL_AMD_gpu_shader_half_float_fetch", GLEW_AMD_gpu_shader_half_float_fetch, glewIsSupported("GL_AMD_gpu_shader_half_float_fetch"), glewGetExtension("GL_AMD_gpu_shader_half_float_fetch")); +} + +#endif /* GL_AMD_gpu_shader_half_float_fetch */ + #ifdef GL_AMD_gpu_shader_int16 static void _glewInfo_GL_AMD_gpu_shader_int16 (void) @@ -878,6 +899,15 @@ static void _glewInfo_GL_AMD_shader_explicit_vertex_parameter (void) #endif /* GL_AMD_shader_explicit_vertex_parameter */ +#ifdef GL_AMD_shader_image_load_store_lod + +static void _glewInfo_GL_AMD_shader_image_load_store_lod (void) +{ + glewPrintExt("GL_AMD_shader_image_load_store_lod", GLEW_AMD_shader_image_load_store_lod, glewIsSupported("GL_AMD_shader_image_load_store_lod"), glewGetExtension("GL_AMD_shader_image_load_store_lod")); +} + +#endif /* GL_AMD_shader_image_load_store_lod */ + #ifdef GL_AMD_shader_stencil_export static void _glewInfo_GL_AMD_shader_stencil_export (void) @@ -4141,23 +4171,23 @@ static void _glewInfo_GL_ATI_vertex_streams (void) #endif /* GL_ATI_vertex_streams */ -#ifdef GL_EGL_KHR_context_flush_control +#ifdef GL_DMP_program_binary -static void _glewInfo_GL_EGL_KHR_context_flush_control (void) +static void _glewInfo_GL_DMP_program_binary (void) { - glewPrintExt("GL_EGL_KHR_context_flush_control", GLEW_EGL_KHR_context_flush_control, glewIsSupported("GL_EGL_KHR_context_flush_control"), glewGetExtension("GL_EGL_KHR_context_flush_control")); + glewPrintExt("GL_DMP_program_binary", GLEW_DMP_program_binary, glewIsSupported("GL_DMP_program_binary"), glewGetExtension("GL_DMP_program_binary")); } -#endif /* GL_EGL_KHR_context_flush_control */ +#endif /* GL_DMP_program_binary */ -#ifdef GL_EGL_NV_robustness_video_memory_purge +#ifdef GL_DMP_shader_binary -static void _glewInfo_GL_EGL_NV_robustness_video_memory_purge (void) +static void _glewInfo_GL_DMP_shader_binary (void) { - glewPrintExt("GL_EGL_NV_robustness_video_memory_purge", GLEW_EGL_NV_robustness_video_memory_purge, glewIsSupported("GL_EGL_NV_robustness_video_memory_purge"), glewGetExtension("GL_EGL_NV_robustness_video_memory_purge")); + glewPrintExt("GL_DMP_shader_binary", GLEW_DMP_shader_binary, glewIsSupported("GL_DMP_shader_binary"), glewGetExtension("GL_DMP_shader_binary")); } -#endif /* GL_EGL_NV_robustness_video_memory_purge */ +#endif /* GL_DMP_shader_binary */ #ifdef GL_EXT_422_pixels @@ -4186,6 +4216,27 @@ static void _glewInfo_GL_EXT_EGL_image_array (void) #endif /* GL_EXT_EGL_image_array */ +#ifdef GL_EXT_EGL_image_external_wrap_modes + +static void _glewInfo_GL_EXT_EGL_image_external_wrap_modes (void) +{ + glewPrintExt("GL_EXT_EGL_image_external_wrap_modes", GLEW_EXT_EGL_image_external_wrap_modes, glewIsSupported("GL_EXT_EGL_image_external_wrap_modes"), glewGetExtension("GL_EXT_EGL_image_external_wrap_modes")); +} + +#endif /* GL_EXT_EGL_image_external_wrap_modes */ + +#ifdef GL_EXT_EGL_image_storage + +static void _glewInfo_GL_EXT_EGL_image_storage (void) +{ + glewPrintExt("GL_EXT_EGL_image_storage", GLEW_EXT_EGL_image_storage, glewIsSupported("GL_EXT_EGL_image_storage"), glewGetExtension("GL_EXT_EGL_image_storage")); + + glewInfoFunc("glEGLImageTargetTexStorageEXT", glEGLImageTargetTexStorageEXT == NULL); + glewInfoFunc("glEGLImageTargetTextureStorageEXT", glEGLImageTargetTextureStorageEXT == NULL); +} + +#endif /* GL_EXT_EGL_image_storage */ + #ifdef GL_EXT_YUV_target static void _glewInfo_GL_EXT_YUV_target (void) @@ -4338,6 +4389,17 @@ static void _glewInfo_GL_EXT_clear_texture (void) #endif /* GL_EXT_clear_texture */ +#ifdef GL_EXT_clip_control + +static void _glewInfo_GL_EXT_clip_control (void) +{ + glewPrintExt("GL_EXT_clip_control", GLEW_EXT_clip_control, glewIsSupported("GL_EXT_clip_control"), glewGetExtension("GL_EXT_clip_control")); + + glewInfoFunc("glClipControlEXT", glClipControlEXT == NULL); +} + +#endif /* GL_EXT_clip_control */ + #ifdef GL_EXT_clip_cull_distance static void _glewInfo_GL_EXT_clip_cull_distance (void) @@ -4769,6 +4831,25 @@ static void _glewInfo_GL_EXT_discard_framebuffer (void) #endif /* GL_EXT_discard_framebuffer */ +#ifdef GL_EXT_disjoint_timer_query + +static void _glewInfo_GL_EXT_disjoint_timer_query (void) +{ + glewPrintExt("GL_EXT_disjoint_timer_query", GLEW_EXT_disjoint_timer_query, glewIsSupported("GL_EXT_disjoint_timer_query"), glewGetExtension("GL_EXT_disjoint_timer_query")); + + glewInfoFunc("glBeginQueryEXT", glBeginQueryEXT == NULL); + glewInfoFunc("glDeleteQueriesEXT", glDeleteQueriesEXT == NULL); + glewInfoFunc("glEndQueryEXT", glEndQueryEXT == NULL); + glewInfoFunc("glGenQueriesEXT", glGenQueriesEXT == NULL); + glewInfoFunc("glGetQueryObjectivEXT", glGetQueryObjectivEXT == NULL); + glewInfoFunc("glGetQueryObjectuivEXT", glGetQueryObjectuivEXT == NULL); + glewInfoFunc("glGetQueryivEXT", glGetQueryivEXT == NULL); + glewInfoFunc("glIsQueryEXT", glIsQueryEXT == NULL); + glewInfoFunc("glQueryCounterEXT", glQueryCounterEXT == NULL); +} + +#endif /* GL_EXT_disjoint_timer_query */ + #ifdef GL_EXT_draw_buffers static void _glewInfo_GL_EXT_draw_buffers (void) @@ -4851,6 +4932,18 @@ static void _glewInfo_GL_EXT_draw_range_elements (void) #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_draw_transform_feedback + +static void _glewInfo_GL_EXT_draw_transform_feedback (void) +{ + glewPrintExt("GL_EXT_draw_transform_feedback", GLEW_EXT_draw_transform_feedback, glewIsSupported("GL_EXT_draw_transform_feedback"), glewGetExtension("GL_EXT_draw_transform_feedback")); + + glewInfoFunc("glDrawTransformFeedbackEXT", glDrawTransformFeedbackEXT == NULL); + glewInfoFunc("glDrawTransformFeedbackInstancedEXT", glDrawTransformFeedbackInstancedEXT == NULL); +} + +#endif /* GL_EXT_draw_transform_feedback */ + #ifdef GL_EXT_external_buffer static void _glewInfo_GL_EXT_external_buffer (void) @@ -5331,6 +5424,15 @@ static void _glewInfo_GL_EXT_multiview_draw_buffers (void) #endif /* GL_EXT_multiview_draw_buffers */ +#ifdef GL_EXT_occlusion_query_boolean + +static void _glewInfo_GL_EXT_occlusion_query_boolean (void) +{ + glewPrintExt("GL_EXT_occlusion_query_boolean", GLEW_EXT_occlusion_query_boolean, glewIsSupported("GL_EXT_occlusion_query_boolean"), glewGetExtension("GL_EXT_occlusion_query_boolean")); +} + +#endif /* GL_EXT_occlusion_query_boolean */ + #ifdef GL_EXT_packed_depth_stencil static void _glewInfo_GL_EXT_packed_depth_stencil (void) @@ -5449,6 +5551,15 @@ static void _glewInfo_GL_EXT_post_depth_coverage (void) #endif /* GL_EXT_post_depth_coverage */ +#ifdef GL_EXT_protected_textures + +static void _glewInfo_GL_EXT_protected_textures (void) +{ + glewPrintExt("GL_EXT_protected_textures", GLEW_EXT_protected_textures, glewIsSupported("GL_EXT_protected_textures"), glewGetExtension("GL_EXT_protected_textures")); +} + +#endif /* GL_EXT_protected_textures */ + #ifdef GL_EXT_provoking_vertex static void _glewInfo_GL_EXT_provoking_vertex (void) @@ -5510,6 +5621,19 @@ static void _glewInfo_GL_EXT_rescale_normal (void) #endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_robustness + +static void _glewInfo_GL_EXT_robustness (void) +{ + glewPrintExt("GL_EXT_robustness", GLEW_EXT_robustness, glewIsSupported("GL_EXT_robustness"), glewGetExtension("GL_EXT_robustness")); + + glewInfoFunc("glGetnUniformfvEXT", glGetnUniformfvEXT == NULL); + glewInfoFunc("glGetnUniformivEXT", glGetnUniformivEXT == NULL); + glewInfoFunc("glReadnPixelsEXT", glReadnPixelsEXT == NULL); +} + +#endif /* GL_EXT_robustness */ + #ifdef GL_EXT_sRGB static void _glewInfo_GL_EXT_sRGB (void) @@ -5634,10 +5758,21 @@ static void _glewInfo_GL_EXT_separate_specular_color (void) static void _glewInfo_GL_EXT_shader_framebuffer_fetch (void) { glewPrintExt("GL_EXT_shader_framebuffer_fetch", GLEW_EXT_shader_framebuffer_fetch, glewIsSupported("GL_EXT_shader_framebuffer_fetch"), glewGetExtension("GL_EXT_shader_framebuffer_fetch")); + + glewInfoFunc("glFramebufferFetchBarrierEXT", glFramebufferFetchBarrierEXT == NULL); } #endif /* GL_EXT_shader_framebuffer_fetch */ +#ifdef GL_EXT_shader_framebuffer_fetch_non_coherent + +static void _glewInfo_GL_EXT_shader_framebuffer_fetch_non_coherent (void) +{ + glewPrintExt("GL_EXT_shader_framebuffer_fetch_non_coherent", GLEW_EXT_shader_framebuffer_fetch_non_coherent, glewIsSupported("GL_EXT_shader_framebuffer_fetch_non_coherent"), glewGetExtension("GL_EXT_shader_framebuffer_fetch_non_coherent")); +} + +#endif /* GL_EXT_shader_framebuffer_fetch_non_coherent */ + #ifdef GL_EXT_shader_group_vote static void _glewInfo_GL_EXT_shader_group_vote (void) @@ -5783,6 +5918,15 @@ static void _glewInfo_GL_EXT_sparse_texture2 (void) #endif /* GL_EXT_sparse_texture2 */ +#ifdef GL_EXT_static_vertex_array + +static void _glewInfo_GL_EXT_static_vertex_array (void) +{ + glewPrintExt("GL_EXT_static_vertex_array", GLEW_EXT_static_vertex_array, glewIsSupported("GL_EXT_static_vertex_array"), glewGetExtension("GL_EXT_static_vertex_array")); +} + +#endif /* GL_EXT_static_vertex_array */ + #ifdef GL_EXT_stencil_clear_tag static void _glewInfo_GL_EXT_stencil_clear_tag (void) @@ -5825,6 +5969,26 @@ static void _glewInfo_GL_EXT_subtexture (void) #endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_tessellation_point_size + +static void _glewInfo_GL_EXT_tessellation_point_size (void) +{ + glewPrintExt("GL_EXT_tessellation_point_size", GLEW_EXT_tessellation_point_size, glewIsSupported("GL_EXT_tessellation_point_size"), glewGetExtension("GL_EXT_tessellation_point_size")); + + glewInfoFunc("glPatchParameteriEXT", glPatchParameteriEXT == NULL); +} + +#endif /* GL_EXT_tessellation_point_size */ + +#ifdef GL_EXT_tessellation_shader + +static void _glewInfo_GL_EXT_tessellation_shader (void) +{ + glewPrintExt("GL_EXT_tessellation_shader", GLEW_EXT_tessellation_shader, glewIsSupported("GL_EXT_tessellation_shader"), glewGetExtension("GL_EXT_tessellation_shader")); +} + +#endif /* GL_EXT_tessellation_shader */ + #ifdef GL_EXT_texture static void _glewInfo_GL_EXT_texture (void) @@ -5856,6 +6020,29 @@ static void _glewInfo_GL_EXT_texture_array (void) #endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_border_clamp + +static void _glewInfo_GL_EXT_texture_border_clamp (void) +{ + glewPrintExt("GL_EXT_texture_border_clamp", GLEW_EXT_texture_border_clamp, glewIsSupported("GL_EXT_texture_border_clamp"), glewGetExtension("GL_EXT_texture_border_clamp")); + + glewInfoFunc("glGetSamplerParameterIivEXT", glGetSamplerParameterIivEXT == NULL); + glewInfoFunc("glGetSamplerParameterIuivEXT", glGetSamplerParameterIuivEXT == NULL); + glewInfoFunc("glSamplerParameterIivEXT", glSamplerParameterIivEXT == NULL); + glewInfoFunc("glSamplerParameterIuivEXT", glSamplerParameterIuivEXT == NULL); +} + +#endif /* GL_EXT_texture_border_clamp */ + +#ifdef GL_EXT_texture_buffer + +static void _glewInfo_GL_EXT_texture_buffer (void) +{ + glewPrintExt("GL_EXT_texture_buffer", GLEW_EXT_texture_buffer, glewIsSupported("GL_EXT_texture_buffer"), glewGetExtension("GL_EXT_texture_buffer")); +} + +#endif /* GL_EXT_texture_buffer */ + #ifdef GL_EXT_texture_buffer_object static void _glewInfo_GL_EXT_texture_buffer_object (void) @@ -5930,6 +6117,15 @@ static void _glewInfo_GL_EXT_texture_compression_s3tc (void) #endif /* GL_EXT_texture_compression_s3tc */ +#ifdef GL_EXT_texture_compression_s3tc_srgb + +static void _glewInfo_GL_EXT_texture_compression_s3tc_srgb (void) +{ + glewPrintExt("GL_EXT_texture_compression_s3tc_srgb", GLEW_EXT_texture_compression_s3tc_srgb, glewIsSupported("GL_EXT_texture_compression_s3tc_srgb"), glewGetExtension("GL_EXT_texture_compression_s3tc_srgb")); +} + +#endif /* GL_EXT_texture_compression_s3tc_srgb */ + #ifdef GL_EXT_texture_cube_map static void _glewInfo_GL_EXT_texture_cube_map (void) @@ -6020,6 +6216,15 @@ static void _glewInfo_GL_EXT_texture_format_BGRA8888 (void) #endif /* GL_EXT_texture_format_BGRA8888 */ +#ifdef GL_EXT_texture_format_sRGB_override + +static void _glewInfo_GL_EXT_texture_format_sRGB_override (void) +{ + glewPrintExt("GL_EXT_texture_format_sRGB_override", GLEW_EXT_texture_format_sRGB_override, glewIsSupported("GL_EXT_texture_format_sRGB_override"), glewGetExtension("GL_EXT_texture_format_sRGB_override")); +} + +#endif /* GL_EXT_texture_format_sRGB_override */ + #ifdef GL_EXT_texture_integer static void _glewInfo_GL_EXT_texture_integer (void) @@ -6054,6 +6259,15 @@ static void _glewInfo_GL_EXT_texture_mirror_clamp (void) #endif /* GL_EXT_texture_mirror_clamp */ +#ifdef GL_EXT_texture_mirror_clamp_to_edge + +static void _glewInfo_GL_EXT_texture_mirror_clamp_to_edge (void) +{ + glewPrintExt("GL_EXT_texture_mirror_clamp_to_edge", GLEW_EXT_texture_mirror_clamp_to_edge, glewIsSupported("GL_EXT_texture_mirror_clamp_to_edge"), glewGetExtension("GL_EXT_texture_mirror_clamp_to_edge")); +} + +#endif /* GL_EXT_texture_mirror_clamp_to_edge */ + #ifdef GL_EXT_texture_norm16 static void _glewInfo_GL_EXT_texture_norm16 (void) @@ -6405,6 +6619,53 @@ static void _glewInfo_GL_EXT_x11_sync_object (void) #endif /* GL_EXT_x11_sync_object */ +#ifdef GL_FJ_shader_binary_GCCSO + +static void _glewInfo_GL_FJ_shader_binary_GCCSO (void) +{ + glewPrintExt("GL_FJ_shader_binary_GCCSO", GLEW_FJ_shader_binary_GCCSO, glewIsSupported("GL_FJ_shader_binary_GCCSO"), glewGetExtension("GL_FJ_shader_binary_GCCSO")); +} + +#endif /* GL_FJ_shader_binary_GCCSO */ + +#ifdef GL_GLU_EXT_nurbs_tessellator + +static void _glewInfo_GL_GLU_EXT_nurbs_tessellator (void) +{ + glewPrintExt("GL_GLU_EXT_nurbs_tessellator", GLEW_GLU_EXT_nurbs_tessellator, glewIsSupported("GL_GLU_EXT_nurbs_tessellator"), glewGetExtension("GL_GLU_EXT_nurbs_tessellator")); +} + +#endif /* GL_GLU_EXT_nurbs_tessellator */ + +#ifdef GL_GLU_EXT_object_space_tess + +static void _glewInfo_GL_GLU_EXT_object_space_tess (void) +{ + glewPrintExt("GL_GLU_EXT_object_space_tess", GLEW_GLU_EXT_object_space_tess, glewIsSupported("GL_GLU_EXT_object_space_tess"), glewGetExtension("GL_GLU_EXT_object_space_tess")); +} + +#endif /* GL_GLU_EXT_object_space_tess */ + +#ifdef GL_GLU_SGIX_icc_compress + +static void _glewInfo_GL_GLU_SGIX_icc_compress (void) +{ + glewPrintExt("GL_GLU_SGIX_icc_compress", GLEW_GLU_SGIX_icc_compress, glewIsSupported("GL_GLU_SGIX_icc_compress"), glewGetExtension("GL_GLU_SGIX_icc_compress")); +} + +#endif /* GL_GLU_SGIX_icc_compress */ + +#ifdef GL_GLU_SGI_filter4_parameters + +static void _glewInfo_GL_GLU_SGI_filter4_parameters (void) +{ + glewPrintExt("GL_GLU_SGI_filter4_parameters", GLEW_GLU_SGI_filter4_parameters, glewIsSupported("GL_GLU_SGI_filter4_parameters"), glewGetExtension("GL_GLU_SGI_filter4_parameters")); + + glewInfoFunc("gluTexFilterFuncSGI", gluTexFilterFuncSGI == NULL); +} + +#endif /* GL_GLU_SGI_filter4_parameters */ + #ifdef GL_GREMEDY_frame_terminator static void _glewInfo_GL_GREMEDY_frame_terminator (void) @@ -6536,6 +6797,109 @@ static void _glewInfo_GL_IBM_vertex_array_lists (void) #endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_IMG_bindless_texture + +static void _glewInfo_GL_IMG_bindless_texture (void) +{ + glewPrintExt("GL_IMG_bindless_texture", GLEW_IMG_bindless_texture, glewIsSupported("GL_IMG_bindless_texture"), glewGetExtension("GL_IMG_bindless_texture")); + + glewInfoFunc("glGetTextureHandleIMG", glGetTextureHandleIMG == NULL); + glewInfoFunc("glGetTextureSamplerHandleIMG", glGetTextureSamplerHandleIMG == NULL); + glewInfoFunc("glProgramUniformHandleui64IMG", glProgramUniformHandleui64IMG == NULL); + glewInfoFunc("glProgramUniformHandleui64vIMG", glProgramUniformHandleui64vIMG == NULL); + glewInfoFunc("glUniformHandleui64IMG", glUniformHandleui64IMG == NULL); + glewInfoFunc("glUniformHandleui64vIMG", glUniformHandleui64vIMG == NULL); +} + +#endif /* GL_IMG_bindless_texture */ + +#ifdef GL_IMG_framebuffer_downsample + +static void _glewInfo_GL_IMG_framebuffer_downsample (void) +{ + glewPrintExt("GL_IMG_framebuffer_downsample", GLEW_IMG_framebuffer_downsample, glewIsSupported("GL_IMG_framebuffer_downsample"), glewGetExtension("GL_IMG_framebuffer_downsample")); + + glewInfoFunc("glFramebufferTexture2DDownsampleIMG", glFramebufferTexture2DDownsampleIMG == NULL); + glewInfoFunc("glFramebufferTextureLayerDownsampleIMG", glFramebufferTextureLayerDownsampleIMG == NULL); +} + +#endif /* GL_IMG_framebuffer_downsample */ + +#ifdef GL_IMG_multisampled_render_to_texture + +static void _glewInfo_GL_IMG_multisampled_render_to_texture (void) +{ + glewPrintExt("GL_IMG_multisampled_render_to_texture", GLEW_IMG_multisampled_render_to_texture, glewIsSupported("GL_IMG_multisampled_render_to_texture"), glewGetExtension("GL_IMG_multisampled_render_to_texture")); + + glewInfoFunc("glFramebufferTexture2DMultisampleIMG", glFramebufferTexture2DMultisampleIMG == NULL); + glewInfoFunc("glRenderbufferStorageMultisampleIMG", glRenderbufferStorageMultisampleIMG == NULL); +} + +#endif /* GL_IMG_multisampled_render_to_texture */ + +#ifdef GL_IMG_program_binary + +static void _glewInfo_GL_IMG_program_binary (void) +{ + glewPrintExt("GL_IMG_program_binary", GLEW_IMG_program_binary, glewIsSupported("GL_IMG_program_binary"), glewGetExtension("GL_IMG_program_binary")); +} + +#endif /* GL_IMG_program_binary */ + +#ifdef GL_IMG_read_format + +static void _glewInfo_GL_IMG_read_format (void) +{ + glewPrintExt("GL_IMG_read_format", GLEW_IMG_read_format, glewIsSupported("GL_IMG_read_format"), glewGetExtension("GL_IMG_read_format")); +} + +#endif /* GL_IMG_read_format */ + +#ifdef GL_IMG_shader_binary + +static void _glewInfo_GL_IMG_shader_binary (void) +{ + glewPrintExt("GL_IMG_shader_binary", GLEW_IMG_shader_binary, glewIsSupported("GL_IMG_shader_binary"), glewGetExtension("GL_IMG_shader_binary")); +} + +#endif /* GL_IMG_shader_binary */ + +#ifdef GL_IMG_texture_compression_pvrtc + +static void _glewInfo_GL_IMG_texture_compression_pvrtc (void) +{ + glewPrintExt("GL_IMG_texture_compression_pvrtc", GLEW_IMG_texture_compression_pvrtc, glewIsSupported("GL_IMG_texture_compression_pvrtc"), glewGetExtension("GL_IMG_texture_compression_pvrtc")); +} + +#endif /* GL_IMG_texture_compression_pvrtc */ + +#ifdef GL_IMG_texture_compression_pvrtc2 + +static void _glewInfo_GL_IMG_texture_compression_pvrtc2 (void) +{ + glewPrintExt("GL_IMG_texture_compression_pvrtc2", GLEW_IMG_texture_compression_pvrtc2, glewIsSupported("GL_IMG_texture_compression_pvrtc2"), glewGetExtension("GL_IMG_texture_compression_pvrtc2")); +} + +#endif /* GL_IMG_texture_compression_pvrtc2 */ + +#ifdef GL_IMG_texture_env_enhanced_fixed_function + +static void _glewInfo_GL_IMG_texture_env_enhanced_fixed_function (void) +{ + glewPrintExt("GL_IMG_texture_env_enhanced_fixed_function", GLEW_IMG_texture_env_enhanced_fixed_function, glewIsSupported("GL_IMG_texture_env_enhanced_fixed_function"), glewGetExtension("GL_IMG_texture_env_enhanced_fixed_function")); +} + +#endif /* GL_IMG_texture_env_enhanced_fixed_function */ + +#ifdef GL_IMG_texture_filter_cubic + +static void _glewInfo_GL_IMG_texture_filter_cubic (void) +{ + glewPrintExt("GL_IMG_texture_filter_cubic", GLEW_IMG_texture_filter_cubic, glewIsSupported("GL_IMG_texture_filter_cubic"), glewGetExtension("GL_IMG_texture_filter_cubic")); +} + +#endif /* GL_IMG_texture_filter_cubic */ + #ifdef GL_INGR_color_clamp static void _glewInfo_GL_INGR_color_clamp (void) @@ -6554,6 +6918,15 @@ static void _glewInfo_GL_INGR_interlace_read (void) #endif /* GL_INGR_interlace_read */ +#ifdef GL_INTEL_blackhole_render + +static void _glewInfo_GL_INTEL_blackhole_render (void) +{ + glewPrintExt("GL_INTEL_blackhole_render", GLEW_INTEL_blackhole_render, glewIsSupported("GL_INTEL_blackhole_render"), glewGetExtension("GL_INTEL_blackhole_render")); +} + +#endif /* GL_INTEL_blackhole_render */ + #ifdef GL_INTEL_conservative_rasterization static void _glewInfo_GL_INTEL_conservative_rasterization (void) @@ -6783,6 +7156,15 @@ static void _glewInfo_GL_MESAX_texture_stack (void) #endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_framebuffer_flip_y + +static void _glewInfo_GL_MESA_framebuffer_flip_y (void) +{ + glewPrintExt("GL_MESA_framebuffer_flip_y", GLEW_MESA_framebuffer_flip_y, glewIsSupported("GL_MESA_framebuffer_flip_y"), glewGetExtension("GL_MESA_framebuffer_flip_y")); +} + +#endif /* GL_MESA_framebuffer_flip_y */ + #ifdef GL_MESA_pack_invert static void _glewInfo_GL_MESA_pack_invert (void) @@ -6792,6 +7174,15 @@ static void _glewInfo_GL_MESA_pack_invert (void) #endif /* GL_MESA_pack_invert */ +#ifdef GL_MESA_program_binary_formats + +static void _glewInfo_GL_MESA_program_binary_formats (void) +{ + glewPrintExt("GL_MESA_program_binary_formats", GLEW_MESA_program_binary_formats, glewIsSupported("GL_MESA_program_binary_formats"), glewGetExtension("GL_MESA_program_binary_formats")); +} + +#endif /* GL_MESA_program_binary_formats */ + #ifdef GL_MESA_resize_buffers static void _glewInfo_GL_MESA_resize_buffers (void) @@ -6812,6 +7203,15 @@ static void _glewInfo_GL_MESA_shader_integer_functions (void) #endif /* GL_MESA_shader_integer_functions */ +#ifdef GL_MESA_tile_raster_order + +static void _glewInfo_GL_MESA_tile_raster_order (void) +{ + glewPrintExt("GL_MESA_tile_raster_order", GLEW_MESA_tile_raster_order, glewIsSupported("GL_MESA_tile_raster_order"), glewGetExtension("GL_MESA_tile_raster_order")); +} + +#endif /* GL_MESA_tile_raster_order */ + #ifdef GL_MESA_window_pos static void _glewInfo_GL_MESA_window_pos (void) @@ -7070,6 +7470,15 @@ static void _glewInfo_GL_NV_compute_program5 (void) #endif /* GL_NV_compute_program5 */ +#ifdef GL_NV_compute_shader_derivatives + +static void _glewInfo_GL_NV_compute_shader_derivatives (void) +{ + glewPrintExt("GL_NV_compute_shader_derivatives", GLEW_NV_compute_shader_derivatives, glewIsSupported("GL_NV_compute_shader_derivatives"), glewGetExtension("GL_NV_compute_shader_derivatives")); +} + +#endif /* GL_NV_compute_shader_derivatives */ + #ifdef GL_NV_conditional_render static void _glewInfo_GL_NV_conditional_render (void) @@ -7104,6 +7513,15 @@ static void _glewInfo_GL_NV_conservative_raster_dilate (void) #endif /* GL_NV_conservative_raster_dilate */ +#ifdef GL_NV_conservative_raster_pre_snap + +static void _glewInfo_GL_NV_conservative_raster_pre_snap (void) +{ + glewPrintExt("GL_NV_conservative_raster_pre_snap", GLEW_NV_conservative_raster_pre_snap, glewIsSupported("GL_NV_conservative_raster_pre_snap"), glewGetExtension("GL_NV_conservative_raster_pre_snap")); +} + +#endif /* GL_NV_conservative_raster_pre_snap */ + #ifdef GL_NV_conservative_raster_pre_snap_triangles static void _glewInfo_GL_NV_conservative_raster_pre_snap_triangles (void) @@ -7115,6 +7533,15 @@ static void _glewInfo_GL_NV_conservative_raster_pre_snap_triangles (void) #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +#ifdef GL_NV_conservative_raster_underestimation + +static void _glewInfo_GL_NV_conservative_raster_underestimation (void) +{ + glewPrintExt("GL_NV_conservative_raster_underestimation", GLEW_NV_conservative_raster_underestimation, glewIsSupported("GL_NV_conservative_raster_underestimation"), glewGetExtension("GL_NV_conservative_raster_underestimation")); +} + +#endif /* GL_NV_conservative_raster_underestimation */ + #ifdef GL_NV_copy_buffer static void _glewInfo_GL_NV_copy_buffer (void) @@ -7177,6 +7604,15 @@ static void _glewInfo_GL_NV_depth_clamp (void) #endif /* GL_NV_depth_clamp */ +#ifdef GL_NV_depth_nonlinear + +static void _glewInfo_GL_NV_depth_nonlinear (void) +{ + glewPrintExt("GL_NV_depth_nonlinear", GLEW_NV_depth_nonlinear, glewIsSupported("GL_NV_depth_nonlinear"), glewGetExtension("GL_NV_depth_nonlinear")); +} + +#endif /* GL_NV_depth_nonlinear */ + #ifdef GL_NV_depth_range_unclamped static void _glewInfo_GL_NV_depth_range_unclamped (void) @@ -7383,6 +7819,15 @@ static void _glewInfo_GL_NV_fragment_program_option (void) #endif /* GL_NV_fragment_program_option */ +#ifdef GL_NV_fragment_shader_barycentric + +static void _glewInfo_GL_NV_fragment_shader_barycentric (void) +{ + glewPrintExt("GL_NV_fragment_shader_barycentric", GLEW_NV_fragment_shader_barycentric, glewIsSupported("GL_NV_fragment_shader_barycentric"), glewGetExtension("GL_NV_fragment_shader_barycentric")); +} + +#endif /* GL_NV_fragment_shader_barycentric */ + #ifdef GL_NV_fragment_shader_interlock static void _glewInfo_GL_NV_fragment_shader_interlock (void) @@ -7683,6 +8128,36 @@ static void _glewInfo_GL_NV_light_max_exponent (void) #endif /* GL_NV_light_max_exponent */ +#ifdef GL_NV_memory_attachment + +static void _glewInfo_GL_NV_memory_attachment (void) +{ + glewPrintExt("GL_NV_memory_attachment", GLEW_NV_memory_attachment, glewIsSupported("GL_NV_memory_attachment"), glewGetExtension("GL_NV_memory_attachment")); + + glewInfoFunc("glBufferAttachMemoryNV", glBufferAttachMemoryNV == NULL); + glewInfoFunc("glGetMemoryObjectDetachedResourcesuivNV", glGetMemoryObjectDetachedResourcesuivNV == NULL); + glewInfoFunc("glNamedBufferAttachMemoryNV", glNamedBufferAttachMemoryNV == NULL); + glewInfoFunc("glResetMemoryObjectParameterNV", glResetMemoryObjectParameterNV == NULL); + glewInfoFunc("glTexAttachMemoryNV", glTexAttachMemoryNV == NULL); + glewInfoFunc("glTextureAttachMemoryNV", glTextureAttachMemoryNV == NULL); +} + +#endif /* GL_NV_memory_attachment */ + +#ifdef GL_NV_mesh_shader + +static void _glewInfo_GL_NV_mesh_shader (void) +{ + glewPrintExt("GL_NV_mesh_shader", GLEW_NV_mesh_shader, glewIsSupported("GL_NV_mesh_shader"), glewGetExtension("GL_NV_mesh_shader")); + + glewInfoFunc("glDrawMeshTasksIndirectNV", glDrawMeshTasksIndirectNV == NULL); + glewInfoFunc("glDrawMeshTasksNV", glDrawMeshTasksNV == NULL); + glewInfoFunc("glMultiDrawMeshTasksIndirectCountNV", glMultiDrawMeshTasksIndirectCountNV == NULL); + glewInfoFunc("glMultiDrawMeshTasksIndirectNV", glMultiDrawMeshTasksIndirectNV == NULL); +} + +#endif /* GL_NV_mesh_shader */ + #ifdef GL_NV_multisample_coverage static void _glewInfo_GL_NV_multisample_coverage (void) @@ -7956,6 +8431,35 @@ static void _glewInfo_GL_NV_primitive_restart (void) #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_query_resource_tag + +static void _glewInfo_GL_NV_query_resource_tag (void) +{ + glewPrintExt("GL_NV_query_resource_tag", GLEW_NV_query_resource_tag, glewIsSupported("GL_NV_query_resource_tag"), glewGetExtension("GL_NV_query_resource_tag")); +} + +#endif /* GL_NV_query_resource_tag */ + +#ifdef GL_NV_read_buffer + +static void _glewInfo_GL_NV_read_buffer (void) +{ + glewPrintExt("GL_NV_read_buffer", GLEW_NV_read_buffer, glewIsSupported("GL_NV_read_buffer"), glewGetExtension("GL_NV_read_buffer")); + + glewInfoFunc("glReadBufferNV", glReadBufferNV == NULL); +} + +#endif /* GL_NV_read_buffer */ + +#ifdef GL_NV_read_buffer_front + +static void _glewInfo_GL_NV_read_buffer_front (void) +{ + glewPrintExt("GL_NV_read_buffer_front", GLEW_NV_read_buffer_front, glewIsSupported("GL_NV_read_buffer_front"), glewGetExtension("GL_NV_read_buffer_front")); +} + +#endif /* GL_NV_read_buffer_front */ + #ifdef GL_NV_read_depth static void _glewInfo_GL_NV_read_depth (void) @@ -8018,6 +8522,15 @@ static void _glewInfo_GL_NV_register_combiners2 (void) #endif /* GL_NV_register_combiners2 */ +#ifdef GL_NV_representative_fragment_test + +static void _glewInfo_GL_NV_representative_fragment_test (void) +{ + glewPrintExt("GL_NV_representative_fragment_test", GLEW_NV_representative_fragment_test, glewIsSupported("GL_NV_representative_fragment_test"), glewGetExtension("GL_NV_representative_fragment_test")); +} + +#endif /* GL_NV_representative_fragment_test */ + #ifdef GL_NV_robustness_video_memory_purge static void _glewInfo_GL_NV_robustness_video_memory_purge (void) @@ -8044,6 +8557,7 @@ static void _glewInfo_GL_NV_sample_locations (void) glewInfoFunc("glFramebufferSampleLocationsfvNV", glFramebufferSampleLocationsfvNV == NULL); glewInfoFunc("glNamedFramebufferSampleLocationsfvNV", glNamedFramebufferSampleLocationsfvNV == NULL); + glewInfoFunc("glResolveDepthValuesNV", glResolveDepthValuesNV == NULL); } #endif /* GL_NV_sample_locations */ @@ -8057,6 +8571,18 @@ static void _glewInfo_GL_NV_sample_mask_override_coverage (void) #endif /* GL_NV_sample_mask_override_coverage */ +#ifdef GL_NV_scissor_exclusive + +static void _glewInfo_GL_NV_scissor_exclusive (void) +{ + glewPrintExt("GL_NV_scissor_exclusive", GLEW_NV_scissor_exclusive, glewIsSupported("GL_NV_scissor_exclusive"), glewGetExtension("GL_NV_scissor_exclusive")); + + glewInfoFunc("glScissorExclusiveArrayvNV", glScissorExclusiveArrayvNV == NULL); + glewInfoFunc("glScissorExclusiveNV", glScissorExclusiveNV == NULL); +} + +#endif /* GL_NV_scissor_exclusive */ + #ifdef GL_NV_shader_atomic_counters static void _glewInfo_GL_NV_shader_atomic_counters (void) @@ -8143,6 +8669,15 @@ static void _glewInfo_GL_NV_shader_storage_buffer_object (void) #endif /* GL_NV_shader_storage_buffer_object */ +#ifdef GL_NV_shader_texture_footprint + +static void _glewInfo_GL_NV_shader_texture_footprint (void) +{ + glewPrintExt("GL_NV_shader_texture_footprint", GLEW_NV_shader_texture_footprint, glewIsSupported("GL_NV_shader_texture_footprint"), glewGetExtension("GL_NV_shader_texture_footprint")); +} + +#endif /* GL_NV_shader_texture_footprint */ + #ifdef GL_NV_shader_thread_group static void _glewInfo_GL_NV_shader_thread_group (void) @@ -8161,6 +8696,22 @@ static void _glewInfo_GL_NV_shader_thread_shuffle (void) #endif /* GL_NV_shader_thread_shuffle */ +#ifdef GL_NV_shading_rate_image + +static void _glewInfo_GL_NV_shading_rate_image (void) +{ + glewPrintExt("GL_NV_shading_rate_image", GLEW_NV_shading_rate_image, glewIsSupported("GL_NV_shading_rate_image"), glewGetExtension("GL_NV_shading_rate_image")); + + glewInfoFunc("glBindShadingRateImageNV", glBindShadingRateImageNV == NULL); + glewInfoFunc("glGetShadingRateImagePaletteNV", glGetShadingRateImagePaletteNV == NULL); + glewInfoFunc("glGetShadingRateSampleLocationivNV", glGetShadingRateSampleLocationivNV == NULL); + glewInfoFunc("glShadingRateImageBarrierNV", glShadingRateImageBarrierNV == NULL); + glewInfoFunc("glShadingRateImagePaletteNV", glShadingRateImagePaletteNV == NULL); + glewInfoFunc("glShadingRateSampleOrderCustomNV", glShadingRateSampleOrderCustomNV == NULL); +} + +#endif /* GL_NV_shading_rate_image */ + #ifdef GL_NV_shadow_samplers_array static void _glewInfo_GL_NV_shadow_samplers_array (void) @@ -8697,6 +9248,69 @@ static void _glewInfo_GL_NV_viewport_swizzle (void) #endif /* GL_NV_viewport_swizzle */ +#ifdef GL_OES_EGL_image + +static void _glewInfo_GL_OES_EGL_image (void) +{ + glewPrintExt("GL_OES_EGL_image", GLEW_OES_EGL_image, glewIsSupported("GL_OES_EGL_image"), glewGetExtension("GL_OES_EGL_image")); + + glewInfoFunc("glEGLImageTargetRenderbufferStorageOES", glEGLImageTargetRenderbufferStorageOES == NULL); + glewInfoFunc("glEGLImageTargetTexture2DOES", glEGLImageTargetTexture2DOES == NULL); +} + +#endif /* GL_OES_EGL_image */ + +#ifdef GL_OES_EGL_image_external + +static void _glewInfo_GL_OES_EGL_image_external (void) +{ + glewPrintExt("GL_OES_EGL_image_external", GLEW_OES_EGL_image_external, glewIsSupported("GL_OES_EGL_image_external"), glewGetExtension("GL_OES_EGL_image_external")); +} + +#endif /* GL_OES_EGL_image_external */ + +#ifdef GL_OES_EGL_image_external_essl3 + +static void _glewInfo_GL_OES_EGL_image_external_essl3 (void) +{ + glewPrintExt("GL_OES_EGL_image_external_essl3", GLEW_OES_EGL_image_external_essl3, glewIsSupported("GL_OES_EGL_image_external_essl3"), glewGetExtension("GL_OES_EGL_image_external_essl3")); +} + +#endif /* GL_OES_EGL_image_external_essl3 */ + +#ifdef GL_OES_blend_equation_separate + +static void _glewInfo_GL_OES_blend_equation_separate (void) +{ + glewPrintExt("GL_OES_blend_equation_separate", GLEW_OES_blend_equation_separate, glewIsSupported("GL_OES_blend_equation_separate"), glewGetExtension("GL_OES_blend_equation_separate")); + + glewInfoFunc("glBlendEquationSeparateOES", glBlendEquationSeparateOES == NULL); +} + +#endif /* GL_OES_blend_equation_separate */ + +#ifdef GL_OES_blend_func_separate + +static void _glewInfo_GL_OES_blend_func_separate (void) +{ + glewPrintExt("GL_OES_blend_func_separate", GLEW_OES_blend_func_separate, glewIsSupported("GL_OES_blend_func_separate"), glewGetExtension("GL_OES_blend_func_separate")); + + glewInfoFunc("glBlendFuncSeparateOES", glBlendFuncSeparateOES == NULL); +} + +#endif /* GL_OES_blend_func_separate */ + +#ifdef GL_OES_blend_subtract + +static void _glewInfo_GL_OES_blend_subtract (void) +{ + glewPrintExt("GL_OES_blend_subtract", GLEW_OES_blend_subtract, glewIsSupported("GL_OES_blend_subtract"), glewGetExtension("GL_OES_blend_subtract")); + + glewInfoFunc("glBlendEquationOES", glBlendEquationOES == NULL); +} + +#endif /* GL_OES_blend_subtract */ + #ifdef GL_OES_byte_coordinates static void _glewInfo_GL_OES_byte_coordinates (void) @@ -8706,6 +9320,586 @@ static void _glewInfo_GL_OES_byte_coordinates (void) #endif /* GL_OES_byte_coordinates */ +#ifdef GL_OES_compressed_ETC1_RGB8_texture + +static void _glewInfo_GL_OES_compressed_ETC1_RGB8_texture (void) +{ + glewPrintExt("GL_OES_compressed_ETC1_RGB8_texture", GLEW_OES_compressed_ETC1_RGB8_texture, glewIsSupported("GL_OES_compressed_ETC1_RGB8_texture"), glewGetExtension("GL_OES_compressed_ETC1_RGB8_texture")); +} + +#endif /* GL_OES_compressed_ETC1_RGB8_texture */ + +#ifdef GL_OES_compressed_paletted_texture + +static void _glewInfo_GL_OES_compressed_paletted_texture (void) +{ + glewPrintExt("GL_OES_compressed_paletted_texture", GLEW_OES_compressed_paletted_texture, glewIsSupported("GL_OES_compressed_paletted_texture"), glewGetExtension("GL_OES_compressed_paletted_texture")); +} + +#endif /* GL_OES_compressed_paletted_texture */ + +#ifdef GL_OES_copy_image + +static void _glewInfo_GL_OES_copy_image (void) +{ + glewPrintExt("GL_OES_copy_image", GLEW_OES_copy_image, glewIsSupported("GL_OES_copy_image"), glewGetExtension("GL_OES_copy_image")); + + glewInfoFunc("glCopyImageSubDataOES", glCopyImageSubDataOES == NULL); +} + +#endif /* GL_OES_copy_image */ + +#ifdef GL_OES_depth24 + +static void _glewInfo_GL_OES_depth24 (void) +{ + glewPrintExt("GL_OES_depth24", GLEW_OES_depth24, glewIsSupported("GL_OES_depth24"), glewGetExtension("GL_OES_depth24")); +} + +#endif /* GL_OES_depth24 */ + +#ifdef GL_OES_depth32 + +static void _glewInfo_GL_OES_depth32 (void) +{ + glewPrintExt("GL_OES_depth32", GLEW_OES_depth32, glewIsSupported("GL_OES_depth32"), glewGetExtension("GL_OES_depth32")); +} + +#endif /* GL_OES_depth32 */ + +#ifdef GL_OES_depth_texture + +static void _glewInfo_GL_OES_depth_texture (void) +{ + glewPrintExt("GL_OES_depth_texture", GLEW_OES_depth_texture, glewIsSupported("GL_OES_depth_texture"), glewGetExtension("GL_OES_depth_texture")); +} + +#endif /* GL_OES_depth_texture */ + +#ifdef GL_OES_depth_texture_cube_map + +static void _glewInfo_GL_OES_depth_texture_cube_map (void) +{ + glewPrintExt("GL_OES_depth_texture_cube_map", GLEW_OES_depth_texture_cube_map, glewIsSupported("GL_OES_depth_texture_cube_map"), glewGetExtension("GL_OES_depth_texture_cube_map")); +} + +#endif /* GL_OES_depth_texture_cube_map */ + +#ifdef GL_OES_draw_buffers_indexed + +static void _glewInfo_GL_OES_draw_buffers_indexed (void) +{ + glewPrintExt("GL_OES_draw_buffers_indexed", GLEW_OES_draw_buffers_indexed, glewIsSupported("GL_OES_draw_buffers_indexed"), glewGetExtension("GL_OES_draw_buffers_indexed")); + + glewInfoFunc("glBlendEquationSeparateiOES", glBlendEquationSeparateiOES == NULL); + glewInfoFunc("glBlendEquationiOES", glBlendEquationiOES == NULL); + glewInfoFunc("glBlendFuncSeparateiOES", glBlendFuncSeparateiOES == NULL); + glewInfoFunc("glBlendFunciOES", glBlendFunciOES == NULL); + glewInfoFunc("glColorMaskiOES", glColorMaskiOES == NULL); + glewInfoFunc("glDisableiOES", glDisableiOES == NULL); + glewInfoFunc("glEnableiOES", glEnableiOES == NULL); + glewInfoFunc("glIsEnablediOES", glIsEnablediOES == NULL); +} + +#endif /* GL_OES_draw_buffers_indexed */ + +#ifdef GL_OES_draw_texture + +static void _glewInfo_GL_OES_draw_texture (void) +{ + glewPrintExt("GL_OES_draw_texture", GLEW_OES_draw_texture, glewIsSupported("GL_OES_draw_texture"), glewGetExtension("GL_OES_draw_texture")); +} + +#endif /* GL_OES_draw_texture */ + +#ifdef GL_OES_element_index_uint + +static void _glewInfo_GL_OES_element_index_uint (void) +{ + glewPrintExt("GL_OES_element_index_uint", GLEW_OES_element_index_uint, glewIsSupported("GL_OES_element_index_uint"), glewGetExtension("GL_OES_element_index_uint")); +} + +#endif /* GL_OES_element_index_uint */ + +#ifdef GL_OES_extended_matrix_palette + +static void _glewInfo_GL_OES_extended_matrix_palette (void) +{ + glewPrintExt("GL_OES_extended_matrix_palette", GLEW_OES_extended_matrix_palette, glewIsSupported("GL_OES_extended_matrix_palette"), glewGetExtension("GL_OES_extended_matrix_palette")); +} + +#endif /* GL_OES_extended_matrix_palette */ + +#ifdef GL_OES_fbo_render_mipmap + +static void _glewInfo_GL_OES_fbo_render_mipmap (void) +{ + glewPrintExt("GL_OES_fbo_render_mipmap", GLEW_OES_fbo_render_mipmap, glewIsSupported("GL_OES_fbo_render_mipmap"), glewGetExtension("GL_OES_fbo_render_mipmap")); +} + +#endif /* GL_OES_fbo_render_mipmap */ + +#ifdef GL_OES_fragment_precision_high + +static void _glewInfo_GL_OES_fragment_precision_high (void) +{ + glewPrintExt("GL_OES_fragment_precision_high", GLEW_OES_fragment_precision_high, glewIsSupported("GL_OES_fragment_precision_high"), glewGetExtension("GL_OES_fragment_precision_high")); +} + +#endif /* GL_OES_fragment_precision_high */ + +#ifdef GL_OES_framebuffer_object + +static void _glewInfo_GL_OES_framebuffer_object (void) +{ + glewPrintExt("GL_OES_framebuffer_object", GLEW_OES_framebuffer_object, glewIsSupported("GL_OES_framebuffer_object"), glewGetExtension("GL_OES_framebuffer_object")); + + glewInfoFunc("glBindFramebufferOES", glBindFramebufferOES == NULL); + glewInfoFunc("glBindRenderbufferOES", glBindRenderbufferOES == NULL); + glewInfoFunc("glCheckFramebufferStatusOES", glCheckFramebufferStatusOES == NULL); + glewInfoFunc("glDeleteFramebuffersOES", glDeleteFramebuffersOES == NULL); + glewInfoFunc("glDeleteRenderbuffersOES", glDeleteRenderbuffersOES == NULL); + glewInfoFunc("glFramebufferRenderbufferOES", glFramebufferRenderbufferOES == NULL); + glewInfoFunc("glFramebufferTexture2DOES", glFramebufferTexture2DOES == NULL); + glewInfoFunc("glGenFramebuffersOES", glGenFramebuffersOES == NULL); + glewInfoFunc("glGenRenderbuffersOES", glGenRenderbuffersOES == NULL); + glewInfoFunc("glGenerateMipmapOES", glGenerateMipmapOES == NULL); + glewInfoFunc("glGetFramebufferAttachmentParameterivOES", glGetFramebufferAttachmentParameterivOES == NULL); + glewInfoFunc("glGetRenderbufferParameterivOES", glGetRenderbufferParameterivOES == NULL); + glewInfoFunc("glIsFramebufferOES", glIsFramebufferOES == NULL); + glewInfoFunc("glIsRenderbufferOES", glIsRenderbufferOES == NULL); + glewInfoFunc("glRenderbufferStorageOES", glRenderbufferStorageOES == NULL); +} + +#endif /* GL_OES_framebuffer_object */ + +#ifdef GL_OES_geometry_point_size + +static void _glewInfo_GL_OES_geometry_point_size (void) +{ + glewPrintExt("GL_OES_geometry_point_size", GLEW_OES_geometry_point_size, glewIsSupported("GL_OES_geometry_point_size"), glewGetExtension("GL_OES_geometry_point_size")); +} + +#endif /* GL_OES_geometry_point_size */ + +#ifdef GL_OES_geometry_shader + +static void _glewInfo_GL_OES_geometry_shader (void) +{ + glewPrintExt("GL_OES_geometry_shader", GLEW_OES_geometry_shader, glewIsSupported("GL_OES_geometry_shader"), glewGetExtension("GL_OES_geometry_shader")); +} + +#endif /* GL_OES_geometry_shader */ + +#ifdef GL_OES_get_program_binary + +static void _glewInfo_GL_OES_get_program_binary (void) +{ + glewPrintExt("GL_OES_get_program_binary", GLEW_OES_get_program_binary, glewIsSupported("GL_OES_get_program_binary"), glewGetExtension("GL_OES_get_program_binary")); + + glewInfoFunc("glGetProgramBinaryOES", glGetProgramBinaryOES == NULL); + glewInfoFunc("glProgramBinaryOES", glProgramBinaryOES == NULL); +} + +#endif /* GL_OES_get_program_binary */ + +#ifdef GL_OES_gpu_shader5 + +static void _glewInfo_GL_OES_gpu_shader5 (void) +{ + glewPrintExt("GL_OES_gpu_shader5", GLEW_OES_gpu_shader5, glewIsSupported("GL_OES_gpu_shader5"), glewGetExtension("GL_OES_gpu_shader5")); +} + +#endif /* GL_OES_gpu_shader5 */ + +#ifdef GL_OES_mapbuffer + +static void _glewInfo_GL_OES_mapbuffer (void) +{ + glewPrintExt("GL_OES_mapbuffer", GLEW_OES_mapbuffer, glewIsSupported("GL_OES_mapbuffer"), glewGetExtension("GL_OES_mapbuffer")); + + glewInfoFunc("glGetBufferPointervOES", glGetBufferPointervOES == NULL); + glewInfoFunc("glMapBufferOES", glMapBufferOES == NULL); + glewInfoFunc("glUnmapBufferOES", glUnmapBufferOES == NULL); +} + +#endif /* GL_OES_mapbuffer */ + +#ifdef GL_OES_matrix_get + +static void _glewInfo_GL_OES_matrix_get (void) +{ + glewPrintExt("GL_OES_matrix_get", GLEW_OES_matrix_get, glewIsSupported("GL_OES_matrix_get"), glewGetExtension("GL_OES_matrix_get")); +} + +#endif /* GL_OES_matrix_get */ + +#ifdef GL_OES_matrix_palette + +static void _glewInfo_GL_OES_matrix_palette (void) +{ + glewPrintExt("GL_OES_matrix_palette", GLEW_OES_matrix_palette, glewIsSupported("GL_OES_matrix_palette"), glewGetExtension("GL_OES_matrix_palette")); + + glewInfoFunc("glCurrentPaletteMatrixOES", glCurrentPaletteMatrixOES == NULL); + glewInfoFunc("glMatrixIndexPointerOES", glMatrixIndexPointerOES == NULL); + glewInfoFunc("glWeightPointerOES", glWeightPointerOES == NULL); +} + +#endif /* GL_OES_matrix_palette */ + +#ifdef GL_OES_packed_depth_stencil + +static void _glewInfo_GL_OES_packed_depth_stencil (void) +{ + glewPrintExt("GL_OES_packed_depth_stencil", GLEW_OES_packed_depth_stencil, glewIsSupported("GL_OES_packed_depth_stencil"), glewGetExtension("GL_OES_packed_depth_stencil")); +} + +#endif /* GL_OES_packed_depth_stencil */ + +#ifdef GL_OES_point_size_array + +static void _glewInfo_GL_OES_point_size_array (void) +{ + glewPrintExt("GL_OES_point_size_array", GLEW_OES_point_size_array, glewIsSupported("GL_OES_point_size_array"), glewGetExtension("GL_OES_point_size_array")); +} + +#endif /* GL_OES_point_size_array */ + +#ifdef GL_OES_point_sprite + +static void _glewInfo_GL_OES_point_sprite (void) +{ + glewPrintExt("GL_OES_point_sprite", GLEW_OES_point_sprite, glewIsSupported("GL_OES_point_sprite"), glewGetExtension("GL_OES_point_sprite")); +} + +#endif /* GL_OES_point_sprite */ + +#ifdef GL_OES_read_format + +static void _glewInfo_GL_OES_read_format (void) +{ + glewPrintExt("GL_OES_read_format", GLEW_OES_read_format, glewIsSupported("GL_OES_read_format"), glewGetExtension("GL_OES_read_format")); +} + +#endif /* GL_OES_read_format */ + +#ifdef GL_OES_required_internalformat + +static void _glewInfo_GL_OES_required_internalformat (void) +{ + glewPrintExt("GL_OES_required_internalformat", GLEW_OES_required_internalformat, glewIsSupported("GL_OES_required_internalformat"), glewGetExtension("GL_OES_required_internalformat")); +} + +#endif /* GL_OES_required_internalformat */ + +#ifdef GL_OES_rgb8_rgba8 + +static void _glewInfo_GL_OES_rgb8_rgba8 (void) +{ + glewPrintExt("GL_OES_rgb8_rgba8", GLEW_OES_rgb8_rgba8, glewIsSupported("GL_OES_rgb8_rgba8"), glewGetExtension("GL_OES_rgb8_rgba8")); +} + +#endif /* GL_OES_rgb8_rgba8 */ + +#ifdef GL_OES_sample_shading + +static void _glewInfo_GL_OES_sample_shading (void) +{ + glewPrintExt("GL_OES_sample_shading", GLEW_OES_sample_shading, glewIsSupported("GL_OES_sample_shading"), glewGetExtension("GL_OES_sample_shading")); + + glewInfoFunc("glMinSampleShadingOES", glMinSampleShadingOES == NULL); +} + +#endif /* GL_OES_sample_shading */ + +#ifdef GL_OES_sample_variables + +static void _glewInfo_GL_OES_sample_variables (void) +{ + glewPrintExt("GL_OES_sample_variables", GLEW_OES_sample_variables, glewIsSupported("GL_OES_sample_variables"), glewGetExtension("GL_OES_sample_variables")); +} + +#endif /* GL_OES_sample_variables */ + +#ifdef GL_OES_shader_image_atomic + +static void _glewInfo_GL_OES_shader_image_atomic (void) +{ + glewPrintExt("GL_OES_shader_image_atomic", GLEW_OES_shader_image_atomic, glewIsSupported("GL_OES_shader_image_atomic"), glewGetExtension("GL_OES_shader_image_atomic")); +} + +#endif /* GL_OES_shader_image_atomic */ + +#ifdef GL_OES_shader_io_blocks + +static void _glewInfo_GL_OES_shader_io_blocks (void) +{ + glewPrintExt("GL_OES_shader_io_blocks", GLEW_OES_shader_io_blocks, glewIsSupported("GL_OES_shader_io_blocks"), glewGetExtension("GL_OES_shader_io_blocks")); +} + +#endif /* GL_OES_shader_io_blocks */ + +#ifdef GL_OES_shader_multisample_interpolation + +static void _glewInfo_GL_OES_shader_multisample_interpolation (void) +{ + glewPrintExt("GL_OES_shader_multisample_interpolation", GLEW_OES_shader_multisample_interpolation, glewIsSupported("GL_OES_shader_multisample_interpolation"), glewGetExtension("GL_OES_shader_multisample_interpolation")); +} + +#endif /* GL_OES_shader_multisample_interpolation */ + +#ifdef GL_OES_single_precision + +static void _glewInfo_GL_OES_single_precision (void) +{ + glewPrintExt("GL_OES_single_precision", GLEW_OES_single_precision, glewIsSupported("GL_OES_single_precision"), glewGetExtension("GL_OES_single_precision")); + + glewInfoFunc("glClearDepthfOES", glClearDepthfOES == NULL); + glewInfoFunc("glClipPlanefOES", glClipPlanefOES == NULL); + glewInfoFunc("glDepthRangefOES", glDepthRangefOES == NULL); + glewInfoFunc("glFrustumfOES", glFrustumfOES == NULL); + glewInfoFunc("glGetClipPlanefOES", glGetClipPlanefOES == NULL); + glewInfoFunc("glOrthofOES", glOrthofOES == NULL); +} + +#endif /* GL_OES_single_precision */ + +#ifdef GL_OES_standard_derivatives + +static void _glewInfo_GL_OES_standard_derivatives (void) +{ + glewPrintExt("GL_OES_standard_derivatives", GLEW_OES_standard_derivatives, glewIsSupported("GL_OES_standard_derivatives"), glewGetExtension("GL_OES_standard_derivatives")); +} + +#endif /* GL_OES_standard_derivatives */ + +#ifdef GL_OES_stencil1 + +static void _glewInfo_GL_OES_stencil1 (void) +{ + glewPrintExt("GL_OES_stencil1", GLEW_OES_stencil1, glewIsSupported("GL_OES_stencil1"), glewGetExtension("GL_OES_stencil1")); +} + +#endif /* GL_OES_stencil1 */ + +#ifdef GL_OES_stencil4 + +static void _glewInfo_GL_OES_stencil4 (void) +{ + glewPrintExt("GL_OES_stencil4", GLEW_OES_stencil4, glewIsSupported("GL_OES_stencil4"), glewGetExtension("GL_OES_stencil4")); +} + +#endif /* GL_OES_stencil4 */ + +#ifdef GL_OES_stencil8 + +static void _glewInfo_GL_OES_stencil8 (void) +{ + glewPrintExt("GL_OES_stencil8", GLEW_OES_stencil8, glewIsSupported("GL_OES_stencil8"), glewGetExtension("GL_OES_stencil8")); +} + +#endif /* GL_OES_stencil8 */ + +#ifdef GL_OES_surfaceless_context + +static void _glewInfo_GL_OES_surfaceless_context (void) +{ + glewPrintExt("GL_OES_surfaceless_context", GLEW_OES_surfaceless_context, glewIsSupported("GL_OES_surfaceless_context"), glewGetExtension("GL_OES_surfaceless_context")); +} + +#endif /* GL_OES_surfaceless_context */ + +#ifdef GL_OES_tessellation_point_size + +static void _glewInfo_GL_OES_tessellation_point_size (void) +{ + glewPrintExt("GL_OES_tessellation_point_size", GLEW_OES_tessellation_point_size, glewIsSupported("GL_OES_tessellation_point_size"), glewGetExtension("GL_OES_tessellation_point_size")); +} + +#endif /* GL_OES_tessellation_point_size */ + +#ifdef GL_OES_tessellation_shader + +static void _glewInfo_GL_OES_tessellation_shader (void) +{ + glewPrintExt("GL_OES_tessellation_shader", GLEW_OES_tessellation_shader, glewIsSupported("GL_OES_tessellation_shader"), glewGetExtension("GL_OES_tessellation_shader")); +} + +#endif /* GL_OES_tessellation_shader */ + +#ifdef GL_OES_texture_3D + +static void _glewInfo_GL_OES_texture_3D (void) +{ + glewPrintExt("GL_OES_texture_3D", GLEW_OES_texture_3D, glewIsSupported("GL_OES_texture_3D"), glewGetExtension("GL_OES_texture_3D")); + + glewInfoFunc("glCompressedTexImage3DOES", glCompressedTexImage3DOES == NULL); + glewInfoFunc("glCompressedTexSubImage3DOES", glCompressedTexSubImage3DOES == NULL); + glewInfoFunc("glCopyTexSubImage3DOES", glCopyTexSubImage3DOES == NULL); + glewInfoFunc("glFramebufferTexture3DOES", glFramebufferTexture3DOES == NULL); + glewInfoFunc("glTexImage3DOES", glTexImage3DOES == NULL); + glewInfoFunc("glTexSubImage3DOES", glTexSubImage3DOES == NULL); +} + +#endif /* GL_OES_texture_3D */ + +#ifdef GL_OES_texture_border_clamp + +static void _glewInfo_GL_OES_texture_border_clamp (void) +{ + glewPrintExt("GL_OES_texture_border_clamp", GLEW_OES_texture_border_clamp, glewIsSupported("GL_OES_texture_border_clamp"), glewGetExtension("GL_OES_texture_border_clamp")); + + glewInfoFunc("glGetSamplerParameterIivOES", glGetSamplerParameterIivOES == NULL); + glewInfoFunc("glGetSamplerParameterIuivOES", glGetSamplerParameterIuivOES == NULL); + glewInfoFunc("glGetTexParameterIivOES", glGetTexParameterIivOES == NULL); + glewInfoFunc("glGetTexParameterIuivOES", glGetTexParameterIuivOES == NULL); + glewInfoFunc("glSamplerParameterIivOES", glSamplerParameterIivOES == NULL); + glewInfoFunc("glSamplerParameterIuivOES", glSamplerParameterIuivOES == NULL); + glewInfoFunc("glTexParameterIivOES", glTexParameterIivOES == NULL); + glewInfoFunc("glTexParameterIuivOES", glTexParameterIuivOES == NULL); +} + +#endif /* GL_OES_texture_border_clamp */ + +#ifdef GL_OES_texture_buffer + +static void _glewInfo_GL_OES_texture_buffer (void) +{ + glewPrintExt("GL_OES_texture_buffer", GLEW_OES_texture_buffer, glewIsSupported("GL_OES_texture_buffer"), glewGetExtension("GL_OES_texture_buffer")); + + glewInfoFunc("glTexBufferOES", glTexBufferOES == NULL); + glewInfoFunc("glTexBufferRangeOES", glTexBufferRangeOES == NULL); +} + +#endif /* GL_OES_texture_buffer */ + +#ifdef GL_OES_texture_compression_astc + +static void _glewInfo_GL_OES_texture_compression_astc (void) +{ + glewPrintExt("GL_OES_texture_compression_astc", GLEW_OES_texture_compression_astc, glewIsSupported("GL_OES_texture_compression_astc"), glewGetExtension("GL_OES_texture_compression_astc")); +} + +#endif /* GL_OES_texture_compression_astc */ + +#ifdef GL_OES_texture_cube_map + +static void _glewInfo_GL_OES_texture_cube_map (void) +{ + glewPrintExt("GL_OES_texture_cube_map", GLEW_OES_texture_cube_map, glewIsSupported("GL_OES_texture_cube_map"), glewGetExtension("GL_OES_texture_cube_map")); + + glewInfoFunc("glGetTexGenfvOES", glGetTexGenfvOES == NULL); + glewInfoFunc("glGetTexGenivOES", glGetTexGenivOES == NULL); + glewInfoFunc("glGetTexGenxvOES", glGetTexGenxvOES == NULL); + glewInfoFunc("glTexGenfOES", glTexGenfOES == NULL); + glewInfoFunc("glTexGenfvOES", glTexGenfvOES == NULL); + glewInfoFunc("glTexGeniOES", glTexGeniOES == NULL); + glewInfoFunc("glTexGenivOES", glTexGenivOES == NULL); + glewInfoFunc("glTexGenxOES", glTexGenxOES == NULL); + glewInfoFunc("glTexGenxvOES", glTexGenxvOES == NULL); +} + +#endif /* GL_OES_texture_cube_map */ + +#ifdef GL_OES_texture_cube_map_array + +static void _glewInfo_GL_OES_texture_cube_map_array (void) +{ + glewPrintExt("GL_OES_texture_cube_map_array", GLEW_OES_texture_cube_map_array, glewIsSupported("GL_OES_texture_cube_map_array"), glewGetExtension("GL_OES_texture_cube_map_array")); +} + +#endif /* GL_OES_texture_cube_map_array */ + +#ifdef GL_OES_texture_env_crossbar + +static void _glewInfo_GL_OES_texture_env_crossbar (void) +{ + glewPrintExt("GL_OES_texture_env_crossbar", GLEW_OES_texture_env_crossbar, glewIsSupported("GL_OES_texture_env_crossbar"), glewGetExtension("GL_OES_texture_env_crossbar")); +} + +#endif /* GL_OES_texture_env_crossbar */ + +#ifdef GL_OES_texture_mirrored_repeat + +static void _glewInfo_GL_OES_texture_mirrored_repeat (void) +{ + glewPrintExt("GL_OES_texture_mirrored_repeat", GLEW_OES_texture_mirrored_repeat, glewIsSupported("GL_OES_texture_mirrored_repeat"), glewGetExtension("GL_OES_texture_mirrored_repeat")); +} + +#endif /* GL_OES_texture_mirrored_repeat */ + +#ifdef GL_OES_texture_npot + +static void _glewInfo_GL_OES_texture_npot (void) +{ + glewPrintExt("GL_OES_texture_npot", GLEW_OES_texture_npot, glewIsSupported("GL_OES_texture_npot"), glewGetExtension("GL_OES_texture_npot")); +} + +#endif /* GL_OES_texture_npot */ + +#ifdef GL_OES_texture_stencil8 + +static void _glewInfo_GL_OES_texture_stencil8 (void) +{ + glewPrintExt("GL_OES_texture_stencil8", GLEW_OES_texture_stencil8, glewIsSupported("GL_OES_texture_stencil8"), glewGetExtension("GL_OES_texture_stencil8")); +} + +#endif /* GL_OES_texture_stencil8 */ + +#ifdef GL_OES_texture_storage_multisample_2d_array + +static void _glewInfo_GL_OES_texture_storage_multisample_2d_array (void) +{ + glewPrintExt("GL_OES_texture_storage_multisample_2d_array", GLEW_OES_texture_storage_multisample_2d_array, glewIsSupported("GL_OES_texture_storage_multisample_2d_array"), glewGetExtension("GL_OES_texture_storage_multisample_2d_array")); + + glewInfoFunc("glTexStorage3DMultisampleOES", glTexStorage3DMultisampleOES == NULL); +} + +#endif /* GL_OES_texture_storage_multisample_2d_array */ + +#ifdef GL_OES_texture_view + +static void _glewInfo_GL_OES_texture_view (void) +{ + glewPrintExt("GL_OES_texture_view", GLEW_OES_texture_view, glewIsSupported("GL_OES_texture_view"), glewGetExtension("GL_OES_texture_view")); + + glewInfoFunc("glTextureViewOES", glTextureViewOES == NULL); +} + +#endif /* GL_OES_texture_view */ + +#ifdef GL_OES_vertex_array_object + +static void _glewInfo_GL_OES_vertex_array_object (void) +{ + glewPrintExt("GL_OES_vertex_array_object", GLEW_OES_vertex_array_object, glewIsSupported("GL_OES_vertex_array_object"), glewGetExtension("GL_OES_vertex_array_object")); + + glewInfoFunc("glBindVertexArrayOES", glBindVertexArrayOES == NULL); + glewInfoFunc("glDeleteVertexArraysOES", glDeleteVertexArraysOES == NULL); + glewInfoFunc("glGenVertexArraysOES", glGenVertexArraysOES == NULL); + glewInfoFunc("glIsVertexArrayOES", glIsVertexArrayOES == NULL); +} + +#endif /* GL_OES_vertex_array_object */ + +#ifdef GL_OES_vertex_half_float + +static void _glewInfo_GL_OES_vertex_half_float (void) +{ + glewPrintExt("GL_OES_vertex_half_float", GLEW_OES_vertex_half_float, glewIsSupported("GL_OES_vertex_half_float"), glewGetExtension("GL_OES_vertex_half_float")); +} + +#endif /* GL_OES_vertex_half_float */ + +#ifdef GL_OES_vertex_type_10_10_10_2 + +static void _glewInfo_GL_OES_vertex_type_10_10_10_2 (void) +{ + glewPrintExt("GL_OES_vertex_type_10_10_10_2", GLEW_OES_vertex_type_10_10_10_2, glewIsSupported("GL_OES_vertex_type_10_10_10_2"), glewGetExtension("GL_OES_vertex_type_10_10_10_2")); +} + +#endif /* GL_OES_vertex_type_10_10_10_2 */ + #ifdef GL_OML_interlace static void _glewInfo_GL_OML_interlace (void) @@ -8740,6 +9934,7 @@ static void _glewInfo_GL_OVR_multiview (void) glewPrintExt("GL_OVR_multiview", GLEW_OVR_multiview, glewIsSupported("GL_OVR_multiview"), glewGetExtension("GL_OVR_multiview")); glewInfoFunc("glFramebufferTextureMultiviewOVR", glFramebufferTextureMultiviewOVR == NULL); + glewInfoFunc("glNamedFramebufferTextureMultiviewOVR", glNamedFramebufferTextureMultiviewOVR == NULL); } #endif /* GL_OVR_multiview */ @@ -8880,6 +10075,35 @@ static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent (void) #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_shader_framebuffer_fetch_rate + +static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate (void) +{ + glewPrintExt("GL_QCOM_shader_framebuffer_fetch_rate", GLEW_QCOM_shader_framebuffer_fetch_rate, glewIsSupported("GL_QCOM_shader_framebuffer_fetch_rate"), glewGetExtension("GL_QCOM_shader_framebuffer_fetch_rate")); +} + +#endif /* GL_QCOM_shader_framebuffer_fetch_rate */ + +#ifdef GL_QCOM_texture_foveated + +static void _glewInfo_GL_QCOM_texture_foveated (void) +{ + glewPrintExt("GL_QCOM_texture_foveated", GLEW_QCOM_texture_foveated, glewIsSupported("GL_QCOM_texture_foveated"), glewGetExtension("GL_QCOM_texture_foveated")); + + glewInfoFunc("glTextureFoveationParametersQCOM", glTextureFoveationParametersQCOM == NULL); +} + +#endif /* GL_QCOM_texture_foveated */ + +#ifdef GL_QCOM_texture_foveated_subsampled_layout + +static void _glewInfo_GL_QCOM_texture_foveated_subsampled_layout (void) +{ + glewPrintExt("GL_QCOM_texture_foveated_subsampled_layout", GLEW_QCOM_texture_foveated_subsampled_layout, glewIsSupported("GL_QCOM_texture_foveated_subsampled_layout"), glewGetExtension("GL_QCOM_texture_foveated_subsampled_layout")); +} + +#endif /* GL_QCOM_texture_foveated_subsampled_layout */ + #ifdef GL_QCOM_tiled_rendering static void _glewInfo_GL_QCOM_tiled_rendering (void) @@ -10249,6 +11473,15 @@ static void _glewInfo_GL_SUN_vertex (void) #endif /* GL_SUN_vertex */ +#ifdef GL_VIV_shader_binary + +static void _glewInfo_GL_VIV_shader_binary (void) +{ + glewPrintExt("GL_VIV_shader_binary", GLEW_VIV_shader_binary, glewIsSupported("GL_VIV_shader_binary"), glewGetExtension("GL_VIV_shader_binary")); +} + +#endif /* GL_VIV_shader_binary */ + #ifdef GL_WIN_phong_shading static void _glewInfo_GL_WIN_phong_shading (void) @@ -10431,6 +11664,32 @@ static void _glewInfo_EGL_ANDROID_front_buffer_auto_refresh (void) #endif /* EGL_ANDROID_front_buffer_auto_refresh */ +#ifdef EGL_ANDROID_get_frame_timestamps + +static void _glewInfo_EGL_ANDROID_get_frame_timestamps (void) +{ + glewPrintExt("EGL_ANDROID_get_frame_timestamps", EGLEW_ANDROID_get_frame_timestamps, eglewIsSupported("EGL_ANDROID_get_frame_timestamps"), eglewGetExtension("EGL_ANDROID_get_frame_timestamps")); + + glewInfoFunc("eglGetCompositorTimingANDROID", eglGetCompositorTimingANDROID == NULL); + glewInfoFunc("eglGetCompositorTimingSupportedANDROID", eglGetCompositorTimingSupportedANDROID == NULL); + glewInfoFunc("eglGetFrameTimestampSupportedANDROID", eglGetFrameTimestampSupportedANDROID == NULL); + glewInfoFunc("eglGetFrameTimestampsANDROID", eglGetFrameTimestampsANDROID == NULL); + glewInfoFunc("eglGetNextFrameIdANDROID", eglGetNextFrameIdANDROID == NULL); +} + +#endif /* EGL_ANDROID_get_frame_timestamps */ + +#ifdef EGL_ANDROID_get_native_client_buffer + +static void _glewInfo_EGL_ANDROID_get_native_client_buffer (void) +{ + glewPrintExt("EGL_ANDROID_get_native_client_buffer", EGLEW_ANDROID_get_native_client_buffer, eglewIsSupported("EGL_ANDROID_get_native_client_buffer"), eglewGetExtension("EGL_ANDROID_get_native_client_buffer")); + + glewInfoFunc("eglGetNativeClientBufferANDROID", eglGetNativeClientBufferANDROID == NULL); +} + +#endif /* EGL_ANDROID_get_native_client_buffer */ + #ifdef EGL_ANDROID_image_native_buffer static void _glewInfo_EGL_ANDROID_image_native_buffer (void) @@ -10536,6 +11795,15 @@ static void _glewInfo_EGL_ARM_pixmap_multisample_discard (void) #endif /* EGL_ARM_pixmap_multisample_discard */ +#ifdef EGL_EXT_bind_to_front + +static void _glewInfo_EGL_EXT_bind_to_front (void) +{ + glewPrintExt("EGL_EXT_bind_to_front", EGLEW_EXT_bind_to_front, eglewIsSupported("EGL_EXT_bind_to_front"), eglewGetExtension("EGL_EXT_bind_to_front")); +} + +#endif /* EGL_EXT_bind_to_front */ + #ifdef EGL_EXT_buffer_age static void _glewInfo_EGL_EXT_buffer_age (void) @@ -10554,6 +11822,34 @@ static void _glewInfo_EGL_EXT_client_extensions (void) #endif /* EGL_EXT_client_extensions */ +#ifdef EGL_EXT_client_sync + +static void _glewInfo_EGL_EXT_client_sync (void) +{ + glewPrintExt("EGL_EXT_client_sync", EGLEW_EXT_client_sync, eglewIsSupported("EGL_EXT_client_sync"), eglewGetExtension("EGL_EXT_client_sync")); + + glewInfoFunc("eglClientSignalSyncEXT", eglClientSignalSyncEXT == NULL); +} + +#endif /* EGL_EXT_client_sync */ + +#ifdef EGL_EXT_compositor + +static void _glewInfo_EGL_EXT_compositor (void) +{ + glewPrintExt("EGL_EXT_compositor", EGLEW_EXT_compositor, eglewIsSupported("EGL_EXT_compositor"), eglewGetExtension("EGL_EXT_compositor")); + + glewInfoFunc("eglCompositorBindTexWindowEXT", eglCompositorBindTexWindowEXT == NULL); + glewInfoFunc("eglCompositorSetContextAttributesEXT", eglCompositorSetContextAttributesEXT == NULL); + glewInfoFunc("eglCompositorSetContextListEXT", eglCompositorSetContextListEXT == NULL); + glewInfoFunc("eglCompositorSetSizeEXT", eglCompositorSetSizeEXT == NULL); + glewInfoFunc("eglCompositorSetWindowAttributesEXT", eglCompositorSetWindowAttributesEXT == NULL); + glewInfoFunc("eglCompositorSetWindowListEXT", eglCompositorSetWindowListEXT == NULL); + glewInfoFunc("eglCompositorSwapPolicyEXT", eglCompositorSwapPolicyEXT == NULL); +} + +#endif /* EGL_EXT_compositor */ + #ifdef EGL_EXT_create_context_robustness static void _glewInfo_EGL_EXT_create_context_robustness (void) @@ -10632,6 +11928,33 @@ static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_pq (void) #endif /* EGL_EXT_gl_colorspace_bt2020_pq */ +#ifdef EGL_EXT_gl_colorspace_display_p3 + +static void _glewInfo_EGL_EXT_gl_colorspace_display_p3 (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_display_p3", EGLEW_EXT_gl_colorspace_display_p3, eglewIsSupported("EGL_EXT_gl_colorspace_display_p3"), eglewGetExtension("EGL_EXT_gl_colorspace_display_p3")); +} + +#endif /* EGL_EXT_gl_colorspace_display_p3 */ + +#ifdef EGL_EXT_gl_colorspace_display_p3_linear + +static void _glewInfo_EGL_EXT_gl_colorspace_display_p3_linear (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_display_p3_linear", EGLEW_EXT_gl_colorspace_display_p3_linear, eglewIsSupported("EGL_EXT_gl_colorspace_display_p3_linear"), eglewGetExtension("EGL_EXT_gl_colorspace_display_p3_linear")); +} + +#endif /* EGL_EXT_gl_colorspace_display_p3_linear */ + +#ifdef EGL_EXT_gl_colorspace_scrgb + +static void _glewInfo_EGL_EXT_gl_colorspace_scrgb (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_scrgb", EGLEW_EXT_gl_colorspace_scrgb, eglewIsSupported("EGL_EXT_gl_colorspace_scrgb"), eglewGetExtension("EGL_EXT_gl_colorspace_scrgb")); +} + +#endif /* EGL_EXT_gl_colorspace_scrgb */ + #ifdef EGL_EXT_gl_colorspace_scrgb_linear static void _glewInfo_EGL_EXT_gl_colorspace_scrgb_linear (void) @@ -10662,6 +11985,24 @@ static void _glewInfo_EGL_EXT_image_dma_buf_import_modifiers (void) #endif /* EGL_EXT_image_dma_buf_import_modifiers */ +#ifdef EGL_EXT_image_gl_colorspace + +static void _glewInfo_EGL_EXT_image_gl_colorspace (void) +{ + glewPrintExt("EGL_EXT_image_gl_colorspace", EGLEW_EXT_image_gl_colorspace, eglewIsSupported("EGL_EXT_image_gl_colorspace"), eglewGetExtension("EGL_EXT_image_gl_colorspace")); +} + +#endif /* EGL_EXT_image_gl_colorspace */ + +#ifdef EGL_EXT_image_implicit_sync_control + +static void _glewInfo_EGL_EXT_image_implicit_sync_control (void) +{ + glewPrintExt("EGL_EXT_image_implicit_sync_control", EGLEW_EXT_image_implicit_sync_control, eglewIsSupported("EGL_EXT_image_implicit_sync_control"), eglewGetExtension("EGL_EXT_image_implicit_sync_control")); +} + +#endif /* EGL_EXT_image_implicit_sync_control */ + #ifdef EGL_EXT_multiview_window static void _glewInfo_EGL_EXT_multiview_window (void) @@ -10785,6 +12126,15 @@ static void _glewInfo_EGL_EXT_stream_consumer_egloutput (void) #endif /* EGL_EXT_stream_consumer_egloutput */ +#ifdef EGL_EXT_surface_CTA861_3_metadata + +static void _glewInfo_EGL_EXT_surface_CTA861_3_metadata (void) +{ + glewPrintExt("EGL_EXT_surface_CTA861_3_metadata", EGLEW_EXT_surface_CTA861_3_metadata, eglewIsSupported("EGL_EXT_surface_CTA861_3_metadata"), eglewGetExtension("EGL_EXT_surface_CTA861_3_metadata")); +} + +#endif /* EGL_EXT_surface_CTA861_3_metadata */ + #ifdef EGL_EXT_surface_SMPTE2086_metadata static void _glewInfo_EGL_EXT_surface_SMPTE2086_metadata (void) @@ -10805,6 +12155,17 @@ static void _glewInfo_EGL_EXT_swap_buffers_with_damage (void) #endif /* EGL_EXT_swap_buffers_with_damage */ +#ifdef EGL_EXT_sync_reuse + +static void _glewInfo_EGL_EXT_sync_reuse (void) +{ + glewPrintExt("EGL_EXT_sync_reuse", EGLEW_EXT_sync_reuse, eglewIsSupported("EGL_EXT_sync_reuse"), eglewGetExtension("EGL_EXT_sync_reuse")); + + glewInfoFunc("eglUnsignalSyncEXT", eglUnsignalSyncEXT == NULL); +} + +#endif /* EGL_EXT_sync_reuse */ + #ifdef EGL_EXT_yuv_surface static void _glewInfo_EGL_EXT_yuv_surface (void) @@ -10930,6 +12291,17 @@ static void _glewInfo_EGL_KHR_debug (void) #endif /* EGL_KHR_debug */ +#ifdef EGL_KHR_display_reference + +static void _glewInfo_EGL_KHR_display_reference (void) +{ + glewPrintExt("EGL_KHR_display_reference", EGLEW_KHR_display_reference, eglewIsSupported("EGL_KHR_display_reference"), eglewGetExtension("EGL_KHR_display_reference")); + + glewInfoFunc("eglQueryDisplayAttribKHR", eglQueryDisplayAttribKHR == NULL); +} + +#endif /* EGL_KHR_display_reference */ + #ifdef EGL_KHR_fence_sync static void _glewInfo_EGL_KHR_fence_sync (void) @@ -11343,6 +12715,15 @@ static void _glewInfo_EGL_NV_3dvision_surface (void) #endif /* EGL_NV_3dvision_surface */ +#ifdef EGL_NV_context_priority_realtime + +static void _glewInfo_EGL_NV_context_priority_realtime (void) +{ + glewPrintExt("EGL_NV_context_priority_realtime", EGLEW_NV_context_priority_realtime, eglewIsSupported("EGL_NV_context_priority_realtime"), eglewGetExtension("EGL_NV_context_priority_realtime")); +} + +#endif /* EGL_NV_context_priority_realtime */ + #ifdef EGL_NV_coverage_sample static void _glewInfo_EGL_NV_coverage_sample (void) @@ -11504,6 +12885,17 @@ static void _glewInfo_EGL_NV_stream_fifo_synchronous (void) #endif /* EGL_NV_stream_fifo_synchronous */ +#ifdef EGL_NV_stream_flush + +static void _glewInfo_EGL_NV_stream_flush (void) +{ + glewPrintExt("EGL_NV_stream_flush", EGLEW_NV_stream_flush, eglewIsSupported("EGL_NV_stream_flush"), eglewGetExtension("EGL_NV_stream_flush")); + + glewInfoFunc("eglStreamFlushNV", eglStreamFlushNV == NULL); +} + +#endif /* EGL_NV_stream_flush */ + #ifdef EGL_NV_stream_frame_limits static void _glewInfo_EGL_NV_stream_frame_limits (void) @@ -12563,6 +13955,15 @@ static void _glewInfo_GLX_EXT_libglvnd (void) #endif /* GLX_EXT_libglvnd */ +#ifdef GLX_EXT_no_config_context + +static void _glewInfo_GLX_EXT_no_config_context (void) +{ + glewPrintExt("GLX_EXT_no_config_context", GLXEW_EXT_no_config_context, glxewIsSupported("GLX_EXT_no_config_context"), glxewGetExtension("GLX_EXT_no_config_context")); +} + +#endif /* GLX_EXT_no_config_context */ + #ifdef GLX_EXT_scene_marker static void _glewInfo_GLX_EXT_scene_marker (void) @@ -13171,6 +14572,9 @@ static void glewInfo (void) #ifdef GL_AMD_draw_buffers_blend _glewInfo_GL_AMD_draw_buffers_blend(); #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_multisample_advanced + _glewInfo_GL_AMD_framebuffer_multisample_advanced(); +#endif /* GL_AMD_framebuffer_multisample_advanced */ #ifdef GL_AMD_framebuffer_sample_positions _glewInfo_GL_AMD_framebuffer_sample_positions(); #endif /* GL_AMD_framebuffer_sample_positions */ @@ -13180,6 +14584,9 @@ static void glewInfo (void) #ifdef GL_AMD_gpu_shader_half_float _glewInfo_GL_AMD_gpu_shader_half_float(); #endif /* GL_AMD_gpu_shader_half_float */ +#ifdef GL_AMD_gpu_shader_half_float_fetch + _glewInfo_GL_AMD_gpu_shader_half_float_fetch(); +#endif /* GL_AMD_gpu_shader_half_float_fetch */ #ifdef GL_AMD_gpu_shader_int16 _glewInfo_GL_AMD_gpu_shader_int16(); #endif /* GL_AMD_gpu_shader_int16 */ @@ -13225,6 +14632,9 @@ static void glewInfo (void) #ifdef GL_AMD_shader_explicit_vertex_parameter _glewInfo_GL_AMD_shader_explicit_vertex_parameter(); #endif /* GL_AMD_shader_explicit_vertex_parameter */ +#ifdef GL_AMD_shader_image_load_store_lod + _glewInfo_GL_AMD_shader_image_load_store_lod(); +#endif /* GL_AMD_shader_image_load_store_lod */ #ifdef GL_AMD_shader_stencil_export _glewInfo_GL_AMD_shader_stencil_export(); #endif /* GL_AMD_shader_stencil_export */ @@ -13972,12 +15382,12 @@ static void glewInfo (void) #ifdef GL_ATI_vertex_streams _glewInfo_GL_ATI_vertex_streams(); #endif /* GL_ATI_vertex_streams */ -#ifdef GL_EGL_KHR_context_flush_control - _glewInfo_GL_EGL_KHR_context_flush_control(); -#endif /* GL_EGL_KHR_context_flush_control */ -#ifdef GL_EGL_NV_robustness_video_memory_purge - _glewInfo_GL_EGL_NV_robustness_video_memory_purge(); -#endif /* GL_EGL_NV_robustness_video_memory_purge */ +#ifdef GL_DMP_program_binary + _glewInfo_GL_DMP_program_binary(); +#endif /* GL_DMP_program_binary */ +#ifdef GL_DMP_shader_binary + _glewInfo_GL_DMP_shader_binary(); +#endif /* GL_DMP_shader_binary */ #ifdef GL_EXT_422_pixels _glewInfo_GL_EXT_422_pixels(); #endif /* GL_EXT_422_pixels */ @@ -13987,6 +15397,12 @@ static void glewInfo (void) #ifdef GL_EXT_EGL_image_array _glewInfo_GL_EXT_EGL_image_array(); #endif /* GL_EXT_EGL_image_array */ +#ifdef GL_EXT_EGL_image_external_wrap_modes + _glewInfo_GL_EXT_EGL_image_external_wrap_modes(); +#endif /* GL_EXT_EGL_image_external_wrap_modes */ +#ifdef GL_EXT_EGL_image_storage + _glewInfo_GL_EXT_EGL_image_storage(); +#endif /* GL_EXT_EGL_image_storage */ #ifdef GL_EXT_YUV_target _glewInfo_GL_EXT_YUV_target(); #endif /* GL_EXT_YUV_target */ @@ -14029,6 +15445,9 @@ static void glewInfo (void) #ifdef GL_EXT_clear_texture _glewInfo_GL_EXT_clear_texture(); #endif /* GL_EXT_clear_texture */ +#ifdef GL_EXT_clip_control + _glewInfo_GL_EXT_clip_control(); +#endif /* GL_EXT_clip_control */ #ifdef GL_EXT_clip_cull_distance _glewInfo_GL_EXT_clip_cull_distance(); #endif /* GL_EXT_clip_cull_distance */ @@ -14086,6 +15505,9 @@ static void glewInfo (void) #ifdef GL_EXT_discard_framebuffer _glewInfo_GL_EXT_discard_framebuffer(); #endif /* GL_EXT_discard_framebuffer */ +#ifdef GL_EXT_disjoint_timer_query + _glewInfo_GL_EXT_disjoint_timer_query(); +#endif /* GL_EXT_disjoint_timer_query */ #ifdef GL_EXT_draw_buffers _glewInfo_GL_EXT_draw_buffers(); #endif /* GL_EXT_draw_buffers */ @@ -14104,6 +15526,9 @@ static void glewInfo (void) #ifdef GL_EXT_draw_range_elements _glewInfo_GL_EXT_draw_range_elements(); #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_draw_transform_feedback + _glewInfo_GL_EXT_draw_transform_feedback(); +#endif /* GL_EXT_draw_transform_feedback */ #ifdef GL_EXT_external_buffer _glewInfo_GL_EXT_external_buffer(); #endif /* GL_EXT_external_buffer */ @@ -14212,6 +15637,9 @@ static void glewInfo (void) #ifdef GL_EXT_multiview_draw_buffers _glewInfo_GL_EXT_multiview_draw_buffers(); #endif /* GL_EXT_multiview_draw_buffers */ +#ifdef GL_EXT_occlusion_query_boolean + _glewInfo_GL_EXT_occlusion_query_boolean(); +#endif /* GL_EXT_occlusion_query_boolean */ #ifdef GL_EXT_packed_depth_stencil _glewInfo_GL_EXT_packed_depth_stencil(); #endif /* GL_EXT_packed_depth_stencil */ @@ -14245,6 +15673,9 @@ static void glewInfo (void) #ifdef GL_EXT_post_depth_coverage _glewInfo_GL_EXT_post_depth_coverage(); #endif /* GL_EXT_post_depth_coverage */ +#ifdef GL_EXT_protected_textures + _glewInfo_GL_EXT_protected_textures(); +#endif /* GL_EXT_protected_textures */ #ifdef GL_EXT_provoking_vertex _glewInfo_GL_EXT_provoking_vertex(); #endif /* GL_EXT_provoking_vertex */ @@ -14263,6 +15694,9 @@ static void glewInfo (void) #ifdef GL_EXT_rescale_normal _glewInfo_GL_EXT_rescale_normal(); #endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_robustness + _glewInfo_GL_EXT_robustness(); +#endif /* GL_EXT_robustness */ #ifdef GL_EXT_sRGB _glewInfo_GL_EXT_sRGB(); #endif /* GL_EXT_sRGB */ @@ -14293,6 +15727,9 @@ static void glewInfo (void) #ifdef GL_EXT_shader_framebuffer_fetch _glewInfo_GL_EXT_shader_framebuffer_fetch(); #endif /* GL_EXT_shader_framebuffer_fetch */ +#ifdef GL_EXT_shader_framebuffer_fetch_non_coherent + _glewInfo_GL_EXT_shader_framebuffer_fetch_non_coherent(); +#endif /* GL_EXT_shader_framebuffer_fetch_non_coherent */ #ifdef GL_EXT_shader_group_vote _glewInfo_GL_EXT_shader_group_vote(); #endif /* GL_EXT_shader_group_vote */ @@ -14338,6 +15775,9 @@ static void glewInfo (void) #ifdef GL_EXT_sparse_texture2 _glewInfo_GL_EXT_sparse_texture2(); #endif /* GL_EXT_sparse_texture2 */ +#ifdef GL_EXT_static_vertex_array + _glewInfo_GL_EXT_static_vertex_array(); +#endif /* GL_EXT_static_vertex_array */ #ifdef GL_EXT_stencil_clear_tag _glewInfo_GL_EXT_stencil_clear_tag(); #endif /* GL_EXT_stencil_clear_tag */ @@ -14350,6 +15790,12 @@ static void glewInfo (void) #ifdef GL_EXT_subtexture _glewInfo_GL_EXT_subtexture(); #endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_tessellation_point_size + _glewInfo_GL_EXT_tessellation_point_size(); +#endif /* GL_EXT_tessellation_point_size */ +#ifdef GL_EXT_tessellation_shader + _glewInfo_GL_EXT_tessellation_shader(); +#endif /* GL_EXT_tessellation_shader */ #ifdef GL_EXT_texture _glewInfo_GL_EXT_texture(); #endif /* GL_EXT_texture */ @@ -14359,6 +15805,12 @@ static void glewInfo (void) #ifdef GL_EXT_texture_array _glewInfo_GL_EXT_texture_array(); #endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_border_clamp + _glewInfo_GL_EXT_texture_border_clamp(); +#endif /* GL_EXT_texture_border_clamp */ +#ifdef GL_EXT_texture_buffer + _glewInfo_GL_EXT_texture_buffer(); +#endif /* GL_EXT_texture_buffer */ #ifdef GL_EXT_texture_buffer_object _glewInfo_GL_EXT_texture_buffer_object(); #endif /* GL_EXT_texture_buffer_object */ @@ -14383,6 +15835,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_compression_s3tc _glewInfo_GL_EXT_texture_compression_s3tc(); #endif /* GL_EXT_texture_compression_s3tc */ +#ifdef GL_EXT_texture_compression_s3tc_srgb + _glewInfo_GL_EXT_texture_compression_s3tc_srgb(); +#endif /* GL_EXT_texture_compression_s3tc_srgb */ #ifdef GL_EXT_texture_cube_map _glewInfo_GL_EXT_texture_cube_map(); #endif /* GL_EXT_texture_cube_map */ @@ -14413,6 +15868,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_format_BGRA8888 _glewInfo_GL_EXT_texture_format_BGRA8888(); #endif /* GL_EXT_texture_format_BGRA8888 */ +#ifdef GL_EXT_texture_format_sRGB_override + _glewInfo_GL_EXT_texture_format_sRGB_override(); +#endif /* GL_EXT_texture_format_sRGB_override */ #ifdef GL_EXT_texture_integer _glewInfo_GL_EXT_texture_integer(); #endif /* GL_EXT_texture_integer */ @@ -14422,6 +15880,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_mirror_clamp _glewInfo_GL_EXT_texture_mirror_clamp(); #endif /* GL_EXT_texture_mirror_clamp */ +#ifdef GL_EXT_texture_mirror_clamp_to_edge + _glewInfo_GL_EXT_texture_mirror_clamp_to_edge(); +#endif /* GL_EXT_texture_mirror_clamp_to_edge */ #ifdef GL_EXT_texture_norm16 _glewInfo_GL_EXT_texture_norm16(); #endif /* GL_EXT_texture_norm16 */ @@ -14503,6 +15964,21 @@ static void glewInfo (void) #ifdef GL_EXT_x11_sync_object _glewInfo_GL_EXT_x11_sync_object(); #endif /* GL_EXT_x11_sync_object */ +#ifdef GL_FJ_shader_binary_GCCSO + _glewInfo_GL_FJ_shader_binary_GCCSO(); +#endif /* GL_FJ_shader_binary_GCCSO */ +#ifdef GL_GLU_EXT_nurbs_tessellator + _glewInfo_GL_GLU_EXT_nurbs_tessellator(); +#endif /* GL_GLU_EXT_nurbs_tessellator */ +#ifdef GL_GLU_EXT_object_space_tess + _glewInfo_GL_GLU_EXT_object_space_tess(); +#endif /* GL_GLU_EXT_object_space_tess */ +#ifdef GL_GLU_SGIX_icc_compress + _glewInfo_GL_GLU_SGIX_icc_compress(); +#endif /* GL_GLU_SGIX_icc_compress */ +#ifdef GL_GLU_SGI_filter4_parameters + _glewInfo_GL_GLU_SGI_filter4_parameters(); +#endif /* GL_GLU_SGI_filter4_parameters */ #ifdef GL_GREMEDY_frame_terminator _glewInfo_GL_GREMEDY_frame_terminator(); #endif /* GL_GREMEDY_frame_terminator */ @@ -14539,12 +16015,45 @@ static void glewInfo (void) #ifdef GL_IBM_vertex_array_lists _glewInfo_GL_IBM_vertex_array_lists(); #endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_IMG_bindless_texture + _glewInfo_GL_IMG_bindless_texture(); +#endif /* GL_IMG_bindless_texture */ +#ifdef GL_IMG_framebuffer_downsample + _glewInfo_GL_IMG_framebuffer_downsample(); +#endif /* GL_IMG_framebuffer_downsample */ +#ifdef GL_IMG_multisampled_render_to_texture + _glewInfo_GL_IMG_multisampled_render_to_texture(); +#endif /* GL_IMG_multisampled_render_to_texture */ +#ifdef GL_IMG_program_binary + _glewInfo_GL_IMG_program_binary(); +#endif /* GL_IMG_program_binary */ +#ifdef GL_IMG_read_format + _glewInfo_GL_IMG_read_format(); +#endif /* GL_IMG_read_format */ +#ifdef GL_IMG_shader_binary + _glewInfo_GL_IMG_shader_binary(); +#endif /* GL_IMG_shader_binary */ +#ifdef GL_IMG_texture_compression_pvrtc + _glewInfo_GL_IMG_texture_compression_pvrtc(); +#endif /* GL_IMG_texture_compression_pvrtc */ +#ifdef GL_IMG_texture_compression_pvrtc2 + _glewInfo_GL_IMG_texture_compression_pvrtc2(); +#endif /* GL_IMG_texture_compression_pvrtc2 */ +#ifdef GL_IMG_texture_env_enhanced_fixed_function + _glewInfo_GL_IMG_texture_env_enhanced_fixed_function(); +#endif /* GL_IMG_texture_env_enhanced_fixed_function */ +#ifdef GL_IMG_texture_filter_cubic + _glewInfo_GL_IMG_texture_filter_cubic(); +#endif /* GL_IMG_texture_filter_cubic */ #ifdef GL_INGR_color_clamp _glewInfo_GL_INGR_color_clamp(); #endif /* GL_INGR_color_clamp */ #ifdef GL_INGR_interlace_read _glewInfo_GL_INGR_interlace_read(); #endif /* GL_INGR_interlace_read */ +#ifdef GL_INTEL_blackhole_render + _glewInfo_GL_INTEL_blackhole_render(); +#endif /* GL_INTEL_blackhole_render */ #ifdef GL_INTEL_conservative_rasterization _glewInfo_GL_INTEL_conservative_rasterization(); #endif /* GL_INTEL_conservative_rasterization */ @@ -14605,15 +16114,24 @@ static void glewInfo (void) #ifdef GL_MESAX_texture_stack _glewInfo_GL_MESAX_texture_stack(); #endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_framebuffer_flip_y + _glewInfo_GL_MESA_framebuffer_flip_y(); +#endif /* GL_MESA_framebuffer_flip_y */ #ifdef GL_MESA_pack_invert _glewInfo_GL_MESA_pack_invert(); #endif /* GL_MESA_pack_invert */ +#ifdef GL_MESA_program_binary_formats + _glewInfo_GL_MESA_program_binary_formats(); +#endif /* GL_MESA_program_binary_formats */ #ifdef GL_MESA_resize_buffers _glewInfo_GL_MESA_resize_buffers(); #endif /* GL_MESA_resize_buffers */ #ifdef GL_MESA_shader_integer_functions _glewInfo_GL_MESA_shader_integer_functions(); #endif /* GL_MESA_shader_integer_functions */ +#ifdef GL_MESA_tile_raster_order + _glewInfo_GL_MESA_tile_raster_order(); +#endif /* GL_MESA_tile_raster_order */ #ifdef GL_MESA_window_pos _glewInfo_GL_MESA_window_pos(); #endif /* GL_MESA_window_pos */ @@ -14674,6 +16192,9 @@ static void glewInfo (void) #ifdef GL_NV_compute_program5 _glewInfo_GL_NV_compute_program5(); #endif /* GL_NV_compute_program5 */ +#ifdef GL_NV_compute_shader_derivatives + _glewInfo_GL_NV_compute_shader_derivatives(); +#endif /* GL_NV_compute_shader_derivatives */ #ifdef GL_NV_conditional_render _glewInfo_GL_NV_conditional_render(); #endif /* GL_NV_conditional_render */ @@ -14683,9 +16204,15 @@ static void glewInfo (void) #ifdef GL_NV_conservative_raster_dilate _glewInfo_GL_NV_conservative_raster_dilate(); #endif /* GL_NV_conservative_raster_dilate */ +#ifdef GL_NV_conservative_raster_pre_snap + _glewInfo_GL_NV_conservative_raster_pre_snap(); +#endif /* GL_NV_conservative_raster_pre_snap */ #ifdef GL_NV_conservative_raster_pre_snap_triangles _glewInfo_GL_NV_conservative_raster_pre_snap_triangles(); #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +#ifdef GL_NV_conservative_raster_underestimation + _glewInfo_GL_NV_conservative_raster_underestimation(); +#endif /* GL_NV_conservative_raster_underestimation */ #ifdef GL_NV_copy_buffer _glewInfo_GL_NV_copy_buffer(); #endif /* GL_NV_copy_buffer */ @@ -14704,6 +16231,9 @@ static void glewInfo (void) #ifdef GL_NV_depth_clamp _glewInfo_GL_NV_depth_clamp(); #endif /* GL_NV_depth_clamp */ +#ifdef GL_NV_depth_nonlinear + _glewInfo_GL_NV_depth_nonlinear(); +#endif /* GL_NV_depth_nonlinear */ #ifdef GL_NV_depth_range_unclamped _glewInfo_GL_NV_depth_range_unclamped(); #endif /* GL_NV_depth_range_unclamped */ @@ -14758,6 +16288,9 @@ static void glewInfo (void) #ifdef GL_NV_fragment_program_option _glewInfo_GL_NV_fragment_program_option(); #endif /* GL_NV_fragment_program_option */ +#ifdef GL_NV_fragment_shader_barycentric + _glewInfo_GL_NV_fragment_shader_barycentric(); +#endif /* GL_NV_fragment_shader_barycentric */ #ifdef GL_NV_fragment_shader_interlock _glewInfo_GL_NV_fragment_shader_interlock(); #endif /* GL_NV_fragment_shader_interlock */ @@ -14818,6 +16351,12 @@ static void glewInfo (void) #ifdef GL_NV_light_max_exponent _glewInfo_GL_NV_light_max_exponent(); #endif /* GL_NV_light_max_exponent */ +#ifdef GL_NV_memory_attachment + _glewInfo_GL_NV_memory_attachment(); +#endif /* GL_NV_memory_attachment */ +#ifdef GL_NV_mesh_shader + _glewInfo_GL_NV_mesh_shader(); +#endif /* GL_NV_mesh_shader */ #ifdef GL_NV_multisample_coverage _glewInfo_GL_NV_multisample_coverage(); #endif /* GL_NV_multisample_coverage */ @@ -14875,6 +16414,15 @@ static void glewInfo (void) #ifdef GL_NV_primitive_restart _glewInfo_GL_NV_primitive_restart(); #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_query_resource_tag + _glewInfo_GL_NV_query_resource_tag(); +#endif /* GL_NV_query_resource_tag */ +#ifdef GL_NV_read_buffer + _glewInfo_GL_NV_read_buffer(); +#endif /* GL_NV_read_buffer */ +#ifdef GL_NV_read_buffer_front + _glewInfo_GL_NV_read_buffer_front(); +#endif /* GL_NV_read_buffer_front */ #ifdef GL_NV_read_depth _glewInfo_GL_NV_read_depth(); #endif /* GL_NV_read_depth */ @@ -14890,6 +16438,9 @@ static void glewInfo (void) #ifdef GL_NV_register_combiners2 _glewInfo_GL_NV_register_combiners2(); #endif /* GL_NV_register_combiners2 */ +#ifdef GL_NV_representative_fragment_test + _glewInfo_GL_NV_representative_fragment_test(); +#endif /* GL_NV_representative_fragment_test */ #ifdef GL_NV_robustness_video_memory_purge _glewInfo_GL_NV_robustness_video_memory_purge(); #endif /* GL_NV_robustness_video_memory_purge */ @@ -14902,6 +16453,9 @@ static void glewInfo (void) #ifdef GL_NV_sample_mask_override_coverage _glewInfo_GL_NV_sample_mask_override_coverage(); #endif /* GL_NV_sample_mask_override_coverage */ +#ifdef GL_NV_scissor_exclusive + _glewInfo_GL_NV_scissor_exclusive(); +#endif /* GL_NV_scissor_exclusive */ #ifdef GL_NV_shader_atomic_counters _glewInfo_GL_NV_shader_atomic_counters(); #endif /* GL_NV_shader_atomic_counters */ @@ -14926,12 +16480,18 @@ static void glewInfo (void) #ifdef GL_NV_shader_storage_buffer_object _glewInfo_GL_NV_shader_storage_buffer_object(); #endif /* GL_NV_shader_storage_buffer_object */ +#ifdef GL_NV_shader_texture_footprint + _glewInfo_GL_NV_shader_texture_footprint(); +#endif /* GL_NV_shader_texture_footprint */ #ifdef GL_NV_shader_thread_group _glewInfo_GL_NV_shader_thread_group(); #endif /* GL_NV_shader_thread_group */ #ifdef GL_NV_shader_thread_shuffle _glewInfo_GL_NV_shader_thread_shuffle(); #endif /* GL_NV_shader_thread_shuffle */ +#ifdef GL_NV_shading_rate_image + _glewInfo_GL_NV_shading_rate_image(); +#endif /* GL_NV_shading_rate_image */ #ifdef GL_NV_shadow_samplers_array _glewInfo_GL_NV_shadow_samplers_array(); #endif /* GL_NV_shadow_samplers_array */ @@ -15052,9 +16612,192 @@ static void glewInfo (void) #ifdef GL_NV_viewport_swizzle _glewInfo_GL_NV_viewport_swizzle(); #endif /* GL_NV_viewport_swizzle */ +#ifdef GL_OES_EGL_image + _glewInfo_GL_OES_EGL_image(); +#endif /* GL_OES_EGL_image */ +#ifdef GL_OES_EGL_image_external + _glewInfo_GL_OES_EGL_image_external(); +#endif /* GL_OES_EGL_image_external */ +#ifdef GL_OES_EGL_image_external_essl3 + _glewInfo_GL_OES_EGL_image_external_essl3(); +#endif /* GL_OES_EGL_image_external_essl3 */ +#ifdef GL_OES_blend_equation_separate + _glewInfo_GL_OES_blend_equation_separate(); +#endif /* GL_OES_blend_equation_separate */ +#ifdef GL_OES_blend_func_separate + _glewInfo_GL_OES_blend_func_separate(); +#endif /* GL_OES_blend_func_separate */ +#ifdef GL_OES_blend_subtract + _glewInfo_GL_OES_blend_subtract(); +#endif /* GL_OES_blend_subtract */ #ifdef GL_OES_byte_coordinates _glewInfo_GL_OES_byte_coordinates(); #endif /* GL_OES_byte_coordinates */ +#ifdef GL_OES_compressed_ETC1_RGB8_texture + _glewInfo_GL_OES_compressed_ETC1_RGB8_texture(); +#endif /* GL_OES_compressed_ETC1_RGB8_texture */ +#ifdef GL_OES_compressed_paletted_texture + _glewInfo_GL_OES_compressed_paletted_texture(); +#endif /* GL_OES_compressed_paletted_texture */ +#ifdef GL_OES_copy_image + _glewInfo_GL_OES_copy_image(); +#endif /* GL_OES_copy_image */ +#ifdef GL_OES_depth24 + _glewInfo_GL_OES_depth24(); +#endif /* GL_OES_depth24 */ +#ifdef GL_OES_depth32 + _glewInfo_GL_OES_depth32(); +#endif /* GL_OES_depth32 */ +#ifdef GL_OES_depth_texture + _glewInfo_GL_OES_depth_texture(); +#endif /* GL_OES_depth_texture */ +#ifdef GL_OES_depth_texture_cube_map + _glewInfo_GL_OES_depth_texture_cube_map(); +#endif /* GL_OES_depth_texture_cube_map */ +#ifdef GL_OES_draw_buffers_indexed + _glewInfo_GL_OES_draw_buffers_indexed(); +#endif /* GL_OES_draw_buffers_indexed */ +#ifdef GL_OES_draw_texture + _glewInfo_GL_OES_draw_texture(); +#endif /* GL_OES_draw_texture */ +#ifdef GL_OES_element_index_uint + _glewInfo_GL_OES_element_index_uint(); +#endif /* GL_OES_element_index_uint */ +#ifdef GL_OES_extended_matrix_palette + _glewInfo_GL_OES_extended_matrix_palette(); +#endif /* GL_OES_extended_matrix_palette */ +#ifdef GL_OES_fbo_render_mipmap + _glewInfo_GL_OES_fbo_render_mipmap(); +#endif /* GL_OES_fbo_render_mipmap */ +#ifdef GL_OES_fragment_precision_high + _glewInfo_GL_OES_fragment_precision_high(); +#endif /* GL_OES_fragment_precision_high */ +#ifdef GL_OES_framebuffer_object + _glewInfo_GL_OES_framebuffer_object(); +#endif /* GL_OES_framebuffer_object */ +#ifdef GL_OES_geometry_point_size + _glewInfo_GL_OES_geometry_point_size(); +#endif /* GL_OES_geometry_point_size */ +#ifdef GL_OES_geometry_shader + _glewInfo_GL_OES_geometry_shader(); +#endif /* GL_OES_geometry_shader */ +#ifdef GL_OES_get_program_binary + _glewInfo_GL_OES_get_program_binary(); +#endif /* GL_OES_get_program_binary */ +#ifdef GL_OES_gpu_shader5 + _glewInfo_GL_OES_gpu_shader5(); +#endif /* GL_OES_gpu_shader5 */ +#ifdef GL_OES_mapbuffer + _glewInfo_GL_OES_mapbuffer(); +#endif /* GL_OES_mapbuffer */ +#ifdef GL_OES_matrix_get + _glewInfo_GL_OES_matrix_get(); +#endif /* GL_OES_matrix_get */ +#ifdef GL_OES_matrix_palette + _glewInfo_GL_OES_matrix_palette(); +#endif /* GL_OES_matrix_palette */ +#ifdef GL_OES_packed_depth_stencil + _glewInfo_GL_OES_packed_depth_stencil(); +#endif /* GL_OES_packed_depth_stencil */ +#ifdef GL_OES_point_size_array + _glewInfo_GL_OES_point_size_array(); +#endif /* GL_OES_point_size_array */ +#ifdef GL_OES_point_sprite + _glewInfo_GL_OES_point_sprite(); +#endif /* GL_OES_point_sprite */ +#ifdef GL_OES_read_format + _glewInfo_GL_OES_read_format(); +#endif /* GL_OES_read_format */ +#ifdef GL_OES_required_internalformat + _glewInfo_GL_OES_required_internalformat(); +#endif /* GL_OES_required_internalformat */ +#ifdef GL_OES_rgb8_rgba8 + _glewInfo_GL_OES_rgb8_rgba8(); +#endif /* GL_OES_rgb8_rgba8 */ +#ifdef GL_OES_sample_shading + _glewInfo_GL_OES_sample_shading(); +#endif /* GL_OES_sample_shading */ +#ifdef GL_OES_sample_variables + _glewInfo_GL_OES_sample_variables(); +#endif /* GL_OES_sample_variables */ +#ifdef GL_OES_shader_image_atomic + _glewInfo_GL_OES_shader_image_atomic(); +#endif /* GL_OES_shader_image_atomic */ +#ifdef GL_OES_shader_io_blocks + _glewInfo_GL_OES_shader_io_blocks(); +#endif /* GL_OES_shader_io_blocks */ +#ifdef GL_OES_shader_multisample_interpolation + _glewInfo_GL_OES_shader_multisample_interpolation(); +#endif /* GL_OES_shader_multisample_interpolation */ +#ifdef GL_OES_single_precision + _glewInfo_GL_OES_single_precision(); +#endif /* GL_OES_single_precision */ +#ifdef GL_OES_standard_derivatives + _glewInfo_GL_OES_standard_derivatives(); +#endif /* GL_OES_standard_derivatives */ +#ifdef GL_OES_stencil1 + _glewInfo_GL_OES_stencil1(); +#endif /* GL_OES_stencil1 */ +#ifdef GL_OES_stencil4 + _glewInfo_GL_OES_stencil4(); +#endif /* GL_OES_stencil4 */ +#ifdef GL_OES_stencil8 + _glewInfo_GL_OES_stencil8(); +#endif /* GL_OES_stencil8 */ +#ifdef GL_OES_surfaceless_context + _glewInfo_GL_OES_surfaceless_context(); +#endif /* GL_OES_surfaceless_context */ +#ifdef GL_OES_tessellation_point_size + _glewInfo_GL_OES_tessellation_point_size(); +#endif /* GL_OES_tessellation_point_size */ +#ifdef GL_OES_tessellation_shader + _glewInfo_GL_OES_tessellation_shader(); +#endif /* GL_OES_tessellation_shader */ +#ifdef GL_OES_texture_3D + _glewInfo_GL_OES_texture_3D(); +#endif /* GL_OES_texture_3D */ +#ifdef GL_OES_texture_border_clamp + _glewInfo_GL_OES_texture_border_clamp(); +#endif /* GL_OES_texture_border_clamp */ +#ifdef GL_OES_texture_buffer + _glewInfo_GL_OES_texture_buffer(); +#endif /* GL_OES_texture_buffer */ +#ifdef GL_OES_texture_compression_astc + _glewInfo_GL_OES_texture_compression_astc(); +#endif /* GL_OES_texture_compression_astc */ +#ifdef GL_OES_texture_cube_map + _glewInfo_GL_OES_texture_cube_map(); +#endif /* GL_OES_texture_cube_map */ +#ifdef GL_OES_texture_cube_map_array + _glewInfo_GL_OES_texture_cube_map_array(); +#endif /* GL_OES_texture_cube_map_array */ +#ifdef GL_OES_texture_env_crossbar + _glewInfo_GL_OES_texture_env_crossbar(); +#endif /* GL_OES_texture_env_crossbar */ +#ifdef GL_OES_texture_mirrored_repeat + _glewInfo_GL_OES_texture_mirrored_repeat(); +#endif /* GL_OES_texture_mirrored_repeat */ +#ifdef GL_OES_texture_npot + _glewInfo_GL_OES_texture_npot(); +#endif /* GL_OES_texture_npot */ +#ifdef GL_OES_texture_stencil8 + _glewInfo_GL_OES_texture_stencil8(); +#endif /* GL_OES_texture_stencil8 */ +#ifdef GL_OES_texture_storage_multisample_2d_array + _glewInfo_GL_OES_texture_storage_multisample_2d_array(); +#endif /* GL_OES_texture_storage_multisample_2d_array */ +#ifdef GL_OES_texture_view + _glewInfo_GL_OES_texture_view(); +#endif /* GL_OES_texture_view */ +#ifdef GL_OES_vertex_array_object + _glewInfo_GL_OES_vertex_array_object(); +#endif /* GL_OES_vertex_array_object */ +#ifdef GL_OES_vertex_half_float + _glewInfo_GL_OES_vertex_half_float(); +#endif /* GL_OES_vertex_half_float */ +#ifdef GL_OES_vertex_type_10_10_10_2 + _glewInfo_GL_OES_vertex_type_10_10_10_2(); +#endif /* GL_OES_vertex_type_10_10_10_2 */ #ifdef GL_OML_interlace _glewInfo_GL_OML_interlace(); #endif /* GL_OML_interlace */ @@ -15103,6 +16846,15 @@ static void glewInfo (void) #ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent(); #endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_shader_framebuffer_fetch_rate + _glewInfo_GL_QCOM_shader_framebuffer_fetch_rate(); +#endif /* GL_QCOM_shader_framebuffer_fetch_rate */ +#ifdef GL_QCOM_texture_foveated + _glewInfo_GL_QCOM_texture_foveated(); +#endif /* GL_QCOM_texture_foveated */ +#ifdef GL_QCOM_texture_foveated_subsampled_layout + _glewInfo_GL_QCOM_texture_foveated_subsampled_layout(); +#endif /* GL_QCOM_texture_foveated_subsampled_layout */ #ifdef GL_QCOM_tiled_rendering _glewInfo_GL_QCOM_tiled_rendering(); #endif /* GL_QCOM_tiled_rendering */ @@ -15478,6 +17230,9 @@ static void glewInfo (void) #ifdef GL_SUN_vertex _glewInfo_GL_SUN_vertex(); #endif /* GL_SUN_vertex */ +#ifdef GL_VIV_shader_binary + _glewInfo_GL_VIV_shader_binary(); +#endif /* GL_VIV_shader_binary */ #ifdef GL_WIN_phong_shading _glewInfo_GL_WIN_phong_shading(); #endif /* GL_WIN_phong_shading */ @@ -15750,6 +17505,9 @@ static void glxewInfo () #ifdef GLX_EXT_libglvnd _glewInfo_GLX_EXT_libglvnd(); #endif /* GLX_EXT_libglvnd */ +#ifdef GLX_EXT_no_config_context + _glewInfo_GLX_EXT_no_config_context(); +#endif /* GLX_EXT_no_config_context */ #ifdef GLX_EXT_scene_marker _glewInfo_GLX_EXT_scene_marker(); #endif /* GLX_EXT_scene_marker */ @@ -15921,6 +17679,12 @@ static void eglewInfo () #ifdef EGL_ANDROID_front_buffer_auto_refresh _glewInfo_EGL_ANDROID_front_buffer_auto_refresh(); #endif /* EGL_ANDROID_front_buffer_auto_refresh */ +#ifdef EGL_ANDROID_get_frame_timestamps + _glewInfo_EGL_ANDROID_get_frame_timestamps(); +#endif /* EGL_ANDROID_get_frame_timestamps */ +#ifdef EGL_ANDROID_get_native_client_buffer + _glewInfo_EGL_ANDROID_get_native_client_buffer(); +#endif /* EGL_ANDROID_get_native_client_buffer */ #ifdef EGL_ANDROID_image_native_buffer _glewInfo_EGL_ANDROID_image_native_buffer(); #endif /* EGL_ANDROID_image_native_buffer */ @@ -15954,12 +17718,21 @@ static void eglewInfo () #ifdef EGL_ARM_pixmap_multisample_discard _glewInfo_EGL_ARM_pixmap_multisample_discard(); #endif /* EGL_ARM_pixmap_multisample_discard */ +#ifdef EGL_EXT_bind_to_front + _glewInfo_EGL_EXT_bind_to_front(); +#endif /* EGL_EXT_bind_to_front */ #ifdef EGL_EXT_buffer_age _glewInfo_EGL_EXT_buffer_age(); #endif /* EGL_EXT_buffer_age */ #ifdef EGL_EXT_client_extensions _glewInfo_EGL_EXT_client_extensions(); #endif /* EGL_EXT_client_extensions */ +#ifdef EGL_EXT_client_sync + _glewInfo_EGL_EXT_client_sync(); +#endif /* EGL_EXT_client_sync */ +#ifdef EGL_EXT_compositor + _glewInfo_EGL_EXT_compositor(); +#endif /* EGL_EXT_compositor */ #ifdef EGL_EXT_create_context_robustness _glewInfo_EGL_EXT_create_context_robustness(); #endif /* EGL_EXT_create_context_robustness */ @@ -15984,6 +17757,15 @@ static void eglewInfo () #ifdef EGL_EXT_gl_colorspace_bt2020_pq _glewInfo_EGL_EXT_gl_colorspace_bt2020_pq(); #endif /* EGL_EXT_gl_colorspace_bt2020_pq */ +#ifdef EGL_EXT_gl_colorspace_display_p3 + _glewInfo_EGL_EXT_gl_colorspace_display_p3(); +#endif /* EGL_EXT_gl_colorspace_display_p3 */ +#ifdef EGL_EXT_gl_colorspace_display_p3_linear + _glewInfo_EGL_EXT_gl_colorspace_display_p3_linear(); +#endif /* EGL_EXT_gl_colorspace_display_p3_linear */ +#ifdef EGL_EXT_gl_colorspace_scrgb + _glewInfo_EGL_EXT_gl_colorspace_scrgb(); +#endif /* EGL_EXT_gl_colorspace_scrgb */ #ifdef EGL_EXT_gl_colorspace_scrgb_linear _glewInfo_EGL_EXT_gl_colorspace_scrgb_linear(); #endif /* EGL_EXT_gl_colorspace_scrgb_linear */ @@ -15993,6 +17775,12 @@ static void eglewInfo () #ifdef EGL_EXT_image_dma_buf_import_modifiers _glewInfo_EGL_EXT_image_dma_buf_import_modifiers(); #endif /* EGL_EXT_image_dma_buf_import_modifiers */ +#ifdef EGL_EXT_image_gl_colorspace + _glewInfo_EGL_EXT_image_gl_colorspace(); +#endif /* EGL_EXT_image_gl_colorspace */ +#ifdef EGL_EXT_image_implicit_sync_control + _glewInfo_EGL_EXT_image_implicit_sync_control(); +#endif /* EGL_EXT_image_implicit_sync_control */ #ifdef EGL_EXT_multiview_window _glewInfo_EGL_EXT_multiview_window(); #endif /* EGL_EXT_multiview_window */ @@ -16029,12 +17817,18 @@ static void eglewInfo () #ifdef EGL_EXT_stream_consumer_egloutput _glewInfo_EGL_EXT_stream_consumer_egloutput(); #endif /* EGL_EXT_stream_consumer_egloutput */ +#ifdef EGL_EXT_surface_CTA861_3_metadata + _glewInfo_EGL_EXT_surface_CTA861_3_metadata(); +#endif /* EGL_EXT_surface_CTA861_3_metadata */ #ifdef EGL_EXT_surface_SMPTE2086_metadata _glewInfo_EGL_EXT_surface_SMPTE2086_metadata(); #endif /* EGL_EXT_surface_SMPTE2086_metadata */ #ifdef EGL_EXT_swap_buffers_with_damage _glewInfo_EGL_EXT_swap_buffers_with_damage(); #endif /* EGL_EXT_swap_buffers_with_damage */ +#ifdef EGL_EXT_sync_reuse + _glewInfo_EGL_EXT_sync_reuse(); +#endif /* EGL_EXT_sync_reuse */ #ifdef EGL_EXT_yuv_surface _glewInfo_EGL_EXT_yuv_surface(); #endif /* EGL_EXT_yuv_surface */ @@ -16074,6 +17868,9 @@ static void eglewInfo () #ifdef EGL_KHR_debug _glewInfo_EGL_KHR_debug(); #endif /* EGL_KHR_debug */ +#ifdef EGL_KHR_display_reference + _glewInfo_EGL_KHR_display_reference(); +#endif /* EGL_KHR_display_reference */ #ifdef EGL_KHR_fence_sync _glewInfo_EGL_KHR_fence_sync(); #endif /* EGL_KHR_fence_sync */ @@ -16194,6 +17991,9 @@ static void eglewInfo () #ifdef EGL_NV_3dvision_surface _glewInfo_EGL_NV_3dvision_surface(); #endif /* EGL_NV_3dvision_surface */ +#ifdef EGL_NV_context_priority_realtime + _glewInfo_EGL_NV_context_priority_realtime(); +#endif /* EGL_NV_context_priority_realtime */ #ifdef EGL_NV_coverage_sample _glewInfo_EGL_NV_coverage_sample(); #endif /* EGL_NV_coverage_sample */ @@ -16245,6 +18045,9 @@ static void eglewInfo () #ifdef EGL_NV_stream_fifo_synchronous _glewInfo_EGL_NV_stream_fifo_synchronous(); #endif /* EGL_NV_stream_fifo_synchronous */ +#ifdef EGL_NV_stream_flush + _glewInfo_EGL_NV_stream_flush(); +#endif /* EGL_NV_stream_flush */ #ifdef EGL_NV_stream_frame_limits _glewInfo_EGL_NV_stream_frame_limits(); #endif /* EGL_NV_stream_frame_limits */