From b38c74c243c130ff16153d2fe445179c08675a26 Mon Sep 17 00:00:00 2001 From: Gyusun Yeom Date: Wed, 18 Sep 2019 22:55:14 +0900 Subject: [PATCH] glew-cmake release from glew-2.1.0 --- build/glew.rc | 8 +- build/glewinfo.rc | 8 +- build/visualinfo.rc | 8 +- doc/advanced.html | 4 +- doc/basic.html | 4 +- doc/build.html | 4 +- doc/credits.html | 4 +- doc/glew.html | 1370 ++++++------ doc/glxew.html | 133 +- doc/index.html | 15 +- doc/install.html | 4 +- doc/log.html | 69 +- doc/wglew.html | 104 +- include/GL/eglew.h | 359 +++- include/GL/glew.h | 3767 ++++++++++++++++++++++++++++++++- include/GL/glxew.h | 16 +- include/GL/wglew.h | 30 +- src/glew.c | 4805 ++++++++++++++++++++++++++++++++++++++++++- src/glewinfo.c | 3069 ++++++++++++++++++++++++++- src/visualinfo.c | 2 +- 20 files changed, 12802 insertions(+), 981 deletions(-) diff --git a/build/glew.rc b/build/glew.rc index e2cb19a..cf434ba 100644 --- a/build/glew.rc +++ b/build/glew.rc @@ -20,8 +20,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 0, 0, 0 -PRODUCTVERSION 2, 0, 0, 0 +FILEVERSION 2, 1, 0, 0 +PRODUCTVERSION 2, 1, 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,0,0,0\0" + VALUE "FileVersion", "2,1,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,0,0,0\0" + VALUE "ProductVersion", "2,1,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/glewinfo.rc b/build/glewinfo.rc index 3e368c6..465e8ba 100644 --- a/build/glewinfo.rc +++ b/build/glewinfo.rc @@ -12,8 +12,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 0, 0, 0 -PRODUCTVERSION 2, 0, 0, 0 +FILEVERSION 2, 1, 0, 0 +PRODUCTVERSION 2, 1, 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,0,0,0\0" + VALUE "FileVersion", "2,1,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,0,0,0\0" + VALUE "ProductVersion", "2,1,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/build/visualinfo.rc b/build/visualinfo.rc index 4062100..a3ca123 100644 --- a/build/visualinfo.rc +++ b/build/visualinfo.rc @@ -12,8 +12,8 @@ // Version // VS_VERSION_INFO VERSIONINFO -FILEVERSION 2, 0, 0, 0 -PRODUCTVERSION 2, 0, 0, 0 +FILEVERSION 2, 1, 0, 0 +PRODUCTVERSION 2, 1, 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,0,0,0\0" + VALUE "FileVersion", "2,1,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,0,0,0\0" + VALUE "ProductVersion", "2,1,0,0\0" VALUE "SpecialBuild", "\0" END END diff --git a/doc/advanced.html b/doc/advanced.html index b4c98bb..8e617b6 100755 --- a/doc/advanced.html +++ b/doc/advanced.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. - + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
diff --git a/doc/basic.html b/doc/basic.html index 4acb9b6..bc3497b 100755 --- a/doc/basic.html +++ b/doc/basic.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
diff --git a/doc/build.html b/doc/build.html index 1bf90a2..8dd5580 100644 --- a/doc/build.html +++ b/doc/build.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
diff --git a/doc/credits.html b/doc/credits.html index dd7e25d..ecf88b1 100755 --- a/doc/credits.html +++ b/doc/credits.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
diff --git a/doc/glew.html b/doc/glew.html index 0e75551..7216aac 100755 --- a/doc/glew.html +++ b/doc/glew.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
@@ -99,624 +99,824 @@ THE POSSIBILITY OF SUCH DAMAGE.

Supported OpenGL Extensions

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

4 AMD_blend_minmax_factor
5 AMD_conservative_depth
6 AMD_debug_output
7 AMD_depth_clamp_separate
8 AMD_draw_buffers_blend
9 AMD_gcn_shader
10 AMD_gpu_shader_int64
11 AMD_interleaved_elements
12 AMD_multi_draw_indirect
13 AMD_name_gen_delete
14 AMD_occlusion_query_event
15 AMD_performance_monitor
16 AMD_pinned_memory
17 AMD_query_buffer_object
18 AMD_sample_positions
19 AMD_seamless_cubemap_per_texture
20 AMD_shader_atomic_counter_ops
21 AMD_shader_explicit_vertex_parameter
22 AMD_shader_stencil_export
23 AMD_shader_stencil_value_export
24 AMD_shader_trinary_minmax
25 AMD_sparse_texture
26 AMD_stencil_operation_extended
27 AMD_texture_texture4
28 AMD_transform_feedback3_lines_triangles
29 AMD_transform_feedback4
30 AMD_vertex_shader_layer
31 AMD_vertex_shader_tessellator
32 AMD_vertex_shader_viewport_index
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

33 ANGLE_depth_texture
34 ANGLE_framebuffer_blit
35 ANGLE_framebuffer_multisample
36 ANGLE_instanced_arrays
37 ANGLE_pack_reverse_row_order
38 ANGLE_program_binary
39 ANGLE_texture_compression_dxt1
40 ANGLE_texture_compression_dxt3
41 ANGLE_texture_compression_dxt5
42 ANGLE_texture_usage
43 ANGLE_timer_query
44 ANGLE_translated_shader_source
41 ANDROID_extension_pack_es31a

45 APPLE_aux_depth_stencil
46 APPLE_client_storage
47 APPLE_element_array
48 APPLE_fence
49 APPLE_float_pixels
50 APPLE_flush_buffer_range
51 APPLE_object_purgeable
52 APPLE_pixel_buffer
53 APPLE_rgb_422
54 APPLE_row_bytes
55 APPLE_specular_vector
56 APPLE_texture_range
57 APPLE_transform_hint
58 APPLE_vertex_array_object
59 APPLE_vertex_array_range
60 APPLE_vertex_program_evaluators
61 APPLE_ycbcr_422
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

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

231 ATIX_point_sprites
232 ATIX_texture_env_combine3
233 ATIX_texture_env_route
234 ATIX_vertex_shader_output_point_size
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

235 ATI_draw_buffers
236 ATI_element_array
237 ATI_envmap_bumpmap
238 ATI_fragment_shader
239 ATI_map_object_buffer
240 ATI_meminfo
241 ATI_pn_triangles
242 ATI_separate_stencil
243 ATI_shader_texture_lod
244 ATI_text_fragment_shader
245 ATI_texture_compression_3dc
246 ATI_texture_env_combine3
247 ATI_texture_float
248 ATI_texture_mirror_once
249 ATI_vertex_array_object
250 ATI_vertex_attrib_array_object
251 ATI_vertex_streams
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

252 EGL_NV_robustness_video_memory_purge
257 ATIX_point_sprites
258 ATIX_texture_env_combine3
259 ATIX_texture_env_route
260 ATIX_vertex_shader_output_point_size

253 EXT_422_pixels
254 EXT_Cg_shader
255 EXT_abgr
256 EXT_bgra
257 EXT_bindable_uniform
258 EXT_blend_color
259 EXT_blend_equation_separate
260 EXT_blend_func_separate
261 EXT_blend_logic_op
262 EXT_blend_minmax
263 EXT_blend_subtract
264 EXT_clip_volume_hint
265 EXT_cmyka
266 EXT_color_subtable
267 EXT_compiled_vertex_array
268 EXT_convolution
269 EXT_coordinate_frame
270 EXT_copy_texture
271 EXT_cull_vertex
272 EXT_debug_label
273 EXT_debug_marker
274 EXT_depth_bounds_test
275 EXT_direct_state_access
276 EXT_draw_buffers2
277 EXT_draw_instanced
278 EXT_draw_range_elements
279 EXT_fog_coord
280 EXT_fragment_lighting
281 EXT_framebuffer_blit
282 EXT_framebuffer_multisample
283 EXT_framebuffer_multisample_blit_scaled
284 EXT_framebuffer_object
285 EXT_framebuffer_sRGB
286 EXT_geometry_shader4
287 EXT_gpu_program_parameters
288 EXT_gpu_shader4
289 EXT_histogram
290 EXT_index_array_formats
291 EXT_index_func
292 EXT_index_material
293 EXT_index_texture
294 EXT_light_texture
295 EXT_misc_attribute
296 EXT_multi_draw_arrays
297 EXT_multisample
298 EXT_packed_depth_stencil
299 EXT_packed_float
300 EXT_packed_pixels
301 EXT_paletted_texture
302 EXT_pixel_buffer_object
303 EXT_pixel_transform
304 EXT_pixel_transform_color_table
305 EXT_point_parameters
306 EXT_polygon_offset
307 EXT_polygon_offset_clamp
308 EXT_post_depth_coverage
309 EXT_provoking_vertex
310 EXT_raster_multisample
311 EXT_rescale_normal
312 EXT_scene_marker
313 EXT_secondary_color
314 EXT_separate_shader_objects
315 EXT_separate_specular_color
316 EXT_shader_image_load_formatted
317 EXT_shader_image_load_store
318 EXT_shader_integer_mix
319 EXT_shadow_funcs
320 EXT_shared_texture_palette
321 EXT_sparse_texture2
322 EXT_stencil_clear_tag
323 EXT_stencil_two_side
324 EXT_stencil_wrap
325 EXT_subtexture
326 EXT_texture
327 EXT_texture3D
328 EXT_texture_array
329 EXT_texture_buffer_object
330 EXT_texture_compression_dxt1
331 EXT_texture_compression_latc
332 EXT_texture_compression_rgtc
333 EXT_texture_compression_s3tc
334 EXT_texture_cube_map
335 EXT_texture_edge_clamp
336 EXT_texture_env
337 EXT_texture_env_add
338 EXT_texture_env_combine
339 EXT_texture_env_dot3
340 EXT_texture_filter_anisotropic
341 EXT_texture_filter_minmax
342 EXT_texture_integer
343 EXT_texture_lod_bias
344 EXT_texture_mirror_clamp
345 EXT_texture_object
346 EXT_texture_perturb_normal
347 EXT_texture_rectangle
348 EXT_texture_sRGB
349 EXT_texture_sRGB_decode
350 EXT_texture_shared_exponent
351 EXT_texture_snorm
352 EXT_texture_swizzle
353 EXT_timer_query
354 EXT_transform_feedback
355 EXT_vertex_array
356 EXT_vertex_array_bgra
357 EXT_vertex_attrib_64bit
358 EXT_vertex_shader
359 EXT_vertex_weighting
360 EXT_window_rectangles
361 EXT_x11_sync_object
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

362 GREMEDY_frame_terminator
363 GREMEDY_string_marker
278 EGL_KHR_context_flush_control
279 EGL_NV_robustness_video_memory_purge

364 HP_convolution_border_modes
365 HP_image_transform
366 HP_occlusion_test
367 HP_texture_lighting
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

368 IBM_cull_vertex
369 IBM_multimode_draw_arrays
370 IBM_rasterpos_clip
371 IBM_static_data
372 IBM_texture_mirrored_repeat
373 IBM_vertex_array_lists
455 GREMEDY_frame_terminator
456 GREMEDY_string_marker

374 INGR_color_clamp
375 INGR_interlace_read
457 HP_convolution_border_modes
458 HP_image_transform
459 HP_occlusion_test
460 HP_texture_lighting

376 INTEL_conservative_rasterization
377 INTEL_fragment_shader_ordering
378 INTEL_framebuffer_CMAA
379 INTEL_map_texture
380 INTEL_parallel_arrays
381 INTEL_performance_query
382 INTEL_texture_scissor
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

383 KHR_blend_equation_advanced
384 KHR_blend_equation_advanced_coherent
385 KHR_context_flush_control
386 KHR_debug
387 KHR_no_error
388 KHR_robust_buffer_access_behavior
389 KHR_robustness
390 KHR_texture_compression_astc_hdr
391 KHR_texture_compression_astc_ldr
392 KHR_texture_compression_astc_sliced_3d
467 INGR_color_clamp
468 INGR_interlace_read

393 KTX_buffer_region
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

394 MESAX_texture_stack
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

395 MESA_pack_invert
396 MESA_resize_buffers
397 MESA_shader_integer_functions
398 MESA_window_pos
399 MESA_ycbcr_texture
487 KTX_buffer_region

400 NVX_blend_equation_advanced_multi_draw_buffers
401 NVX_conditional_render
402 NVX_gpu_memory_info
403 NVX_linked_gpu_multicast
488 MESAX_texture_stack

404 NV_bindless_multi_draw_indirect
405 NV_bindless_multi_draw_indirect_count
406 NV_bindless_texture
407 NV_blend_equation_advanced
408 NV_blend_equation_advanced_coherent
409 NV_blend_square
410 NV_clip_space_w_scaling
411 NV_command_list
412 NV_compute_program5
413 NV_conditional_render
414 NV_conservative_raster
415 NV_conservative_raster_dilate
416 NV_conservative_raster_pre_snap_triangles
417 NV_copy_depth_to_color
418 NV_copy_image
419 NV_deep_texture3D
420 NV_depth_buffer_float
421 NV_depth_clamp
422 NV_depth_range_unclamped
423 NV_draw_texture
424 NV_draw_vulkan_image
425 NV_evaluators
426 NV_explicit_multisample
427 NV_fence
428 NV_fill_rectangle
429 NV_float_buffer
430 NV_fog_distance
431 NV_fragment_coverage_to_color
432 NV_fragment_program
433 NV_fragment_program2
434 NV_fragment_program4
435 NV_fragment_program_option
436 NV_fragment_shader_interlock
437 NV_framebuffer_mixed_samples
438 NV_framebuffer_multisample_coverage
439 NV_geometry_program4
440 NV_geometry_shader4
441 NV_geometry_shader_passthrough
442 NV_gpu_multicast
443 NV_gpu_program4
444 NV_gpu_program5
445 NV_gpu_program5_mem_extended
446 NV_gpu_program_fp64
447 NV_gpu_shader5
448 NV_half_float
449 NV_internalformat_sample_query
450 NV_light_max_exponent
451 NV_multisample_coverage
452 NV_multisample_filter_hint
453 NV_occlusion_query
454 NV_packed_depth_stencil
455 NV_parameter_buffer_object
456 NV_parameter_buffer_object2
457 NV_path_rendering
458 NV_path_rendering_shared_edge
459 NV_pixel_data_range
460 NV_point_sprite
461 NV_present_video
462 NV_primitive_restart
463 NV_register_combiners
464 NV_register_combiners2
465 NV_robustness_video_memory_purge
466 NV_sample_locations
467 NV_sample_mask_override_coverage
468 NV_shader_atomic_counters
469 NV_shader_atomic_float
470 NV_shader_atomic_float64
471 NV_shader_atomic_fp16_vector
472 NV_shader_atomic_int64
473 NV_shader_buffer_load
474 NV_shader_storage_buffer_object
475 NV_shader_thread_group
476 NV_shader_thread_shuffle
477 NV_stereo_view_rendering
478 NV_tessellation_program5
479 NV_texgen_emboss
480 NV_texgen_reflection
481 NV_texture_barrier
482 NV_texture_compression_vtc
483 NV_texture_env_combine4
484 NV_texture_expand_normal
485 NV_texture_multisample
486 NV_texture_rectangle
487 NV_texture_shader
488 NV_texture_shader2
489 NV_texture_shader3
490 NV_transform_feedback
491 NV_transform_feedback2
492 NV_uniform_buffer_unified_memory
493 NV_vdpau_interop
494 NV_vertex_array_range
495 NV_vertex_array_range2
496 NV_vertex_attrib_integer_64bit
497 NV_vertex_buffer_unified_memory
498 NV_vertex_program
499 NV_vertex_program1_1
500 NV_vertex_program2
501 NV_vertex_program2_option
502 NV_vertex_program3
503 NV_vertex_program4
504 NV_video_capture
505 NV_viewport_array2
506 NV_viewport_swizzle
489 MESA_pack_invert
490 MESA_resize_buffers
491 MESA_shader_integer_functions
492 MESA_window_pos
493 MESA_ycbcr_texture

507 OES_byte_coordinates
508 OES_compressed_paletted_texture
509 OES_read_format
510 OES_single_precision
494 NVX_blend_equation_advanced_multi_draw_buffers
495 NVX_conditional_render
496 NVX_gpu_memory_info
497 NVX_linked_gpu_multicast

511 OML_interlace
512 OML_resample
513 OML_subsample
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

514 OVR_multiview
515 OVR_multiview2
638 OES_byte_coordinates

516 PGI_misc_hints
517 PGI_vertex_hints
639 OML_interlace
640 OML_resample
641 OML_subsample

518 REGAL_ES1_0_compatibility
519 REGAL_ES1_1_compatibility
520 REGAL_enable
521 REGAL_error_string
522 REGAL_extension_query
523 REGAL_log
524 REGAL_proc_address
642 OVR_multiview
643 OVR_multiview2
644 OVR_multiview_multisampled_render_to_texture

525 REND_screen_coordinates
645 PGI_misc_hints
646 PGI_vertex_hints

526 S3_s3tc
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

527 SGIS_color_range
528 SGIS_detail_texture
529 SGIS_fog_function
530 SGIS_generate_mipmap
531 SGIS_multisample
532 SGIS_pixel_texture
533 SGIS_point_line_texgen
534 SGIS_sharpen_texture
535 SGIS_texture4D
536 SGIS_texture_border_clamp
537 SGIS_texture_edge_clamp
538 SGIS_texture_filter4
539 SGIS_texture_lod
540 SGIS_texture_select
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

541 SGIX_async
542 SGIX_async_histogram
543 SGIX_async_pixel
544 SGIX_blend_alpha_minmax
545 SGIX_clipmap
546 SGIX_convolution_accuracy
547 SGIX_depth_texture
548 SGIX_flush_raster
549 SGIX_fog_offset
550 SGIX_fog_texture
551 SGIX_fragment_specular_lighting
552 SGIX_framezoom
553 SGIX_interlace
554 SGIX_ir_instrument1
555 SGIX_list_priority
556 SGIX_pixel_texture
557 SGIX_pixel_texture_bits
558 SGIX_reference_plane
559 SGIX_resample
560 SGIX_shadow
561 SGIX_shadow_ambient
562 SGIX_sprite
563 SGIX_tag_sample_buffer
564 SGIX_texture_add_env
565 SGIX_texture_coordinate_clamp
566 SGIX_texture_lod_bias
567 SGIX_texture_multi_buffer
568 SGIX_texture_range
569 SGIX_texture_scale_bias
570 SGIX_vertex_preclip
571 SGIX_vertex_preclip_hint
572 SGIX_ycrcb
664 REND_screen_coordinates

573 SGI_color_matrix
574 SGI_color_table
575 SGI_texture_color_table
665 S3_s3tc

576 SUNX_constant_data
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

577 SUN_convolution_border_modes
578 SUN_global_alpha
579 SUN_mesh_array
580 SUN_read_video_pixels
581 SUN_slice_accum
582 SUN_triangle_list
583 SUN_vertex
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

584 WIN_phong_shading
585 WIN_specular_fog
586 WIN_swap_hint
766 SGI_color_matrix
767 SGI_color_table
768 SGI_complex
769 SGI_complex_type
770 SGI_fft
771 SGI_texture_color_table

772 SUNX_constant_data

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

780 WIN_phong_shading
781 WIN_scene_markerXXX
782 WIN_specular_fog
783 WIN_swap_hint
diff --git a/doc/glxew.html b/doc/glxew.html index 4e5d617..d1ee00c 100755 --- a/doc/glxew.html +++ b/doc/glxew.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
@@ -99,85 +99,86 @@ 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_profile
6 ARB_create_context_robustness
7 ARB_fbconfig_float
8 ARB_framebuffer_sRGB
9 ARB_get_proc_address
10 ARB_multisample
11 ARB_robustness_application_isolation
12 ARB_robustness_share_group_isolation
13 ARB_vertex_buffer_object
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

14 ATI_pixel_format_float
15 ATI_render_texture
15 ATI_pixel_format_float
16 ATI_render_texture

16 EXT_buffer_age
17 EXT_create_context_es2_profile
18 EXT_create_context_es_profile
19 EXT_fbconfig_packed_float
20 EXT_framebuffer_sRGB
21 EXT_import_context
22 EXT_libglvnd
23 EXT_scene_marker
24 EXT_stereo_tree
25 EXT_swap_control
26 EXT_swap_control_tear
27 EXT_texture_from_pixmap
28 EXT_visual_info
29 EXT_visual_rating
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

30 INTEL_swap_event
31 INTEL_swap_event

31 MESA_agp_offset
32 MESA_copy_sub_buffer
33 MESA_pixmap_colormap
34 MESA_query_renderer
35 MESA_release_buffers
36 MESA_set_3dfx_mode
37 MESA_swap_control
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

38 NV_copy_buffer
39 NV_copy_image
40 NV_delay_before_swap
41 NV_float_buffer
42 NV_multisample_coverage
43 NV_present_video
44 NV_robustness_video_memory_purge
45 NV_swap_group
46 NV_vertex_array_range
47 NV_video_capture
48 NV_video_out
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

49 OML_swap_method
50 OML_sync_control
50 OML_swap_method
51 OML_sync_control

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

55 SGIX_fbconfig
56 SGIX_hyperpipe
57 SGIX_pbuffer
58 SGIX_swap_barrier
59 SGIX_swap_group
60 SGIX_video_resize
61 SGIX_visual_select_group
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

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

66 SUN_get_transparent_index
67 SUN_video_resize
67 SUN_get_transparent_index
68 SUN_video_resize
diff --git a/doc/index.html b/doc/index.html index 6f61c2f..84e7407 100755 --- a/doc/index.html +++ b/doc/index.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- + +ZIP |  +TGZ @@ -134,7 +134,7 @@ The latest release is @@ -153,7 +153,7 @@ An up-to-date copy is also available using git

Supported Extensions

-The latest release contains support for OpenGL 4.5, compatibility and forward-compatible contexts and the following extensions: +The latest release contains support for OpenGL 4.6, compatibility and forward-compatible contexts and the following extensions:

  • OpenGL extensions @@ -163,6 +163,7 @@ The latest release contains support for OpenGL 4.5, compatibility and forward-co

    News

      +
    • [07-31-17] GLEW 2.1.0 adds support for OpenGL 4.6, new extensions and minor bug fixes
    • [07-24-16] GLEW 2.0.0 adds support for forward-compatible contexts, adds new extensions, OSMesa and EGL support, MX discontinued and minor bug fixes
    • [08-10-15] GLEW 1.13.0 adds support for new extensions, fixes minor bugs
    • [26-01-15] GLEW 1.12.0 fixes minor bugs and adds new extensions
      • diff --git a/doc/install.html b/doc/install.html index 7c9421d..19129e3 100755 --- a/doc/install.html +++ b/doc/install.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
@@ -111,7 +111,7 @@ Mac OS X, FreeBSD, Irix, and Solaris. GLEW is distributed as source and precompiled binaries.
The latest release is -2.2.0[07-24-16]: +2.1.0[07-31-17]:

@@ -125,8 +125,8 @@ The latest release is 		Source -ZIP |  -TGZ
Binaries -Windows 32-bit and 64-bit +Windows 32-bit and 64-bit
- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
diff --git a/doc/log.html b/doc/log.html index 9b701e8..a343f2b 100755 --- a/doc/log.html +++ b/doc/log.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE. 		- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
@@ -100,7 +100,70 @@ THE POSSIBILITY OF SUCH DAMAGE.
    -
  • 2.2.0 [07-24-16] +
  • 2.1.0 [07-31-17] +
      +
    • Enhancements: +
        +
      • OpenGL 4.6 support added +
      • Improved Mac OSX build support +
      • Improved cmake build support +
      +
    + +
      +
    • Bug fixes: +
        +
      • Resovled crash when glXGetCurrentDisplay() is NULL +
      • CMake: only install PDB files with MSVC +
      • wglGetProcAddress crash with NOGDI defined +
      • Mac: using -Os rather than -O2 +
      +
    + +
      +
    • New extensions: +
        +
      • GL_AMD_gpu_shader_half_float +
      • GL_AMD_shader_ballot +
      • GL_ARB_gl_spirv +
      • GL_EGL_KHR_context_flush_control +
      • GL_INTEL_conservative_rasterization +
      • GL_MESA_shader_integer_functions +
      • GL_NVX_blend_equation_advanced_multi_draw_buffers +
      • GL_NV_gpu_multicast +
      • EGL_ARM_implicit_external_sync +
      • EGL_EXT_gl_colorspace_bt2020_linear +
      • EGL_EXT_gl_colorspace_bt2020_pq +
      • EGL_EXT_gl_colorspace_scrgb_linear +
      • EGL_EXT_image_dma_buf_import_modifiers +
      • EGL_EXT_pixel_format_float +
      • EGL_EXT_surface_SMPTE2086_metadata +
      • EGL_KHR_context_flush_control +
      • EGL_KHR_no_config_context +
      • EGL_KHR_stream_attrib +
      • EGL_MESA_platform_surfaceless +
      • EGL_NV_stream_cross_display +
      • EGL_NV_stream_cross_object +
      • EGL_NV_stream_cross_partition +
      • EGL_NV_stream_cross_process +
      • EGL_NV_stream_cross_system +
      • EGL_NV_stream_fifo_next +
      • EGL_NV_stream_fifo_synchronous +
      • EGL_NV_stream_frame_limits +
      • EGL_NV_stream_remote +
      • EGL_NV_stream_reset +
      • EGL_NV_stream_socket +
      • EGL_NV_stream_socket_inet +
      • EGL_NV_stream_socket_unix +
      • WGL_EXT_colorspace +
      +
    + +
+ +
+
    +
  • 2.0.0 [07-24-16]
    • Enhancements:
        diff --git a/doc/wglew.html b/doc/wglew.html index 12e33c1..bf5c9da 100755 --- a/doc/wglew.html +++ b/doc/wglew.html @@ -46,7 +46,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
- + @@ -75,7 +75,7 @@ THE POSSIBILITY OF SUCH DAMAGE.
Latest Release: 2.2.0
Latest Release: 2.1.0

GLEW Logo

- +
Last Update: 07-24-16
Last Update: 07-31-17
OpenGL Logo
GitHub Logo
@@ -99,7 +99,7 @@ THE POSSIBILITY OF SUCH DAMAGE.

Supported WGL Extensions

- + @@ -108,59 +108,61 @@ THE POSSIBILITY OF SUCH DAMAGE. - - - - - - - - - - - - + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - +
1 3DFX_multisample
1 3DFX_multisample

2 3DL_stereo_control

4 ARB_buffer_region
5 ARB_context_flush_control
6 ARB_create_context
7 ARB_create_context_profile
8 ARB_create_context_robustness
9 ARB_extensions_string
10 ARB_framebuffer_sRGB
11 ARB_make_current_read
12 ARB_multisample
13 ARB_pbuffer
14 ARB_pixel_format
15 ARB_pixel_format_float
16 ARB_render_texture
17 ARB_robustness_application_isolation
18 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

19 ATI_pixel_format_float
20 ATI_render_texture_rectangle
20 ATI_pixel_format_float
21 ATI_render_texture_rectangle

21 EXT_create_context_es2_profile
22 EXT_create_context_es_profile
23 EXT_depth_float
24 EXT_display_color_table
25 EXT_extensions_string
26 EXT_framebuffer_sRGB
27 EXT_make_current_read
28 EXT_multisample
29 EXT_pbuffer
30 EXT_pixel_format
31 EXT_pixel_format_packed_float
32 EXT_swap_control
33 EXT_swap_control_tear
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
28 EXT_framebuffer_sRGB
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 I3D_digital_video_control
35 I3D_gamma
36 I3D_genlock
37 I3D_image_buffer
38 I3D_swap_frame_lock
39 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

40 NV_DX_interop
41 NV_DX_interop2
42 NV_copy_image
43 NV_delay_before_swap
44 NV_float_buffer
45 NV_gpu_affinity
46 NV_multisample_coverage
47 NV_present_video
48 NV_render_depth_texture
49 NV_render_texture_rectangle
50 NV_swap_group
51 NV_vertex_array_range
52 NV_video_capture
53 NV_video_output
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
53 NV_vertex_array_range
54 NV_video_capture
55 NV_video_output

54 OML_sync_control
56 OML_sync_control
diff --git a/include/GL/eglew.h b/include/GL/eglew.h index aef65c8..4670147 100644 --- a/include/GL/eglew.h +++ b/include/GL/eglew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -639,6 +639,17 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACEPOINTERANGLEPROC) (EGLDisplay dpy, EG #endif /* EGL_ANGLE_window_fixed_size */ +/* --------------------- EGL_ARM_implicit_external_sync -------------------- */ + +#ifndef EGL_ARM_implicit_external_sync +#define EGL_ARM_implicit_external_sync 1 + +#define EGL_SYNC_PRIOR_COMMANDS_IMPLICIT_EXTERNAL_ARM 0x328A + +#define EGLEW_ARM_implicit_external_sync EGLEW_GET_VAR(__EGLEW_ARM_implicit_external_sync) + +#endif /* EGL_ARM_implicit_external_sync */ + /* ------------------- EGL_ARM_pixmap_multisample_discard ------------------ */ #ifndef EGL_ARM_pixmap_multisample_discard @@ -751,6 +762,39 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLin #endif /* EGL_EXT_device_query */ +/* ------------------ EGL_EXT_gl_colorspace_bt2020_linear ------------------ */ + +#ifndef EGL_EXT_gl_colorspace_bt2020_linear +#define EGL_EXT_gl_colorspace_bt2020_linear 1 + +#define EGL_GL_COLORSPACE_BT2020_LINEAR_EXT 0x333F + +#define EGLEW_EXT_gl_colorspace_bt2020_linear EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_bt2020_linear) + +#endif /* EGL_EXT_gl_colorspace_bt2020_linear */ + +/* -------------------- EGL_EXT_gl_colorspace_bt2020_pq -------------------- */ + +#ifndef EGL_EXT_gl_colorspace_bt2020_pq +#define EGL_EXT_gl_colorspace_bt2020_pq 1 + +#define EGL_GL_COLORSPACE_BT2020_PQ_EXT 0x3340 + +#define EGLEW_EXT_gl_colorspace_bt2020_pq EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_bt2020_pq) + +#endif /* EGL_EXT_gl_colorspace_bt2020_pq */ + +/* ------------------- EGL_EXT_gl_colorspace_scrgb_linear ------------------ */ + +#ifndef EGL_EXT_gl_colorspace_scrgb_linear +#define EGL_EXT_gl_colorspace_scrgb_linear 1 + +#define EGL_GL_COLORSPACE_SCRGB_LINEAR_EXT 0x3350 + +#define EGLEW_EXT_gl_colorspace_scrgb_linear EGLEW_GET_VAR(__EGLEW_EXT_gl_colorspace_scrgb_linear) + +#endif /* EGL_EXT_gl_colorspace_scrgb_linear */ + /* ---------------------- EGL_EXT_image_dma_buf_import --------------------- */ #ifndef EGL_EXT_image_dma_buf_import @@ -783,6 +827,33 @@ typedef EGLBoolean ( * PFNEGLQUERYDISPLAYATTRIBEXTPROC) (EGLDisplay dpy, EGLin #endif /* EGL_EXT_image_dma_buf_import */ +/* ----------------- EGL_EXT_image_dma_buf_import_modifiers ---------------- */ + +#ifndef EGL_EXT_image_dma_buf_import_modifiers +#define EGL_EXT_image_dma_buf_import_modifiers 1 + +#define EGL_DMA_BUF_PLANE3_FD_EXT 0x3440 +#define EGL_DMA_BUF_PLANE3_OFFSET_EXT 0x3441 +#define EGL_DMA_BUF_PLANE3_PITCH_EXT 0x3442 +#define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443 +#define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444 +#define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445 +#define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446 +#define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447 +#define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448 +#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); + +#define eglQueryDmaBufFormatsEXT EGLEW_GET_FUN(__eglewQueryDmaBufFormatsEXT) +#define eglQueryDmaBufModifiersEXT EGLEW_GET_FUN(__eglewQueryDmaBufModifiersEXT) + +#define EGLEW_EXT_image_dma_buf_import_modifiers EGLEW_GET_VAR(__EGLEW_EXT_image_dma_buf_import_modifiers) + +#endif /* EGL_EXT_image_dma_buf_import_modifiers */ + /* ------------------------ EGL_EXT_multiview_window ----------------------- */ #ifndef EGL_EXT_multiview_window @@ -850,6 +921,19 @@ typedef const char * ( * PFNEGLQUERYOUTPUTPORTSTRINGEXTPROC) (EGLDisplay dpy, E #endif /* EGL_EXT_output_openwf */ +/* ----------------------- EGL_EXT_pixel_format_float ---------------------- */ + +#ifndef EGL_EXT_pixel_format_float +#define EGL_EXT_pixel_format_float 1 + +#define EGL_COLOR_COMPONENT_TYPE_EXT 0x3339 +#define EGL_COLOR_COMPONENT_TYPE_FIXED_EXT 0x333A +#define EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT 0x333B + +#define EGLEW_EXT_pixel_format_float EGLEW_GET_VAR(__EGLEW_EXT_pixel_format_float) + +#endif /* EGL_EXT_pixel_format_float */ + /* ------------------------- EGL_EXT_platform_base ------------------------- */ #ifndef EGL_EXT_platform_base @@ -936,6 +1020,26 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMEROUTPUTEXTPROC) (EGLDisplay dpy, EGL #endif /* EGL_EXT_stream_consumer_egloutput */ +/* ------------------- EGL_EXT_surface_SMPTE2086_metadata ------------------ */ + +#ifndef EGL_EXT_surface_SMPTE2086_metadata +#define EGL_EXT_surface_SMPTE2086_metadata 1 + +#define EGL_SMPTE2086_DISPLAY_PRIMARY_RX_EXT 0x3341 +#define EGL_SMPTE2086_DISPLAY_PRIMARY_RY_EXT 0x3342 +#define EGL_SMPTE2086_DISPLAY_PRIMARY_GX_EXT 0x3343 +#define EGL_SMPTE2086_DISPLAY_PRIMARY_GY_EXT 0x3344 +#define EGL_SMPTE2086_DISPLAY_PRIMARY_BX_EXT 0x3345 +#define EGL_SMPTE2086_DISPLAY_PRIMARY_BY_EXT 0x3346 +#define EGL_SMPTE2086_WHITE_POINT_X_EXT 0x3347 +#define EGL_SMPTE2086_WHITE_POINT_Y_EXT 0x3348 +#define EGL_SMPTE2086_MAX_LUMINANCE_EXT 0x3349 +#define EGL_SMPTE2086_MIN_LUMINANCE_EXT 0x334A + +#define EGLEW_EXT_surface_SMPTE2086_metadata EGLEW_GET_VAR(__EGLEW_EXT_surface_SMPTE2086_metadata) + +#endif /* EGL_EXT_surface_SMPTE2086_metadata */ + /* -------------------- EGL_EXT_swap_buffers_with_damage ------------------- */ #ifndef EGL_EXT_swap_buffers_with_damage @@ -1091,6 +1195,19 @@ typedef EGLSyncKHR ( * PFNEGLCREATESYNC64KHRPROC) (EGLDisplay dpy, EGLenum ty #endif /* EGL_KHR_config_attribs */ +/* --------------------- EGL_KHR_context_flush_control --------------------- */ + +#ifndef EGL_KHR_context_flush_control +#define EGL_KHR_context_flush_control 1 + +#define EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR 0 +#define EGL_CONTEXT_RELEASE_BEHAVIOR_KHR 0x2097 +#define EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR 0x2098 + +#define EGLEW_KHR_context_flush_control EGLEW_GET_VAR(__EGLEW_KHR_context_flush_control) + +#endif /* EGL_KHR_context_flush_control */ + /* ------------------------- EGL_KHR_create_context ------------------------ */ #ifndef EGL_KHR_create_context @@ -1376,6 +1493,15 @@ typedef EGLBoolean ( * PFNEGLQUERYSURFACE64KHRPROC) (EGLDisplay dpy, EGLSurfac #endif /* EGL_KHR_mutable_render_buffer */ +/* ----------------------- EGL_KHR_no_config_context ----------------------- */ + +#ifndef EGL_KHR_no_config_context +#define EGL_KHR_no_config_context 1 + +#define EGLEW_KHR_no_config_context EGLEW_GET_VAR(__EGLEW_KHR_no_config_context) + +#endif /* EGL_KHR_no_config_context */ + /* ------------------------- EGL_KHR_partial_update ------------------------ */ #ifndef EGL_KHR_partial_update @@ -1501,6 +1627,32 @@ typedef EGLBoolean ( * PFNEGLSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKH #endif /* EGL_KHR_stream */ +/* ------------------------- EGL_KHR_stream_attrib ------------------------- */ + +#ifndef EGL_KHR_stream_attrib +#define EGL_KHR_stream_attrib 1 + +#define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210 +#define EGL_STREAM_STATE_KHR 0x3214 +#define EGL_STREAM_STATE_CREATED_KHR 0x3215 +#define EGL_STREAM_STATE_CONNECTING_KHR 0x3216 + +typedef EGLStreamKHR ( * PFNEGLCREATESTREAMATTRIBKHRPROC) (EGLDisplay dpy, const EGLAttrib * attrib_list); +typedef EGLBoolean ( * PFNEGLQUERYSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib * value); +typedef EGLBoolean ( * PFNEGLSETSTREAMATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, EGLenum attribute, EGLAttrib value); +typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib * attrib_list); +typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC) (EGLDisplay dpy, EGLStreamKHR stream, const EGLAttrib * attrib_list); + +#define eglCreateStreamAttribKHR EGLEW_GET_FUN(__eglewCreateStreamAttribKHR) +#define eglQueryStreamAttribKHR EGLEW_GET_FUN(__eglewQueryStreamAttribKHR) +#define eglSetStreamAttribKHR EGLEW_GET_FUN(__eglewSetStreamAttribKHR) +#define eglStreamConsumerAcquireAttribKHR EGLEW_GET_FUN(__eglewStreamConsumerAcquireAttribKHR) +#define eglStreamConsumerReleaseAttribKHR EGLEW_GET_FUN(__eglewStreamConsumerReleaseAttribKHR) + +#define EGLEW_KHR_stream_attrib EGLEW_GET_VAR(__EGLEW_KHR_stream_attrib) + +#endif /* EGL_KHR_stream_attrib */ + /* ------------------- EGL_KHR_stream_consumer_gltexture ------------------- */ #ifndef EGL_KHR_stream_consumer_gltexture @@ -1672,6 +1824,17 @@ typedef EGLBoolean ( * PFNEGLEXPORTDMABUFIMAGEQUERYMESAPROC) (EGLDisplay dpy, #endif /* EGL_MESA_platform_gbm */ +/* --------------------- EGL_MESA_platform_surfaceless --------------------- */ + +#ifndef EGL_MESA_platform_surfaceless +#define EGL_MESA_platform_surfaceless 1 + +#define EGL_PLATFORM_SURFACELESS_MESA 0x31DD + +#define EGLEW_MESA_platform_surfaceless EGLEW_GET_VAR(__EGLEW_MESA_platform_surfaceless) + +#endif /* EGL_MESA_platform_surfaceless */ + /* -------------------------- EGL_NOK_swap_region -------------------------- */ #ifndef EGL_NOK_swap_region @@ -1853,6 +2016,96 @@ typedef EGLBoolean ( * PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALATTRIBSNVPROC) (EGL #endif /* EGL_NV_stream_consumer_gltexture_yuv */ +/* ---------------------- EGL_NV_stream_cross_display ---------------------- */ + +#ifndef EGL_NV_stream_cross_display +#define EGL_NV_stream_cross_display 1 + +#define EGL_STREAM_CROSS_DISPLAY_NV 0x334E + +#define EGLEW_NV_stream_cross_display EGLEW_GET_VAR(__EGLEW_NV_stream_cross_display) + +#endif /* EGL_NV_stream_cross_display */ + +/* ----------------------- EGL_NV_stream_cross_object ---------------------- */ + +#ifndef EGL_NV_stream_cross_object +#define EGL_NV_stream_cross_object 1 + +#define EGL_STREAM_CROSS_OBJECT_NV 0x334D + +#define EGLEW_NV_stream_cross_object EGLEW_GET_VAR(__EGLEW_NV_stream_cross_object) + +#endif /* EGL_NV_stream_cross_object */ + +/* --------------------- EGL_NV_stream_cross_partition --------------------- */ + +#ifndef EGL_NV_stream_cross_partition +#define EGL_NV_stream_cross_partition 1 + +#define EGL_STREAM_CROSS_PARTITION_NV 0x323F + +#define EGLEW_NV_stream_cross_partition EGLEW_GET_VAR(__EGLEW_NV_stream_cross_partition) + +#endif /* EGL_NV_stream_cross_partition */ + +/* ---------------------- EGL_NV_stream_cross_process ---------------------- */ + +#ifndef EGL_NV_stream_cross_process +#define EGL_NV_stream_cross_process 1 + +#define EGL_STREAM_CROSS_PROCESS_NV 0x3245 + +#define EGLEW_NV_stream_cross_process EGLEW_GET_VAR(__EGLEW_NV_stream_cross_process) + +#endif /* EGL_NV_stream_cross_process */ + +/* ----------------------- EGL_NV_stream_cross_system ---------------------- */ + +#ifndef EGL_NV_stream_cross_system +#define EGL_NV_stream_cross_system 1 + +#define EGL_STREAM_CROSS_SYSTEM_NV 0x334F + +#define EGLEW_NV_stream_cross_system EGLEW_GET_VAR(__EGLEW_NV_stream_cross_system) + +#endif /* EGL_NV_stream_cross_system */ + +/* ------------------------ EGL_NV_stream_fifo_next ------------------------ */ + +#ifndef EGL_NV_stream_fifo_next +#define EGL_NV_stream_fifo_next 1 + +#define EGL_PENDING_FRAME_NV 0x3329 +#define EGL_STREAM_TIME_PENDING_NV 0x332A + +#define EGLEW_NV_stream_fifo_next EGLEW_GET_VAR(__EGLEW_NV_stream_fifo_next) + +#endif /* EGL_NV_stream_fifo_next */ + +/* --------------------- EGL_NV_stream_fifo_synchronous -------------------- */ + +#ifndef EGL_NV_stream_fifo_synchronous +#define EGL_NV_stream_fifo_synchronous 1 + +#define EGL_STREAM_FIFO_SYNCHRONOUS_NV 0x3336 + +#define EGLEW_NV_stream_fifo_synchronous EGLEW_GET_VAR(__EGLEW_NV_stream_fifo_synchronous) + +#endif /* EGL_NV_stream_fifo_synchronous */ + +/* ----------------------- EGL_NV_stream_frame_limits ---------------------- */ + +#ifndef EGL_NV_stream_frame_limits +#define EGL_NV_stream_frame_limits 1 + +#define EGL_PRODUCER_MAX_FRAME_HINT_NV 0x3337 +#define EGL_CONSUMER_MAX_FRAME_HINT_NV 0x3338 + +#define EGLEW_NV_stream_frame_limits EGLEW_GET_VAR(__EGLEW_NV_stream_frame_limits) + +#endif /* EGL_NV_stream_frame_limits */ + /* ------------------------- EGL_NV_stream_metadata ------------------------ */ #ifndef EGL_NV_stream_metadata @@ -1885,6 +2138,75 @@ typedef EGLBoolean ( * PFNEGLSETSTREAMMETADATANVPROC) (EGLDisplay dpy, EGLStre #endif /* EGL_NV_stream_metadata */ +/* -------------------------- EGL_NV_stream_remote ------------------------- */ + +#ifndef EGL_NV_stream_remote +#define EGL_NV_stream_remote 1 + +#define EGL_STREAM_STATE_INITIALIZING_NV 0x3240 +#define EGL_STREAM_TYPE_NV 0x3241 +#define EGL_STREAM_PROTOCOL_NV 0x3242 +#define EGL_STREAM_ENDPOINT_NV 0x3243 +#define EGL_STREAM_LOCAL_NV 0x3244 +#define EGL_STREAM_PROTOCOL_FD_NV 0x3246 +#define EGL_STREAM_PRODUCER_NV 0x3247 +#define EGL_STREAM_CONSUMER_NV 0x3248 + +#define EGLEW_NV_stream_remote EGLEW_GET_VAR(__EGLEW_NV_stream_remote) + +#endif /* EGL_NV_stream_remote */ + +/* -------------------------- EGL_NV_stream_reset -------------------------- */ + +#ifndef EGL_NV_stream_reset +#define EGL_NV_stream_reset 1 + +#define EGL_SUPPORT_RESET_NV 0x3334 +#define EGL_SUPPORT_REUSE_NV 0x3335 + +typedef EGLBoolean ( * PFNEGLRESETSTREAMNVPROC) (EGLDisplay dpy, EGLStreamKHR stream); + +#define eglResetStreamNV EGLEW_GET_FUN(__eglewResetStreamNV) + +#define EGLEW_NV_stream_reset EGLEW_GET_VAR(__EGLEW_NV_stream_reset) + +#endif /* EGL_NV_stream_reset */ + +/* -------------------------- EGL_NV_stream_socket ------------------------- */ + +#ifndef EGL_NV_stream_socket +#define EGL_NV_stream_socket 1 + +#define EGL_STREAM_PROTOCOL_SOCKET_NV 0x324B +#define EGL_SOCKET_HANDLE_NV 0x324C +#define EGL_SOCKET_TYPE_NV 0x324D + +#define EGLEW_NV_stream_socket EGLEW_GET_VAR(__EGLEW_NV_stream_socket) + +#endif /* EGL_NV_stream_socket */ + +/* ----------------------- EGL_NV_stream_socket_inet ----------------------- */ + +#ifndef EGL_NV_stream_socket_inet +#define EGL_NV_stream_socket_inet 1 + +#define EGL_SOCKET_TYPE_INET_NV 0x324F + +#define EGLEW_NV_stream_socket_inet EGLEW_GET_VAR(__EGLEW_NV_stream_socket_inet) + +#endif /* EGL_NV_stream_socket_inet */ + +/* ----------------------- EGL_NV_stream_socket_unix ----------------------- */ + +#ifndef EGL_NV_stream_socket_unix +#define EGL_NV_stream_socket_unix 1 + +#define EGL_SOCKET_TYPE_UNIX_NV 0x324E + +#define EGLEW_NV_stream_socket_unix EGLEW_GET_VAR(__EGLEW_NV_stream_socket_unix) + +#endif /* EGL_NV_stream_socket_unix */ + /* --------------------------- EGL_NV_stream_sync -------------------------- */ #ifndef EGL_NV_stream_sync @@ -2043,6 +2365,9 @@ EGLEW_FUN_EXPORT PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT; EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT; +EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT; +EGLEW_FUN_EXPORT PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT; + EGLEW_FUN_EXPORT PFNEGLGETOUTPUTLAYERSEXTPROC __eglewGetOutputLayersEXT; EGLEW_FUN_EXPORT PFNEGLGETOUTPUTPORTSEXTPROC __eglewGetOutputPortsEXT; EGLEW_FUN_EXPORT PFNEGLOUTPUTLAYERATTRIBEXTPROC __eglewOutputLayerAttribEXT; @@ -2090,6 +2415,12 @@ EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMKHRPROC __eglewQueryStreamKHR; EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMU64KHRPROC __eglewQueryStreamu64KHR; EGLEW_FUN_EXPORT PFNEGLSTREAMATTRIBKHRPROC __eglewStreamAttribKHR; +EGLEW_FUN_EXPORT PFNEGLCREATESTREAMATTRIBKHRPROC __eglewCreateStreamAttribKHR; +EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMATTRIBKHRPROC __eglewQueryStreamAttribKHR; +EGLEW_FUN_EXPORT PFNEGLSETSTREAMATTRIBKHRPROC __eglewSetStreamAttribKHR; +EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC __eglewStreamConsumerAcquireAttribKHR; +EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC __eglewStreamConsumerReleaseAttribKHR; + EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERACQUIREKHRPROC __eglewStreamConsumerAcquireKHR; EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC __eglewStreamConsumerGLTextureExternalKHR; EGLEW_FUN_EXPORT PFNEGLSTREAMCONSUMERRELEASEKHRPROC __eglewStreamConsumerReleaseKHR; @@ -2127,6 +2458,8 @@ EGLEW_FUN_EXPORT PFNEGLQUERYDISPLAYATTRIBNVPROC __eglewQueryDisplayAttribNV; EGLEW_FUN_EXPORT PFNEGLQUERYSTREAMMETADATANVPROC __eglewQueryStreamMetadataNV; EGLEW_FUN_EXPORT PFNEGLSETSTREAMMETADATANVPROC __eglewSetStreamMetadataNV; +EGLEW_FUN_EXPORT PFNEGLRESETSTREAMNVPROC __eglewResetStreamNV; + EGLEW_FUN_EXPORT PFNEGLCREATESTREAMSYNCNVPROC __eglewCreateStreamSyncNV; EGLEW_FUN_EXPORT PFNEGLCLIENTWAITSYNCNVPROC __eglewClientWaitSyncNV; @@ -2157,6 +2490,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_device_d3d; EGLEW_VAR_EXPORT GLboolean __EGLEW_ANGLE_query_surface_pointer; 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_buffer_age; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_client_extensions; @@ -2166,11 +2500,16 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_drm; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_device_enumeration; 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_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_multiview_window; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_output_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_output_drm; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_output_openwf; +EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_pixel_format_float; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_base; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_device; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_platform_wayland; @@ -2178,6 +2517,7 @@ 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_SMPTE2086_metadata; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_swap_buffers_with_damage; EGLEW_VAR_EXPORT GLboolean __EGLEW_EXT_yuv_surface; EGLEW_VAR_EXPORT GLboolean __EGLEW_HI_clientpixmap; @@ -2188,6 +2528,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_cl_event; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_cl_event2; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_client_get_all_proc_addresses; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_config_attribs; +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; @@ -2205,6 +2546,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_lock_surface; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_lock_surface2; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_lock_surface3; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_mutable_render_buffer; +EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_no_config_context; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_partial_update; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_platform_android; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_platform_gbm; @@ -2212,6 +2554,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_platform_wayland; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_platform_x11; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_reusable_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_stream; +EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_stream_attrib; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_stream_consumer_gltexture; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_stream_cross_process_fd; EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_stream_fifo; @@ -2224,6 +2567,7 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_KHR_wait_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_MESA_drm_image; EGLEW_VAR_EXPORT GLboolean __EGLEW_MESA_image_dma_buf_export; EGLEW_VAR_EXPORT GLboolean __EGLEW_MESA_platform_gbm; +EGLEW_VAR_EXPORT GLboolean __EGLEW_MESA_platform_surfaceless; 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; @@ -2238,7 +2582,20 @@ EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_convert_rounding; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_post_sub_buffer; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_robustness_video_memory_purge; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_display; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_object; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_cross_partition; +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_frame_limits; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_metadata; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_remote; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_reset; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_socket; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_socket_inet; +EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_socket_unix; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_stream_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_sync; EGLEW_VAR_EXPORT GLboolean __EGLEW_NV_system_time; diff --git a/include/GL/glew.h b/include/GL/glew.h index fae0c21..b5b6987 100755 --- a/include/GL/glew.h +++ b/include/GL/glew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -2496,6 +2496,46 @@ typedef void (GLAPIENTRY * PFNGLGETNUNIFORMDVPROC) (GLuint program, GLint locati #endif /* GL_VERSION_4_5 */ +/* ----------------------------- GL_VERSION_4_6 ---------------------------- */ + +#ifndef GL_VERSION_4_6 +#define GL_VERSION_4_6 1 + +#define GL_CONTEXT_FLAG_NO_ERROR_BIT 0x00000008 +#define GL_PARAMETER_BUFFER 0x80EE +#define GL_PARAMETER_BUFFER_BINDING 0x80EF +#define GL_TRANSFORM_FEEDBACK_OVERFLOW 0x82EC +#define GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW 0x82ED +#define GL_VERTICES_SUBMITTED 0x82EE +#define GL_PRIMITIVES_SUBMITTED 0x82EF +#define GL_VERTEX_SHADER_INVOCATIONS 0x82F0 +#define GL_TESS_CONTROL_SHADER_PATCHES 0x82F1 +#define GL_TESS_EVALUATION_SHADER_INVOCATIONS 0x82F2 +#define GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED 0x82F3 +#define GL_FRAGMENT_SHADER_INVOCATIONS 0x82F4 +#define GL_COMPUTE_SHADER_INVOCATIONS 0x82F5 +#define GL_CLIPPING_INPUT_PRIMITIVES 0x82F6 +#define GL_CLIPPING_OUTPUT_PRIMITIVES 0x82F7 +#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE +#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF +#define GL_POLYGON_OFFSET_CLAMP 0x8E1B +#define GL_SHADER_BINARY_FORMAT_SPIR_V 0x9551 +#define GL_SPIR_V_BINARY 0x9552 +#define GL_SPIR_V_EXTENSIONS 0x9553 +#define GL_NUM_SPIR_V_EXTENSIONS 0x9554 + +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC) (GLenum mode, const GLvoid *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC) (GLenum mode, GLenum type, const GLvoid *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLSPECIALIZESHADERPROC) (GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue); + +#define glMultiDrawArraysIndirectCount GLEW_GET_FUN(__glewMultiDrawArraysIndirectCount) +#define glMultiDrawElementsIndirectCount GLEW_GET_FUN(__glewMultiDrawElementsIndirectCount) +#define glSpecializeShader GLEW_GET_FUN(__glewSpecializeShader) + +#define GLEW_VERSION_4_6 GLEW_GET_VAR(__GLEW_VERSION_4_6) + +#endif /* GL_VERSION_4_6 */ + /* -------------------------- GL_3DFX_multisample -------------------------- */ #ifndef GL_3DFX_multisample @@ -2547,6 +2587,31 @@ typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); #endif /* GL_AMD_blend_minmax_factor */ +/* --------------------- GL_AMD_compressed_3DC_texture --------------------- */ + +#ifndef GL_AMD_compressed_3DC_texture +#define GL_AMD_compressed_3DC_texture 1 + +#define GL_3DC_X_AMD 0x87F9 +#define GL_3DC_XY_AMD 0x87FA + +#define GLEW_AMD_compressed_3DC_texture GLEW_GET_VAR(__GLEW_AMD_compressed_3DC_texture) + +#endif /* GL_AMD_compressed_3DC_texture */ + +/* --------------------- GL_AMD_compressed_ATC_texture --------------------- */ + +#ifndef GL_AMD_compressed_ATC_texture +#define GL_AMD_compressed_ATC_texture 1 + +#define GL_ATC_RGBA_INTERPOLATED_ALPHA_AMD 0x87EE +#define GL_ATC_RGB_AMD 0x8C92 +#define GL_ATC_RGBA_EXPLICIT_ALPHA_AMD 0x8C93 + +#define GLEW_AMD_compressed_ATC_texture GLEW_GET_VAR(__GLEW_AMD_compressed_ATC_texture) + +#endif /* GL_AMD_compressed_ATC_texture */ + /* ----------------------- GL_AMD_conservative_depth ----------------------- */ #ifndef GL_AMD_conservative_depth @@ -2623,6 +2688,30 @@ typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GL #endif /* GL_AMD_draw_buffers_blend */ +/* ------------------ GL_AMD_framebuffer_sample_positions ------------------ */ + +#ifndef GL_AMD_framebuffer_sample_positions +#define GL_AMD_framebuffer_sample_positions 1 + +#define GL_SUBSAMPLE_DISTANCE_AMD 0x883F +#define GL_PIXELS_PER_SAMPLE_PATTERN_X_AMD 0x91AE +#define GL_PIXELS_PER_SAMPLE_PATTERN_Y_AMD 0x91AF +#define GL_ALL_PIXELS_AMD 0xFFFFFFFF + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC) (GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat* values); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC) (GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values); +typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC) (GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat* values); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC) (GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat* values); + +#define glFramebufferSamplePositionsfvAMD GLEW_GET_FUN(__glewFramebufferSamplePositionsfvAMD) +#define glGetFramebufferParameterfvAMD GLEW_GET_FUN(__glewGetFramebufferParameterfvAMD) +#define glGetNamedFramebufferParameterfvAMD GLEW_GET_FUN(__glewGetNamedFramebufferParameterfvAMD) +#define glNamedFramebufferSamplePositionsfvAMD GLEW_GET_FUN(__glewNamedFramebufferSamplePositionsfvAMD) + +#define GLEW_AMD_framebuffer_sample_positions GLEW_GET_VAR(__GLEW_AMD_framebuffer_sample_positions) + +#endif /* GL_AMD_framebuffer_sample_positions */ + /* --------------------------- GL_AMD_gcn_shader --------------------------- */ #ifndef GL_AMD_gcn_shader @@ -2632,6 +2721,38 @@ typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC) (GLuint buf, GL #endif /* GL_AMD_gcn_shader */ +/* ---------------------- GL_AMD_gpu_shader_half_float --------------------- */ + +#ifndef GL_AMD_gpu_shader_half_float +#define GL_AMD_gpu_shader_half_float 1 + +#define GL_FLOAT16_NV 0x8FF8 +#define GL_FLOAT16_VEC2_NV 0x8FF9 +#define GL_FLOAT16_VEC3_NV 0x8FFA +#define GL_FLOAT16_VEC4_NV 0x8FFB +#define GL_FLOAT16_MAT2_AMD 0x91C5 +#define GL_FLOAT16_MAT3_AMD 0x91C6 +#define GL_FLOAT16_MAT4_AMD 0x91C7 +#define GL_FLOAT16_MAT2x3_AMD 0x91C8 +#define GL_FLOAT16_MAT2x4_AMD 0x91C9 +#define GL_FLOAT16_MAT3x2_AMD 0x91CA +#define GL_FLOAT16_MAT3x4_AMD 0x91CB +#define GL_FLOAT16_MAT4x2_AMD 0x91CC +#define GL_FLOAT16_MAT4x3_AMD 0x91CD + +#define GLEW_AMD_gpu_shader_half_float GLEW_GET_VAR(__GLEW_AMD_gpu_shader_half_float) + +#endif /* GL_AMD_gpu_shader_half_float */ + +/* ------------------------ GL_AMD_gpu_shader_int16 ------------------------ */ + +#ifndef GL_AMD_gpu_shader_int16 +#define GL_AMD_gpu_shader_int16 1 + +#define GLEW_AMD_gpu_shader_int16 GLEW_GET_VAR(__GLEW_AMD_gpu_shader_int16) + +#endif /* GL_AMD_gpu_shader_int16 */ + /* ------------------------ GL_AMD_gpu_shader_int64 ------------------------ */ #ifndef GL_AMD_gpu_shader_int64 @@ -2774,6 +2895,17 @@ typedef void (GLAPIENTRY * PFNGLSELECTPERFMONITORCOUNTERSAMDPROC) (GLuint monito #endif /* GL_AMD_pinned_memory */ +/* ----------------------- GL_AMD_program_binary_Z400 ---------------------- */ + +#ifndef GL_AMD_program_binary_Z400 +#define GL_AMD_program_binary_Z400 1 + +#define GL_Z400_BINARY_AMD 0x8740 + +#define GLEW_AMD_program_binary_Z400 GLEW_GET_VAR(__GLEW_AMD_program_binary_Z400) + +#endif /* GL_AMD_program_binary_Z400 */ + /* ----------------------- GL_AMD_query_buffer_object ---------------------- */ #ifndef GL_AMD_query_buffer_object @@ -2807,7 +2939,7 @@ typedef void (GLAPIENTRY * PFNGLSETMULTISAMPLEFVAMDPROC) (GLenum pname, GLuint i #ifndef GL_AMD_seamless_cubemap_per_texture #define GL_AMD_seamless_cubemap_per_texture 1 -#define GL_TEXTURE_CUBE_MAP_SEAMLESS_ARB 0x884F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F #define GLEW_AMD_seamless_cubemap_per_texture GLEW_GET_VAR(__GLEW_AMD_seamless_cubemap_per_texture) @@ -2822,6 +2954,15 @@ typedef void (GLAPIENTRY * PFNGLSETMULTISAMPLEFVAMDPROC) (GLenum pname, GLuint i #endif /* GL_AMD_shader_atomic_counter_ops */ +/* -------------------------- GL_AMD_shader_ballot ------------------------- */ + +#ifndef GL_AMD_shader_ballot +#define GL_AMD_shader_ballot 1 + +#define GLEW_AMD_shader_ballot GLEW_GET_VAR(__GLEW_AMD_shader_ballot) + +#endif /* GL_AMD_shader_ballot */ + /* ---------------- GL_AMD_shader_explicit_vertex_parameter ---------------- */ #ifndef GL_AMD_shader_explicit_vertex_parameter @@ -2901,6 +3042,15 @@ typedef void (GLAPIENTRY * PFNGLSTENCILOPVALUEAMDPROC) (GLenum face, GLuint valu #endif /* GL_AMD_stencil_operation_extended */ +/* --------------------- GL_AMD_texture_gather_bias_lod -------------------- */ + +#ifndef GL_AMD_texture_gather_bias_lod +#define GL_AMD_texture_gather_bias_lod 1 + +#define GLEW_AMD_texture_gather_bias_lod GLEW_GET_VAR(__GLEW_AMD_texture_gather_bias_lod) + +#endif /* GL_AMD_texture_gather_bias_lod */ + /* ------------------------ GL_AMD_texture_texture4 ------------------------ */ #ifndef GL_AMD_texture_texture4 @@ -2971,6 +3121,15 @@ typedef void (GLAPIENTRY * PFNGLTESSELLATIONMODEAMDPROC) (GLenum mode); #endif /* GL_AMD_vertex_shader_viewport_index */ +/* -------------------- GL_ANDROID_extension_pack_es31a -------------------- */ + +#ifndef GL_ANDROID_extension_pack_es31a +#define GL_ANDROID_extension_pack_es31a 1 + +#define GLEW_ANDROID_extension_pack_es31a GLEW_GET_VAR(__GLEW_ANDROID_extension_pack_es31a) + +#endif /* GL_ANDROID_extension_pack_es31a */ + /* ------------------------- GL_ANGLE_depth_texture ------------------------ */ #ifndef GL_ANGLE_depth_texture @@ -3187,6 +3346,47 @@ typedef void (GLAPIENTRY * PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC) (GLuint shad #endif /* GL_APPLE_client_storage */ +/* ------------------------- GL_APPLE_clip_distance ------------------------ */ + +#ifndef GL_APPLE_clip_distance +#define GL_APPLE_clip_distance 1 + +#define GL_MAX_CLIP_DISTANCES_APPLE 0x0D32 +#define GL_CLIP_DISTANCE0_APPLE 0x3000 +#define GL_CLIP_DISTANCE1_APPLE 0x3001 +#define GL_CLIP_DISTANCE2_APPLE 0x3002 +#define GL_CLIP_DISTANCE3_APPLE 0x3003 +#define GL_CLIP_DISTANCE4_APPLE 0x3004 +#define GL_CLIP_DISTANCE5_APPLE 0x3005 +#define GL_CLIP_DISTANCE6_APPLE 0x3006 +#define GL_CLIP_DISTANCE7_APPLE 0x3007 + +#define GLEW_APPLE_clip_distance GLEW_GET_VAR(__GLEW_APPLE_clip_distance) + +#endif /* GL_APPLE_clip_distance */ + +/* ------------------- GL_APPLE_color_buffer_packed_float ------------------ */ + +#ifndef GL_APPLE_color_buffer_packed_float +#define GL_APPLE_color_buffer_packed_float 1 + +#define GLEW_APPLE_color_buffer_packed_float GLEW_GET_VAR(__GLEW_APPLE_color_buffer_packed_float) + +#endif /* GL_APPLE_color_buffer_packed_float */ + +/* ---------------------- GL_APPLE_copy_texture_levels --------------------- */ + +#ifndef GL_APPLE_copy_texture_levels +#define GL_APPLE_copy_texture_levels 1 + +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURELEVELSAPPLEPROC) (GLuint destinationTexture, GLuint sourceTexture, GLint sourceBaseLevel, GLsizei sourceLevelCount); + +#define glCopyTextureLevelsAPPLE GLEW_GET_FUN(__glewCopyTextureLevelsAPPLE) + +#define GLEW_APPLE_copy_texture_levels GLEW_GET_VAR(__GLEW_APPLE_copy_texture_levels) + +#endif /* GL_APPLE_copy_texture_levels */ + /* ------------------------- GL_APPLE_element_array ------------------------ */ #ifndef GL_APPLE_element_array @@ -3284,6 +3484,29 @@ typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target, #endif /* GL_APPLE_flush_buffer_range */ +/* -------------------- GL_APPLE_framebuffer_multisample ------------------- */ + +#ifndef GL_APPLE_framebuffer_multisample +#define GL_APPLE_framebuffer_multisample 1 + +#define GL_DRAW_FRAMEBUFFER_BINDING_APPLE 0x8CA6 +#define GL_READ_FRAMEBUFFER_APPLE 0x8CA8 +#define GL_DRAW_FRAMEBUFFER_APPLE 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING_APPLE 0x8CAA +#define GL_RENDERBUFFER_SAMPLES_APPLE 0x8CAB +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE 0x8D56 +#define GL_MAX_SAMPLES_APPLE 0x8D57 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC) (void); + +#define glRenderbufferStorageMultisampleAPPLE GLEW_GET_FUN(__glewRenderbufferStorageMultisampleAPPLE) +#define glResolveMultisampleFramebufferAPPLE GLEW_GET_FUN(__glewResolveMultisampleFramebufferAPPLE) + +#define GLEW_APPLE_framebuffer_multisample GLEW_GET_VAR(__GLEW_APPLE_framebuffer_multisample) + +#endif /* GL_APPLE_framebuffer_multisample */ + /* ----------------------- GL_APPLE_object_purgeable ----------------------- */ #ifndef GL_APPLE_object_purgeable @@ -3356,6 +3579,94 @@ typedef GLenum (GLAPIENTRY * PFNGLOBJECTUNPURGEABLEAPPLEPROC) (GLenum objectType #endif /* GL_APPLE_specular_vector */ +/* ----------------------------- GL_APPLE_sync ----------------------------- */ + +#ifndef GL_APPLE_sync +#define GL_APPLE_sync 1 + +#define GL_SYNC_FLUSH_COMMANDS_BIT_APPLE 0x00000001 +#define GL_SYNC_OBJECT_APPLE 0x8A53 +#define GL_MAX_SERVER_WAIT_TIMEOUT_APPLE 0x9111 +#define GL_OBJECT_TYPE_APPLE 0x9112 +#define GL_SYNC_CONDITION_APPLE 0x9113 +#define GL_SYNC_STATUS_APPLE 0x9114 +#define GL_SYNC_FLAGS_APPLE 0x9115 +#define GL_SYNC_FENCE_APPLE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE_APPLE 0x9117 +#define GL_UNSIGNALED_APPLE 0x9118 +#define GL_SIGNALED_APPLE 0x9119 +#define GL_ALREADY_SIGNALED_APPLE 0x911A +#define GL_TIMEOUT_EXPIRED_APPLE 0x911B +#define GL_CONDITION_SATISFIED_APPLE 0x911C +#define GL_WAIT_FAILED_APPLE 0x911D +#define GL_TIMEOUT_IGNORED_APPLE 0xFFFFFFFFFFFFFFFFull + +typedef GLenum (GLAPIENTRY * PFNGLCLIENTWAITSYNCAPPLEPROC) (GLsync GLsync, GLbitfield flags, GLuint64 timeout); +typedef void (GLAPIENTRY * PFNGLDELETESYNCAPPLEPROC) (GLsync GLsync); +typedef GLsync (GLAPIENTRY * PFNGLFENCESYNCAPPLEPROC) (GLenum condition, GLbitfield flags); +typedef void (GLAPIENTRY * PFNGLGETINTEGER64VAPPLEPROC) (GLenum pname, GLint64* params); +typedef void (GLAPIENTRY * PFNGLGETSYNCIVAPPLEPROC) (GLsync GLsync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint *values); +typedef GLboolean (GLAPIENTRY * PFNGLISSYNCAPPLEPROC) (GLsync GLsync); +typedef void (GLAPIENTRY * PFNGLWAITSYNCAPPLEPROC) (GLsync GLsync, GLbitfield flags, GLuint64 timeout); + +#define glClientWaitSyncAPPLE GLEW_GET_FUN(__glewClientWaitSyncAPPLE) +#define glDeleteSyncAPPLE GLEW_GET_FUN(__glewDeleteSyncAPPLE) +#define glFenceSyncAPPLE GLEW_GET_FUN(__glewFenceSyncAPPLE) +#define glGetInteger64vAPPLE GLEW_GET_FUN(__glewGetInteger64vAPPLE) +#define glGetSyncivAPPLE GLEW_GET_FUN(__glewGetSyncivAPPLE) +#define glIsSyncAPPLE GLEW_GET_FUN(__glewIsSyncAPPLE) +#define glWaitSyncAPPLE GLEW_GET_FUN(__glewWaitSyncAPPLE) + +#define GLEW_APPLE_sync GLEW_GET_VAR(__GLEW_APPLE_sync) + +#endif /* GL_APPLE_sync */ + +/* -------------------- GL_APPLE_texture_2D_limited_npot ------------------- */ + +#ifndef GL_APPLE_texture_2D_limited_npot +#define GL_APPLE_texture_2D_limited_npot 1 + +#define GLEW_APPLE_texture_2D_limited_npot GLEW_GET_VAR(__GLEW_APPLE_texture_2D_limited_npot) + +#endif /* GL_APPLE_texture_2D_limited_npot */ + +/* -------------------- GL_APPLE_texture_format_BGRA8888 ------------------- */ + +#ifndef GL_APPLE_texture_format_BGRA8888 +#define GL_APPLE_texture_format_BGRA8888 1 + +#define GL_BGRA_EXT 0x80E1 +#define GL_BGRA8_EXT 0x93A1 + +#define GLEW_APPLE_texture_format_BGRA8888 GLEW_GET_VAR(__GLEW_APPLE_texture_format_BGRA8888) + +#endif /* GL_APPLE_texture_format_BGRA8888 */ + +/* ----------------------- GL_APPLE_texture_max_level ---------------------- */ + +#ifndef GL_APPLE_texture_max_level +#define GL_APPLE_texture_max_level 1 + +#define GL_TEXTURE_MAX_LEVEL_APPLE 0x813D + +#define GLEW_APPLE_texture_max_level GLEW_GET_VAR(__GLEW_APPLE_texture_max_level) + +#endif /* GL_APPLE_texture_max_level */ + +/* --------------------- GL_APPLE_texture_packed_float --------------------- */ + +#ifndef GL_APPLE_texture_packed_float +#define GL_APPLE_texture_packed_float 1 + +#define GL_R11F_G11F_B10F_APPLE 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE 0x8C3B +#define GL_RGB9_E5_APPLE 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV_APPLE 0x8C3E + +#define GLEW_APPLE_texture_packed_float GLEW_GET_VAR(__GLEW_APPLE_texture_packed_float) + +#endif /* GL_APPLE_texture_packed_float */ + /* ------------------------- GL_APPLE_texture_range ------------------------ */ #ifndef GL_APPLE_texture_range @@ -3684,10 +3995,8 @@ typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATAINDEXPROC) (GLuint program, const GL #define GL_BUFFER_STORAGE_FLAGS 0x8220 typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEPROC) (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags); -typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags); #define glBufferStorage GLEW_GET_FUN(__glewBufferStorage) -#define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT) #define GLEW_ARB_buffer_storage GLEW_GET_VAR(__GLEW_ARB_buffer_storage) @@ -4067,10 +4376,10 @@ typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAPROC) (GLuint buffer, GLint typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params); typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERPARAMETERIVPROC) (GLuint framebuffer, GLenum pname, GLint* param); typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVPROC) (GLuint renderbuffer, GLenum pname, GLint* params); -typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTI64VPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); -typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTIVPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); -typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUI64VPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); -typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUIVPROC) (GLuint id,GLuint buffer,GLenum pname,GLintptr offset); +typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTI64VPROC) (GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTIVPROC) (GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUI64VPROC) (GLuint id, GLuint buffer, GLenum pname, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLGETQUERYBUFFEROBJECTUIVPROC) (GLuint id, GLuint buffer, GLenum pname, GLintptr offset); typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEPROC) (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVPROC) (GLuint texture, GLint level, GLenum pname, GLfloat* params); typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVPROC) (GLuint texture, GLint level, GLenum pname, GLint* params); @@ -4285,10 +4594,10 @@ typedef void (GLAPIENTRY * PFNGLBLENDFUNCIARBPROC) (GLuint buf, GLenum src, GLen #ifndef GL_ARB_draw_elements_base_vertex #define GL_ARB_draw_elements_base_vertex 1 -typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, void *indices, GLint basevertex); typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLint basevertex); -typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); -typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, void *indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC) (GLenum mode, GLsizei* count, GLenum type, void**indices, GLsizei primcount, GLint *basevertex); #define glDrawElementsBaseVertex GLEW_GET_FUN(__glewDrawElementsBaseVertex) #define glDrawElementsInstancedBaseVertex GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertex) @@ -5590,6 +5899,21 @@ typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GL #endif /* GL_ARB_point_sprite */ +/* ---------------------- GL_ARB_polygon_offset_clamp ---------------------- */ + +#ifndef GL_ARB_polygon_offset_clamp +#define GL_ARB_polygon_offset_clamp 1 + +#define GL_POLYGON_OFFSET_CLAMP 0x8E1B + +typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETCLAMPPROC) (GLfloat factor, GLfloat units, GLfloat clamp); + +#define glPolygonOffsetClamp GLEW_GET_FUN(__glewPolygonOffsetClamp) + +#define GLEW_ARB_polygon_offset_clamp GLEW_GET_VAR(__GLEW_ARB_polygon_offset_clamp) + +#endif /* GL_ARB_polygon_offset_clamp */ + /* ----------------------- GL_ARB_post_depth_coverage ---------------------- */ #ifndef GL_ARB_post_depth_coverage @@ -6571,10 +6895,8 @@ typedef void (GLAPIENTRY * PFNGLBUFFERPAGECOMMITMENTARBPROC) (GLenum target, GLi #define GL_NUM_SPARSE_LEVELS_ARB 0x91AA typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); -typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); #define glTexPageCommitmentARB GLEW_GET_FUN(__glewTexPageCommitmentARB) -#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT) #define GLEW_ARB_sparse_texture GLEW_GET_VAR(__GLEW_ARB_sparse_texture) @@ -6598,6 +6920,18 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, G #endif /* GL_ARB_sparse_texture_clamp */ +/* ------------------------ GL_ARB_spirv_extensions ------------------------ */ + +#ifndef GL_ARB_spirv_extensions +#define GL_ARB_spirv_extensions 1 + +#define GL_SPIR_V_EXTENSIONS 0x9553 +#define GL_NUM_SPIR_V_EXTENSIONS 0x9554 + +#define GLEW_ARB_spirv_extensions GLEW_GET_VAR(__GLEW_ARB_spirv_extensions) + +#endif /* GL_ARB_spirv_extensions */ + /* ------------------------ GL_ARB_stencil_texturing ----------------------- */ #ifndef GL_ARB_stencil_texturing @@ -6935,6 +7269,18 @@ typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GL #endif /* GL_ARB_texture_env_dot3 */ +/* ------------------- GL_ARB_texture_filter_anisotropic ------------------- */ + +#ifndef GL_ARB_texture_filter_anisotropic +#define GL_ARB_texture_filter_anisotropic 1 + +#define GL_TEXTURE_MAX_ANISOTROPY 0x84FE +#define GL_MAX_TEXTURE_MAX_ANISOTROPY 0x84FF + +#define GLEW_ARB_texture_filter_anisotropic GLEW_GET_VAR(__GLEW_ARB_texture_filter_anisotropic) + +#endif /* GL_ARB_texture_filter_anisotropic */ + /* ---------------------- GL_ARB_texture_filter_minmax --------------------- */ #ifndef GL_ARB_texture_filter_minmax @@ -7163,16 +7509,10 @@ typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DMULTISAMPLEPROC) (GLenum target, GLsiz typedef void (GLAPIENTRY * PFNGLTEXSTORAGE1DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); -typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); -typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); -typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); #define glTexStorage1D GLEW_GET_FUN(__glewTexStorage1D) #define glTexStorage2D GLEW_GET_FUN(__glewTexStorage2D) #define glTexStorage3D GLEW_GET_FUN(__glewTexStorage3D) -#define glTextureStorage1DEXT GLEW_GET_FUN(__glewTextureStorage1DEXT) -#define glTextureStorage2DEXT GLEW_GET_FUN(__glewTextureStorage2DEXT) -#define glTextureStorage3DEXT GLEW_GET_FUN(__glewTextureStorage3DEXT) #define GLEW_ARB_texture_storage GLEW_GET_VAR(__GLEW_ARB_texture_storage) @@ -8097,6 +8437,60 @@ typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p); #endif /* GL_ARB_window_pos */ +/* ----------------------- GL_ARM_mali_program_binary ---------------------- */ + +#ifndef GL_ARM_mali_program_binary +#define GL_ARM_mali_program_binary 1 + +#define GL_MALI_PROGRAM_BINARY_ARM 0x8F61 + +#define GLEW_ARM_mali_program_binary GLEW_GET_VAR(__GLEW_ARM_mali_program_binary) + +#endif /* GL_ARM_mali_program_binary */ + +/* ----------------------- GL_ARM_mali_shader_binary ----------------------- */ + +#ifndef GL_ARM_mali_shader_binary +#define GL_ARM_mali_shader_binary 1 + +#define GL_MALI_SHADER_BINARY_ARM 0x8F60 + +#define GLEW_ARM_mali_shader_binary GLEW_GET_VAR(__GLEW_ARM_mali_shader_binary) + +#endif /* GL_ARM_mali_shader_binary */ + +/* ------------------------------ GL_ARM_rgba8 ----------------------------- */ + +#ifndef GL_ARM_rgba8 +#define GL_ARM_rgba8 1 + +#define GL_RGBA8_OES 0x8058 + +#define GLEW_ARM_rgba8 GLEW_GET_VAR(__GLEW_ARM_rgba8) + +#endif /* GL_ARM_rgba8 */ + +/* -------------------- GL_ARM_shader_framebuffer_fetch -------------------- */ + +#ifndef GL_ARM_shader_framebuffer_fetch +#define GL_ARM_shader_framebuffer_fetch 1 + +#define GL_FETCH_PER_SAMPLE_ARM 0x8F65 +#define GL_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM 0x8F66 + +#define GLEW_ARM_shader_framebuffer_fetch GLEW_GET_VAR(__GLEW_ARM_shader_framebuffer_fetch) + +#endif /* GL_ARM_shader_framebuffer_fetch */ + +/* ------------- GL_ARM_shader_framebuffer_fetch_depth_stencil ------------- */ + +#ifndef GL_ARM_shader_framebuffer_fetch_depth_stencil +#define GL_ARM_shader_framebuffer_fetch_depth_stencil 1 + +#define GLEW_ARM_shader_framebuffer_fetch_depth_stencil GLEW_GET_VAR(__GLEW_ARM_shader_framebuffer_fetch_depth_stencil) + +#endif /* GL_ARM_shader_framebuffer_fetch_depth_stencil */ + /* ------------------------- GL_ATIX_point_sprites ------------------------- */ #ifndef GL_ATIX_point_sprites @@ -8648,6 +9042,15 @@ typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GL #endif /* GL_ATI_vertex_streams */ +/* -------------------- GL_EGL_KHR_context_flush_control ------------------- */ + +#ifndef GL_EGL_KHR_context_flush_control +#define GL_EGL_KHR_context_flush_control 1 + +#define GLEW_EGL_KHR_context_flush_control GLEW_GET_VAR(__GLEW_EGL_KHR_context_flush_control) + +#endif /* GL_EGL_KHR_context_flush_control */ + /* ---------------- GL_EGL_NV_robustness_video_memory_purge ---------------- */ #ifndef GL_EGL_NV_robustness_video_memory_purge @@ -8686,6 +9089,26 @@ typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GL #endif /* GL_EXT_Cg_shader */ +/* ------------------------- GL_EXT_EGL_image_array ------------------------ */ + +#ifndef GL_EXT_EGL_image_array +#define GL_EXT_EGL_image_array 1 + +#define GLEW_EXT_EGL_image_array GLEW_GET_VAR(__GLEW_EXT_EGL_image_array) + +#endif /* GL_EXT_EGL_image_array */ + +/* --------------------------- GL_EXT_YUV_target --------------------------- */ + +#ifndef GL_EXT_YUV_target +#define GL_EXT_YUV_target 1 + +#define GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT 0x8BE7 + +#define GLEW_EXT_YUV_target GLEW_GET_VAR(__GLEW_EXT_YUV_target) + +#endif /* GL_EXT_YUV_target */ + /* ------------------------------ GL_EXT_abgr ------------------------------ */ #ifndef GL_EXT_abgr @@ -8697,6 +9120,23 @@ typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GL #endif /* GL_EXT_abgr */ +/* -------------------------- GL_EXT_base_instance ------------------------- */ + +#ifndef GL_EXT_base_instance +#define GL_EXT_base_instance 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC) (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance); + +#define glDrawArraysInstancedBaseInstanceEXT GLEW_GET_FUN(__glewDrawArraysInstancedBaseInstanceEXT) +#define glDrawElementsInstancedBaseInstanceEXT GLEW_GET_FUN(__glewDrawElementsInstancedBaseInstanceEXT) +#define glDrawElementsInstancedBaseVertexBaseInstanceEXT GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexBaseInstanceEXT) + +#define GLEW_EXT_base_instance GLEW_GET_VAR(__GLEW_EXT_base_instance) + +#endif /* GL_EXT_base_instance */ + /* ------------------------------ GL_EXT_bgra ------------------------------ */ #ifndef GL_EXT_bgra @@ -8768,6 +9208,31 @@ typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, G #endif /* GL_EXT_blend_equation_separate */ +/* ----------------------- GL_EXT_blend_func_extended ---------------------- */ + +#ifndef GL_EXT_blend_func_extended +#define GL_EXT_blend_func_extended 1 + +#define GL_SRC_ALPHA_SATURATE_EXT 0x0308 +#define GL_SRC1_ALPHA_EXT 0x8589 +#define GL_SRC1_COLOR_EXT 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR_EXT 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA_EXT 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT 0x88FC +#define GL_LOCATION_INDEX_EXT 0x930F + +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC) (GLuint program, GLuint colorNumber, GLuint index, const GLchar * name); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATAINDEXEXTPROC) (GLuint program, const GLchar * name); +typedef GLint (GLAPIENTRY * PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC) (GLuint program, GLenum programInterface, const GLchar* name); + +#define glBindFragDataLocationIndexedEXT GLEW_GET_FUN(__glewBindFragDataLocationIndexedEXT) +#define glGetFragDataIndexEXT GLEW_GET_FUN(__glewGetFragDataIndexEXT) +#define glGetProgramResourceLocationIndexEXT GLEW_GET_FUN(__glewGetProgramResourceLocationIndexEXT) + +#define GLEW_EXT_blend_func_extended GLEW_GET_VAR(__GLEW_EXT_blend_func_extended) + +#endif /* GL_EXT_blend_func_extended */ + /* ----------------------- GL_EXT_blend_func_separate ---------------------- */ #ifndef GL_EXT_blend_func_separate @@ -8825,6 +9290,67 @@ typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); #endif /* GL_EXT_blend_subtract */ +/* ------------------------- GL_EXT_buffer_storage ------------------------- */ + +#ifndef GL_EXT_buffer_storage +#define GL_EXT_buffer_storage 1 + +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_PERSISTENT_BIT_EXT 0x0040 +#define GL_MAP_COHERENT_BIT_EXT 0x0080 +#define GL_DYNAMIC_STORAGE_BIT_EXT 0x0100 +#define GL_CLIENT_STORAGE_BIT_EXT 0x0200 +#define GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT 0x00004000 +#define GL_BUFFER_IMMUTABLE_STORAGE_EXT 0x821F +#define GL_BUFFER_STORAGE_FLAGS_EXT 0x8220 + +typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEEXTPROC) (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTPROC) (GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags); + +#define glBufferStorageEXT GLEW_GET_FUN(__glewBufferStorageEXT) +#define glNamedBufferStorageEXT GLEW_GET_FUN(__glewNamedBufferStorageEXT) + +#define GLEW_EXT_buffer_storage GLEW_GET_VAR(__GLEW_EXT_buffer_storage) + +#endif /* GL_EXT_buffer_storage */ + +/* -------------------------- GL_EXT_clear_texture ------------------------- */ + +#ifndef GL_EXT_clear_texture +#define GL_EXT_clear_texture 1 + +typedef void (GLAPIENTRY * PFNGLCLEARTEXIMAGEEXTPROC) (GLuint texture, GLint level, GLenum format, GLenum type, const void *data); +typedef void (GLAPIENTRY * PFNGLCLEARTEXSUBIMAGEEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data); + +#define glClearTexImageEXT GLEW_GET_FUN(__glewClearTexImageEXT) +#define glClearTexSubImageEXT GLEW_GET_FUN(__glewClearTexSubImageEXT) + +#define GLEW_EXT_clear_texture GLEW_GET_VAR(__GLEW_EXT_clear_texture) + +#endif /* GL_EXT_clear_texture */ + +/* ----------------------- GL_EXT_clip_cull_distance ----------------------- */ + +#ifndef GL_EXT_clip_cull_distance +#define GL_EXT_clip_cull_distance 1 + +#define GL_MAX_CLIP_DISTANCES_EXT 0x0D32 +#define GL_CLIP_DISTANCE0_EXT 0x3000 +#define GL_CLIP_DISTANCE1_EXT 0x3001 +#define GL_CLIP_DISTANCE2_EXT 0x3002 +#define GL_CLIP_DISTANCE3_EXT 0x3003 +#define GL_CLIP_DISTANCE4_EXT 0x3004 +#define GL_CLIP_DISTANCE5_EXT 0x3005 +#define GL_CLIP_DISTANCE6_EXT 0x3006 +#define GL_CLIP_DISTANCE7_EXT 0x3007 +#define GL_MAX_CULL_DISTANCES_EXT 0x82F9 +#define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT 0x82FA + +#define GLEW_EXT_clip_cull_distance GLEW_GET_VAR(__GLEW_EXT_clip_cull_distance) + +#endif /* GL_EXT_clip_cull_distance */ + /* ------------------------ GL_EXT_clip_volume_hint ------------------------ */ #ifndef GL_EXT_clip_volume_hint @@ -8850,6 +9376,31 @@ typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); #endif /* GL_EXT_cmyka */ +/* ----------------------- GL_EXT_color_buffer_float ----------------------- */ + +#ifndef GL_EXT_color_buffer_float +#define GL_EXT_color_buffer_float 1 + +#define GLEW_EXT_color_buffer_float GLEW_GET_VAR(__GLEW_EXT_color_buffer_float) + +#endif /* GL_EXT_color_buffer_float */ + +/* --------------------- GL_EXT_color_buffer_half_float -------------------- */ + +#ifndef GL_EXT_color_buffer_half_float +#define GL_EXT_color_buffer_half_float 1 + +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT 0x8211 +#define GL_R16F_EXT 0x822D +#define GL_RG16F_EXT 0x822F +#define GL_RGBA16F_EXT 0x881A +#define GL_RGB16F_EXT 0x881B +#define GL_UNSIGNED_NORMALIZED_EXT 0x8C17 + +#define GLEW_EXT_color_buffer_half_float GLEW_GET_VAR(__GLEW_EXT_color_buffer_half_float) + +#endif /* GL_EXT_color_buffer_half_float */ + /* ------------------------- GL_EXT_color_subtable ------------------------- */ #ifndef GL_EXT_color_subtable @@ -8883,6 +9434,24 @@ typedef void (GLAPIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void); #endif /* GL_EXT_compiled_vertex_array */ +/* ---------------- GL_EXT_compressed_ETC1_RGB8_sub_texture ---------------- */ + +#ifndef GL_EXT_compressed_ETC1_RGB8_sub_texture +#define GL_EXT_compressed_ETC1_RGB8_sub_texture 1 + +#define GLEW_EXT_compressed_ETC1_RGB8_sub_texture GLEW_GET_VAR(__GLEW_EXT_compressed_ETC1_RGB8_sub_texture) + +#endif /* GL_EXT_compressed_ETC1_RGB8_sub_texture */ + +/* ----------------------- GL_EXT_conservative_depth ----------------------- */ + +#ifndef GL_EXT_conservative_depth +#define GL_EXT_conservative_depth 1 + +#define GLEW_EXT_conservative_depth GLEW_GET_VAR(__GLEW_EXT_conservative_depth) + +#endif /* GL_EXT_conservative_depth */ + /* --------------------------- GL_EXT_convolution -------------------------- */ #ifndef GL_EXT_convolution @@ -8971,6 +9540,19 @@ typedef void (GLAPIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei str #endif /* GL_EXT_coordinate_frame */ +/* --------------------------- GL_EXT_copy_image --------------------------- */ + +#ifndef GL_EXT_copy_image +#define GL_EXT_copy_image 1 + +typedef void (GLAPIENTRY * PFNGLCOPYIMAGESUBDATAEXTPROC) (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 glCopyImageSubDataEXT GLEW_GET_FUN(__glewCopyImageSubDataEXT) + +#define GLEW_EXT_copy_image GLEW_GET_VAR(__GLEW_EXT_copy_image) + +#endif /* GL_EXT_copy_image */ + /* -------------------------- GL_EXT_copy_texture -------------------------- */ #ifndef GL_EXT_copy_texture @@ -9509,6 +10091,71 @@ typedef void (GLAPIENTRY * PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC) (GLuint vaobj, G #endif /* GL_EXT_direct_state_access */ +/* ----------------------- GL_EXT_discard_framebuffer ---------------------- */ + +#ifndef GL_EXT_discard_framebuffer +#define GL_EXT_discard_framebuffer 1 + +#define GL_COLOR_EXT 0x1800 +#define GL_DEPTH_EXT 0x1801 +#define GL_STENCIL_EXT 0x1802 + +typedef void (GLAPIENTRY * PFNGLDISCARDFRAMEBUFFEREXTPROC) (GLenum target, GLsizei numAttachments, const GLenum* attachments); + +#define glDiscardFramebufferEXT GLEW_GET_FUN(__glewDiscardFramebufferEXT) + +#define GLEW_EXT_discard_framebuffer GLEW_GET_VAR(__GLEW_EXT_discard_framebuffer) + +#endif /* GL_EXT_discard_framebuffer */ + +/* -------------------------- GL_EXT_draw_buffers -------------------------- */ + +#ifndef GL_EXT_draw_buffers +#define GL_EXT_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_EXT 0x8824 +#define GL_DRAW_BUFFER0_EXT 0x8825 +#define GL_DRAW_BUFFER1_EXT 0x8826 +#define GL_DRAW_BUFFER2_EXT 0x8827 +#define GL_DRAW_BUFFER3_EXT 0x8828 +#define GL_DRAW_BUFFER4_EXT 0x8829 +#define GL_DRAW_BUFFER5_EXT 0x882A +#define GL_DRAW_BUFFER6_EXT 0x882B +#define GL_DRAW_BUFFER7_EXT 0x882C +#define GL_DRAW_BUFFER8_EXT 0x882D +#define GL_DRAW_BUFFER9_EXT 0x882E +#define GL_DRAW_BUFFER10_EXT 0x882F +#define GL_DRAW_BUFFER11_EXT 0x8830 +#define GL_DRAW_BUFFER12_EXT 0x8831 +#define GL_DRAW_BUFFER13_EXT 0x8832 +#define GL_DRAW_BUFFER14_EXT 0x8833 +#define GL_DRAW_BUFFER15_EXT 0x8834 +#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 +#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 +#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 +#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 +#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 +#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 +#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 +#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 +#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 +#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA +#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB +#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC +#define GL_COLOR_ATTACHMENT13_EXT 0x8CED +#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE +#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSEXTPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersEXT GLEW_GET_FUN(__glewDrawBuffersEXT) + +#define GLEW_EXT_draw_buffers GLEW_GET_VAR(__GLEW_EXT_draw_buffers) + +#endif /* GL_EXT_draw_buffers */ + /* -------------------------- GL_EXT_draw_buffers2 ------------------------- */ #ifndef GL_EXT_draw_buffers2 @@ -9532,6 +10179,52 @@ typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GL #endif /* GL_EXT_draw_buffers2 */ +/* ---------------------- GL_EXT_draw_buffers_indexed ---------------------- */ + +#ifndef GL_EXT_draw_buffers_indexed +#define GL_EXT_draw_buffers_indexed 1 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEIEXTPROC) (GLuint buf, GLenum modeRGB, GLenum modeAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONIEXTPROC) (GLuint buf, GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEIEXTPROC) (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCIEXTPROC) (GLuint buf, GLenum src, GLenum dst); +typedef void (GLAPIENTRY * PFNGLCOLORMASKIEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLDISABLEIEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEIEXTPROC) (GLenum target, GLuint index); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIEXTPROC) (GLenum target, GLuint index); + +#define glBlendEquationSeparateiEXT GLEW_GET_FUN(__glewBlendEquationSeparateiEXT) +#define glBlendEquationiEXT GLEW_GET_FUN(__glewBlendEquationiEXT) +#define glBlendFuncSeparateiEXT GLEW_GET_FUN(__glewBlendFuncSeparateiEXT) +#define glBlendFunciEXT GLEW_GET_FUN(__glewBlendFunciEXT) +#define glColorMaskiEXT GLEW_GET_FUN(__glewColorMaskiEXT) +#define glDisableiEXT GLEW_GET_FUN(__glewDisableiEXT) +#define glEnableiEXT GLEW_GET_FUN(__glewEnableiEXT) +#define glIsEnablediEXT GLEW_GET_FUN(__glewIsEnablediEXT) + +#define GLEW_EXT_draw_buffers_indexed GLEW_GET_VAR(__GLEW_EXT_draw_buffers_indexed) + +#endif /* GL_EXT_draw_buffers_indexed */ + +/* -------------------- GL_EXT_draw_elements_base_vertex ------------------- */ + +#ifndef GL_EXT_draw_elements_base_vertex +#define GL_EXT_draw_elements_base_vertex 1 + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC) (GLenum mode, const GLsizei* count, GLenum type, const void *const *indices, GLsizei primcount, const GLint *basevertex); + +#define glDrawElementsBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsBaseVertexEXT) +#define glDrawElementsInstancedBaseVertexEXT GLEW_GET_FUN(__glewDrawElementsInstancedBaseVertexEXT) +#define glDrawRangeElementsBaseVertexEXT GLEW_GET_FUN(__glewDrawRangeElementsBaseVertexEXT) +#define glMultiDrawElementsBaseVertexEXT GLEW_GET_FUN(__glewMultiDrawElementsBaseVertexEXT) + +#define GLEW_EXT_draw_elements_base_vertex GLEW_GET_VAR(__GLEW_EXT_draw_elements_base_vertex) + +#endif /* GL_EXT_draw_elements_base_vertex */ + /* ------------------------- GL_EXT_draw_instanced ------------------------- */ #ifndef GL_EXT_draw_instanced @@ -9563,6 +10256,32 @@ typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint s #endif /* GL_EXT_draw_range_elements */ +/* ------------------------- GL_EXT_external_buffer ------------------------ */ + +#ifndef GL_EXT_external_buffer +#define GL_EXT_external_buffer 1 + +typedef void* GLeglClientBufferEXT; + +typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEEXTERNALEXTPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags); + +#define glBufferStorageExternalEXT GLEW_GET_FUN(__glewBufferStorageExternalEXT) +#define glNamedBufferStorageExternalEXT GLEW_GET_FUN(__glewNamedBufferStorageExternalEXT) + +#define GLEW_EXT_external_buffer GLEW_GET_VAR(__GLEW_EXT_external_buffer) + +#endif /* GL_EXT_external_buffer */ + +/* --------------------------- GL_EXT_float_blend -------------------------- */ + +#ifndef GL_EXT_float_blend +#define GL_EXT_float_blend 1 + +#define GLEW_EXT_float_blend GLEW_GET_VAR(__GLEW_EXT_float_blend) + +#endif /* GL_EXT_float_blend */ + /* ---------------------------- GL_EXT_fog_coord --------------------------- */ #ifndef GL_EXT_fog_coord @@ -9593,6 +10312,15 @@ typedef void (GLAPIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); #endif /* GL_EXT_fog_coord */ +/* --------------------------- GL_EXT_frag_depth --------------------------- */ + +#ifndef GL_EXT_frag_depth +#define GL_EXT_frag_depth 1 + +#define GLEW_EXT_frag_depth GLEW_GET_VAR(__GLEW_EXT_frag_depth) + +#endif /* GL_EXT_frag_depth */ + /* ------------------------ GL_EXT_fragment_lighting ----------------------- */ #ifndef GL_EXT_fragment_lighting @@ -9811,6 +10539,92 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLen #endif /* GL_EXT_framebuffer_sRGB */ +/* ----------------------- GL_EXT_geometry_point_size ---------------------- */ + +#ifndef GL_EXT_geometry_point_size +#define GL_EXT_geometry_point_size 1 + +#define GL_GEOMETRY_SHADER_BIT_EXT 0x00000004 +#define GL_LINES_ADJACENCY_EXT 0xA +#define GL_LINE_STRIP_ADJACENCY_EXT 0xB +#define GL_TRIANGLES_ADJACENCY_EXT 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD +#define GL_LAYER_PROVOKING_VERTEX_EXT 0x825E +#define GL_UNDEFINED_VERTEX_EXT 0x8260 +#define GL_GEOMETRY_SHADER_INVOCATIONS_EXT 0x887F +#define GL_GEOMETRY_LINKED_VERTICES_OUT_EXT 0x8916 +#define GL_GEOMETRY_LINKED_INPUT_TYPE_EXT 0x8917 +#define GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT 0x8A2C +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8A32 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29 +#define GL_PRIMITIVES_GENERATED_EXT 0x8C87 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8 +#define GL_GEOMETRY_SHADER_EXT 0x8DD9 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1 +#define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D +#define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT 0x8E5A +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT 0x90CD +#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT 0x90D7 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT 0x9124 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT 0x92CF +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT 0x92D5 +#define GL_REFERENCED_BY_GEOMETRY_SHADER_EXT 0x9309 +#define GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT 0x9312 +#define GL_MAX_FRAMEBUFFER_LAYERS_EXT 0x9317 + +#define GLEW_EXT_geometry_point_size GLEW_GET_VAR(__GLEW_EXT_geometry_point_size) + +#endif /* GL_EXT_geometry_point_size */ + +/* ------------------------- GL_EXT_geometry_shader ------------------------ */ + +#ifndef GL_EXT_geometry_shader +#define GL_EXT_geometry_shader 1 + +#define GL_GEOMETRY_SHADER_BIT_EXT 0x00000004 +#define GL_LINES_ADJACENCY_EXT 0xA +#define GL_LINE_STRIP_ADJACENCY_EXT 0xB +#define GL_TRIANGLES_ADJACENCY_EXT 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD +#define GL_LAYER_PROVOKING_VERTEX_EXT 0x825E +#define GL_UNDEFINED_VERTEX_EXT 0x8260 +#define GL_GEOMETRY_SHADER_INVOCATIONS_EXT 0x887F +#define GL_GEOMETRY_LINKED_VERTICES_OUT_EXT 0x8916 +#define GL_GEOMETRY_LINKED_INPUT_TYPE_EXT 0x8917 +#define GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT 0x8A2C +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8A32 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29 +#define GL_PRIMITIVES_GENERATED_EXT 0x8C87 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8 +#define GL_GEOMETRY_SHADER_EXT 0x8DD9 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1 +#define GL_FIRST_VERTEX_CONVENTION_EXT 0x8E4D +#define GL_LAST_VERTEX_CONVENTION_EXT 0x8E4E +#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT 0x8E5A +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT 0x90CD +#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT 0x90D7 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT 0x9124 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT 0x92CF +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT 0x92D5 +#define GL_REFERENCED_BY_GEOMETRY_SHADER_EXT 0x9309 +#define GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT 0x9312 +#define GL_MAX_FRAMEBUFFER_LAYERS_EXT 0x9317 + +#define GLEW_EXT_geometry_shader GLEW_GET_VAR(__GLEW_EXT_geometry_shader) + +#endif /* GL_EXT_geometry_shader */ + /* ------------------------ GL_EXT_geometry_shader4 ------------------------ */ #ifndef GL_EXT_geometry_shader4 @@ -9970,6 +10784,15 @@ typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLin #endif /* GL_EXT_gpu_shader4 */ +/* --------------------------- GL_EXT_gpu_shader5 -------------------------- */ + +#ifndef GL_EXT_gpu_shader5 +#define GL_EXT_gpu_shader5 1 + +#define GLEW_EXT_gpu_shader5 GLEW_GET_VAR(__GLEW_EXT_gpu_shader5) + +#endif /* GL_EXT_gpu_shader5 */ + /* ---------------------------- GL_EXT_histogram --------------------------- */ #ifndef GL_EXT_histogram @@ -10059,6 +10882,21 @@ typedef void (GLAPIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode) #endif /* GL_EXT_index_texture */ +/* ------------------------ GL_EXT_instanced_arrays ------------------------ */ + +#ifndef GL_EXT_instanced_arrays +#define GL_EXT_instanced_arrays 1 + +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT 0x88FE + +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISOREXTPROC) (GLuint index, GLuint divisor); + +#define glVertexAttribDivisorEXT GLEW_GET_FUN(__glewVertexAttribDivisorEXT) + +#define GLEW_EXT_instanced_arrays GLEW_GET_VAR(__GLEW_EXT_instanced_arrays) + +#endif /* GL_EXT_instanced_arrays */ + /* -------------------------- GL_EXT_light_texture ------------------------- */ #ifndef GL_EXT_light_texture @@ -10086,6 +10924,138 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mod #endif /* GL_EXT_light_texture */ +/* ------------------------ GL_EXT_map_buffer_range ------------------------ */ + +#ifndef GL_EXT_map_buffer_range +#define GL_EXT_map_buffer_range 1 + +#define GL_MAP_READ_BIT_EXT 0x0001 +#define GL_MAP_WRITE_BIT_EXT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT_EXT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT_EXT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT_EXT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT_EXT 0x0020 + +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC) (GLenum target, GLintptr offset, GLsizeiptr length); +typedef void * (GLAPIENTRY * PFNGLMAPBUFFERRANGEEXTPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + +#define glFlushMappedBufferRangeEXT GLEW_GET_FUN(__glewFlushMappedBufferRangeEXT) +#define glMapBufferRangeEXT GLEW_GET_FUN(__glewMapBufferRangeEXT) + +#define GLEW_EXT_map_buffer_range GLEW_GET_VAR(__GLEW_EXT_map_buffer_range) + +#endif /* GL_EXT_map_buffer_range */ + +/* -------------------------- GL_EXT_memory_object ------------------------- */ + +#ifndef GL_EXT_memory_object +#define GL_EXT_memory_object 1 + +#define GL_UUID_SIZE_EXT 16 +#define GL_TEXTURE_TILING_EXT 0x9580 +#define GL_DEDICATED_MEMORY_OBJECT_EXT 0x9581 +#define GL_NUM_TILING_TYPES_EXT 0x9582 +#define GL_TILING_TYPES_EXT 0x9583 +#define GL_OPTIMAL_TILING_EXT 0x9584 +#define GL_LINEAR_TILING_EXT 0x9585 +#define GL_LAYOUT_GENERAL_EXT 0x958D +#define GL_LAYOUT_COLOR_ATTACHMENT_EXT 0x958E +#define GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT 0x958F +#define GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT 0x9590 +#define GL_LAYOUT_SHADER_READ_ONLY_EXT 0x9591 +#define GL_LAYOUT_TRANSFER_SRC_EXT 0x9592 +#define GL_LAYOUT_TRANSFER_DST_EXT 0x9593 +#define GL_NUM_DEVICE_UUIDS_EXT 0x9596 +#define GL_DEVICE_UUID_EXT 0x9597 +#define GL_DRIVER_UUID_EXT 0x9598 +#define GL_PROTECTED_MEMORY_OBJECT_EXT 0x959B + +typedef void (GLAPIENTRY * PFNGLBUFFERSTORAGEMEMEXTPROC) (GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLCREATEMEMORYOBJECTSEXTPROC) (GLsizei n, GLuint* memoryObjects); +typedef void (GLAPIENTRY * PFNGLDELETEMEMORYOBJECTSEXTPROC) (GLsizei n, const GLuint* memoryObjects); +typedef void (GLAPIENTRY * PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC) (GLuint memoryObject, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETUNSIGNEDBYTEI_VEXTPROC) (GLenum target, GLuint index, GLubyte* data); +typedef void (GLAPIENTRY * PFNGLGETUNSIGNEDBYTEVEXTPROC) (GLenum pname, GLubyte* data); +typedef GLboolean (GLAPIENTRY * PFNGLISMEMORYOBJECTEXTPROC) (GLuint memoryObject); +typedef void (GLAPIENTRY * PFNGLMEMORYOBJECTPARAMETERIVEXTPROC) (GLuint memoryObject, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC) (GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEMEM1DEXTPROC) (GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEMEM2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEMEM3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGEMEM1DEXTPROC) (GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGEMEM2DEXTPROC) (GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC) (GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGEMEM3DEXTPROC) (GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC) (GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations, GLuint memory, GLuint64 offset); + +#define glBufferStorageMemEXT GLEW_GET_FUN(__glewBufferStorageMemEXT) +#define glCreateMemoryObjectsEXT GLEW_GET_FUN(__glewCreateMemoryObjectsEXT) +#define glDeleteMemoryObjectsEXT GLEW_GET_FUN(__glewDeleteMemoryObjectsEXT) +#define glGetMemoryObjectParameterivEXT GLEW_GET_FUN(__glewGetMemoryObjectParameterivEXT) +#define glGetUnsignedBytei_vEXT GLEW_GET_FUN(__glewGetUnsignedBytei_vEXT) +#define glGetUnsignedBytevEXT GLEW_GET_FUN(__glewGetUnsignedBytevEXT) +#define glIsMemoryObjectEXT GLEW_GET_FUN(__glewIsMemoryObjectEXT) +#define glMemoryObjectParameterivEXT GLEW_GET_FUN(__glewMemoryObjectParameterivEXT) +#define glNamedBufferStorageMemEXT GLEW_GET_FUN(__glewNamedBufferStorageMemEXT) +#define glTexStorageMem1DEXT GLEW_GET_FUN(__glewTexStorageMem1DEXT) +#define glTexStorageMem2DEXT GLEW_GET_FUN(__glewTexStorageMem2DEXT) +#define glTexStorageMem2DMultisampleEXT GLEW_GET_FUN(__glewTexStorageMem2DMultisampleEXT) +#define glTexStorageMem3DEXT GLEW_GET_FUN(__glewTexStorageMem3DEXT) +#define glTexStorageMem3DMultisampleEXT GLEW_GET_FUN(__glewTexStorageMem3DMultisampleEXT) +#define glTextureStorageMem1DEXT GLEW_GET_FUN(__glewTextureStorageMem1DEXT) +#define glTextureStorageMem2DEXT GLEW_GET_FUN(__glewTextureStorageMem2DEXT) +#define glTextureStorageMem2DMultisampleEXT GLEW_GET_FUN(__glewTextureStorageMem2DMultisampleEXT) +#define glTextureStorageMem3DEXT GLEW_GET_FUN(__glewTextureStorageMem3DEXT) +#define glTextureStorageMem3DMultisampleEXT GLEW_GET_FUN(__glewTextureStorageMem3DMultisampleEXT) + +#define GLEW_EXT_memory_object GLEW_GET_VAR(__GLEW_EXT_memory_object) + +#endif /* GL_EXT_memory_object */ + +/* ------------------------ GL_EXT_memory_object_fd ------------------------ */ + +#ifndef GL_EXT_memory_object_fd +#define GL_EXT_memory_object_fd 1 + +#define GL_HANDLE_TYPE_OPAQUE_FD_EXT 0x9586 + +typedef void (GLAPIENTRY * PFNGLIMPORTMEMORYFDEXTPROC) (GLuint memory, GLuint64 size, GLenum handleType, GLint fd); + +#define glImportMemoryFdEXT GLEW_GET_FUN(__glewImportMemoryFdEXT) + +#define GLEW_EXT_memory_object_fd GLEW_GET_VAR(__GLEW_EXT_memory_object_fd) + +#endif /* GL_EXT_memory_object_fd */ + +/* ----------------------- GL_EXT_memory_object_win32 ---------------------- */ + +#ifndef GL_EXT_memory_object_win32 +#define GL_EXT_memory_object_win32 1 + +#define GL_LUID_SIZE_EXT 8 +#define GL_HANDLE_TYPE_OPAQUE_WIN32_EXT 0x9587 +#define GL_HANDLE_TYPE_OPAQUE_WIN32_KMT_EXT 0x9588 +#define GL_HANDLE_TYPE_D3D12_TILEPOOL_EXT 0x9589 +#define GL_HANDLE_TYPE_D3D12_RESOURCE_EXT 0x958A +#define GL_HANDLE_TYPE_D3D11_IMAGE_EXT 0x958B +#define GL_HANDLE_TYPE_D3D11_IMAGE_KMT_EXT 0x958C +#define GL_HANDLE_TYPE_D3D12_FENCE_EXT 0x9594 +#define GL_D3D12_FENCE_VALUE_EXT 0x9595 +#define GL_DEVICE_LUID_EXT 0x9599 +#define GL_DEVICE_NODE_MASK_EXT 0x959A + +typedef void (GLAPIENTRY * PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC) (GLuint memory, GLuint64 size, GLenum handleType, void *handle); +typedef void (GLAPIENTRY * PFNGLIMPORTMEMORYWIN32NAMEEXTPROC) (GLuint memory, GLuint64 size, GLenum handleType, const void *name); + +#define glImportMemoryWin32HandleEXT GLEW_GET_FUN(__glewImportMemoryWin32HandleEXT) +#define glImportMemoryWin32NameEXT GLEW_GET_FUN(__glewImportMemoryWin32NameEXT) + +#define GLEW_EXT_memory_object_win32 GLEW_GET_VAR(__GLEW_EXT_memory_object_win32) + +#endif /* GL_EXT_memory_object_win32 */ + /* ------------------------- GL_EXT_misc_attribute ------------------------- */ #ifndef GL_EXT_misc_attribute @@ -10110,6 +11080,30 @@ typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, GLsizei* #endif /* GL_EXT_multi_draw_arrays */ +/* ----------------------- GL_EXT_multi_draw_indirect ---------------------- */ + +#ifndef GL_EXT_multi_draw_indirect +#define GL_EXT_multi_draw_indirect 1 + +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC) (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC) (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride); + +#define glMultiDrawArraysIndirectEXT GLEW_GET_FUN(__glewMultiDrawArraysIndirectEXT) +#define glMultiDrawElementsIndirectEXT GLEW_GET_FUN(__glewMultiDrawElementsIndirectEXT) + +#define GLEW_EXT_multi_draw_indirect GLEW_GET_VAR(__GLEW_EXT_multi_draw_indirect) + +#endif /* GL_EXT_multi_draw_indirect */ + +/* ------------------------ GL_EXT_multiple_textures ----------------------- */ + +#ifndef GL_EXT_multiple_textures +#define GL_EXT_multiple_textures 1 + +#define GLEW_EXT_multiple_textures GLEW_GET_VAR(__GLEW_EXT_multiple_textures) + +#endif /* GL_EXT_multiple_textures */ + /* --------------------------- GL_EXT_multisample -------------------------- */ #ifndef GL_EXT_multisample @@ -10143,6 +11137,68 @@ typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); #endif /* GL_EXT_multisample */ +/* -------------------- GL_EXT_multisample_compatibility ------------------- */ + +#ifndef GL_EXT_multisample_compatibility +#define GL_EXT_multisample_compatibility 1 + +#define GL_MULTISAMPLE_EXT 0x809D +#define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F + +#define GLEW_EXT_multisample_compatibility GLEW_GET_VAR(__GLEW_EXT_multisample_compatibility) + +#endif /* GL_EXT_multisample_compatibility */ + +/* ----------------- GL_EXT_multisampled_render_to_texture ----------------- */ + +#ifndef GL_EXT_multisampled_render_to_texture +#define GL_EXT_multisampled_render_to_texture 1 + +#define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56 +#define GL_MAX_SAMPLES_EXT 0x8D57 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT 0x8D6C + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples); + +#define glFramebufferTexture2DMultisampleEXT GLEW_GET_FUN(__glewFramebufferTexture2DMultisampleEXT) + +#define GLEW_EXT_multisampled_render_to_texture GLEW_GET_VAR(__GLEW_EXT_multisampled_render_to_texture) + +#endif /* GL_EXT_multisampled_render_to_texture */ + +/* ----------------- GL_EXT_multisampled_render_to_texture2 ---------------- */ + +#ifndef GL_EXT_multisampled_render_to_texture2 +#define GL_EXT_multisampled_render_to_texture2 1 + +#define GLEW_EXT_multisampled_render_to_texture2 GLEW_GET_VAR(__GLEW_EXT_multisampled_render_to_texture2) + +#endif /* GL_EXT_multisampled_render_to_texture2 */ + +/* --------------------- GL_EXT_multiview_draw_buffers --------------------- */ + +#ifndef GL_EXT_multiview_draw_buffers +#define GL_EXT_multiview_draw_buffers 1 + +#define GL_DRAW_BUFFER_EXT 0x0C01 +#define GL_READ_BUFFER_EXT 0x0C02 +#define GL_COLOR_ATTACHMENT_EXT 0x90F0 +#define GL_MULTIVIEW_EXT 0x90F1 +#define GL_MAX_MULTIVIEW_BUFFERS_EXT 0x90F2 + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSINDEXEDEXTPROC) (GLint n, const GLenum* location, const GLint *indices); +typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VEXTPROC) (GLenum target, GLuint index, GLint* data); +typedef void (GLAPIENTRY * PFNGLREADBUFFERINDEXEDEXTPROC) (GLenum src, GLint index); + +#define glDrawBuffersIndexedEXT GLEW_GET_FUN(__glewDrawBuffersIndexedEXT) +#define glGetIntegeri_vEXT GLEW_GET_FUN(__glewGetIntegeri_vEXT) +#define glReadBufferIndexedEXT GLEW_GET_FUN(__glewReadBufferIndexedEXT) + +#define GLEW_EXT_multiview_draw_buffers GLEW_GET_VAR(__GLEW_EXT_multiview_draw_buffers) + +#endif /* GL_EXT_multiview_draw_buffers */ + /* ---------------------- GL_EXT_packed_depth_stencil ---------------------- */ #ifndef GL_EXT_packed_depth_stencil @@ -10361,6 +11417,20 @@ typedef void (GLAPIENTRY * PFNGLPROVOKINGVERTEXEXTPROC) (GLenum mode); #endif /* GL_EXT_provoking_vertex */ +/* --------------------------- GL_EXT_pvrtc_sRGB --------------------------- */ + +#ifndef GL_EXT_pvrtc_sRGB +#define GL_EXT_pvrtc_sRGB 1 + +#define GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT 0x8A54 +#define GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT 0x8A55 +#define GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT 0x8A56 +#define GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT 0x8A57 + +#define GLEW_EXT_pvrtc_sRGB GLEW_GET_VAR(__GLEW_EXT_pvrtc_sRGB) + +#endif /* GL_EXT_pvrtc_sRGB */ + /* ----------------------- GL_EXT_raster_multisample ----------------------- */ #ifndef GL_EXT_raster_multisample @@ -10395,6 +11465,37 @@ typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean #endif /* GL_EXT_raster_multisample */ +/* ------------------------ GL_EXT_read_format_bgra ------------------------ */ + +#ifndef GL_EXT_read_format_bgra +#define GL_EXT_read_format_bgra 1 + +#define GL_BGRA_EXT 0x80E1 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT 0x8366 + +#define GLEW_EXT_read_format_bgra GLEW_GET_VAR(__GLEW_EXT_read_format_bgra) + +#endif /* GL_EXT_read_format_bgra */ + +/* -------------------------- GL_EXT_render_snorm -------------------------- */ + +#ifndef GL_EXT_render_snorm +#define GL_EXT_render_snorm 1 + +#define GL_BYTE 0x1400 +#define GL_SHORT 0x1402 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM_EXT 0x8F98 +#define GL_RG16_SNORM_EXT 0x8F99 +#define GL_RGBA16_SNORM_EXT 0x8F9B + +#define GLEW_EXT_render_snorm GLEW_GET_VAR(__GLEW_EXT_render_snorm) + +#endif /* GL_EXT_render_snorm */ + /* ------------------------- GL_EXT_rescale_normal ------------------------- */ #ifndef GL_EXT_rescale_normal @@ -10406,6 +11507,31 @@ typedef void (GLAPIENTRY * PFNGLRASTERSAMPLESEXTPROC) (GLuint samples, GLboolean #endif /* GL_EXT_rescale_normal */ +/* ------------------------------ GL_EXT_sRGB ------------------------------ */ + +#ifndef GL_EXT_sRGB +#define GL_EXT_sRGB 1 + +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT 0x8210 +#define GL_SRGB_EXT 0x8C40 +#define GL_SRGB_ALPHA_EXT 0x8C42 +#define GL_SRGB8_ALPHA8_EXT 0x8C43 + +#define GLEW_EXT_sRGB GLEW_GET_VAR(__GLEW_EXT_sRGB) + +#endif /* GL_EXT_sRGB */ + +/* ----------------------- GL_EXT_sRGB_write_control ----------------------- */ + +#ifndef GL_EXT_sRGB_write_control +#define GL_EXT_sRGB_write_control 1 + +#define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9 + +#define GLEW_EXT_sRGB_write_control GLEW_GET_VAR(__GLEW_EXT_sRGB_write_control) + +#endif /* GL_EXT_sRGB_write_control */ + /* -------------------------- GL_EXT_scene_marker -------------------------- */ #ifndef GL_EXT_scene_marker @@ -10474,6 +11600,59 @@ typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenu #endif /* GL_EXT_secondary_color */ +/* ---------------------------- GL_EXT_semaphore --------------------------- */ + +#ifndef GL_EXT_semaphore +#define GL_EXT_semaphore 1 + +typedef void (GLAPIENTRY * PFNGLDELETESEMAPHORESEXTPROC) (GLsizei n, const GLuint* semaphores); +typedef void (GLAPIENTRY * PFNGLGENSEMAPHORESEXTPROC) (GLsizei n, GLuint* semaphores); +typedef void (GLAPIENTRY * PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC) (GLuint semaphore, GLenum pname, GLuint64* params); +typedef GLboolean (GLAPIENTRY * PFNGLISSEMAPHOREEXTPROC) (GLuint semaphore); +typedef void (GLAPIENTRY * PFNGLSEMAPHOREPARAMETERUI64VEXTPROC) (GLuint semaphore, GLenum pname, const GLuint64* params); +typedef void (GLAPIENTRY * PFNGLSIGNALSEMAPHOREEXTPROC) (GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts); +typedef void (GLAPIENTRY * PFNGLWAITSEMAPHOREEXTPROC) (GLuint semaphore, GLuint numBufferBarriers, const GLuint* buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts); + +#define glDeleteSemaphoresEXT GLEW_GET_FUN(__glewDeleteSemaphoresEXT) +#define glGenSemaphoresEXT GLEW_GET_FUN(__glewGenSemaphoresEXT) +#define glGetSemaphoreParameterui64vEXT GLEW_GET_FUN(__glewGetSemaphoreParameterui64vEXT) +#define glIsSemaphoreEXT GLEW_GET_FUN(__glewIsSemaphoreEXT) +#define glSemaphoreParameterui64vEXT GLEW_GET_FUN(__glewSemaphoreParameterui64vEXT) +#define glSignalSemaphoreEXT GLEW_GET_FUN(__glewSignalSemaphoreEXT) +#define glWaitSemaphoreEXT GLEW_GET_FUN(__glewWaitSemaphoreEXT) + +#define GLEW_EXT_semaphore GLEW_GET_VAR(__GLEW_EXT_semaphore) + +#endif /* GL_EXT_semaphore */ + +/* -------------------------- GL_EXT_semaphore_fd -------------------------- */ + +#ifndef GL_EXT_semaphore_fd +#define GL_EXT_semaphore_fd 1 + +typedef void (GLAPIENTRY * PFNGLIMPORTSEMAPHOREFDEXTPROC) (GLuint semaphore, GLenum handleType, GLint fd); + +#define glImportSemaphoreFdEXT GLEW_GET_FUN(__glewImportSemaphoreFdEXT) + +#define GLEW_EXT_semaphore_fd GLEW_GET_VAR(__GLEW_EXT_semaphore_fd) + +#endif /* GL_EXT_semaphore_fd */ + +/* ------------------------- GL_EXT_semaphore_win32 ------------------------ */ + +#ifndef GL_EXT_semaphore_win32 +#define GL_EXT_semaphore_win32 1 + +typedef void (GLAPIENTRY * PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC) (GLuint semaphore, GLenum handleType, void *handle); +typedef void (GLAPIENTRY * PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC) (GLuint semaphore, GLenum handleType, const void *name); + +#define glImportSemaphoreWin32HandleEXT GLEW_GET_FUN(__glewImportSemaphoreWin32HandleEXT) +#define glImportSemaphoreWin32NameEXT GLEW_GET_FUN(__glewImportSemaphoreWin32NameEXT) + +#define GLEW_EXT_semaphore_win32 GLEW_GET_VAR(__GLEW_EXT_semaphore_win32) + +#endif /* GL_EXT_semaphore_win32 */ + /* --------------------- GL_EXT_separate_shader_objects -------------------- */ #ifndef GL_EXT_separate_shader_objects @@ -10506,6 +11685,26 @@ typedef void (GLAPIENTRY * PFNGLUSESHADERPROGRAMEXTPROC) (GLenum type, GLuint pr #endif /* GL_EXT_separate_specular_color */ +/* -------------------- GL_EXT_shader_framebuffer_fetch -------------------- */ + +#ifndef GL_EXT_shader_framebuffer_fetch +#define GL_EXT_shader_framebuffer_fetch 1 + +#define GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT 0x8A52 + +#define GLEW_EXT_shader_framebuffer_fetch GLEW_GET_VAR(__GLEW_EXT_shader_framebuffer_fetch) + +#endif /* GL_EXT_shader_framebuffer_fetch */ + +/* ------------------------ GL_EXT_shader_group_vote ----------------------- */ + +#ifndef GL_EXT_shader_group_vote +#define GL_EXT_shader_group_vote 1 + +#define GLEW_EXT_shader_group_vote GLEW_GET_VAR(__GLEW_EXT_shader_group_vote) + +#endif /* GL_EXT_shader_group_vote */ + /* ------------------- GL_EXT_shader_image_load_formatted ------------------ */ #ifndef GL_EXT_shader_image_load_formatted @@ -10586,6 +11785,15 @@ typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); #endif /* GL_EXT_shader_image_load_store */ +/* ------------------- GL_EXT_shader_implicit_conversions ------------------ */ + +#ifndef GL_EXT_shader_implicit_conversions +#define GL_EXT_shader_implicit_conversions 1 + +#define GLEW_EXT_shader_implicit_conversions GLEW_GET_VAR(__GLEW_EXT_shader_implicit_conversions) + +#endif /* GL_EXT_shader_implicit_conversions */ + /* ----------------------- GL_EXT_shader_integer_mix ----------------------- */ #ifndef GL_EXT_shader_integer_mix @@ -10595,6 +11803,67 @@ typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); #endif /* GL_EXT_shader_integer_mix */ +/* ------------------------ GL_EXT_shader_io_blocks ------------------------ */ + +#ifndef GL_EXT_shader_io_blocks +#define GL_EXT_shader_io_blocks 1 + +#define GLEW_EXT_shader_io_blocks GLEW_GET_VAR(__GLEW_EXT_shader_io_blocks) + +#endif /* GL_EXT_shader_io_blocks */ + +/* ------------- GL_EXT_shader_non_constant_global_initializers ------------ */ + +#ifndef GL_EXT_shader_non_constant_global_initializers +#define GL_EXT_shader_non_constant_global_initializers 1 + +#define GLEW_EXT_shader_non_constant_global_initializers GLEW_GET_VAR(__GLEW_EXT_shader_non_constant_global_initializers) + +#endif /* GL_EXT_shader_non_constant_global_initializers */ + +/* ------------------- GL_EXT_shader_pixel_local_storage ------------------- */ + +#ifndef GL_EXT_shader_pixel_local_storage +#define GL_EXT_shader_pixel_local_storage 1 + +#define GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT 0x8F63 +#define GL_SHADER_PIXEL_LOCAL_STORAGE_EXT 0x8F64 +#define GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT 0x8F67 + +#define GLEW_EXT_shader_pixel_local_storage GLEW_GET_VAR(__GLEW_EXT_shader_pixel_local_storage) + +#endif /* GL_EXT_shader_pixel_local_storage */ + +/* ------------------- GL_EXT_shader_pixel_local_storage2 ------------------ */ + +#ifndef GL_EXT_shader_pixel_local_storage2 +#define GL_EXT_shader_pixel_local_storage2 1 + +#define GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_FAST_SIZE_EXT 0x9650 +#define GL_MAX_SHADER_COMBINED_LOCAL_STORAGE_SIZE_EXT 0x9651 +#define GL_FRAMEBUFFER_INCOMPLETE_INSUFFICIENT_SHADER_COMBINED_LOCAL_STORAGE_EXT 0x9652 + +typedef void (GLAPIENTRY * PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC) (GLsizei offset, GLsizei n, const GLuint* values); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) (GLuint target, GLsizei size); +typedef GLsizei (GLAPIENTRY * PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC) (GLuint target); + +#define glClearPixelLocalStorageuiEXT GLEW_GET_FUN(__glewClearPixelLocalStorageuiEXT) +#define glFramebufferPixelLocalStorageSizeEXT GLEW_GET_FUN(__glewFramebufferPixelLocalStorageSizeEXT) +#define glGetFramebufferPixelLocalStorageSizeEXT GLEW_GET_FUN(__glewGetFramebufferPixelLocalStorageSizeEXT) + +#define GLEW_EXT_shader_pixel_local_storage2 GLEW_GET_VAR(__GLEW_EXT_shader_pixel_local_storage2) + +#endif /* GL_EXT_shader_pixel_local_storage2 */ + +/* ----------------------- GL_EXT_shader_texture_lod ----------------------- */ + +#ifndef GL_EXT_shader_texture_lod +#define GL_EXT_shader_texture_lod 1 + +#define GLEW_EXT_shader_texture_lod GLEW_GET_VAR(__GLEW_EXT_shader_texture_lod) + +#endif /* GL_EXT_shader_texture_lod */ + /* -------------------------- GL_EXT_shadow_funcs -------------------------- */ #ifndef GL_EXT_shadow_funcs @@ -10604,6 +11873,20 @@ typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); #endif /* GL_EXT_shadow_funcs */ +/* ------------------------- GL_EXT_shadow_samplers ------------------------ */ + +#ifndef GL_EXT_shadow_samplers +#define GL_EXT_shadow_samplers 1 + +#define GL_TEXTURE_COMPARE_MODE_EXT 0x884C +#define GL_TEXTURE_COMPARE_FUNC_EXT 0x884D +#define GL_COMPARE_REF_TO_TEXTURE_EXT 0x884E +#define GL_SAMPLER_2D_SHADOW_EXT 0x8B62 + +#define GLEW_EXT_shadow_samplers GLEW_GET_VAR(__GLEW_EXT_shadow_samplers) + +#endif /* GL_EXT_shadow_samplers */ + /* --------------------- GL_EXT_shared_texture_palette --------------------- */ #ifndef GL_EXT_shared_texture_palette @@ -10615,6 +11898,38 @@ typedef void (GLAPIENTRY * PFNGLMEMORYBARRIEREXTPROC) (GLbitfield barriers); #endif /* GL_EXT_shared_texture_palette */ +/* ------------------------- GL_EXT_sparse_texture ------------------------- */ + +#ifndef GL_EXT_sparse_texture +#define GL_EXT_sparse_texture 1 + +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_3D 0x806F +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_TEXTURE_CUBE_MAP_ARRAY_OES 0x9009 +#define GL_VIRTUAL_PAGE_SIZE_X_EXT 0x9195 +#define GL_VIRTUAL_PAGE_SIZE_Y_EXT 0x9196 +#define GL_VIRTUAL_PAGE_SIZE_Z_EXT 0x9197 +#define GL_MAX_SPARSE_TEXTURE_SIZE_EXT 0x9198 +#define GL_MAX_SPARSE_3D_TEXTURE_SIZE_EXT 0x9199 +#define GL_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_EXT 0x919A +#define GL_TEXTURE_SPARSE_EXT 0x91A6 +#define GL_VIRTUAL_PAGE_SIZE_INDEX_EXT 0x91A7 +#define GL_NUM_VIRTUAL_PAGE_SIZES_EXT 0x91A8 +#define GL_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_EXT 0x91A9 +#define GL_NUM_SPARSE_LEVELS_EXT 0x91AA + +typedef void (GLAPIENTRY * PFNGLTEXPAGECOMMITMENTEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); +typedef void (GLAPIENTRY * PFNGLTEXTUREPAGECOMMITMENTEXTPROC) (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean commit); + +#define glTexPageCommitmentEXT GLEW_GET_FUN(__glewTexPageCommitmentEXT) +#define glTexturePageCommitmentEXT GLEW_GET_FUN(__glewTexturePageCommitmentEXT) + +#define GLEW_EXT_sparse_texture GLEW_GET_VAR(__GLEW_EXT_sparse_texture) + +#endif /* GL_EXT_sparse_texture */ + /* ------------------------- GL_EXT_sparse_texture2 ------------------------ */ #ifndef GL_EXT_sparse_texture2 @@ -10797,6 +12112,42 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #endif /* GL_EXT_texture_buffer_object */ +/* -------------- GL_EXT_texture_compression_astc_decode_mode -------------- */ + +#ifndef GL_EXT_texture_compression_astc_decode_mode +#define GL_EXT_texture_compression_astc_decode_mode 1 + +#define GL_TEXTURE_ASTC_DECODE_PRECISION_EXT 0x8F69 + +#define GLEW_EXT_texture_compression_astc_decode_mode GLEW_GET_VAR(__GLEW_EXT_texture_compression_astc_decode_mode) + +#endif /* GL_EXT_texture_compression_astc_decode_mode */ + +/* ----------- GL_EXT_texture_compression_astc_decode_mode_rgb9e5 ---------- */ + +#ifndef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 +#define GL_EXT_texture_compression_astc_decode_mode_rgb9e5 1 + +#define GL_TEXTURE_ASTC_DECODE_PRECISION_EXT 0x8F69 + +#define GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5 GLEW_GET_VAR(__GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5) + +#endif /* GL_EXT_texture_compression_astc_decode_mode_rgb9e5 */ + +/* -------------------- GL_EXT_texture_compression_bptc -------------------- */ + +#ifndef GL_EXT_texture_compression_bptc +#define GL_EXT_texture_compression_bptc 1 + +#define GL_COMPRESSED_RGBA_BPTC_UNORM_EXT 0x8E8C +#define GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT 0x8E8D +#define GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT 0x8E8E +#define GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT 0x8E8F + +#define GLEW_EXT_texture_compression_bptc GLEW_GET_VAR(__GLEW_EXT_texture_compression_bptc) + +#endif /* GL_EXT_texture_compression_bptc */ + /* -------------------- GL_EXT_texture_compression_dxt1 -------------------- */ #ifndef GL_EXT_texture_compression_dxt1 @@ -10870,6 +12221,25 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #endif /* GL_EXT_texture_cube_map */ +/* --------------------- GL_EXT_texture_cube_map_array --------------------- */ + +#ifndef GL_EXT_texture_cube_map_array +#define GL_EXT_texture_cube_map_array 1 + +#define GL_TEXTURE_CUBE_MAP_ARRAY_EXT 0x9009 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT 0x900A +#define GL_SAMPLER_CUBE_MAP_ARRAY_EXT 0x900C +#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT 0x900D +#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_EXT 0x900E +#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT 0x900F +#define GL_IMAGE_CUBE_MAP_ARRAY_EXT 0x9054 +#define GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x905F +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT 0x906A + +#define GLEW_EXT_texture_cube_map_array GLEW_GET_VAR(__GLEW_EXT_texture_cube_map_array) + +#endif /* GL_EXT_texture_cube_map_array */ + /* ----------------------- GL_EXT_texture_edge_clamp ----------------------- */ #ifndef GL_EXT_texture_edge_clamp @@ -10966,6 +12336,17 @@ typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum interna #endif /* GL_EXT_texture_filter_minmax */ +/* --------------------- GL_EXT_texture_format_BGRA8888 -------------------- */ + +#ifndef GL_EXT_texture_format_BGRA8888 +#define GL_EXT_texture_format_BGRA8888 1 + +#define GL_BGRA_EXT 0x80E1 + +#define GLEW_EXT_texture_format_BGRA8888 GLEW_GET_VAR(__GLEW_EXT_texture_format_BGRA8888) + +#endif /* GL_EXT_texture_format_BGRA8888 */ + /* ------------------------- GL_EXT_texture_integer ------------------------ */ #ifndef GL_EXT_texture_integer @@ -11063,6 +12444,24 @@ typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum #endif /* GL_EXT_texture_mirror_clamp */ +/* ------------------------- GL_EXT_texture_norm16 ------------------------- */ + +#ifndef GL_EXT_texture_norm16 +#define GL_EXT_texture_norm16 1 + +#define GL_RGB16_EXT 0x8054 +#define GL_RGBA16_EXT 0x805B +#define GL_R16_EXT 0x822A +#define GL_RG16_EXT 0x822C +#define GL_R16_SNORM_EXT 0x8F98 +#define GL_RG16_SNORM_EXT 0x8F99 +#define GL_RGB16_SNORM_EXT 0x8F9A +#define GL_RGBA16_SNORM_EXT 0x8F9B + +#define GLEW_EXT_texture_norm16 GLEW_GET_VAR(__GLEW_EXT_texture_norm16) + +#endif /* GL_EXT_texture_norm16 */ + /* ------------------------- GL_EXT_texture_object ------------------------- */ #ifndef GL_EXT_texture_object @@ -11122,6 +12521,20 @@ typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #endif /* GL_EXT_texture_rectangle */ +/* --------------------------- GL_EXT_texture_rg --------------------------- */ + +#ifndef GL_EXT_texture_rg +#define GL_EXT_texture_rg 1 + +#define GL_RED_EXT 0x1903 +#define GL_RG_EXT 0x8227 +#define GL_R8_EXT 0x8229 +#define GL_RG8_EXT 0x822B + +#define GLEW_EXT_texture_rg GLEW_GET_VAR(__GLEW_EXT_texture_rg) + +#endif /* GL_EXT_texture_rg */ + /* -------------------------- GL_EXT_texture_sRGB -------------------------- */ #ifndef GL_EXT_texture_sRGB @@ -11148,6 +12561,28 @@ typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #endif /* GL_EXT_texture_sRGB */ +/* ------------------------- GL_EXT_texture_sRGB_R8 ------------------------ */ + +#ifndef GL_EXT_texture_sRGB_R8 +#define GL_EXT_texture_sRGB_R8 1 + +#define GL_SR8_EXT 0x8FBD + +#define GLEW_EXT_texture_sRGB_R8 GLEW_GET_VAR(__GLEW_EXT_texture_sRGB_R8) + +#endif /* GL_EXT_texture_sRGB_R8 */ + +/* ------------------------ GL_EXT_texture_sRGB_RG8 ------------------------ */ + +#ifndef GL_EXT_texture_sRGB_RG8 +#define GL_EXT_texture_sRGB_RG8 1 + +#define GL_SRG8_EXT 0x8FBE + +#define GLEW_EXT_texture_sRGB_RG8 GLEW_GET_VAR(__GLEW_EXT_texture_sRGB_RG8) + +#endif /* GL_EXT_texture_sRGB_RG8 */ + /* ----------------------- GL_EXT_texture_sRGB_decode ---------------------- */ #ifndef GL_EXT_texture_sRGB_decode @@ -11209,6 +12644,54 @@ typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #endif /* GL_EXT_texture_snorm */ +/* ------------------------- GL_EXT_texture_storage ------------------------ */ + +#ifndef GL_EXT_texture_storage +#define GL_EXT_texture_storage 1 + +#define GL_ALPHA8_EXT 0x803C +#define GL_LUMINANCE8_EXT 0x8040 +#define GL_LUMINANCE8_ALPHA8_EXT 0x8045 +#define GL_RGB10_EXT 0x8052 +#define GL_RGB10_A2_EXT 0x8059 +#define GL_R8_EXT 0x8229 +#define GL_RG8_EXT 0x822B +#define GL_R16F_EXT 0x822D +#define GL_R32F_EXT 0x822E +#define GL_RG16F_EXT 0x822F +#define GL_RG32F_EXT 0x8230 +#define GL_RGBA32F_EXT 0x8814 +#define GL_RGB32F_EXT 0x8815 +#define GL_ALPHA32F_EXT 0x8816 +#define GL_LUMINANCE32F_EXT 0x8818 +#define GL_LUMINANCE_ALPHA32F_EXT 0x8819 +#define GL_RGBA16F_EXT 0x881A +#define GL_RGB16F_EXT 0x881B +#define GL_ALPHA16F_EXT 0x881C +#define GL_LUMINANCE16F_EXT 0x881E +#define GL_LUMINANCE_ALPHA16F_EXT 0x881F +#define GL_RGB_RAW_422_APPLE 0x8A51 +#define GL_TEXTURE_IMMUTABLE_FORMAT_EXT 0x912F +#define GL_BGRA8_EXT 0x93A1 + +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE1DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE2DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXSTORAGE3DEXTPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); + +#define glTexStorage1DEXT GLEW_GET_FUN(__glewTexStorage1DEXT) +#define glTexStorage2DEXT GLEW_GET_FUN(__glewTexStorage2DEXT) +#define glTexStorage3DEXT GLEW_GET_FUN(__glewTexStorage3DEXT) +#define glTextureStorage1DEXT GLEW_GET_FUN(__glewTextureStorage1DEXT) +#define glTextureStorage2DEXT GLEW_GET_FUN(__glewTextureStorage2DEXT) +#define glTextureStorage3DEXT GLEW_GET_FUN(__glewTextureStorage3DEXT) + +#define GLEW_EXT_texture_storage GLEW_GET_VAR(__GLEW_EXT_texture_storage) + +#endif /* GL_EXT_texture_storage */ + /* ------------------------- GL_EXT_texture_swizzle ------------------------ */ #ifndef GL_EXT_texture_swizzle @@ -11224,6 +12707,36 @@ typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); #endif /* GL_EXT_texture_swizzle */ +/* ------------------- GL_EXT_texture_type_2_10_10_10_REV ------------------ */ + +#ifndef GL_EXT_texture_type_2_10_10_10_REV +#define GL_EXT_texture_type_2_10_10_10_REV 1 + +#define GL_UNSIGNED_INT_2_10_10_10_REV_EXT 0x8368 + +#define GLEW_EXT_texture_type_2_10_10_10_REV GLEW_GET_VAR(__GLEW_EXT_texture_type_2_10_10_10_REV) + +#endif /* GL_EXT_texture_type_2_10_10_10_REV */ + +/* -------------------------- GL_EXT_texture_view -------------------------- */ + +#ifndef GL_EXT_texture_view +#define GL_EXT_texture_view 1 + +#define GL_TEXTURE_VIEW_MIN_LEVEL_EXT 0x82DB +#define GL_TEXTURE_VIEW_NUM_LEVELS_EXT 0x82DC +#define GL_TEXTURE_VIEW_MIN_LAYER_EXT 0x82DD +#define GL_TEXTURE_VIEW_NUM_LAYERS_EXT 0x82DE +#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF + +typedef void (GLAPIENTRY * PFNGLTEXTUREVIEWEXTPROC) (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers); + +#define glTextureViewEXT GLEW_GET_FUN(__glewTextureViewEXT) + +#define GLEW_EXT_texture_view GLEW_GET_VAR(__GLEW_EXT_texture_view) + +#endif /* GL_EXT_texture_view */ + /* --------------------------- GL_EXT_timer_query -------------------------- */ #ifndef GL_EXT_timer_query @@ -11282,6 +12795,19 @@ typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) (GLuint progra #endif /* GL_EXT_transform_feedback */ +/* ------------------------- GL_EXT_unpack_subimage ------------------------ */ + +#ifndef GL_EXT_unpack_subimage +#define GL_EXT_unpack_subimage 1 + +#define GL_UNPACK_ROW_LENGTH_EXT 0x0CF2 +#define GL_UNPACK_SKIP_ROWS_EXT 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS_EXT 0x0CF4 + +#define GLEW_EXT_unpack_subimage GLEW_GET_VAR(__GLEW_EXT_unpack_subimage) + +#endif /* GL_EXT_unpack_subimage */ + /* -------------------------- GL_EXT_vertex_array -------------------------- */ #ifndef GL_EXT_vertex_array @@ -11354,6 +12880,23 @@ typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, #endif /* GL_EXT_vertex_array_bgra */ +/* ----------------------- GL_EXT_vertex_array_setXXX ---------------------- */ + +#ifndef GL_EXT_vertex_array_setXXX +#define GL_EXT_vertex_array_setXXX 1 + +typedef void (GLAPIENTRY * PFNGLBINDARRAYSETEXTPROC) (const void *arrayset); +typedef const void * (GLAPIENTRY * PFNGLCREATEARRAYSETEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLDELETEARRAYSETSEXTPROC) (GLsizei n, const void *arrayset[]); + +#define glBindArraySetEXT GLEW_GET_FUN(__glewBindArraySetEXT) +#define glCreateArraySetExt GLEW_GET_FUN(__glewCreateArraySetExt) +#define glDeleteArraySetsEXT GLEW_GET_FUN(__glewDeleteArraySetsEXT) + +#define GLEW_EXT_vertex_array_setXXX GLEW_GET_VAR(__GLEW_EXT_vertex_array_setXXX) + +#endif /* GL_EXT_vertex_array_setXXX */ + /* ----------------------- GL_EXT_vertex_attrib_64bit ---------------------- */ #ifndef GL_EXT_vertex_attrib_64bit @@ -11637,6 +13180,21 @@ typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (GLfloat* weight); #endif /* GL_EXT_vertex_weighting */ +/* ------------------------ GL_EXT_win32_keyed_mutex ----------------------- */ + +#ifndef GL_EXT_win32_keyed_mutex +#define GL_EXT_win32_keyed_mutex 1 + +typedef GLboolean (GLAPIENTRY * PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC) (GLuint memory, GLuint64 key, GLuint timeout); +typedef GLboolean (GLAPIENTRY * PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC) (GLuint memory, GLuint64 key); + +#define glAcquireKeyedMutexWin32EXT GLEW_GET_FUN(__glewAcquireKeyedMutexWin32EXT) +#define glReleaseKeyedMutexWin32EXT GLEW_GET_FUN(__glewReleaseKeyedMutexWin32EXT) + +#define GLEW_EXT_win32_keyed_mutex GLEW_GET_VAR(__GLEW_EXT_win32_keyed_mutex) + +#endif /* GL_EXT_win32_keyed_mutex */ + /* ------------------------ GL_EXT_window_rectangles ----------------------- */ #ifndef GL_EXT_window_rectangles @@ -12068,9 +13626,6 @@ 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 */ @@ -12128,9 +13683,9 @@ typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGECONTROLPROC) (GLenum source, GLenum typedef void (GLAPIENTRY * PFNGLDEBUGMESSAGEINSERTPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf); typedef GLuint (GLAPIENTRY * PFNGLGETDEBUGMESSAGELOGPROC) (GLuint count, GLsizei bufSize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog); typedef void (GLAPIENTRY * PFNGLGETOBJECTLABELPROC) (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar *label); -typedef void (GLAPIENTRY * PFNGLGETOBJECTPTRLABELPROC) (const void *ptr, GLsizei bufSize, GLsizei* length, GLchar *label); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPTRLABELPROC) (void* ptr, GLsizei bufSize, GLsizei* length, GLchar *label); typedef void (GLAPIENTRY * PFNGLOBJECTLABELPROC) (GLenum identifier, GLuint name, GLsizei length, const GLchar* label); -typedef void (GLAPIENTRY * PFNGLOBJECTPTRLABELPROC) (const void *ptr, GLsizei length, const GLchar* label); +typedef void (GLAPIENTRY * PFNGLOBJECTPTRLABELPROC) (void* ptr, GLsizei length, const GLchar* label); typedef void (GLAPIENTRY * PFNGLPOPDEBUGGROUPPROC) (void); typedef void (GLAPIENTRY * PFNGLPUSHDEBUGGROUPPROC) (GLenum source, GLuint id, GLsizei length, const GLchar * message); @@ -12160,6 +13715,22 @@ typedef void (GLAPIENTRY * PFNGLPUSHDEBUGGROUPPROC) (GLenum source, GLuint id, G #endif /* GL_KHR_no_error */ +/* --------------------- GL_KHR_parallel_shader_compile -------------------- */ + +#ifndef GL_KHR_parallel_shader_compile +#define GL_KHR_parallel_shader_compile 1 + +#define GL_MAX_SHADER_COMPILER_THREADS_KHR 0x91B0 +#define GL_COMPLETION_STATUS_KHR 0x91B1 + +typedef void (GLAPIENTRY * PFNGLMAXSHADERCOMPILERTHREADSKHRPROC) (GLuint count); + +#define glMaxShaderCompilerThreadsKHR GLEW_GET_FUN(__glewMaxShaderCompilerThreadsKHR) + +#define GLEW_KHR_parallel_shader_compile GLEW_GET_VAR(__GLEW_KHR_parallel_shader_compile) + +#endif /* GL_KHR_parallel_shader_compile */ + /* ------------------ GL_KHR_robust_buffer_access_behavior ----------------- */ #ifndef GL_KHR_robust_buffer_access_behavior @@ -12488,6 +14059,68 @@ typedef void (GLAPIENTRY * PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC) (GLbitfield gpuMa #endif /* GL_NVX_linked_gpu_multicast */ +/* ------------------------ GL_NV_3dvision_settings ------------------------ */ + +#ifndef GL_NV_3dvision_settings +#define GL_NV_3dvision_settings 1 + +#define GL_3DVISION_STEREO_NV 0x90F4 +#define GL_STEREO_SEPARATION_NV 0x90F5 +#define GL_STEREO_CONVERGENCE_NV 0x90F6 +#define GL_STEREO_CUTOFF_NV 0x90F7 +#define GL_STEREO_PROJECTION_NV 0x90F8 +#define GL_STEREO_PROJECTION_PERSPECTIVE_NV 0x90F9 +#define GL_STEREO_PROJECTION_ORTHO_NV 0x90FA + +typedef void (GLAPIENTRY * PFNGLSTEREOPARAMETERFNVPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLSTEREOPARAMETERINVPROC) (GLenum pname, GLint param); + +#define glStereoParameterfNV GLEW_GET_FUN(__glewStereoParameterfNV) +#define glStereoParameteriNV GLEW_GET_FUN(__glewStereoParameteriNV) + +#define GLEW_NV_3dvision_settings GLEW_GET_VAR(__GLEW_NV_3dvision_settings) + +#endif /* GL_NV_3dvision_settings */ + +/* ------------------- GL_NV_EGL_stream_consumer_external ------------------ */ + +#ifndef GL_NV_EGL_stream_consumer_external +#define GL_NV_EGL_stream_consumer_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_NV_EGL_stream_consumer_external GLEW_GET_VAR(__GLEW_NV_EGL_stream_consumer_external) + +#endif /* GL_NV_EGL_stream_consumer_external */ + +/* ----------------- GL_NV_alpha_to_coverage_dither_control ---------------- */ + +#ifndef GL_NV_alpha_to_coverage_dither_control +#define GL_NV_alpha_to_coverage_dither_control 1 + +#define GL_ALPHA_TO_COVERAGE_DITHER_MODE_NV 0x92BF +#define GL_ALPHA_TO_COVERAGE_DITHER_DEFAULT_NV 0x934D +#define GL_ALPHA_TO_COVERAGE_DITHER_ENABLE_NV 0x934E +#define GL_ALPHA_TO_COVERAGE_DITHER_DISABLE_NV 0x934F + +#define GLEW_NV_alpha_to_coverage_dither_control GLEW_GET_VAR(__GLEW_NV_alpha_to_coverage_dither_control) + +#endif /* GL_NV_alpha_to_coverage_dither_control */ + +/* ------------------------------- GL_NV_bgr ------------------------------- */ + +#ifndef GL_NV_bgr +#define GL_NV_bgr 1 + +#define GL_BGR_NV 0x80E0 + +#define GLEW_NV_bgr GLEW_GET_VAR(__GLEW_NV_bgr) + +#endif /* GL_NV_bgr */ + /* ------------------- GL_NV_bindless_multi_draw_indirect ------------------ */ #ifndef GL_NV_bindless_multi_draw_indirect @@ -12630,6 +14263,18 @@ typedef void (GLAPIENTRY * PFNGLBLENDPARAMETERINVPROC) (GLenum pname, GLint valu #endif /* GL_NV_blend_equation_advanced_coherent */ +/* ----------------------- GL_NV_blend_minmax_factor ----------------------- */ + +#ifndef GL_NV_blend_minmax_factor +#define GL_NV_blend_minmax_factor 1 + +#define GL_FACTOR_MIN_AMD 0x901C +#define GL_FACTOR_MAX_AMD 0x901D + +#define GLEW_NV_blend_minmax_factor GLEW_GET_VAR(__GLEW_NV_blend_minmax_factor) + +#endif /* GL_NV_blend_minmax_factor */ + /* --------------------------- GL_NV_blend_square -------------------------- */ #ifndef GL_NV_blend_square @@ -12805,6 +14450,22 @@ typedef void (GLAPIENTRY * PFNGLCONSERVATIVERASTERPARAMETERINVPROC) (GLenum pnam #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +/* --------------------------- GL_NV_copy_buffer --------------------------- */ + +#ifndef GL_NV_copy_buffer +#define GL_NV_copy_buffer 1 + +#define GL_COPY_READ_BUFFER_NV 0x8F36 +#define GL_COPY_WRITE_BUFFER_NV 0x8F37 + +typedef void (GLAPIENTRY * PFNGLCOPYBUFFERSUBDATANVPROC) (GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size); + +#define glCopyBufferSubDataNV GLEW_GET_FUN(__glewCopyBufferSubDataNV) + +#define GLEW_NV_copy_buffer GLEW_GET_VAR(__GLEW_NV_copy_buffer) + +#endif /* GL_NV_copy_buffer */ + /* ----------------------- GL_NV_copy_depth_to_color ----------------------- */ #ifndef GL_NV_copy_depth_to_color @@ -12890,6 +14551,68 @@ typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFa #endif /* GL_NV_depth_range_unclamped */ +/* --------------------------- GL_NV_draw_buffers -------------------------- */ + +#ifndef GL_NV_draw_buffers +#define GL_NV_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_NV 0x8824 +#define GL_DRAW_BUFFER0_NV 0x8825 +#define GL_DRAW_BUFFER1_NV 0x8826 +#define GL_DRAW_BUFFER2_NV 0x8827 +#define GL_DRAW_BUFFER3_NV 0x8828 +#define GL_DRAW_BUFFER4_NV 0x8829 +#define GL_DRAW_BUFFER5_NV 0x882A +#define GL_DRAW_BUFFER6_NV 0x882B +#define GL_DRAW_BUFFER7_NV 0x882C +#define GL_DRAW_BUFFER8_NV 0x882D +#define GL_DRAW_BUFFER9_NV 0x882E +#define GL_DRAW_BUFFER10_NV 0x882F +#define GL_DRAW_BUFFER11_NV 0x8830 +#define GL_DRAW_BUFFER12_NV 0x8831 +#define GL_DRAW_BUFFER13_NV 0x8832 +#define GL_DRAW_BUFFER14_NV 0x8833 +#define GL_DRAW_BUFFER15_NV 0x8834 +#define GL_COLOR_ATTACHMENT0_NV 0x8CE0 +#define GL_COLOR_ATTACHMENT1_NV 0x8CE1 +#define GL_COLOR_ATTACHMENT2_NV 0x8CE2 +#define GL_COLOR_ATTACHMENT3_NV 0x8CE3 +#define GL_COLOR_ATTACHMENT4_NV 0x8CE4 +#define GL_COLOR_ATTACHMENT5_NV 0x8CE5 +#define GL_COLOR_ATTACHMENT6_NV 0x8CE6 +#define GL_COLOR_ATTACHMENT7_NV 0x8CE7 +#define GL_COLOR_ATTACHMENT8_NV 0x8CE8 +#define GL_COLOR_ATTACHMENT9_NV 0x8CE9 +#define GL_COLOR_ATTACHMENT10_NV 0x8CEA +#define GL_COLOR_ATTACHMENT11_NV 0x8CEB +#define GL_COLOR_ATTACHMENT12_NV 0x8CEC +#define GL_COLOR_ATTACHMENT13_NV 0x8CED +#define GL_COLOR_ATTACHMENT14_NV 0x8CEE +#define GL_COLOR_ATTACHMENT15_NV 0x8CEF + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSNVPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersNV GLEW_GET_FUN(__glewDrawBuffersNV) + +#define GLEW_NV_draw_buffers GLEW_GET_VAR(__GLEW_NV_draw_buffers) + +#endif /* GL_NV_draw_buffers */ + +/* -------------------------- GL_NV_draw_instanced ------------------------- */ + +#ifndef GL_NV_draw_instanced +#define GL_NV_draw_instanced 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDNVPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDNVPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount); + +#define glDrawArraysInstancedNV GLEW_GET_FUN(__glewDrawArraysInstancedNV) +#define glDrawElementsInstancedNV GLEW_GET_FUN(__glewDrawElementsInstancedNV) + +#define GLEW_NV_draw_instanced GLEW_GET_VAR(__GLEW_NV_draw_instanced) + +#endif /* GL_NV_draw_instanced */ + /* --------------------------- GL_NV_draw_texture -------------------------- */ #ifndef GL_NV_draw_texture @@ -12980,6 +14703,15 @@ typedef void (GLAPIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pna #endif /* GL_NV_evaluators */ +/* --------------------- GL_NV_explicit_attrib_location -------------------- */ + +#ifndef GL_NV_explicit_attrib_location +#define GL_NV_explicit_attrib_location 1 + +#define GLEW_NV_explicit_attrib_location GLEW_GET_VAR(__GLEW_NV_explicit_attrib_location) + +#endif /* GL_NV_explicit_attrib_location */ + /* ----------------------- GL_NV_explicit_multisample ---------------------- */ #ifndef GL_NV_explicit_multisample @@ -13008,6 +14740,33 @@ typedef void (GLAPIENTRY * PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint re #endif /* GL_NV_explicit_multisample */ +/* ---------------------- GL_NV_fbo_color_attachments ---------------------- */ + +#ifndef GL_NV_fbo_color_attachments +#define GL_NV_fbo_color_attachments 1 + +#define GL_MAX_COLOR_ATTACHMENTS_NV 0x8CDF +#define GL_COLOR_ATTACHMENT0_NV 0x8CE0 +#define GL_COLOR_ATTACHMENT1_NV 0x8CE1 +#define GL_COLOR_ATTACHMENT2_NV 0x8CE2 +#define GL_COLOR_ATTACHMENT3_NV 0x8CE3 +#define GL_COLOR_ATTACHMENT4_NV 0x8CE4 +#define GL_COLOR_ATTACHMENT5_NV 0x8CE5 +#define GL_COLOR_ATTACHMENT6_NV 0x8CE6 +#define GL_COLOR_ATTACHMENT7_NV 0x8CE7 +#define GL_COLOR_ATTACHMENT8_NV 0x8CE8 +#define GL_COLOR_ATTACHMENT9_NV 0x8CE9 +#define GL_COLOR_ATTACHMENT10_NV 0x8CEA +#define GL_COLOR_ATTACHMENT11_NV 0x8CEB +#define GL_COLOR_ATTACHMENT12_NV 0x8CEC +#define GL_COLOR_ATTACHMENT13_NV 0x8CED +#define GL_COLOR_ATTACHMENT14_NV 0x8CEE +#define GL_COLOR_ATTACHMENT15_NV 0x8CEF + +#define GLEW_NV_fbo_color_attachments GLEW_GET_VAR(__GLEW_NV_fbo_color_attachments) + +#endif /* GL_NV_fbo_color_attachments */ + /* ------------------------------ GL_NV_fence ------------------------------ */ #ifndef GL_NV_fence @@ -13174,6 +14933,24 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsi #endif /* GL_NV_fragment_shader_interlock */ +/* ------------------------- GL_NV_framebuffer_blit ------------------------ */ + +#ifndef GL_NV_framebuffer_blit +#define GL_NV_framebuffer_blit 1 + +#define GL_DRAW_FRAMEBUFFER_BINDING_NV 0x8CA6 +#define GL_READ_FRAMEBUFFER_NV 0x8CA8 +#define GL_DRAW_FRAMEBUFFER_NV 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING_NV 0x8CAA + +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERNVPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + +#define glBlitFramebufferNV GLEW_GET_FUN(__glewBlitFramebufferNV) + +#define GLEW_NV_framebuffer_blit GLEW_GET_VAR(__GLEW_NV_framebuffer_blit) + +#endif /* GL_NV_framebuffer_blit */ + /* -------------------- GL_NV_framebuffer_mixed_samples -------------------- */ #ifndef GL_NV_framebuffer_mixed_samples @@ -13198,6 +14975,23 @@ typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsi #endif /* GL_NV_framebuffer_mixed_samples */ +/* --------------------- GL_NV_framebuffer_multisample --------------------- */ + +#ifndef GL_NV_framebuffer_multisample +#define GL_NV_framebuffer_multisample 1 + +#define GL_RENDERBUFFER_SAMPLES_NV 0x8CAB +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV 0x8D56 +#define GL_MAX_SAMPLES_NV 0x8D57 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glRenderbufferStorageMultisampleNV GLEW_GET_FUN(__glewRenderbufferStorageMultisampleNV) + +#define GLEW_NV_framebuffer_multisample GLEW_GET_VAR(__GLEW_NV_framebuffer_multisample) + +#endif /* GL_NV_framebuffer_multisample */ + /* ----------------- GL_NV_framebuffer_multisample_coverage ---------------- */ #ifndef GL_NV_framebuffer_multisample_coverage @@ -13216,6 +15010,15 @@ typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) (G #endif /* GL_NV_framebuffer_multisample_coverage */ +/* ----------------------- GL_NV_generate_mipmap_sRGB ---------------------- */ + +#ifndef GL_NV_generate_mipmap_sRGB +#define GL_NV_generate_mipmap_sRGB 1 + +#define GLEW_NV_generate_mipmap_sRGB GLEW_GET_VAR(__GLEW_NV_generate_mipmap_sRGB) + +#endif /* GL_NV_generate_mipmap_sRGB */ + /* ------------------------ GL_NV_geometry_program4 ------------------------ */ #ifndef GL_NV_geometry_program4 @@ -13266,7 +15069,7 @@ typedef void (GLAPIENTRY * PFNGLMULTICASTBARRIERNVPROC) (void); typedef void (GLAPIENTRY * PFNGLMULTICASTBLITFRAMEBUFFERNVPROC) (GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); typedef void (GLAPIENTRY * PFNGLMULTICASTBUFFERSUBDATANVPROC) (GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data); typedef void (GLAPIENTRY * PFNGLMULTICASTCOPYBUFFERSUBDATANVPROC) (GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); -typedef void (GLAPIENTRY * PFNGLMULTICASTCOPYIMAGESUBDATANVPROC) (GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth); +typedef void (GLAPIENTRY * PFNGLMULTICASTCOPYIMAGESUBDATANVPROC) (GLuint srcGpu, GLbitfield dstGpuMask, 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); typedef void (GLAPIENTRY * PFNGLMULTICASTFRAMEBUFFERSAMPLELOCATIONSFVNVPROC) (GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v); typedef void (GLAPIENTRY * PFNGLMULTICASTGETQUERYOBJECTI64VNVPROC) (GLuint gpu, GLuint id, GLenum pname, GLint64* params); typedef void (GLAPIENTRY * PFNGLMULTICASTGETQUERYOBJECTIVNVPROC) (GLuint gpu, GLuint id, GLenum pname, GLint* params); @@ -13585,6 +15388,30 @@ typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalf* weight); #endif /* GL_NV_half_float */ +/* -------------------------- GL_NV_image_formats -------------------------- */ + +#ifndef GL_NV_image_formats +#define GL_NV_image_formats 1 + +#define GLEW_NV_image_formats GLEW_GET_VAR(__GLEW_NV_image_formats) + +#endif /* GL_NV_image_formats */ + +/* ------------------------- GL_NV_instanced_arrays ------------------------ */ + +#ifndef GL_NV_instanced_arrays +#define GL_NV_instanced_arrays 1 + +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV 0x88FE + +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORNVPROC) (GLuint index, GLuint divisor); + +#define glVertexAttribDivisorNV GLEW_GET_FUN(__glewVertexAttribDivisorNV) + +#define GLEW_NV_instanced_arrays GLEW_GET_VAR(__GLEW_NV_instanced_arrays) + +#endif /* GL_NV_instanced_arrays */ + /* ------------------- GL_NV_internalformat_sample_query ------------------- */ #ifndef GL_NV_internalformat_sample_query @@ -13637,6 +15464,36 @@ typedef void (GLAPIENTRY * PFNGLGETINTERNALFORMATSAMPLEIVNVPROC) (GLenum target, #endif /* GL_NV_multisample_filter_hint */ +/* ----------------------- GL_NV_non_square_matrices ----------------------- */ + +#ifndef GL_NV_non_square_matrices +#define GL_NV_non_square_matrices 1 + +#define GL_FLOAT_MAT2x3_NV 0x8B65 +#define GL_FLOAT_MAT2x4_NV 0x8B66 +#define GL_FLOAT_MAT3x2_NV 0x8B67 +#define GL_FLOAT_MAT3x4_NV 0x8B68 +#define GL_FLOAT_MAT4x2_NV 0x8B69 +#define GL_FLOAT_MAT4x3_NV 0x8B6A + +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVNVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); + +#define glUniformMatrix2x3fvNV GLEW_GET_FUN(__glewUniformMatrix2x3fvNV) +#define glUniformMatrix2x4fvNV GLEW_GET_FUN(__glewUniformMatrix2x4fvNV) +#define glUniformMatrix3x2fvNV GLEW_GET_FUN(__glewUniformMatrix3x2fvNV) +#define glUniformMatrix3x4fvNV GLEW_GET_FUN(__glewUniformMatrix3x4fvNV) +#define glUniformMatrix4x2fvNV GLEW_GET_FUN(__glewUniformMatrix4x2fvNV) +#define glUniformMatrix4x3fvNV GLEW_GET_FUN(__glewUniformMatrix4x3fvNV) + +#define GLEW_NV_non_square_matrices GLEW_GET_VAR(__GLEW_NV_non_square_matrices) + +#endif /* GL_NV_non_square_matrices */ + /* ------------------------- GL_NV_occlusion_query ------------------------- */ #ifndef GL_NV_occlusion_query @@ -13667,6 +15524,19 @@ typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); #endif /* GL_NV_occlusion_query */ +/* -------------------------- GL_NV_pack_subimage -------------------------- */ + +#ifndef GL_NV_pack_subimage +#define GL_NV_pack_subimage 1 + +#define GL_PACK_ROW_LENGTH_NV 0x0D02 +#define GL_PACK_SKIP_ROWS_NV 0x0D03 +#define GL_PACK_SKIP_PIXELS_NV 0x0D04 + +#define GLEW_NV_pack_subimage GLEW_GET_VAR(__GLEW_NV_pack_subimage) + +#endif /* GL_NV_pack_subimage */ + /* ----------------------- GL_NV_packed_depth_stencil ---------------------- */ #ifndef GL_NV_packed_depth_stencil @@ -13679,6 +15549,30 @@ typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); #endif /* GL_NV_packed_depth_stencil */ +/* --------------------------- GL_NV_packed_float -------------------------- */ + +#ifndef GL_NV_packed_float +#define GL_NV_packed_float 1 + +#define GL_R11F_G11F_B10F_NV 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV_NV 0x8C3B + +#define GLEW_NV_packed_float GLEW_GET_VAR(__GLEW_NV_packed_float) + +#endif /* GL_NV_packed_float */ + +/* ----------------------- GL_NV_packed_float_linear ----------------------- */ + +#ifndef GL_NV_packed_float_linear +#define GL_NV_packed_float_linear 1 + +#define GL_R11F_G11F_B10F_NV 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV_NV 0x8C3B + +#define GLEW_NV_packed_float_linear GLEW_GET_VAR(__GLEW_NV_packed_float_linear) + +#endif /* GL_NV_packed_float_linear */ + /* --------------------- GL_NV_parameter_buffer_object --------------------- */ #ifndef GL_NV_parameter_buffer_object @@ -14011,6 +15905,20 @@ typedef void (GLAPIENTRY * PFNGLWEIGHTPATHSNVPROC) (GLuint resultPath, GLsizei n #endif /* GL_NV_path_rendering_shared_edge */ +/* ----------------------- GL_NV_pixel_buffer_object ----------------------- */ + +#ifndef GL_NV_pixel_buffer_object +#define GL_NV_pixel_buffer_object 1 + +#define GL_PIXEL_PACK_BUFFER_NV 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_NV 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_NV 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_NV 0x88EF + +#define GLEW_NV_pixel_buffer_object GLEW_GET_VAR(__GLEW_NV_pixel_buffer_object) + +#endif /* GL_NV_pixel_buffer_object */ + /* ------------------------- GL_NV_pixel_data_range ------------------------ */ #ifndef GL_NV_pixel_data_range @@ -14033,6 +15941,17 @@ typedef void (GLAPIENTRY * PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei le #endif /* GL_NV_pixel_data_range */ +/* ------------------------- GL_NV_platform_binary ------------------------- */ + +#ifndef GL_NV_platform_binary +#define GL_NV_platform_binary 1 + +#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B + +#define GLEW_NV_platform_binary GLEW_GET_VAR(__GLEW_NV_platform_binary) + +#endif /* GL_NV_platform_binary */ + /* --------------------------- GL_NV_point_sprite -------------------------- */ #ifndef GL_NV_point_sprite @@ -14052,6 +15971,26 @@ typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLi #endif /* GL_NV_point_sprite */ +/* --------------------------- GL_NV_polygon_mode -------------------------- */ + +#ifndef GL_NV_polygon_mode +#define GL_NV_polygon_mode 1 + +#define GL_POLYGON_MODE_NV 0x0B40 +#define GL_POINT_NV 0x1B00 +#define GL_LINE_NV 0x1B01 +#define GL_FILL_NV 0x1B02 +#define GL_POLYGON_OFFSET_POINT_NV 0x2A01 +#define GL_POLYGON_OFFSET_LINE_NV 0x2A02 + +typedef void (GLAPIENTRY * PFNGLPOLYGONMODENVPROC) (GLenum face, GLenum mode); + +#define glPolygonModeNV GLEW_GET_FUN(__glewPolygonModeNV) + +#define GLEW_NV_polygon_mode GLEW_GET_VAR(__GLEW_NV_polygon_mode) + +#endif /* GL_NV_polygon_mode */ + /* -------------------------- GL_NV_present_video -------------------------- */ #ifndef GL_NV_present_video @@ -14100,6 +16039,33 @@ typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); #endif /* GL_NV_primitive_restart */ +/* ---------------------------- GL_NV_read_depth --------------------------- */ + +#ifndef GL_NV_read_depth +#define GL_NV_read_depth 1 + +#define GLEW_NV_read_depth GLEW_GET_VAR(__GLEW_NV_read_depth) + +#endif /* GL_NV_read_depth */ + +/* ------------------------ GL_NV_read_depth_stencil ----------------------- */ + +#ifndef GL_NV_read_depth_stencil +#define GL_NV_read_depth_stencil 1 + +#define GLEW_NV_read_depth_stencil GLEW_GET_VAR(__GLEW_NV_read_depth_stencil) + +#endif /* GL_NV_read_depth_stencil */ + +/* --------------------------- GL_NV_read_stencil -------------------------- */ + +#ifndef GL_NV_read_stencil +#define GL_NV_read_stencil 1 + +#define GLEW_NV_read_stencil GLEW_GET_VAR(__GLEW_NV_read_stencil) + +#endif /* GL_NV_read_stencil */ + /* ------------------------ GL_NV_register_combiners ----------------------- */ #ifndef GL_NV_register_combiners @@ -14218,6 +16184,26 @@ typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage #endif /* GL_NV_robustness_video_memory_purge */ +/* --------------------------- GL_NV_sRGB_formats -------------------------- */ + +#ifndef GL_NV_sRGB_formats +#define GL_NV_sRGB_formats 1 + +#define GL_ETC1_SRGB8_NV 0x88EE +#define GL_SRGB8_NV 0x8C41 +#define GL_SLUMINANCE_ALPHA_NV 0x8C44 +#define GL_SLUMINANCE8_ALPHA8_NV 0x8C45 +#define GL_SLUMINANCE_NV 0x8C46 +#define GL_SLUMINANCE8_NV 0x8C47 +#define GL_COMPRESSED_SRGB_S3TC_DXT1_NV 0x8C4C +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV 0x8C4D +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV 0x8C4E +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV 0x8C4F + +#define GLEW_NV_sRGB_formats GLEW_GET_VAR(__GLEW_NV_sRGB_formats) + +#endif /* GL_NV_sRGB_formats */ + /* ------------------------- GL_NV_sample_locations ------------------------ */ #ifndef GL_NV_sample_locations @@ -14337,6 +16323,15 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou #endif /* GL_NV_shader_buffer_load */ +/* ---------------- GL_NV_shader_noperspective_interpolation --------------- */ + +#ifndef GL_NV_shader_noperspective_interpolation +#define GL_NV_shader_noperspective_interpolation 1 + +#define GLEW_NV_shader_noperspective_interpolation GLEW_GET_VAR(__GLEW_NV_shader_noperspective_interpolation) + +#endif /* GL_NV_shader_noperspective_interpolation */ + /* ------------------- GL_NV_shader_storage_buffer_object ------------------ */ #ifndef GL_NV_shader_storage_buffer_object @@ -14368,6 +16363,28 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou #endif /* GL_NV_shader_thread_shuffle */ +/* ---------------------- GL_NV_shadow_samplers_array ---------------------- */ + +#ifndef GL_NV_shadow_samplers_array +#define GL_NV_shadow_samplers_array 1 + +#define GL_SAMPLER_2D_ARRAY_SHADOW_NV 0x8DC4 + +#define GLEW_NV_shadow_samplers_array GLEW_GET_VAR(__GLEW_NV_shadow_samplers_array) + +#endif /* GL_NV_shadow_samplers_array */ + +/* ----------------------- GL_NV_shadow_samplers_cube ---------------------- */ + +#ifndef GL_NV_shadow_samplers_cube +#define GL_NV_shadow_samplers_cube 1 + +#define GL_SAMPLER_CUBE_SHADOW_NV 0x8DC5 + +#define GLEW_NV_shadow_samplers_cube GLEW_GET_VAR(__GLEW_NV_shadow_samplers_cube) + +#endif /* GL_NV_shadow_samplers_cube */ + /* ---------------------- GL_NV_stereo_view_rendering ---------------------- */ #ifndef GL_NV_stereo_view_rendering @@ -14417,6 +16434,37 @@ typedef void (GLAPIENTRY * PFNGLUNIFORMUI64VNVPROC) (GLint location, GLsizei cou #endif /* GL_NV_texgen_reflection */ +/* -------------------------- GL_NV_texture_array -------------------------- */ + +#ifndef GL_NV_texture_array +#define GL_NV_texture_array 1 + +#define GL_UNPACK_SKIP_IMAGES_NV 0x806D +#define GL_UNPACK_IMAGE_HEIGHT_NV 0x806E +#define GL_MAX_ARRAY_TEXTURE_LAYERS_NV 0x88FF +#define GL_TEXTURE_2D_ARRAY_NV 0x8C1A +#define GL_TEXTURE_BINDING_2D_ARRAY_NV 0x8C1D +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_NV 0x8CD4 +#define GL_SAMPLER_2D_ARRAY_NV 0x8DC1 + +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DNVPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC) (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 * PFNGLCOPYTEXSUBIMAGE3DNVPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERNVPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DNVPROC) (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DNVPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); + +#define glCompressedTexImage3DNV GLEW_GET_FUN(__glewCompressedTexImage3DNV) +#define glCompressedTexSubImage3DNV GLEW_GET_FUN(__glewCompressedTexSubImage3DNV) +#define glCopyTexSubImage3DNV GLEW_GET_FUN(__glewCopyTexSubImage3DNV) +#define glFramebufferTextureLayerNV GLEW_GET_FUN(__glewFramebufferTextureLayerNV) +#define glTexImage3DNV GLEW_GET_FUN(__glewTexImage3DNV) +#define glTexSubImage3DNV GLEW_GET_FUN(__glewTexSubImage3DNV) + +#define GLEW_NV_texture_array GLEW_GET_VAR(__GLEW_NV_texture_array) + +#endif /* GL_NV_texture_array */ + /* ------------------------- GL_NV_texture_barrier ------------------------- */ #ifndef GL_NV_texture_barrier @@ -14430,6 +16478,55 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREBARRIERNVPROC) (void); #endif /* GL_NV_texture_barrier */ +/* ----------------------- GL_NV_texture_border_clamp ---------------------- */ + +#ifndef GL_NV_texture_border_clamp +#define GL_NV_texture_border_clamp 1 + +#define GL_TEXTURE_BORDER_COLOR_NV 0x1004 +#define GL_CLAMP_TO_BORDER_NV 0x812D + +#define GLEW_NV_texture_border_clamp GLEW_GET_VAR(__GLEW_NV_texture_border_clamp) + +#endif /* GL_NV_texture_border_clamp */ + +/* --------------------- GL_NV_texture_compression_latc -------------------- */ + +#ifndef GL_NV_texture_compression_latc +#define GL_NV_texture_compression_latc 1 + +#define GL_COMPRESSED_LUMINANCE_LATC1_NV 0x8C70 +#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_NV 0x8C71 +#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_NV 0x8C72 +#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_NV 0x8C73 + +#define GLEW_NV_texture_compression_latc GLEW_GET_VAR(__GLEW_NV_texture_compression_latc) + +#endif /* GL_NV_texture_compression_latc */ + +/* --------------------- GL_NV_texture_compression_s3tc -------------------- */ + +#ifndef GL_NV_texture_compression_s3tc +#define GL_NV_texture_compression_s3tc 1 + +#define GL_COMPRESSED_RGB_S3TC_DXT1_NV 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_NV 0x83F1 +#define GL_COMPRESSED_RGBA_S3TC_DXT3_NV 0x83F2 +#define GL_COMPRESSED_RGBA_S3TC_DXT5_NV 0x83F3 + +#define GLEW_NV_texture_compression_s3tc GLEW_GET_VAR(__GLEW_NV_texture_compression_s3tc) + +#endif /* GL_NV_texture_compression_s3tc */ + +/* ----------------- GL_NV_texture_compression_s3tc_update ----------------- */ + +#ifndef GL_NV_texture_compression_s3tc_update +#define GL_NV_texture_compression_s3tc_update 1 + +#define GLEW_NV_texture_compression_s3tc_update GLEW_GET_VAR(__GLEW_NV_texture_compression_s3tc_update) + +#endif /* GL_NV_texture_compression_s3tc_update */ + /* --------------------- GL_NV_texture_compression_vtc --------------------- */ #ifndef GL_NV_texture_compression_vtc @@ -14491,6 +16588,15 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture #endif /* GL_NV_texture_multisample */ +/* ---------------------- GL_NV_texture_npot_2D_mipmap --------------------- */ + +#ifndef GL_NV_texture_npot_2D_mipmap +#define GL_NV_texture_npot_2D_mipmap 1 + +#define GLEW_NV_texture_npot_2D_mipmap GLEW_GET_VAR(__GLEW_NV_texture_npot_2D_mipmap) + +#endif /* GL_NV_texture_npot_2D_mipmap */ + /* ------------------------ GL_NV_texture_rectangle ------------------------ */ #ifndef GL_NV_texture_rectangle @@ -14505,6 +16611,15 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DMULTISAMPLENVPROC) (GLuint texture #endif /* GL_NV_texture_rectangle */ +/* ------------------- GL_NV_texture_rectangle_compressed ------------------ */ + +#ifndef GL_NV_texture_rectangle_compressed +#define GL_NV_texture_rectangle_compressed 1 + +#define GLEW_NV_texture_rectangle_compressed GLEW_GET_VAR(__GLEW_NV_texture_rectangle_compressed) + +#endif /* GL_NV_texture_rectangle_compressed */ + /* -------------------------- GL_NV_texture_shader ------------------------- */ #ifndef GL_NV_texture_shader @@ -15278,6 +17393,50 @@ typedef void (GLAPIENTRY * PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC) (GLuint vid #endif /* GL_NV_video_capture */ +/* -------------------------- GL_NV_viewport_array ------------------------- */ + +#ifndef GL_NV_viewport_array +#define GL_NV_viewport_array 1 + +#define GL_DEPTH_RANGE 0x0B70 +#define GL_VIEWPORT 0x0BA2 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_MAX_VIEWPORTS_NV 0x825B +#define GL_VIEWPORT_SUBPIXEL_BITS_NV 0x825C +#define GL_VIEWPORT_BOUNDS_RANGE_NV 0x825D +#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV 0x825F + +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEARRAYFVNVPROC) (GLuint first, GLsizei count, const GLfloat * v); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEINDEXEDFNVPROC) (GLuint index, GLfloat n, GLfloat f); +typedef void (GLAPIENTRY * PFNGLDISABLEINVPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEINVPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLGETFLOATI_VNVPROC) (GLenum target, GLuint index, GLfloat* data); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINVPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLSCISSORARRAYVNVPROC) (GLuint first, GLsizei count, const GLint * v); +typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDNVPROC) (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLSCISSORINDEXEDVNVPROC) (GLuint index, const GLint * v); +typedef void (GLAPIENTRY * PFNGLVIEWPORTARRAYVNVPROC) (GLuint first, GLsizei count, const GLfloat * v); +typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h); +typedef void (GLAPIENTRY * PFNGLVIEWPORTINDEXEDFVNVPROC) (GLuint index, const GLfloat * v); + +#define glDepthRangeArrayfvNV GLEW_GET_FUN(__glewDepthRangeArrayfvNV) +#define glDepthRangeIndexedfNV GLEW_GET_FUN(__glewDepthRangeIndexedfNV) +#define glDisableiNV GLEW_GET_FUN(__glewDisableiNV) +#define glEnableiNV GLEW_GET_FUN(__glewEnableiNV) +#define glGetFloati_vNV GLEW_GET_FUN(__glewGetFloati_vNV) +#define glIsEnablediNV GLEW_GET_FUN(__glewIsEnablediNV) +#define glScissorArrayvNV GLEW_GET_FUN(__glewScissorArrayvNV) +#define glScissorIndexedNV GLEW_GET_FUN(__glewScissorIndexedNV) +#define glScissorIndexedvNV GLEW_GET_FUN(__glewScissorIndexedvNV) +#define glViewportArrayvNV GLEW_GET_FUN(__glewViewportArrayvNV) +#define glViewportIndexedfNV GLEW_GET_FUN(__glewViewportIndexedfNV) +#define glViewportIndexedfvNV GLEW_GET_FUN(__glewViewportIndexedfvNV) + +#define GLEW_NV_viewport_array GLEW_GET_VAR(__GLEW_NV_viewport_array) + +#endif /* GL_NV_viewport_array */ + /* ------------------------- GL_NV_viewport_array2 ------------------------- */ #ifndef GL_NV_viewport_array2 @@ -15322,61 +17481,6 @@ typedef void (GLAPIENTRY * PFNGLVIEWPORTSWIZZLENVPROC) (GLuint index, GLenum swi #endif /* GL_OES_byte_coordinates */ -/* ------------------- 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_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_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_OML_interlace --------------------------- */ #ifndef GL_OML_interlace @@ -15444,6 +17548,19 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum targ #endif /* GL_OVR_multiview2 */ +/* ------------ GL_OVR_multiview_multisampled_render_to_texture ------------ */ + +#ifndef GL_OVR_multiview_multisampled_render_to_texture +#define GL_OVR_multiview_multisampled_render_to_texture 1 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLsizei samples, GLint baseViewIndex, GLsizei numViews); + +#define glFramebufferTextureMultisampleMultiviewOVR GLEW_GET_FUN(__glewFramebufferTextureMultisampleMultiviewOVR) + +#define GLEW_OVR_multiview_multisampled_render_to_texture GLEW_GET_VAR(__GLEW_OVR_multiview_multisampled_render_to_texture) + +#endif /* GL_OVR_multiview_multisampled_render_to_texture */ + /* --------------------------- GL_PGI_misc_hints --------------------------- */ #ifndef GL_PGI_misc_hints @@ -15506,6 +17623,218 @@ typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC) (GLenum targ #endif /* GL_PGI_vertex_hints */ +/* --------------------------- GL_QCOM_alpha_test -------------------------- */ + +#ifndef GL_QCOM_alpha_test +#define GL_QCOM_alpha_test 1 + +#define GL_ALPHA_TEST_QCOM 0x0BC0 +#define GL_ALPHA_TEST_FUNC_QCOM 0x0BC1 +#define GL_ALPHA_TEST_REF_QCOM 0x0BC2 + +typedef void (GLAPIENTRY * PFNGLALPHAFUNCQCOMPROC) (GLenum func, GLclampf ref); + +#define glAlphaFuncQCOM GLEW_GET_FUN(__glewAlphaFuncQCOM) + +#define GLEW_QCOM_alpha_test GLEW_GET_VAR(__GLEW_QCOM_alpha_test) + +#endif /* GL_QCOM_alpha_test */ + +/* ------------------------ GL_QCOM_binning_control ------------------------ */ + +#ifndef GL_QCOM_binning_control +#define GL_QCOM_binning_control 1 + +#define GL_DONT_CARE 0x1100 +#define GL_BINNING_CONTROL_HINT_QCOM 0x8FB0 +#define GL_CPU_OPTIMIZED_QCOM 0x8FB1 +#define GL_GPU_OPTIMIZED_QCOM 0x8FB2 +#define GL_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM 0x8FB3 + +#define GLEW_QCOM_binning_control GLEW_GET_VAR(__GLEW_QCOM_binning_control) + +#endif /* GL_QCOM_binning_control */ + +/* ------------------------- GL_QCOM_driver_control ------------------------ */ + +#ifndef GL_QCOM_driver_control +#define GL_QCOM_driver_control 1 + +typedef void (GLAPIENTRY * PFNGLDISABLEDRIVERCONTROLQCOMPROC) (GLuint driverControl); +typedef void (GLAPIENTRY * PFNGLENABLEDRIVERCONTROLQCOMPROC) (GLuint driverControl); +typedef void (GLAPIENTRY * PFNGLGETDRIVERCONTROLSTRINGQCOMPROC) (GLuint driverControl, GLsizei bufSize, GLsizei* length, GLchar *driverControlString); +typedef void (GLAPIENTRY * PFNGLGETDRIVERCONTROLSQCOMPROC) (GLint* num, GLsizei size, GLuint *driverControls); + +#define glDisableDriverControlQCOM GLEW_GET_FUN(__glewDisableDriverControlQCOM) +#define glEnableDriverControlQCOM GLEW_GET_FUN(__glewEnableDriverControlQCOM) +#define glGetDriverControlStringQCOM GLEW_GET_FUN(__glewGetDriverControlStringQCOM) +#define glGetDriverControlsQCOM GLEW_GET_FUN(__glewGetDriverControlsQCOM) + +#define GLEW_QCOM_driver_control GLEW_GET_VAR(__GLEW_QCOM_driver_control) + +#endif /* GL_QCOM_driver_control */ + +/* -------------------------- GL_QCOM_extended_get ------------------------- */ + +#ifndef GL_QCOM_extended_get +#define GL_QCOM_extended_get 1 + +#define GL_TEXTURE_WIDTH_QCOM 0x8BD2 +#define GL_TEXTURE_HEIGHT_QCOM 0x8BD3 +#define GL_TEXTURE_DEPTH_QCOM 0x8BD4 +#define GL_TEXTURE_INTERNAL_FORMAT_QCOM 0x8BD5 +#define GL_TEXTURE_FORMAT_QCOM 0x8BD6 +#define GL_TEXTURE_TYPE_QCOM 0x8BD7 +#define GL_TEXTURE_IMAGE_VALID_QCOM 0x8BD8 +#define GL_TEXTURE_NUM_LEVELS_QCOM 0x8BD9 +#define GL_TEXTURE_TARGET_QCOM 0x8BDA +#define GL_TEXTURE_OBJECT_VALID_QCOM 0x8BDB +#define GL_STATE_RESTORE 0x8BDC + +typedef void (GLAPIENTRY * PFNGLEXTGETBUFFERPOINTERVQCOMPROC) (GLenum target, void** params); +typedef void (GLAPIENTRY * PFNGLEXTGETBUFFERSQCOMPROC) (GLuint* buffers, GLint maxBuffers, GLint* numBuffers); +typedef void (GLAPIENTRY * PFNGLEXTGETFRAMEBUFFERSQCOMPROC) (GLuint* framebuffers, GLint maxFramebuffers, GLint* numFramebuffers); +typedef void (GLAPIENTRY * PFNGLEXTGETRENDERBUFFERSQCOMPROC) (GLuint* renderbuffers, GLint maxRenderbuffers, GLint* numRenderbuffers); +typedef void (GLAPIENTRY * PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC) (GLuint texture, GLenum face, GLint level, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLEXTGETTEXSUBIMAGEQCOMPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, void *texels); +typedef void (GLAPIENTRY * PFNGLEXTGETTEXTURESQCOMPROC) (GLuint* textures, GLint maxTextures, GLint* numTextures); +typedef void (GLAPIENTRY * PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC) (GLenum target, GLenum pname, GLint param); + +#define glExtGetBufferPointervQCOM GLEW_GET_FUN(__glewExtGetBufferPointervQCOM) +#define glExtGetBuffersQCOM GLEW_GET_FUN(__glewExtGetBuffersQCOM) +#define glExtGetFramebuffersQCOM GLEW_GET_FUN(__glewExtGetFramebuffersQCOM) +#define glExtGetRenderbuffersQCOM GLEW_GET_FUN(__glewExtGetRenderbuffersQCOM) +#define glExtGetTexLevelParameterivQCOM GLEW_GET_FUN(__glewExtGetTexLevelParameterivQCOM) +#define glExtGetTexSubImageQCOM GLEW_GET_FUN(__glewExtGetTexSubImageQCOM) +#define glExtGetTexturesQCOM GLEW_GET_FUN(__glewExtGetTexturesQCOM) +#define glExtTexObjectStateOverrideiQCOM GLEW_GET_FUN(__glewExtTexObjectStateOverrideiQCOM) + +#define GLEW_QCOM_extended_get GLEW_GET_VAR(__GLEW_QCOM_extended_get) + +#endif /* GL_QCOM_extended_get */ + +/* ------------------------- GL_QCOM_extended_get2 ------------------------- */ + +#ifndef GL_QCOM_extended_get2 +#define GL_QCOM_extended_get2 1 + +typedef void (GLAPIENTRY * PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC) (GLuint program, GLenum shadertype, GLchar* source, GLint* length); +typedef void (GLAPIENTRY * PFNGLEXTGETPROGRAMSQCOMPROC) (GLuint* programs, GLint maxPrograms, GLint* numPrograms); +typedef void (GLAPIENTRY * PFNGLEXTGETSHADERSQCOMPROC) (GLuint* shaders, GLint maxShaders, GLint* numShaders); +typedef GLboolean (GLAPIENTRY * PFNGLEXTISPROGRAMBINARYQCOMPROC) (GLuint program); + +#define glExtGetProgramBinarySourceQCOM GLEW_GET_FUN(__glewExtGetProgramBinarySourceQCOM) +#define glExtGetProgramsQCOM GLEW_GET_FUN(__glewExtGetProgramsQCOM) +#define glExtGetShadersQCOM GLEW_GET_FUN(__glewExtGetShadersQCOM) +#define glExtIsProgramBinaryQCOM GLEW_GET_FUN(__glewExtIsProgramBinaryQCOM) + +#define GLEW_QCOM_extended_get2 GLEW_GET_VAR(__GLEW_QCOM_extended_get2) + +#endif /* GL_QCOM_extended_get2 */ + +/* ---------------------- GL_QCOM_framebuffer_foveated --------------------- */ + +#ifndef GL_QCOM_framebuffer_foveated +#define GL_QCOM_framebuffer_foveated 1 + +#define GL_FOVEATION_ENABLE_BIT_QCOM 0x1 +#define GL_FOVEATION_SCALED_BIN_METHOD_BIT_QCOM 0x2 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC) (GLuint fbo, GLuint numLayers, GLuint focalPointsPerLayer, GLuint requestedFeatures, GLuint* providedFeatures); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC) (GLuint fbo, GLuint layer, GLuint focalPoint, GLfloat focalX, GLfloat focalY, GLfloat gainX, GLfloat gainY, GLfloat foveaArea); + +#define glFramebufferFoveationConfigQCOM GLEW_GET_FUN(__glewFramebufferFoveationConfigQCOM) +#define glFramebufferFoveationParametersQCOM GLEW_GET_FUN(__glewFramebufferFoveationParametersQCOM) + +#define GLEW_QCOM_framebuffer_foveated GLEW_GET_VAR(__GLEW_QCOM_framebuffer_foveated) + +#endif /* GL_QCOM_framebuffer_foveated */ + +/* ---------------------- GL_QCOM_perfmon_global_mode ---------------------- */ + +#ifndef GL_QCOM_perfmon_global_mode +#define GL_QCOM_perfmon_global_mode 1 + +#define GL_PERFMON_GLOBAL_MODE_QCOM 0x8FA0 + +#define GLEW_QCOM_perfmon_global_mode GLEW_GET_VAR(__GLEW_QCOM_perfmon_global_mode) + +#endif /* GL_QCOM_perfmon_global_mode */ + +/* -------------- GL_QCOM_shader_framebuffer_fetch_noncoherent ------------- */ + +#ifndef GL_QCOM_shader_framebuffer_fetch_noncoherent +#define GL_QCOM_shader_framebuffer_fetch_noncoherent 1 + +#define GL_FRAMEBUFFER_FETCH_NONCOHERENT_QCOM 0x96A2 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC) (void); + +#define glFramebufferFetchBarrierQCOM GLEW_GET_FUN(__glewFramebufferFetchBarrierQCOM) + +#define GLEW_QCOM_shader_framebuffer_fetch_noncoherent GLEW_GET_VAR(__GLEW_QCOM_shader_framebuffer_fetch_noncoherent) + +#endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ + +/* ------------------------ GL_QCOM_tiled_rendering ------------------------ */ + +#ifndef GL_QCOM_tiled_rendering +#define GL_QCOM_tiled_rendering 1 + +#define GL_COLOR_BUFFER_BIT0_QCOM 0x00000001 +#define GL_COLOR_BUFFER_BIT1_QCOM 0x00000002 +#define GL_COLOR_BUFFER_BIT2_QCOM 0x00000004 +#define GL_COLOR_BUFFER_BIT3_QCOM 0x00000008 +#define GL_COLOR_BUFFER_BIT4_QCOM 0x00000010 +#define GL_COLOR_BUFFER_BIT5_QCOM 0x00000020 +#define GL_COLOR_BUFFER_BIT6_QCOM 0x00000040 +#define GL_COLOR_BUFFER_BIT7_QCOM 0x00000080 +#define GL_DEPTH_BUFFER_BIT0_QCOM 0x00000100 +#define GL_DEPTH_BUFFER_BIT1_QCOM 0x00000200 +#define GL_DEPTH_BUFFER_BIT2_QCOM 0x00000400 +#define GL_DEPTH_BUFFER_BIT3_QCOM 0x00000800 +#define GL_DEPTH_BUFFER_BIT4_QCOM 0x00001000 +#define GL_DEPTH_BUFFER_BIT5_QCOM 0x00002000 +#define GL_DEPTH_BUFFER_BIT6_QCOM 0x00004000 +#define GL_DEPTH_BUFFER_BIT7_QCOM 0x00008000 +#define GL_STENCIL_BUFFER_BIT0_QCOM 0x00010000 +#define GL_STENCIL_BUFFER_BIT1_QCOM 0x00020000 +#define GL_STENCIL_BUFFER_BIT2_QCOM 0x00040000 +#define GL_STENCIL_BUFFER_BIT3_QCOM 0x00080000 +#define GL_STENCIL_BUFFER_BIT4_QCOM 0x00100000 +#define GL_STENCIL_BUFFER_BIT5_QCOM 0x00200000 +#define GL_STENCIL_BUFFER_BIT6_QCOM 0x00400000 +#define GL_STENCIL_BUFFER_BIT7_QCOM 0x00800000 +#define GL_MULTISAMPLE_BUFFER_BIT0_QCOM 0x01000000 +#define GL_MULTISAMPLE_BUFFER_BIT1_QCOM 0x02000000 +#define GL_MULTISAMPLE_BUFFER_BIT2_QCOM 0x04000000 +#define GL_MULTISAMPLE_BUFFER_BIT3_QCOM 0x08000000 +#define GL_MULTISAMPLE_BUFFER_BIT4_QCOM 0x10000000 +#define GL_MULTISAMPLE_BUFFER_BIT5_QCOM 0x20000000 +#define GL_MULTISAMPLE_BUFFER_BIT6_QCOM 0x40000000 +#define GL_MULTISAMPLE_BUFFER_BIT7_QCOM 0x80000000 + +typedef void (GLAPIENTRY * PFNGLENDTILINGQCOMPROC) (GLbitfield preserveMask); +typedef void (GLAPIENTRY * PFNGLSTARTTILINGQCOMPROC) (GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask); + +#define glEndTilingQCOM GLEW_GET_FUN(__glewEndTilingQCOM) +#define glStartTilingQCOM GLEW_GET_FUN(__glewStartTilingQCOM) + +#define GLEW_QCOM_tiled_rendering GLEW_GET_VAR(__GLEW_QCOM_tiled_rendering) + +#endif /* GL_QCOM_tiled_rendering */ + +/* ---------------------- GL_QCOM_writeonly_rendering ---------------------- */ + +#ifndef GL_QCOM_writeonly_rendering +#define GL_QCOM_writeonly_rendering 1 + +#define GL_WRITEONLY_RENDERING_QCOM 0x8823 + +#define GLEW_QCOM_writeonly_rendering GLEW_GET_VAR(__GLEW_QCOM_writeonly_rendering) + +#endif /* GL_QCOM_writeonly_rendering */ + /* ---------------------- GL_REGAL_ES1_0_compatibility --------------------- */ #ifndef GL_REGAL_ES1_0_compatibility @@ -15732,6 +18061,15 @@ typedef void * (GLAPIENTRY * PFNGLGETPROCADDRESSREGALPROC) (const GLchar *name); #endif /* GL_S3_s3tc */ +/* ------------------------- GL_SGIS_clip_band_hint ------------------------ */ + +#ifndef GL_SGIS_clip_band_hint +#define GL_SGIS_clip_band_hint 1 + +#define GLEW_SGIS_clip_band_hint GLEW_GET_VAR(__GLEW_SGIS_clip_band_hint) + +#endif /* GL_SGIS_clip_band_hint */ + /* -------------------------- GL_SGIS_color_range -------------------------- */ #ifndef GL_SGIS_color_range @@ -15793,6 +18131,15 @@ typedef void (GLAPIENTRY * PFNGLGETFOGFUNCSGISPROC) (GLfloat* points); #endif /* GL_SGIS_generate_mipmap */ +/* -------------------------- GL_SGIS_line_texgen -------------------------- */ + +#ifndef GL_SGIS_line_texgen +#define GL_SGIS_line_texgen 1 + +#define GLEW_SGIS_line_texgen GLEW_GET_VAR(__GLEW_SGIS_line_texgen) + +#endif /* GL_SGIS_line_texgen */ + /* -------------------------- GL_SGIS_multisample -------------------------- */ #ifndef GL_SGIS_multisample @@ -15825,6 +18172,37 @@ typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); #endif /* GL_SGIS_multisample */ +/* -------------------------- GL_SGIS_multitexture ------------------------- */ + +#ifndef GL_SGIS_multitexture +#define GL_SGIS_multitexture 1 + +#define GL_SELECTED_TEXTURE_SGIS 0x83C0 +#define GL_SELECTED_TEXTURE_COORD_SET_SGIS 0x83C1 +#define GL_SELECTED_TEXTURE_TRANSFORM_SGIS 0x83C2 +#define GL_MAX_TEXTURES_SGIS 0x83C3 +#define GL_MAX_TEXTURE_COORD_SETS_SGIS 0x83C4 +#define GL_TEXTURE_COORD_SET_INTERLEAVE_FACTOR_SGIS 0x83C5 +#define GL_TEXTURE_ENV_COORD_SET_SGIS 0x83C6 +#define GL_TEXTURE0_SGIS 0x83C7 +#define GL_TEXTURE1_SGIS 0x83C8 +#define GL_TEXTURE2_SGIS 0x83C9 +#define GL_TEXTURE3_SGIS 0x83CA + +typedef void (GLAPIENTRY * PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC) (GLint factor); +typedef void (GLAPIENTRY * PFNGLSELECTTEXTURECOORDSETSGISPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLSELECTTEXTURESGISPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLSELECTTEXTURETRANSFORMSGISPROC) (GLenum target); + +#define glInterleavedTextureCoordSetsSGIS GLEW_GET_FUN(__glewInterleavedTextureCoordSetsSGIS) +#define glSelectTextureCoordSetSGIS GLEW_GET_FUN(__glewSelectTextureCoordSetSGIS) +#define glSelectTextureSGIS GLEW_GET_FUN(__glewSelectTextureSGIS) +#define glSelectTextureTransformSGIS GLEW_GET_FUN(__glewSelectTextureTransformSGIS) + +#define GLEW_SGIS_multitexture GLEW_GET_VAR(__GLEW_SGIS_multitexture) + +#endif /* GL_SGIS_multitexture */ + /* ------------------------- GL_SGIS_pixel_texture ------------------------- */ #ifndef GL_SGIS_pixel_texture @@ -15852,6 +18230,19 @@ typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); #endif /* GL_SGIS_point_line_texgen */ +/* ----------------------- GL_SGIS_shared_multisample ---------------------- */ + +#ifndef GL_SGIS_shared_multisample +#define GL_SGIS_shared_multisample 1 + +typedef void (GLAPIENTRY * PFNGLMULTISAMPLESUBRECTPOSSGISPROC) (GLint x, GLint y); + +#define glMultisampleSubRectPosSGIS GLEW_GET_FUN(__glewMultisampleSubRectPosSGIS) + +#define GLEW_SGIS_shared_multisample GLEW_GET_VAR(__GLEW_SGIS_shared_multisample) + +#endif /* GL_SGIS_shared_multisample */ + /* ------------------------ GL_SGIS_sharpen_texture ------------------------ */ #ifndef GL_SGIS_sharpen_texture @@ -15995,6 +18386,42 @@ typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #endif /* GL_SGIX_async_pixel */ +/* ----------------------- GL_SGIX_bali_g_instruments ---------------------- */ + +#ifndef GL_SGIX_bali_g_instruments +#define GL_SGIX_bali_g_instruments 1 + +#define GL_BALI_NUM_TRIS_CULLED_INSTRUMENT 0x6080 +#define GL_BALI_NUM_PRIMS_CLIPPED_INSTRUMENT 0x6081 +#define GL_BALI_NUM_PRIMS_REJECT_INSTRUMENT 0x6082 +#define GL_BALI_NUM_PRIMS_CLIP_RESULT_INSTRUMENT 0x6083 + +#define GLEW_SGIX_bali_g_instruments GLEW_GET_VAR(__GLEW_SGIX_bali_g_instruments) + +#endif /* GL_SGIX_bali_g_instruments */ + +/* ----------------------- GL_SGIX_bali_r_instruments ---------------------- */ + +#ifndef GL_SGIX_bali_r_instruments +#define GL_SGIX_bali_r_instruments 1 + +#define GL_BALI_FRAGMENTS_GENERATED_INSTRUMENT 0x6090 +#define GL_BALI_DEPTH_PASS_INSTRUMENT 0x6091 +#define GL_BALI_R_CHIP_COUNT 0x6092 + +#define GLEW_SGIX_bali_r_instruments GLEW_GET_VAR(__GLEW_SGIX_bali_r_instruments) + +#endif /* GL_SGIX_bali_r_instruments */ + +/* --------------------- GL_SGIX_bali_timer_instruments -------------------- */ + +#ifndef GL_SGIX_bali_timer_instruments +#define GL_SGIX_bali_timer_instruments 1 + +#define GLEW_SGIX_bali_timer_instruments GLEW_GET_VAR(__GLEW_SGIX_bali_timer_instruments) + +#endif /* GL_SGIX_bali_timer_instruments */ + /* ----------------------- GL_SGIX_blend_alpha_minmax ---------------------- */ #ifndef GL_SGIX_blend_alpha_minmax @@ -16007,6 +18434,37 @@ typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #endif /* GL_SGIX_blend_alpha_minmax */ +/* --------------------------- GL_SGIX_blend_cadd -------------------------- */ + +#ifndef GL_SGIX_blend_cadd +#define GL_SGIX_blend_cadd 1 + +#define GL_FUNC_COMPLEX_ADD_EXT 0x601C + +#define GLEW_SGIX_blend_cadd GLEW_GET_VAR(__GLEW_SGIX_blend_cadd) + +#endif /* GL_SGIX_blend_cadd */ + +/* ------------------------ GL_SGIX_blend_cmultiply ------------------------ */ + +#ifndef GL_SGIX_blend_cmultiply +#define GL_SGIX_blend_cmultiply 1 + +#define GL_FUNC_COMPLEX_MULTIPLY_EXT 0x601B + +#define GLEW_SGIX_blend_cmultiply GLEW_GET_VAR(__GLEW_SGIX_blend_cmultiply) + +#endif /* GL_SGIX_blend_cmultiply */ + +/* --------------------- GL_SGIX_calligraphic_fragment --------------------- */ + +#ifndef GL_SGIX_calligraphic_fragment +#define GL_SGIX_calligraphic_fragment 1 + +#define GLEW_SGIX_calligraphic_fragment GLEW_GET_VAR(__GLEW_SGIX_calligraphic_fragment) + +#endif /* GL_SGIX_calligraphic_fragment */ + /* ---------------------------- GL_SGIX_clipmap ---------------------------- */ #ifndef GL_SGIX_clipmap @@ -16016,6 +18474,35 @@ typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #endif /* GL_SGIX_clipmap */ +/* --------------------- GL_SGIX_color_matrix_accuracy --------------------- */ + +#ifndef GL_SGIX_color_matrix_accuracy +#define GL_SGIX_color_matrix_accuracy 1 + +#define GL_COLOR_MATRIX_HINT 0x8317 + +#define GLEW_SGIX_color_matrix_accuracy GLEW_GET_VAR(__GLEW_SGIX_color_matrix_accuracy) + +#endif /* GL_SGIX_color_matrix_accuracy */ + +/* --------------------- GL_SGIX_color_table_index_mode -------------------- */ + +#ifndef GL_SGIX_color_table_index_mode +#define GL_SGIX_color_table_index_mode 1 + +#define GLEW_SGIX_color_table_index_mode GLEW_GET_VAR(__GLEW_SGIX_color_table_index_mode) + +#endif /* GL_SGIX_color_table_index_mode */ + +/* ------------------------- GL_SGIX_complex_polar ------------------------- */ + +#ifndef GL_SGIX_complex_polar +#define GL_SGIX_complex_polar 1 + +#define GLEW_SGIX_complex_polar GLEW_GET_VAR(__GLEW_SGIX_complex_polar) + +#endif /* GL_SGIX_complex_polar */ + /* ---------------------- GL_SGIX_convolution_accuracy --------------------- */ #ifndef GL_SGIX_convolution_accuracy @@ -16027,6 +18514,74 @@ typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #endif /* GL_SGIX_convolution_accuracy */ +/* ---------------------------- GL_SGIX_cube_map --------------------------- */ + +#ifndef GL_SGIX_cube_map +#define GL_SGIX_cube_map 1 + +#define GL_ENV_MAP_SGIX 0x8340 +#define GL_CUBE_MAP_SGIX 0x8341 +#define GL_CUBE_MAP_ZP_SGIX 0x8342 +#define GL_CUBE_MAP_ZN_SGIX 0x8343 +#define GL_CUBE_MAP_XN_SGIX 0x8344 +#define GL_CUBE_MAP_XP_SGIX 0x8345 +#define GL_CUBE_MAP_YN_SGIX 0x8346 +#define GL_CUBE_MAP_YP_SGIX 0x8347 +#define GL_CUBE_MAP_BINDING_SGIX 0x8348 + +#define GLEW_SGIX_cube_map GLEW_GET_VAR(__GLEW_SGIX_cube_map) + +#endif /* GL_SGIX_cube_map */ + +/* ------------------------ GL_SGIX_cylinder_texgen ------------------------ */ + +#ifndef GL_SGIX_cylinder_texgen +#define GL_SGIX_cylinder_texgen 1 + +#define GLEW_SGIX_cylinder_texgen GLEW_GET_VAR(__GLEW_SGIX_cylinder_texgen) + +#endif /* GL_SGIX_cylinder_texgen */ + +/* ---------------------------- GL_SGIX_datapipe --------------------------- */ + +#ifndef GL_SGIX_datapipe +#define GL_SGIX_datapipe 1 + +#define GL_GEOMETRY_BIT 0x1 +#define GL_IMAGE_BIT 0x2 + +typedef void (GLAPIENTRY * PFNGLADDRESSSPACEPROC) (GLenum space, GLbitfield mask); +typedef GLint (GLAPIENTRY * PFNGLDATAPIPEPROC) (GLenum space); + +#define glAddressSpace GLEW_GET_FUN(__glewAddressSpace) +#define glDataPipe GLEW_GET_FUN(__glewDataPipe) + +#define GLEW_SGIX_datapipe GLEW_GET_VAR(__GLEW_SGIX_datapipe) + +#endif /* GL_SGIX_datapipe */ + +/* --------------------------- GL_SGIX_decimation -------------------------- */ + +#ifndef GL_SGIX_decimation +#define GL_SGIX_decimation 1 + +#define GLEW_SGIX_decimation GLEW_GET_VAR(__GLEW_SGIX_decimation) + +#endif /* GL_SGIX_decimation */ + +/* --------------------- GL_SGIX_depth_pass_instrument --------------------- */ + +#ifndef GL_SGIX_depth_pass_instrument +#define GL_SGIX_depth_pass_instrument 1 + +#define GL_DEPTH_PASS_INSTRUMENT_SGIX 0x8310 +#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311 +#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312 + +#define GLEW_SGIX_depth_pass_instrument GLEW_GET_VAR(__GLEW_SGIX_depth_pass_instrument) + +#endif /* GL_SGIX_depth_pass_instrument */ + /* ------------------------- GL_SGIX_depth_texture ------------------------- */ #ifndef GL_SGIX_depth_texture @@ -16040,6 +18595,15 @@ typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); #endif /* GL_SGIX_depth_texture */ +/* ------------------------------ GL_SGIX_dvc ------------------------------ */ + +#ifndef GL_SGIX_dvc +#define GL_SGIX_dvc 1 + +#define GLEW_SGIX_dvc GLEW_GET_VAR(__GLEW_SGIX_dvc) + +#endif /* GL_SGIX_dvc */ + /* -------------------------- GL_SGIX_flush_raster ------------------------- */ #ifndef GL_SGIX_flush_raster @@ -16053,6 +18617,49 @@ typedef void (GLAPIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void); #endif /* GL_SGIX_flush_raster */ +/* --------------------------- GL_SGIX_fog_blend --------------------------- */ + +#ifndef GL_SGIX_fog_blend +#define GL_SGIX_fog_blend 1 + +#define GL_FOG_BLEND_ALPHA_SGIX 0x81FE +#define GL_FOG_BLEND_COLOR_SGIX 0x81FF + +#define GLEW_SGIX_fog_blend GLEW_GET_VAR(__GLEW_SGIX_fog_blend) + +#endif /* GL_SGIX_fog_blend */ + +/* ---------------------- GL_SGIX_fog_factor_to_alpha ---------------------- */ + +#ifndef GL_SGIX_fog_factor_to_alpha +#define GL_SGIX_fog_factor_to_alpha 1 + +#define GLEW_SGIX_fog_factor_to_alpha GLEW_GET_VAR(__GLEW_SGIX_fog_factor_to_alpha) + +#endif /* GL_SGIX_fog_factor_to_alpha */ + +/* --------------------------- GL_SGIX_fog_layers -------------------------- */ + +#ifndef GL_SGIX_fog_layers +#define GL_SGIX_fog_layers 1 + +#define GL_FOG_TYPE_SGIX 0x8323 +#define GL_UNIFORM_SGIX 0x8324 +#define GL_LAYERED_SGIX 0x8325 +#define GL_FOG_GROUND_PLANE_SGIX 0x8326 +#define GL_FOG_LAYERS_POINTS_SGIX 0x8327 +#define GL_MAX_FOG_LAYERS_POINTS_SGIX 0x8328 + +typedef void (GLAPIENTRY * PFNGLFOGLAYERSSGIXPROC) (GLsizei n, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLGETFOGLAYERSSGIXPROC) (GLfloat* points); + +#define glFogLayersSGIX GLEW_GET_FUN(__glewFogLayersSGIX) +#define glGetFogLayersSGIX GLEW_GET_FUN(__glewGetFogLayersSGIX) + +#define GLEW_SGIX_fog_layers GLEW_GET_VAR(__GLEW_SGIX_fog_layers) + +#endif /* GL_SGIX_fog_layers */ + /* --------------------------- GL_SGIX_fog_offset -------------------------- */ #ifndef GL_SGIX_fog_offset @@ -16065,6 +18672,27 @@ typedef void (GLAPIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void); #endif /* GL_SGIX_fog_offset */ +/* --------------------------- GL_SGIX_fog_patchy -------------------------- */ + +#ifndef GL_SGIX_fog_patchy +#define GL_SGIX_fog_patchy 1 + +#define GLEW_SGIX_fog_patchy GLEW_GET_VAR(__GLEW_SGIX_fog_patchy) + +#endif /* GL_SGIX_fog_patchy */ + +/* --------------------------- GL_SGIX_fog_scale --------------------------- */ + +#ifndef GL_SGIX_fog_scale +#define GL_SGIX_fog_scale 1 + +#define GL_FOG_SCALE_SGIX 0x81FC +#define GL_FOG_SCALE_VALUE_SGIX 0x81FD + +#define GLEW_SGIX_fog_scale GLEW_GET_VAR(__GLEW_SGIX_fog_scale) + +#endif /* GL_SGIX_fog_scale */ + /* -------------------------- GL_SGIX_fog_texture -------------------------- */ #ifndef GL_SGIX_fog_texture @@ -16078,6 +18706,20 @@ typedef void (GLAPIENTRY * PFNGLTEXTUREFOGSGIXPROC) (GLenum pname); #endif /* GL_SGIX_fog_texture */ +/* -------------------- GL_SGIX_fragment_lighting_space -------------------- */ + +#ifndef GL_SGIX_fragment_lighting_space +#define GL_SGIX_fragment_lighting_space 1 + +#define GL_EYE_SPACE_SGIX 0x8436 +#define GL_TANGENT_SPACE_SGIX 0x8437 +#define GL_OBJECT_SPACE_SGIX 0x8438 +#define GL_FRAGMENT_LIGHT_SPACE_SGIX 0x843D + +#define GLEW_SGIX_fragment_lighting_space GLEW_GET_VAR(__GLEW_SGIX_fragment_lighting_space) + +#endif /* GL_SGIX_fragment_lighting_space */ + /* ------------------- GL_SGIX_fragment_specular_lighting ------------------ */ #ifndef GL_SGIX_fragment_specular_lighting @@ -16123,6 +18765,19 @@ typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLe #endif /* GL_SGIX_fragment_specular_lighting */ +/* ---------------------- GL_SGIX_fragments_instrument --------------------- */ + +#ifndef GL_SGIX_fragments_instrument +#define GL_SGIX_fragments_instrument 1 + +#define GL_FRAGMENTS_INSTRUMENT_SGIX 0x8313 +#define GL_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX 0x8314 +#define GL_FRAGMENTS_INSTRUMENT_MAX_SGIX 0x8315 + +#define GLEW_SGIX_fragments_instrument GLEW_GET_VAR(__GLEW_SGIX_fragments_instrument) + +#endif /* GL_SGIX_fragments_instrument */ + /* --------------------------- GL_SGIX_framezoom --------------------------- */ #ifndef GL_SGIX_framezoom @@ -16136,6 +18791,77 @@ typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); #endif /* GL_SGIX_framezoom */ +/* -------------------------- GL_SGIX_icc_texture -------------------------- */ + +#ifndef GL_SGIX_icc_texture +#define GL_SGIX_icc_texture 1 + +#define GL_RGB_ICC_SGIX 0x8460 +#define GL_RGBA_ICC_SGIX 0x8461 +#define GL_ALPHA_ICC_SGIX 0x8462 +#define GL_LUMINANCE_ICC_SGIX 0x8463 +#define GL_INTENSITY_ICC_SGIX 0x8464 +#define GL_LUMINANCE_ALPHA_ICC_SGIX 0x8465 +#define GL_R5_G6_B5_ICC_SGIX 0x8466 +#define GL_R5_G6_B5_A8_ICC_SGIX 0x8467 +#define GL_ALPHA16_ICC_SGIX 0x8468 +#define GL_LUMINANCE16_ICC_SGIX 0x8469 +#define GL_INTENSITY16_ICC_SGIX 0x846A +#define GL_LUMINANCE16_ALPHA8_ICC_SGIX 0x846B + +#define GLEW_SGIX_icc_texture GLEW_GET_VAR(__GLEW_SGIX_icc_texture) + +#endif /* GL_SGIX_icc_texture */ + +/* ------------------------ GL_SGIX_igloo_interface ------------------------ */ + +#ifndef GL_SGIX_igloo_interface +#define GL_SGIX_igloo_interface 1 + +#define GL_IGLOO_FULLSCREEN_SGIX 0x819E +#define GL_IGLOO_VIEWPORT_OFFSET_SGIX 0x819F +#define GL_IGLOO_SWAPTMESH_SGIX 0x81A0 +#define GL_IGLOO_COLORNORMAL_SGIX 0x81A1 +#define GL_IGLOO_IRISGL_MODE_SGIX 0x81A2 +#define GL_IGLOO_LMC_COLOR_SGIX 0x81A3 +#define GL_IGLOO_TMESHMODE_SGIX 0x81A4 +#define GL_LIGHT31 0xBEAD + +typedef void (GLAPIENTRY * PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, void *param); + +#define glIglooInterfaceSGIX GLEW_GET_FUN(__glewIglooInterfaceSGIX) + +#define GLEW_SGIX_igloo_interface GLEW_GET_VAR(__GLEW_SGIX_igloo_interface) + +#endif /* GL_SGIX_igloo_interface */ + +/* ----------------------- GL_SGIX_image_compression ----------------------- */ + +#ifndef GL_SGIX_image_compression +#define GL_SGIX_image_compression 1 + +#define GLEW_SGIX_image_compression GLEW_GET_VAR(__GLEW_SGIX_image_compression) + +#endif /* GL_SGIX_image_compression */ + +/* ---------------------- GL_SGIX_impact_pixel_texture --------------------- */ + +#ifndef GL_SGIX_impact_pixel_texture +#define GL_SGIX_impact_pixel_texture 1 + +#define GLEW_SGIX_impact_pixel_texture GLEW_GET_VAR(__GLEW_SGIX_impact_pixel_texture) + +#endif /* GL_SGIX_impact_pixel_texture */ + +/* ------------------------ GL_SGIX_instrument_error ----------------------- */ + +#ifndef GL_SGIX_instrument_error +#define GL_SGIX_instrument_error 1 + +#define GLEW_SGIX_instrument_error GLEW_GET_VAR(__GLEW_SGIX_instrument_error) + +#endif /* GL_SGIX_instrument_error */ + /* --------------------------- GL_SGIX_interlace --------------------------- */ #ifndef GL_SGIX_interlace @@ -16156,6 +18882,17 @@ typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); #endif /* GL_SGIX_ir_instrument1 */ +/* ----------------------- GL_SGIX_line_quality_hint ----------------------- */ + +#ifndef GL_SGIX_line_quality_hint +#define GL_SGIX_line_quality_hint 1 + +#define GL_LINE_QUALITY_HINT_SGIX 0x835B + +#define GLEW_SGIX_line_quality_hint GLEW_GET_VAR(__GLEW_SGIX_line_quality_hint) + +#endif /* GL_SGIX_line_quality_hint */ + /* ------------------------- GL_SGIX_list_priority ------------------------- */ #ifndef GL_SGIX_list_priority @@ -16165,6 +18902,117 @@ typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); #endif /* GL_SGIX_list_priority */ +/* ----------------------------- GL_SGIX_mpeg1 ----------------------------- */ + +#ifndef GL_SGIX_mpeg1 +#define GL_SGIX_mpeg1 1 + +typedef void (GLAPIENTRY * PFNGLALLOCMPEGPREDICTORSSGIXPROC) (GLsizei width, GLsizei height, GLsizei n, GLuint* predictors); +typedef void (GLAPIENTRY * PFNGLDELETEMPEGPREDICTORSSGIXPROC) (GLsizei n, GLuint* predictors); +typedef void (GLAPIENTRY * PFNGLGENMPEGPREDICTORSSGIXPROC) (GLsizei n, GLuint* predictors); +typedef void (GLAPIENTRY * PFNGLGETMPEGPARAMETERFVSGIXPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMPEGPARAMETERIVSGIXPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMPEGPREDICTORSGIXPROC) (GLenum target, GLenum format, GLenum type, void *pixels); +typedef void (GLAPIENTRY * PFNGLGETMPEGQUANTTABLEUBVPROC) (GLenum target, GLubyte* values); +typedef GLboolean (GLAPIENTRY * PFNGLISMPEGPREDICTORSGIXPROC) (GLuint predictor); +typedef void (GLAPIENTRY * PFNGLMPEGPREDICTORSGIXPROC) (GLenum target, GLenum format, GLenum type, void *pixels); +typedef void (GLAPIENTRY * PFNGLMPEGQUANTTABLEUBVPROC) (GLenum target, GLubyte* values); +typedef void (GLAPIENTRY * PFNGLSWAPMPEGPREDICTORSSGIXPROC) (GLenum target0, GLenum target1); + +#define glAllocMPEGPredictorsSGIX GLEW_GET_FUN(__glewAllocMPEGPredictorsSGIX) +#define glDeleteMPEGPredictorsSGIX GLEW_GET_FUN(__glewDeleteMPEGPredictorsSGIX) +#define glGenMPEGPredictorsSGIX GLEW_GET_FUN(__glewGenMPEGPredictorsSGIX) +#define glGetMPEGParameterfvSGIX GLEW_GET_FUN(__glewGetMPEGParameterfvSGIX) +#define glGetMPEGParameterivSGIX GLEW_GET_FUN(__glewGetMPEGParameterivSGIX) +#define glGetMPEGPredictorSGIX GLEW_GET_FUN(__glewGetMPEGPredictorSGIX) +#define glGetMPEGQuantTableubv GLEW_GET_FUN(__glewGetMPEGQuantTableubv) +#define glIsMPEGPredictorSGIX GLEW_GET_FUN(__glewIsMPEGPredictorSGIX) +#define glMPEGPredictorSGIX GLEW_GET_FUN(__glewMPEGPredictorSGIX) +#define glMPEGQuantTableubv GLEW_GET_FUN(__glewMPEGQuantTableubv) +#define glSwapMPEGPredictorsSGIX GLEW_GET_FUN(__glewSwapMPEGPredictorsSGIX) + +#define GLEW_SGIX_mpeg1 GLEW_GET_VAR(__GLEW_SGIX_mpeg1) + +#endif /* GL_SGIX_mpeg1 */ + +/* ----------------------------- GL_SGIX_mpeg2 ----------------------------- */ + +#ifndef GL_SGIX_mpeg2 +#define GL_SGIX_mpeg2 1 + +#define GLEW_SGIX_mpeg2 GLEW_GET_VAR(__GLEW_SGIX_mpeg2) + +#endif /* GL_SGIX_mpeg2 */ + +/* ------------------ GL_SGIX_nonlinear_lighting_pervertex ----------------- */ + +#ifndef GL_SGIX_nonlinear_lighting_pervertex +#define GL_SGIX_nonlinear_lighting_pervertex 1 + +typedef void (GLAPIENTRY * PFNGLGETNONLINLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLint* terms, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETNONLINMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLint* terms, const GLfloat *data); +typedef void (GLAPIENTRY * PFNGLNONLINLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLint terms, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLNONLINMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLint terms, const GLfloat* params); + +#define glGetNonlinLightfvSGIX GLEW_GET_FUN(__glewGetNonlinLightfvSGIX) +#define glGetNonlinMaterialfvSGIX GLEW_GET_FUN(__glewGetNonlinMaterialfvSGIX) +#define glNonlinLightfvSGIX GLEW_GET_FUN(__glewNonlinLightfvSGIX) +#define glNonlinMaterialfvSGIX GLEW_GET_FUN(__glewNonlinMaterialfvSGIX) + +#define GLEW_SGIX_nonlinear_lighting_pervertex GLEW_GET_VAR(__GLEW_SGIX_nonlinear_lighting_pervertex) + +#endif /* GL_SGIX_nonlinear_lighting_pervertex */ + +/* --------------------------- GL_SGIX_nurbs_eval -------------------------- */ + +#ifndef GL_SGIX_nurbs_eval +#define GL_SGIX_nurbs_eval 1 + +#define GL_MAP1_VERTEX_3_NURBS_SGIX 0x81CB +#define GL_MAP1_VERTEX_4_NURBS_SGIX 0x81CC +#define GL_MAP1_INDEX_NURBS_SGIX 0x81CD +#define GL_MAP1_COLOR_4_NURBS_SGIX 0x81CE +#define GL_MAP1_NORMAL_NURBS_SGIX 0x81CF +#define GL_MAP1_TEXTURE_COORD_1_NURBS_SGIX 0x81E0 +#define GL_MAP1_TEXTURE_COORD_2_NURBS_SGIX 0x81E1 +#define GL_MAP1_TEXTURE_COORD_3_NURBS_SGIX 0x81E2 +#define GL_MAP1_TEXTURE_COORD_4_NURBS_SGIX 0x81E3 +#define GL_MAP2_VERTEX_3_NURBS_SGIX 0x81E4 +#define GL_MAP2_VERTEX_4_NURBS_SGIX 0x81E5 +#define GL_MAP2_INDEX_NURBS_SGIX 0x81E6 +#define GL_MAP2_COLOR_4_NURBS_SGIX 0x81E7 +#define GL_MAP2_NORMAL_NURBS_SGIX 0x81E8 +#define GL_MAP2_TEXTURE_COORD_1_NURBS_SGIX 0x81E9 +#define GL_MAP2_TEXTURE_COORD_2_NURBS_SGIX 0x81EA +#define GL_MAP2_TEXTURE_COORD_3_NURBS_SGIX 0x81EB +#define GL_MAP2_TEXTURE_COORD_4_NURBS_SGIX 0x81EC +#define GL_NURBS_KNOT_COUNT_SGIX 0x81ED +#define GL_NURBS_KNOT_VECTOR_SGIX 0x81EE + +#define GLEW_SGIX_nurbs_eval GLEW_GET_VAR(__GLEW_SGIX_nurbs_eval) + +#endif /* GL_SGIX_nurbs_eval */ + +/* ---------------------- GL_SGIX_occlusion_instrument --------------------- */ + +#ifndef GL_SGIX_occlusion_instrument +#define GL_SGIX_occlusion_instrument 1 + +#define GL_OCCLUSION_INSTRUMENT_SGIX 0x6060 + +#define GLEW_SGIX_occlusion_instrument GLEW_GET_VAR(__GLEW_SGIX_occlusion_instrument) + +#endif /* GL_SGIX_occlusion_instrument */ + +/* ------------------------- GL_SGIX_packed_6bytes ------------------------- */ + +#ifndef GL_SGIX_packed_6bytes +#define GL_SGIX_packed_6bytes 1 + +#define GLEW_SGIX_packed_6bytes GLEW_GET_VAR(__GLEW_SGIX_packed_6bytes) + +#endif /* GL_SGIX_packed_6bytes */ + /* ------------------------- GL_SGIX_pixel_texture ------------------------- */ #ifndef GL_SGIX_pixel_texture @@ -16187,6 +19035,57 @@ typedef void (GLAPIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); #endif /* GL_SGIX_pixel_texture_bits */ +/* ----------------------- GL_SGIX_pixel_texture_lod ----------------------- */ + +#ifndef GL_SGIX_pixel_texture_lod +#define GL_SGIX_pixel_texture_lod 1 + +#define GLEW_SGIX_pixel_texture_lod GLEW_GET_VAR(__GLEW_SGIX_pixel_texture_lod) + +#endif /* GL_SGIX_pixel_texture_lod */ + +/* -------------------------- GL_SGIX_pixel_tiles -------------------------- */ + +#ifndef GL_SGIX_pixel_tiles +#define GL_SGIX_pixel_tiles 1 + +#define GLEW_SGIX_pixel_tiles GLEW_GET_VAR(__GLEW_SGIX_pixel_tiles) + +#endif /* GL_SGIX_pixel_tiles */ + +/* ------------------------- GL_SGIX_polynomial_ffd ------------------------ */ + +#ifndef GL_SGIX_polynomial_ffd +#define GL_SGIX_polynomial_ffd 1 + +#define GL_TEXTURE_DEFORMATION_BIT_SGIX 0x1 +#define GL_GEOMETRY_DEFORMATION_BIT_SGIX 0x2 + +typedef void (GLAPIENTRY * PFNGLDEFORMSGIXPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfield mask); + +#define glDeformSGIX GLEW_GET_FUN(__glewDeformSGIX) +#define glLoadIdentityDeformationMapSGIX GLEW_GET_FUN(__glewLoadIdentityDeformationMapSGIX) + +#define GLEW_SGIX_polynomial_ffd GLEW_GET_VAR(__GLEW_SGIX_polynomial_ffd) + +#endif /* GL_SGIX_polynomial_ffd */ + +/* --------------------------- GL_SGIX_quad_mesh --------------------------- */ + +#ifndef GL_SGIX_quad_mesh +#define GL_SGIX_quad_mesh 1 + +typedef void (GLAPIENTRY * PFNGLMESHBREADTHSGIXPROC) (GLint breadth); +typedef void (GLAPIENTRY * PFNGLMESHSTRIDESGIXPROC) (GLint stride); + +#define glMeshBreadthSGIX GLEW_GET_FUN(__glewMeshBreadthSGIX) +#define glMeshStrideSGIX GLEW_GET_FUN(__glewMeshStrideSGIX) + +#define GLEW_SGIX_quad_mesh GLEW_GET_VAR(__GLEW_SGIX_quad_mesh) + +#endif /* GL_SGIX_quad_mesh */ + /* ------------------------ GL_SGIX_reference_plane ------------------------ */ #ifndef GL_SGIX_reference_plane @@ -16215,6 +19114,17 @@ typedef void (GLAPIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble* equatio #endif /* GL_SGIX_resample */ +/* ------------------------- GL_SGIX_scalebias_hint ------------------------ */ + +#ifndef GL_SGIX_scalebias_hint +#define GL_SGIX_scalebias_hint 1 + +#define GL_SCALEBIAS_HINT_SGIX 0x8322 + +#define GLEW_SGIX_scalebias_hint GLEW_GET_VAR(__GLEW_SGIX_scalebias_hint) + +#endif /* GL_SGIX_scalebias_hint */ + /* ----------------------------- GL_SGIX_shadow ---------------------------- */ #ifndef GL_SGIX_shadow @@ -16240,6 +19150,31 @@ typedef void (GLAPIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble* equatio #endif /* GL_SGIX_shadow_ambient */ +/* ------------------------------ GL_SGIX_slim ----------------------------- */ + +#ifndef GL_SGIX_slim +#define GL_SGIX_slim 1 + +#define GL_PACK_MAX_COMPRESSED_SIZE_SGIX 0x831B +#define GL_SLIM8U_SGIX 0x831D +#define GL_SLIM10U_SGIX 0x831E +#define GL_SLIM12S_SGIX 0x831F + +#define GLEW_SGIX_slim GLEW_GET_VAR(__GLEW_SGIX_slim) + +#endif /* GL_SGIX_slim */ + +/* ------------------------ GL_SGIX_spotlight_cutoff ----------------------- */ + +#ifndef GL_SGIX_spotlight_cutoff +#define GL_SGIX_spotlight_cutoff 1 + +#define GL_SPOT_CUTOFF_DELTA_SGIX 0x8193 + +#define GLEW_SGIX_spotlight_cutoff GLEW_GET_VAR(__GLEW_SGIX_spotlight_cutoff) + +#endif /* GL_SGIX_spotlight_cutoff */ + /* ----------------------------- GL_SGIX_sprite ---------------------------- */ #ifndef GL_SGIX_sprite @@ -16259,6 +19194,30 @@ typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, GLint* #endif /* GL_SGIX_sprite */ +/* -------------------------- GL_SGIX_subdiv_patch ------------------------- */ + +#ifndef GL_SGIX_subdiv_patch +#define GL_SGIX_subdiv_patch 1 + +#define GLEW_SGIX_subdiv_patch GLEW_GET_VAR(__GLEW_SGIX_subdiv_patch) + +#endif /* GL_SGIX_subdiv_patch */ + +/* --------------------------- GL_SGIX_subsample --------------------------- */ + +#ifndef GL_SGIX_subsample +#define GL_SGIX_subsample 1 + +#define GL_PACK_SUBSAMPLE_RATE_SGIX 0x85A0 +#define GL_UNPACK_SUBSAMPLE_RATE_SGIX 0x85A1 +#define GL_PIXEL_SUBSAMPLE_4444_SGIX 0x85A2 +#define GL_PIXEL_SUBSAMPLE_2424_SGIX 0x85A3 +#define GL_PIXEL_SUBSAMPLE_4242_SGIX 0x85A4 + +#define GLEW_SGIX_subsample GLEW_GET_VAR(__GLEW_SGIX_subsample) + +#endif /* GL_SGIX_subsample */ + /* ----------------------- GL_SGIX_tag_sample_buffer ----------------------- */ #ifndef GL_SGIX_tag_sample_buffer @@ -16303,6 +19262,18 @@ typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #endif /* GL_SGIX_texture_lod_bias */ +/* ------------------- GL_SGIX_texture_mipmap_anisotropic ------------------ */ + +#ifndef GL_SGIX_texture_mipmap_anisotropic +#define GL_SGIX_texture_mipmap_anisotropic 1 + +#define GL_TEXTURE_MIPMAP_ANISOTROPY_SGIX 0x832E +#define GL_MAX_MIPMAP_ANISOTROPY_SGIX 0x832F + +#define GLEW_SGIX_texture_mipmap_anisotropic GLEW_GET_VAR(__GLEW_SGIX_texture_mipmap_anisotropic) + +#endif /* GL_SGIX_texture_mipmap_anisotropic */ + /* ---------------------- GL_SGIX_texture_multi_buffer --------------------- */ #ifndef GL_SGIX_texture_multi_buffer @@ -16314,6 +19285,17 @@ typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #endif /* GL_SGIX_texture_multi_buffer */ +/* ------------------------- GL_SGIX_texture_phase ------------------------- */ + +#ifndef GL_SGIX_texture_phase +#define GL_SGIX_texture_phase 1 + +#define GL_PHASE_SGIX 0x832A + +#define GLEW_SGIX_texture_phase GLEW_GET_VAR(__GLEW_SGIX_texture_phase) + +#endif /* GL_SGIX_texture_phase */ + /* ------------------------- GL_SGIX_texture_range ------------------------- */ #ifndef GL_SGIX_texture_range @@ -16366,6 +19348,53 @@ typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #endif /* GL_SGIX_texture_scale_bias */ +/* ---------------------- GL_SGIX_texture_supersample ---------------------- */ + +#ifndef GL_SGIX_texture_supersample +#define GL_SGIX_texture_supersample 1 + +#define GLEW_SGIX_texture_supersample GLEW_GET_VAR(__GLEW_SGIX_texture_supersample) + +#endif /* GL_SGIX_texture_supersample */ + +/* --------------------------- GL_SGIX_vector_ops -------------------------- */ + +#ifndef GL_SGIX_vector_ops +#define GL_SGIX_vector_ops 1 + +typedef void (GLAPIENTRY * PFNGLGETVECTOROPERATIONSGIXPROC) (GLenum operation); +typedef void (GLAPIENTRY * PFNGLVECTOROPERATIONSGIXPROC) (GLenum operation); + +#define glGetVectorOperationSGIX GLEW_GET_FUN(__glewGetVectorOperationSGIX) +#define glVectorOperationSGIX GLEW_GET_FUN(__glewVectorOperationSGIX) + +#define GLEW_SGIX_vector_ops GLEW_GET_VAR(__GLEW_SGIX_vector_ops) + +#endif /* GL_SGIX_vector_ops */ + +/* ---------------------- GL_SGIX_vertex_array_object ---------------------- */ + +#ifndef GL_SGIX_vertex_array_object +#define GL_SGIX_vertex_array_object 1 + +typedef GLboolean (GLAPIENTRY * PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC) (GLsizei n, const GLuint* arrays, GLboolean* residences); +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYSGIXPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSSGIXPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSSGIXPROC) (GLsizei n, GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYSGIXPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC) (GLsizei n, const GLuint* arrays, const GLclampf* priorities); + +#define glAreVertexArraysResidentSGIX GLEW_GET_FUN(__glewAreVertexArraysResidentSGIX) +#define glBindVertexArraySGIX GLEW_GET_FUN(__glewBindVertexArraySGIX) +#define glDeleteVertexArraysSGIX GLEW_GET_FUN(__glewDeleteVertexArraysSGIX) +#define glGenVertexArraysSGIX GLEW_GET_FUN(__glewGenVertexArraysSGIX) +#define glIsVertexArraySGIX GLEW_GET_FUN(__glewIsVertexArraySGIX) +#define glPrioritizeVertexArraysSGIX GLEW_GET_FUN(__glewPrioritizeVertexArraysSGIX) + +#define GLEW_SGIX_vertex_array_object GLEW_GET_VAR(__GLEW_SGIX_vertex_array_object) + +#endif /* GL_SGIX_vertex_array_object */ + /* ------------------------- GL_SGIX_vertex_preclip ------------------------ */ #ifndef GL_SGIX_vertex_preclip @@ -16399,6 +19428,27 @@ typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); #endif /* GL_SGIX_ycrcb */ +/* ------------------------ GL_SGIX_ycrcb_subsample ------------------------ */ + +#ifndef GL_SGIX_ycrcb_subsample +#define GL_SGIX_ycrcb_subsample 1 + +#define GLEW_SGIX_ycrcb_subsample GLEW_GET_VAR(__GLEW_SGIX_ycrcb_subsample) + +#endif /* GL_SGIX_ycrcb_subsample */ + +/* ----------------------------- GL_SGIX_ycrcba ---------------------------- */ + +#ifndef GL_SGIX_ycrcba +#define GL_SGIX_ycrcba 1 + +#define GL_YCRCB_SGIX 0x8318 +#define GL_YCRCBA_SGIX 0x8319 + +#define GLEW_SGIX_ycrcba GLEW_GET_VAR(__GLEW_SGIX_ycrcba) + +#endif /* GL_SGIX_ycrcba */ + /* -------------------------- GL_SGI_color_matrix -------------------------- */ #ifndef GL_SGI_color_matrix @@ -16462,6 +19512,63 @@ typedef void (GLAPIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum for #endif /* GL_SGI_color_table */ +/* ----------------------------- GL_SGI_complex ---------------------------- */ + +#ifndef GL_SGI_complex +#define GL_SGI_complex 1 + +#define GLEW_SGI_complex GLEW_GET_VAR(__GLEW_SGI_complex) + +#endif /* GL_SGI_complex */ + +/* -------------------------- GL_SGI_complex_type -------------------------- */ + +#ifndef GL_SGI_complex_type +#define GL_SGI_complex_type 1 + +#define GL_COMPLEX_UNSIGNED_BYTE_SGI 0x81BD +#define GL_COMPLEX_BYTE_SGI 0x81BE +#define GL_COMPLEX_UNSIGNED_SHORT_SGI 0x81BF +#define GL_COMPLEX_SHORT_SGI 0x81C0 +#define GL_COMPLEX_UNSIGNED_INT_SGI 0x81C1 +#define GL_COMPLEX_INT_SGI 0x81C2 +#define GL_COMPLEX_FLOAT_SGI 0x81C3 + +#define GLEW_SGI_complex_type GLEW_GET_VAR(__GLEW_SGI_complex_type) + +#endif /* GL_SGI_complex_type */ + +/* ------------------------------- GL_SGI_fft ------------------------------ */ + +#ifndef GL_SGI_fft +#define GL_SGI_fft 1 + +#define GL_PIXEL_TRANSFORM_OPERATOR_SGI 0x81C4 +#define GL_CONVOLUTION_SGI 0x81C5 +#define GL_FFT_1D_SGI 0x81C6 +#define GL_PIXEL_TRANSFORM_SGI 0x81C7 +#define GL_MAX_FFT_WIDTH_SGI 0x81C8 + +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFSGIPROC) (GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERISGIPROC) (GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMSGIPROC) (GLenum target); + +#define glGetPixelTransformParameterfvSGI GLEW_GET_FUN(__glewGetPixelTransformParameterfvSGI) +#define glGetPixelTransformParameterivSGI GLEW_GET_FUN(__glewGetPixelTransformParameterivSGI) +#define glPixelTransformParameterfSGI GLEW_GET_FUN(__glewPixelTransformParameterfSGI) +#define glPixelTransformParameterfvSGI GLEW_GET_FUN(__glewPixelTransformParameterfvSGI) +#define glPixelTransformParameteriSGI GLEW_GET_FUN(__glewPixelTransformParameteriSGI) +#define glPixelTransformParameterivSGI GLEW_GET_FUN(__glewPixelTransformParameterivSGI) +#define glPixelTransformSGI GLEW_GET_FUN(__glewPixelTransformSGI) + +#define GLEW_SGI_fft GLEW_GET_VAR(__GLEW_SGI_fft) + +#endif /* GL_SGI_fft */ + /* ----------------------- GL_SGI_texture_color_table ---------------------- */ #ifndef GL_SGI_texture_color_table @@ -16713,6 +19820,15 @@ typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat* tc, #endif /* GL_WIN_phong_shading */ +/* ------------------------- GL_WIN_scene_markerXXX ------------------------ */ + +#ifndef GL_WIN_scene_markerXXX +#define GL_WIN_scene_markerXXX 1 + +#define GLEW_WIN_scene_markerXXX GLEW_GET_VAR(__GLEW_WIN_scene_markerXXX) + +#endif /* GL_WIN_scene_markerXXX */ + /* -------------------------- GL_WIN_specular_fog -------------------------- */ #ifndef GL_WIN_specular_fog @@ -17040,6 +20156,10 @@ GLEW_FUN_EXPORT PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage; GLEW_FUN_EXPORT PFNGLGETNTEXIMAGEPROC __glewGetnTexImage; GLEW_FUN_EXPORT PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv; +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC __glewMultiDrawArraysIndirectCount; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC __glewMultiDrawElementsIndirectCount; +GLEW_FUN_EXPORT PFNGLSPECIALIZESHADERPROC __glewSpecializeShader; + GLEW_FUN_EXPORT PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX; GLEW_FUN_EXPORT PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD; @@ -17052,6 +20172,11 @@ GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSepa GLEW_FUN_EXPORT PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD; GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewFramebufferSamplePositionsfvAMD; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC __glewGetFramebufferParameterfvAMD; +GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC __glewGetNamedFramebufferParameterfvAMD; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewNamedFramebufferSamplePositionsfvAMD; + GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD; GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD; @@ -17107,6 +20232,8 @@ GLEW_FUN_EXPORT PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE; GLEW_FUN_EXPORT PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURELEVELSAPPLEPROC __glewCopyTextureLevelsAPPLE; + GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE; GLEW_FUN_EXPORT PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE; @@ -17125,10 +20252,21 @@ GLEW_FUN_EXPORT PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE; GLEW_FUN_EXPORT PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE; GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC __glewRenderbufferStorageMultisampleAPPLE; +GLEW_FUN_EXPORT PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC __glewResolveMultisampleFramebufferAPPLE; + GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE; GLEW_FUN_EXPORT PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE; GLEW_FUN_EXPORT PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE; +GLEW_FUN_EXPORT PFNGLCLIENTWAITSYNCAPPLEPROC __glewClientWaitSyncAPPLE; +GLEW_FUN_EXPORT PFNGLDELETESYNCAPPLEPROC __glewDeleteSyncAPPLE; +GLEW_FUN_EXPORT PFNGLFENCESYNCAPPLEPROC __glewFenceSyncAPPLE; +GLEW_FUN_EXPORT PFNGLGETINTEGER64VAPPLEPROC __glewGetInteger64vAPPLE; +GLEW_FUN_EXPORT PFNGLGETSYNCIVAPPLEPROC __glewGetSyncivAPPLE; +GLEW_FUN_EXPORT PFNGLISSYNCAPPLEPROC __glewIsSyncAPPLE; +GLEW_FUN_EXPORT PFNGLWAITSYNCAPPLEPROC __glewWaitSyncAPPLE; + GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE; GLEW_FUN_EXPORT PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE; @@ -17184,7 +20322,6 @@ GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationI GLEW_FUN_EXPORT PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex; GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEPROC __glewBufferStorage; -GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT; GLEW_FUN_EXPORT PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB; @@ -17544,6 +20681,8 @@ GLEW_FUN_EXPORT PFNGLMAXSHADERCOMPILERTHREADSARBPROC __glewMaxShaderCompilerThre GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB; +GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETCLAMPPROC __glewPolygonOffsetClamp; + GLEW_FUN_EXPORT PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex; GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation; @@ -17721,7 +20860,6 @@ GLEW_FUN_EXPORT PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB; GLEW_FUN_EXPORT PFNGLBUFFERPAGECOMMITMENTARBPROC __glewBufferPageCommitmentARB; GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB; -GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT; GLEW_FUN_EXPORT PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync; GLEW_FUN_EXPORT PFNGLDELETESYNCPROC __glewDeleteSync; @@ -17757,9 +20895,6 @@ GLEW_FUN_EXPORT PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample; GLEW_FUN_EXPORT PFNGLTEXSTORAGE1DPROC __glewTexStorage1D; GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DPROC __glewTexStorage2D; GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DPROC __glewTexStorage3D; -GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT; -GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT; -GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT; GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample; GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample; @@ -18088,6 +21223,10 @@ GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI; GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI; +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __glewDrawArraysInstancedBaseInstanceEXT; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseInstanceEXT; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseVertexBaseInstanceEXT; + GLEW_FUN_EXPORT PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT; GLEW_FUN_EXPORT PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT; GLEW_FUN_EXPORT PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT; @@ -18096,10 +21235,20 @@ GLEW_FUN_EXPORT PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT; +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC __glewBindFragDataLocationIndexedEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGDATAINDEXEXTPROC __glewGetFragDataIndexEXT; +GLEW_FUN_EXPORT PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC __glewGetProgramResourceLocationIndexEXT; + GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT; GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT; +GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT; + +GLEW_FUN_EXPORT PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT; +GLEW_FUN_EXPORT PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT; + GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT; GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT; @@ -18123,6 +21272,8 @@ GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT; GLEW_FUN_EXPORT PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT; GLEW_FUN_EXPORT PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT; +GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATAEXTPROC __glewCopyImageSubDataEXT; + GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT; GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT; @@ -18356,6 +21507,10 @@ GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVert GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT; +GLEW_FUN_EXPORT PFNGLDISCARDFRAMEBUFFEREXTPROC __glewDiscardFramebufferEXT; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSEXTPROC __glewDrawBuffersEXT; + GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT; GLEW_FUN_EXPORT PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT; GLEW_FUN_EXPORT PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT; @@ -18363,11 +21518,28 @@ GLEW_FUN_EXPORT PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT; GLEW_FUN_EXPORT PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT; GLEW_FUN_EXPORT PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEIEXTPROC __glewBlendEquationSeparateiEXT; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONIEXTPROC __glewBlendEquationiEXT; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEIEXTPROC __glewBlendFuncSeparateiEXT; +GLEW_FUN_EXPORT PFNGLBLENDFUNCIEXTPROC __glewBlendFunciEXT; +GLEW_FUN_EXPORT PFNGLCOLORMASKIEXTPROC __glewColorMaskiEXT; +GLEW_FUN_EXPORT PFNGLDISABLEIEXTPROC __glewDisableiEXT; +GLEW_FUN_EXPORT PFNGLENABLEIEXTPROC __glewEnableiEXT; +GLEW_FUN_EXPORT PFNGLISENABLEDIEXTPROC __glewIsEnablediEXT; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSBASEVERTEXEXTPROC __glewDrawElementsBaseVertexEXT; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC __glewDrawElementsInstancedBaseVertexEXT; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC __glewDrawRangeElementsBaseVertexEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC __glewMultiDrawElementsBaseVertexEXT; + GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT; GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT; GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT; +GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEEXTERNALEXTPROC __glewBufferStorageExternalEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC __glewNamedBufferStorageExternalEXT; + GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT; GLEW_FUN_EXPORT PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT; @@ -18472,16 +21644,55 @@ GLEW_FUN_EXPORT PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT; GLEW_FUN_EXPORT PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISOREXTPROC __glewVertexAttribDivisorEXT; + GLEW_FUN_EXPORT PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT; GLEW_FUN_EXPORT PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT; GLEW_FUN_EXPORT PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT; +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC __glewFlushMappedBufferRangeEXT; +GLEW_FUN_EXPORT PFNGLMAPBUFFERRANGEEXTPROC __glewMapBufferRangeEXT; + +GLEW_FUN_EXPORT PFNGLBUFFERSTORAGEMEMEXTPROC __glewBufferStorageMemEXT; +GLEW_FUN_EXPORT PFNGLCREATEMEMORYOBJECTSEXTPROC __glewCreateMemoryObjectsEXT; +GLEW_FUN_EXPORT PFNGLDELETEMEMORYOBJECTSEXTPROC __glewDeleteMemoryObjectsEXT; +GLEW_FUN_EXPORT PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC __glewGetMemoryObjectParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETUNSIGNEDBYTEI_VEXTPROC __glewGetUnsignedBytei_vEXT; +GLEW_FUN_EXPORT PFNGLGETUNSIGNEDBYTEVEXTPROC __glewGetUnsignedBytevEXT; +GLEW_FUN_EXPORT PFNGLISMEMORYOBJECTEXTPROC __glewIsMemoryObjectEXT; +GLEW_FUN_EXPORT PFNGLMEMORYOBJECTPARAMETERIVEXTPROC __glewMemoryObjectParameterivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC __glewNamedBufferStorageMemEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEMEM1DEXTPROC __glewTexStorageMem1DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEMEM2DEXTPROC __glewTexStorageMem2DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC __glewTexStorageMem2DMultisampleEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEMEM3DEXTPROC __glewTexStorageMem3DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC __glewTexStorageMem3DMultisampleEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGEMEM1DEXTPROC __glewTextureStorageMem1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGEMEM2DEXTPROC __glewTextureStorageMem2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC __glewTextureStorageMem2DMultisampleEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGEMEM3DEXTPROC __glewTextureStorageMem3DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC __glewTextureStorageMem3DMultisampleEXT; + +GLEW_FUN_EXPORT PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT; + +GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT; +GLEW_FUN_EXPORT PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT; + GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC __glewMultiDrawArraysIndirectEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC __glewMultiDrawElementsIndirectEXT; + GLEW_FUN_EXPORT PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT; GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC __glewFramebufferTexture2DMultisampleEXT; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSINDEXEDEXTPROC __glewDrawBuffersIndexedEXT; +GLEW_FUN_EXPORT PFNGLGETINTEGERI_VEXTPROC __glewGetIntegeri_vEXT; +GLEW_FUN_EXPORT PFNGLREADBUFFERINDEXEDEXTPROC __glewReadBufferIndexedEXT; + GLEW_FUN_EXPORT PFNGLCOLORTABLEEXTPROC __glewColorTableEXT; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT; GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT; @@ -18529,6 +21740,19 @@ GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT; GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT; +GLEW_FUN_EXPORT PFNGLDELETESEMAPHORESEXTPROC __glewDeleteSemaphoresEXT; +GLEW_FUN_EXPORT PFNGLGENSEMAPHORESEXTPROC __glewGenSemaphoresEXT; +GLEW_FUN_EXPORT PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC __glewGetSemaphoreParameterui64vEXT; +GLEW_FUN_EXPORT PFNGLISSEMAPHOREEXTPROC __glewIsSemaphoreEXT; +GLEW_FUN_EXPORT PFNGLSEMAPHOREPARAMETERUI64VEXTPROC __glewSemaphoreParameterui64vEXT; +GLEW_FUN_EXPORT PFNGLSIGNALSEMAPHOREEXTPROC __glewSignalSemaphoreEXT; +GLEW_FUN_EXPORT PFNGLWAITSEMAPHOREEXTPROC __glewWaitSemaphoreEXT; + +GLEW_FUN_EXPORT PFNGLIMPORTSEMAPHOREFDEXTPROC __glewImportSemaphoreFdEXT; + +GLEW_FUN_EXPORT PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC __glewImportSemaphoreWin32HandleEXT; +GLEW_FUN_EXPORT PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC __glewImportSemaphoreWin32NameEXT; + GLEW_FUN_EXPORT PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT; GLEW_FUN_EXPORT PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT; GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT; @@ -18536,6 +21760,13 @@ GLEW_FUN_EXPORT PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT; GLEW_FUN_EXPORT PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT; GLEW_FUN_EXPORT PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT; +GLEW_FUN_EXPORT PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC __glewClearPixelLocalStorageuiEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPixelLocalStorageSizeEXT; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT; + +GLEW_FUN_EXPORT PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT; + GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT; GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT; @@ -18564,6 +21795,15 @@ GLEW_FUN_EXPORT PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT; GLEW_FUN_EXPORT PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGE1DEXTPROC __glewTexStorage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGE2DEXTPROC __glewTexStorage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXSTORAGE3DEXTPROC __glewTexStorage3DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT; + +GLEW_FUN_EXPORT PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT; + GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT; GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT; @@ -18584,6 +21824,10 @@ GLEW_FUN_EXPORT PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT; GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT; GLEW_FUN_EXPORT PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT; +GLEW_FUN_EXPORT PFNGLBINDARRAYSETEXTPROC __glewBindArraySetEXT; +GLEW_FUN_EXPORT PFNGLCREATEARRAYSETEXTPROC __glewCreateArraySetExt; +GLEW_FUN_EXPORT PFNGLDELETEARRAYSETSEXTPROC __glewDeleteArraySetsEXT; + GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT; GLEW_FUN_EXPORT PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT; GLEW_FUN_EXPORT PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT; @@ -18643,6 +21887,9 @@ GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT; +GLEW_FUN_EXPORT PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC __glewAcquireKeyedMutexWin32EXT; +GLEW_FUN_EXPORT PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC __glewReleaseKeyedMutexWin32EXT; + GLEW_FUN_EXPORT PFNGLWINDOWRECTANGLESEXTPROC __glewWindowRectanglesEXT; GLEW_FUN_EXPORT PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT; @@ -18706,6 +21953,8 @@ GLEW_FUN_EXPORT PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel; GLEW_FUN_EXPORT PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup; GLEW_FUN_EXPORT PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup; +GLEW_FUN_EXPORT PFNGLMAXSHADERCOMPILERTHREADSKHRPROC __glewMaxShaderCompilerThreadsKHR; + GLEW_FUN_EXPORT PFNGLGETNUNIFORMFVPROC __glewGetnUniformfv; GLEW_FUN_EXPORT PFNGLGETNUNIFORMIVPROC __glewGetnUniformiv; GLEW_FUN_EXPORT PFNGLGETNUNIFORMUIVPROC __glewGetnUniformuiv; @@ -18751,6 +22000,9 @@ GLEW_FUN_EXPORT PFNGLLGPUCOPYIMAGESUBDATANVXPROC __glewLGPUCopyImageSubDataNVX; GLEW_FUN_EXPORT PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX; GLEW_FUN_EXPORT PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX; +GLEW_FUN_EXPORT PFNGLSTEREOPARAMETERFNVPROC __glewStereoParameterfNV; +GLEW_FUN_EXPORT PFNGLSTEREOPARAMETERINVPROC __glewStereoParameteriNV; + GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV; GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV; @@ -18803,12 +22055,19 @@ GLEW_FUN_EXPORT PFNGLCONSERVATIVERASTERPARAMETERFNVPROC __glewConservativeRaster GLEW_FUN_EXPORT PFNGLCONSERVATIVERASTERPARAMETERINVPROC __glewConservativeRasterParameteriNV; +GLEW_FUN_EXPORT PFNGLCOPYBUFFERSUBDATANVPROC __glewCopyBufferSubDataNV; + GLEW_FUN_EXPORT PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV; GLEW_FUN_EXPORT PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV; GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV; GLEW_FUN_EXPORT PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV; +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSNVPROC __glewDrawBuffersNV; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDNVPROC __glewDrawArraysInstancedNV; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDNVPROC __glewDrawElementsInstancedNV; + GLEW_FUN_EXPORT PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV; GLEW_FUN_EXPORT PFNGLDRAWVKIMAGENVPROC __glewDrawVkImageNV; @@ -18848,6 +22107,10 @@ GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4 GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV; GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV; +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERNVPROC __glewBlitFramebufferNV; + +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC __glewRenderbufferStorageMultisampleNV; + GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV; GLEW_FUN_EXPORT PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV; @@ -18960,8 +22223,17 @@ GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV; GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORNVPROC __glewVertexAttribDivisorNV; + GLEW_FUN_EXPORT PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3FVNVPROC __glewUniformMatrix2x3fvNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4FVNVPROC __glewUniformMatrix2x4fvNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2FVNVPROC __glewUniformMatrix3x2fvNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4FVNVPROC __glewUniformMatrix3x4fvNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2FVNVPROC __glewUniformMatrix4x2fvNV; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3FVNVPROC __glewUniformMatrix4x3fvNV; + GLEW_FUN_EXPORT PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV; GLEW_FUN_EXPORT PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV; GLEW_FUN_EXPORT PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV; @@ -19045,6 +22317,8 @@ GLEW_FUN_EXPORT PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV; GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV; +GLEW_FUN_EXPORT PFNGLPOLYGONMODENVPROC __glewPolygonModeNV; + GLEW_FUN_EXPORT PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV; GLEW_FUN_EXPORT PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV; GLEW_FUN_EXPORT PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV; @@ -19089,6 +22363,13 @@ GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64NVPROC __glewUniformui64NV; GLEW_FUN_EXPORT PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DNVPROC __glewCopyTexSubImage3DNV; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERNVPROC __glewFramebufferTextureLayerNV; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DNVPROC __glewTexImage3DNV; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DNVPROC __glewTexSubImage3DNV; + GLEW_FUN_EXPORT PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV; GLEW_FUN_EXPORT PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV; @@ -19243,17 +22524,54 @@ GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStrea GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV; GLEW_FUN_EXPORT PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEARRAYFVNVPROC __glewDepthRangeArrayfvNV; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEINDEXEDFNVPROC __glewDepthRangeIndexedfNV; +GLEW_FUN_EXPORT PFNGLDISABLEINVPROC __glewDisableiNV; +GLEW_FUN_EXPORT PFNGLENABLEINVPROC __glewEnableiNV; +GLEW_FUN_EXPORT PFNGLGETFLOATI_VNVPROC __glewGetFloati_vNV; +GLEW_FUN_EXPORT PFNGLISENABLEDINVPROC __glewIsEnablediNV; +GLEW_FUN_EXPORT PFNGLSCISSORARRAYVNVPROC __glewScissorArrayvNV; +GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDNVPROC __glewScissorIndexedNV; +GLEW_FUN_EXPORT PFNGLSCISSORINDEXEDVNVPROC __glewScissorIndexedvNV; +GLEW_FUN_EXPORT PFNGLVIEWPORTARRAYVNVPROC __glewViewportArrayvNV; +GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFNVPROC __glewViewportIndexedfNV; +GLEW_FUN_EXPORT PFNGLVIEWPORTINDEXEDFVNVPROC __glewViewportIndexedfvNV; + GLEW_FUN_EXPORT PFNGLVIEWPORTSWIZZLENVPROC __glewViewportSwizzleNV; -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 PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __glewFramebufferTextureMultisampleMultiviewOVR; + +GLEW_FUN_EXPORT PFNGLALPHAFUNCQCOMPROC __glewAlphaFuncQCOM; + +GLEW_FUN_EXPORT PFNGLDISABLEDRIVERCONTROLQCOMPROC __glewDisableDriverControlQCOM; +GLEW_FUN_EXPORT PFNGLENABLEDRIVERCONTROLQCOMPROC __glewEnableDriverControlQCOM; +GLEW_FUN_EXPORT PFNGLGETDRIVERCONTROLSTRINGQCOMPROC __glewGetDriverControlStringQCOM; +GLEW_FUN_EXPORT PFNGLGETDRIVERCONTROLSQCOMPROC __glewGetDriverControlsQCOM; + +GLEW_FUN_EXPORT PFNGLEXTGETBUFFERPOINTERVQCOMPROC __glewExtGetBufferPointervQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETBUFFERSQCOMPROC __glewExtGetBuffersQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETFRAMEBUFFERSQCOMPROC __glewExtGetFramebuffersQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETRENDERBUFFERSQCOMPROC __glewExtGetRenderbuffersQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC __glewExtGetTexLevelParameterivQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETTEXSUBIMAGEQCOMPROC __glewExtGetTexSubImageQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETTEXTURESQCOMPROC __glewExtGetTexturesQCOM; +GLEW_FUN_EXPORT PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC __glewExtTexObjectStateOverrideiQCOM; + +GLEW_FUN_EXPORT PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC __glewExtGetProgramBinarySourceQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM; +GLEW_FUN_EXPORT PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM; +GLEW_FUN_EXPORT PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM; + +GLEW_FUN_EXPORT PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM; +GLEW_FUN_EXPORT PFNGLSTARTTILINGQCOMPROC __glewStartTilingQCOM; + GLEW_FUN_EXPORT PFNGLALPHAFUNCXPROC __glewAlphaFuncx; GLEW_FUN_EXPORT PFNGLCLEARCOLORXPROC __glewClearColorx; GLEW_FUN_EXPORT PFNGLCLEARDEPTHXPROC __glewClearDepthx; @@ -19318,6 +22636,13 @@ GLEW_FUN_EXPORT PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS; GLEW_FUN_EXPORT PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS; GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS; +GLEW_FUN_EXPORT PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC __glewInterleavedTextureCoordSetsSGIS; +GLEW_FUN_EXPORT PFNGLSELECTTEXTURECOORDSETSGISPROC __glewSelectTextureCoordSetSGIS; +GLEW_FUN_EXPORT PFNGLSELECTTEXTURESGISPROC __glewSelectTextureSGIS; +GLEW_FUN_EXPORT PFNGLSELECTTEXTURETRANSFORMSGISPROC __glewSelectTextureTransformSGIS; + +GLEW_FUN_EXPORT PFNGLMULTISAMPLESUBRECTPOSSGISPROC __glewMultisampleSubRectPosSGIS; + GLEW_FUN_EXPORT PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS; GLEW_FUN_EXPORT PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS; @@ -19334,8 +22659,14 @@ GLEW_FUN_EXPORT PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX; GLEW_FUN_EXPORT PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX; GLEW_FUN_EXPORT PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX; +GLEW_FUN_EXPORT PFNGLADDRESSSPACEPROC __glewAddressSpace; +GLEW_FUN_EXPORT PFNGLDATAPIPEPROC __glewDataPipe; + GLEW_FUN_EXPORT PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX; +GLEW_FUN_EXPORT PFNGLFOGLAYERSSGIXPROC __glewFogLayersSGIX; +GLEW_FUN_EXPORT PFNGLGETFOGLAYERSSGIXPROC __glewGetFogLayersSGIX; + GLEW_FUN_EXPORT PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX; GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX; @@ -19358,8 +22689,33 @@ GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSG GLEW_FUN_EXPORT PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX; +GLEW_FUN_EXPORT PFNGLIGLOOINTERFACESGIXPROC __glewIglooInterfaceSGIX; + +GLEW_FUN_EXPORT PFNGLALLOCMPEGPREDICTORSSGIXPROC __glewAllocMPEGPredictorsSGIX; +GLEW_FUN_EXPORT PFNGLDELETEMPEGPREDICTORSSGIXPROC __glewDeleteMPEGPredictorsSGIX; +GLEW_FUN_EXPORT PFNGLGENMPEGPREDICTORSSGIXPROC __glewGenMPEGPredictorsSGIX; +GLEW_FUN_EXPORT PFNGLGETMPEGPARAMETERFVSGIXPROC __glewGetMPEGParameterfvSGIX; +GLEW_FUN_EXPORT PFNGLGETMPEGPARAMETERIVSGIXPROC __glewGetMPEGParameterivSGIX; +GLEW_FUN_EXPORT PFNGLGETMPEGPREDICTORSGIXPROC __glewGetMPEGPredictorSGIX; +GLEW_FUN_EXPORT PFNGLGETMPEGQUANTTABLEUBVPROC __glewGetMPEGQuantTableubv; +GLEW_FUN_EXPORT PFNGLISMPEGPREDICTORSGIXPROC __glewIsMPEGPredictorSGIX; +GLEW_FUN_EXPORT PFNGLMPEGPREDICTORSGIXPROC __glewMPEGPredictorSGIX; +GLEW_FUN_EXPORT PFNGLMPEGQUANTTABLEUBVPROC __glewMPEGQuantTableubv; +GLEW_FUN_EXPORT PFNGLSWAPMPEGPREDICTORSSGIXPROC __glewSwapMPEGPredictorsSGIX; + +GLEW_FUN_EXPORT PFNGLGETNONLINLIGHTFVSGIXPROC __glewGetNonlinLightfvSGIX; +GLEW_FUN_EXPORT PFNGLGETNONLINMATERIALFVSGIXPROC __glewGetNonlinMaterialfvSGIX; +GLEW_FUN_EXPORT PFNGLNONLINLIGHTFVSGIXPROC __glewNonlinLightfvSGIX; +GLEW_FUN_EXPORT PFNGLNONLINMATERIALFVSGIXPROC __glewNonlinMaterialfvSGIX; + GLEW_FUN_EXPORT PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX; +GLEW_FUN_EXPORT PFNGLDEFORMSGIXPROC __glewDeformSGIX; +GLEW_FUN_EXPORT PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC __glewLoadIdentityDeformationMapSGIX; + +GLEW_FUN_EXPORT PFNGLMESHBREADTHSGIXPROC __glewMeshBreadthSGIX; +GLEW_FUN_EXPORT PFNGLMESHSTRIDESGIXPROC __glewMeshStrideSGIX; + GLEW_FUN_EXPORT PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX; GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX; @@ -19369,6 +22725,16 @@ GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX; GLEW_FUN_EXPORT PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX; +GLEW_FUN_EXPORT PFNGLGETVECTOROPERATIONSGIXPROC __glewGetVectorOperationSGIX; +GLEW_FUN_EXPORT PFNGLVECTOROPERATIONSGIXPROC __glewVectorOperationSGIX; + +GLEW_FUN_EXPORT PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC __glewAreVertexArraysResidentSGIX; +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYSGIXPROC __glewBindVertexArraySGIX; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSSGIXPROC __glewDeleteVertexArraysSGIX; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSSGIXPROC __glewGenVertexArraysSGIX; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYSGIXPROC __glewIsVertexArraySGIX; +GLEW_FUN_EXPORT PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC __glewPrioritizeVertexArraysSGIX; + GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI; GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI; GLEW_FUN_EXPORT PFNGLCOLORTABLESGIPROC __glewColorTableSGI; @@ -19377,6 +22743,14 @@ GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParamete GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI; GLEW_FUN_EXPORT PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI; +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC __glewGetPixelTransformParameterfvSGI; +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC __glewGetPixelTransformParameterivSGI; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFSGIPROC __glewPixelTransformParameterfSGI; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC __glewPixelTransformParameterfvSGI; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERISGIPROC __glewPixelTransformParameteriSGI; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC __glewPixelTransformParameterivSGI; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMSGIPROC __glewPixelTransformSGI; + GLEW_FUN_EXPORT PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX; GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN; @@ -19458,15 +22832,21 @@ GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_2; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_3; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_4; GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_5; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_4_6; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_tbuffer; GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_texture_compression_FXT1; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_blend_minmax_factor; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_compressed_3DC_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_compressed_ATC_texture; 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_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_int16; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_gpu_shader_int64; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_interleaved_elements; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_multi_draw_indirect; @@ -19474,22 +22854,26 @@ GLEW_VAR_EXPORT GLboolean __GLEW_AMD_name_gen_delete; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_occlusion_query_event; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_performance_monitor; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_pinned_memory; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_program_binary_Z400; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_query_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_sample_positions; 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_stencil_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_stencil_value_export; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_shader_trinary_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_sparse_texture; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_stencil_operation_extended; +GLEW_VAR_EXPORT GLboolean __GLEW_AMD_texture_gather_bias_lod; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_texture_texture4; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_transform_feedback3_lines_triangles; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_transform_feedback4; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_layer; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_tessellator; GLEW_VAR_EXPORT GLboolean __GLEW_AMD_vertex_shader_viewport_index; +GLEW_VAR_EXPORT GLboolean __GLEW_ANDROID_extension_pack_es31a; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_depth_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_framebuffer_multisample; @@ -19504,15 +22888,24 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_ANGLE_translated_shader_source; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_aux_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_client_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_clip_distance; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_color_buffer_packed_float; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_copy_texture_levels; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_element_array; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_fence; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_float_pixels; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_flush_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_object_purgeable; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_pixel_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_rgb_422; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_row_bytes; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_specular_vector; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_sync; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_2D_limited_npot; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_format_BGRA8888; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_max_level; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_packed_float; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_range; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_transform_hint; GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_object; @@ -19594,6 +22987,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pipeline_statistics_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pixel_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_polygon_offset_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_post_depth_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_program_interface_query; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_provoking_vertex; @@ -19635,6 +23029,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture2; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sparse_texture_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_spirv_extensions; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_stencil_texturing; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_sync; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_tessellation_shader; @@ -19652,6 +23047,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_add; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_combine; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_crossbar; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_dot3; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_filter_anisotropic; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_filter_minmax; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_float; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_gather; @@ -19688,6 +23084,11 @@ GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_viewport_array; GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_program_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_mali_shader_binary; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_rgba8; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch; +GLEW_VAR_EXPORT GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_point_sprites; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_combine3; GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_route; @@ -19709,52 +23110,86 @@ 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_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_YUV_target; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_base_instance; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bgra; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bindable_uniform; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_color; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_equation_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_func_extended; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_func_separate; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_logic_op; 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_cull_distance; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_volume_hint; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cmyka; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_buffer_half_float; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_subtable; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_compiled_vertex_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_compressed_ETC1_RGB8_sub_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_conservative_depth; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_convolution; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_coordinate_frame; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_copy_image; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_copy_texture; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cull_vertex; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_debug_label; 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_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_external_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_float_blend; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_frag_depth; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_shader; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_program_parameters; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_shader5; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_histogram; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_array_formats; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_func; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_material; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_instanced_arrays; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_light_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_map_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_fd; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_memory_object_win32; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_indirect; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multiple_textures; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisample; +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_packed_depth_stencil; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_float; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_pixels; @@ -19767,17 +23202,35 @@ 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_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_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_sRGB_write_control; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_semaphore_fd; +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_group_vote; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_formatted; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_image_load_store; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_implicit_conversions; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_integer_mix; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_io_blocks; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_non_constant_global_initializers; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_pixel_local_storage2; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shader_texture_lod; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs; +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_stencil_clear_tag; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_two_side; @@ -19787,11 +23240,15 @@ 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_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; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_bptc; 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_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_edge_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_add; @@ -19799,24 +23256,35 @@ GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_combine; 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_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_norm16; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_object; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rg; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB_R8; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB_RG8; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB_decode; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_snorm; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_storage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_view; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_timer_query; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_transform_feedback; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_unpack_subimage; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_setXXX; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_attrib_64bit; GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_shader; 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_GREMEDY_frame_terminator; @@ -19845,6 +23313,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_KHR_blend_equation_advanced_coherent; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_context_flush_control; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_debug; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_no_error; +GLEW_VAR_EXPORT GLboolean __GLEW_KHR_parallel_shader_compile; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_robust_buffer_access_behavior; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_robustness; GLEW_VAR_EXPORT GLboolean __GLEW_KHR_texture_compression_astc_hdr; @@ -19861,11 +23330,16 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NVX_blend_equation_advanced_multi_draw_buffers; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_conditional_render; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_gpu_memory_info; GLEW_VAR_EXPORT GLboolean __GLEW_NVX_linked_gpu_multicast; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_3dvision_settings; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_EGL_stream_consumer_external; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_alpha_to_coverage_dither_control; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_bgr; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_multi_draw_indirect; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_multi_draw_indirect_count; GLEW_VAR_EXPORT GLboolean __GLEW_NV_bindless_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_equation_advanced; GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_equation_advanced_coherent; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_minmax_factor; 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; @@ -19874,16 +23348,21 @@ 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_triangles; +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_range_unclamped; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_instanced; GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_texture; GLEW_VAR_EXPORT GLboolean __GLEW_NV_draw_vulkan_image; GLEW_VAR_EXPORT GLboolean __GLEW_NV_evaluators; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_explicit_attrib_location; GLEW_VAR_EXPORT GLboolean __GLEW_NV_explicit_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fbo_color_attachments; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fence; GLEW_VAR_EXPORT GLboolean __GLEW_NV_fill_rectangle; GLEW_VAR_EXPORT GLboolean __GLEW_NV_float_buffer; @@ -19894,8 +23373,11 @@ 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_interlock; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_blit; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_mixed_samples; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_generate_mipmap_sRGB; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_program4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader_passthrough; @@ -19906,23 +23388,36 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program5_mem_extended; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program_fp64; GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_shader5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_half_float; +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_multisample_coverage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_non_square_matrices; GLEW_VAR_EXPORT GLboolean __GLEW_NV_occlusion_query; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_pack_subimage; GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_float; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_float_linear; GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_path_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_NV_path_rendering_shared_edge; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_buffer_object; GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_data_range; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_platform_binary; 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_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_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_shader_atomic_counters; @@ -19931,19 +23426,29 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_float64; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_atomic_fp16_vector; 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_thread_group; GLEW_VAR_EXPORT GLboolean __GLEW_NV_shader_thread_shuffle; +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; GLEW_VAR_EXPORT GLboolean __GLEW_NV_tessellation_program5; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_emboss; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_reflection; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_array; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_barrier; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_latc; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_s3tc_update; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_vtc; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_env_combine4; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_expand_normal; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_npot_2D_mipmap; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle_compressed; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2; GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3; @@ -19962,19 +23467,28 @@ GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2_option; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program3; GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program4; 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_byte_coordinates; -GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_paletted_texture; -GLEW_VAR_EXPORT GLboolean __GLEW_OES_read_format; -GLEW_VAR_EXPORT GLboolean __GLEW_OES_single_precision; GLEW_VAR_EXPORT GLboolean __GLEW_OML_interlace; GLEW_VAR_EXPORT GLboolean __GLEW_OML_resample; GLEW_VAR_EXPORT GLboolean __GLEW_OML_subsample; GLEW_VAR_EXPORT GLboolean __GLEW_OVR_multiview; GLEW_VAR_EXPORT GLboolean __GLEW_OVR_multiview2; +GLEW_VAR_EXPORT GLboolean __GLEW_OVR_multiview_multisampled_render_to_texture; GLEW_VAR_EXPORT GLboolean __GLEW_PGI_misc_hints; GLEW_VAR_EXPORT GLboolean __GLEW_PGI_vertex_hints; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_alpha_test; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_binning_control; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_driver_control; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_extended_get; +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_tiled_rendering; +GLEW_VAR_EXPORT GLboolean __GLEW_QCOM_writeonly_rendering; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_0_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_ES1_1_compatibility; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_enable; @@ -19984,13 +23498,17 @@ GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_log; GLEW_VAR_EXPORT GLboolean __GLEW_REGAL_proc_address; GLEW_VAR_EXPORT GLboolean __GLEW_REND_screen_coordinates; GLEW_VAR_EXPORT GLboolean __GLEW_S3_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_clip_band_hint; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_color_range; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_detail_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_fog_function; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_generate_mipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_line_texgen; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_multitexture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_pixel_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_point_line_texgen; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_shared_multisample; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_sharpen_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture4D; GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_border_clamp; @@ -20001,37 +23519,90 @@ GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_select; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_histogram; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_pixel; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_bali_g_instruments; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_bali_r_instruments; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_bali_timer_instruments; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_alpha_minmax; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_cadd; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_cmultiply; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_calligraphic_fragment; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_clipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_color_matrix_accuracy; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_color_table_index_mode; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_complex_polar; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_convolution_accuracy; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_cylinder_texgen; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_datapipe; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_decimation; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_depth_pass_instrument; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_dvc; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_flush_raster; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_factor_to_alpha; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_layers; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_offset; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_patchy; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_scale; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragment_lighting_space; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragment_specular_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragments_instrument; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_framezoom; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_icc_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_igloo_interface; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_image_compression; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_impact_pixel_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_instrument_error; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_interlace; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ir_instrument1; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_line_quality_hint; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_list_priority; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_mpeg1; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_mpeg2; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_nonlinear_lighting_pervertex; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_nurbs_eval; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_occlusion_instrument; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_packed_6bytes; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture_bits; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_tiles; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_polynomial_ffd; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_quad_mesh; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_reference_plane; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_resample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_scalebias_hint; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow_ambient; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_slim; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_spotlight_cutoff; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_subdiv_patch; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_subsample; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_tag_sample_buffer; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_add_env; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_coordinate_clamp; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_lod_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_mipmap_anisotropic; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_multi_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_phase; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_range; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_scale_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_supersample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vector_ops; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_array_object; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip_hint; GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcb; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcb_subsample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcba; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_matrix; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_complex; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_complex_type; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_fft; GLEW_VAR_EXPORT GLboolean __GLEW_SGI_texture_color_table; GLEW_VAR_EXPORT GLboolean __GLEW_SUNX_constant_data; GLEW_VAR_EXPORT GLboolean __GLEW_SUN_convolution_border_modes; @@ -20042,6 +23613,7 @@ 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_WIN_phong_shading; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_scene_markerXXX; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_specular_fog; GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; /* ------------------------------------------------------------------------- */ @@ -20052,6 +23624,7 @@ GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; #define GLEW_ERROR_NO_GL_VERSION 1 /* missing GL version */ #define GLEW_ERROR_GL_VERSION_10_ONLY 2 /* Need at least OpenGL 1.1 */ #define GLEW_ERROR_GLX_VERSION_11_ONLY 3 /* Need at least GLX 1.2 */ +#define GLEW_ERROR_NO_GLX_DISPLAY 4 /* Need GLX display for GLX support */ /* string codes */ #define GLEW_VERSION 1 @@ -20064,9 +23637,9 @@ GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; /* GLEW version info */ /* -VERSION 2.0.0 +VERSION 2.1.0 VERSION_MAJOR 2 -VERSION_MINOR 0 +VERSION_MINOR 1 VERSION_MICRO 0 */ diff --git a/include/GL/glxew.h b/include/GL/glxew.h index 1e2596d..7e39c2f 100755 --- a/include/GL/glxew.h +++ b/include/GL/glxew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -392,10 +392,6 @@ 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 */ @@ -419,6 +415,15 @@ typedef GLXContext ( * PFNGLXCREATECONTEXTATTRIBSARBPROC) (Display* dpy, GLXFBCo #endif /* GLX_ARB_create_context */ +/* -------------------- GLX_ARB_create_context_no_error -------------------- */ + +#ifndef GLX_ARB_create_context_no_error +#define GLX_ARB_create_context_no_error 1 + +#define GLXEW_ARB_create_context_no_error GLXEW_GET_VAR(__GLXEW_ARB_create_context_no_error) + +#endif /* GLX_ARB_create_context_no_error */ + /* --------------------- GLX_ARB_create_context_profile -------------------- */ #ifndef GLX_ARB_create_context_profile @@ -1684,6 +1689,7 @@ GLXEW_VAR_EXPORT GLboolean __GLXEW_3DFX_multisample; GLXEW_VAR_EXPORT GLboolean __GLXEW_AMD_gpu_association; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_context_flush_control; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context; +GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context_no_error; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context_profile; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_create_context_robustness; GLXEW_VAR_EXPORT GLboolean __GLXEW_ARB_fbconfig_float; diff --git a/include/GL/wglew.h b/include/GL/wglew.h index 71ee0f3..2097c0f 100755 --- a/include/GL/wglew.h +++ b/include/GL/wglew.h @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -188,10 +188,6 @@ 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 */ @@ -218,6 +214,15 @@ typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShar #endif /* WGL_ARB_create_context */ +/* -------------------- WGL_ARB_create_context_no_error -------------------- */ + +#ifndef WGL_ARB_create_context_no_error +#define WGL_ARB_create_context_no_error 1 + +#define WGLEW_ARB_create_context_no_error WGLEW_GET_VAR(__WGLEW_ARB_create_context_no_error) + +#endif /* WGL_ARB_create_context_no_error */ + /* --------------------- WGL_ARB_create_context_profile -------------------- */ #ifndef WGL_ARB_create_context_profile @@ -506,6 +511,19 @@ typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, con #endif /* WGL_ATI_render_texture_rectangle */ +/* --------------------------- WGL_EXT_colorspace -------------------------- */ + +#ifndef WGL_EXT_colorspace +#define WGL_EXT_colorspace 1 + +#define WGL_COLORSPACE_SRGB_EXT 0x3089 +#define WGL_COLORSPACE_LINEAR_EXT 0x308A +#define WGL_COLORSPACE_EXT 0x309D + +#define WGLEW_EXT_colorspace WGLEW_GET_VAR(__WGLEW_EXT_colorspace) + +#endif /* WGL_EXT_colorspace */ + /* ------------------- WGL_EXT_create_context_es2_profile ------------------ */ #ifndef WGL_EXT_create_context_es2_profile @@ -1355,6 +1373,7 @@ WGLEW_VAR_EXPORT GLboolean __WGLEW_AMD_gpu_association; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_buffer_region; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_context_flush_control; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context; +WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context_no_error; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_create_context_robustness; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_extensions_string; @@ -1369,6 +1388,7 @@ WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_robustness_application_isolation; WGLEW_VAR_EXPORT GLboolean __WGLEW_ARB_robustness_share_group_isolation; WGLEW_VAR_EXPORT GLboolean __WGLEW_ATI_pixel_format_float; WGLEW_VAR_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle; +WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_colorspace; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_create_context_es2_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_create_context_es_profile; WGLEW_VAR_EXPORT GLboolean __WGLEW_EXT_depth_float; diff --git a/src/glew.c b/src/glew.c index 6c93c07..18a2853 100755 --- a/src/glew.c +++ b/src/glew.c @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -30,7 +30,11 @@ ** THE POSSIBILITY OF SUCH DAMAGE. */ +#ifndef GLEW_INCLUDE #include +#else +#include GLEW_INCLUDE +#endif #if defined(GLEW_OSMESA) # define GLAPI extern @@ -38,6 +42,14 @@ #elif defined(GLEW_EGL) # include #elif defined(_WIN32) +/* + * If NOGDI is defined, wingdi.h won't be included by windows.h, and thus + * wglGetProcAddress won't be declared. It will instead be implicitly declared, + * potentially incorrectly, which we don't want. + */ +# if defined(NOGDI) +# undef NOGDI +# endif # include #elif !defined(__ANDROID__) && !defined(__native_client__) && !defined(__HAIKU__) && (!defined(__APPLE__) || defined(GLEW_APPLE_GLX)) # include @@ -607,6 +619,10 @@ PFNGLGETNCOMPRESSEDTEXIMAGEPROC __glewGetnCompressedTexImage = NULL; PFNGLGETNTEXIMAGEPROC __glewGetnTexImage = NULL; PFNGLGETNUNIFORMDVPROC __glewGetnUniformdv = NULL; +PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC __glewMultiDrawArraysIndirectCount = NULL; +PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC __glewMultiDrawElementsIndirectCount = NULL; +PFNGLSPECIALIZESHADERPROC __glewSpecializeShader = NULL; + PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL; PFNGLDEBUGMESSAGECALLBACKAMDPROC __glewDebugMessageCallbackAMD = NULL; @@ -619,6 +635,11 @@ PFNGLBLENDEQUATIONSEPARATEINDEXEDAMDPROC __glewBlendEquationSeparateIndexedAMD = PFNGLBLENDFUNCINDEXEDAMDPROC __glewBlendFuncIndexedAMD = NULL; PFNGLBLENDFUNCSEPARATEINDEXEDAMDPROC __glewBlendFuncSeparateIndexedAMD = NULL; +PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewFramebufferSamplePositionsfvAMD = NULL; +PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC __glewGetFramebufferParameterfvAMD = NULL; +PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC __glewGetNamedFramebufferParameterfvAMD = NULL; +PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC __glewNamedFramebufferSamplePositionsfvAMD = NULL; + PFNGLVERTEXATTRIBPARAMETERIAMDPROC __glewVertexAttribParameteriAMD = NULL; PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC __glewMultiDrawArraysIndirectAMD = NULL; @@ -674,6 +695,8 @@ PFNGLQUERYCOUNTERANGLEPROC __glewQueryCounterANGLE = NULL; PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC __glewGetTranslatedShaderSourceANGLE = NULL; +PFNGLCOPYTEXTURELEVELSAPPLEPROC __glewCopyTextureLevelsAPPLE = NULL; + PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL; PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL; PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL; @@ -692,10 +715,21 @@ PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL; PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL; PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC __glewRenderbufferStorageMultisampleAPPLE = NULL; +PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC __glewResolveMultisampleFramebufferAPPLE = NULL; + PFNGLGETOBJECTPARAMETERIVAPPLEPROC __glewGetObjectParameterivAPPLE = NULL; PFNGLOBJECTPURGEABLEAPPLEPROC __glewObjectPurgeableAPPLE = NULL; PFNGLOBJECTUNPURGEABLEAPPLEPROC __glewObjectUnpurgeableAPPLE = NULL; +PFNGLCLIENTWAITSYNCAPPLEPROC __glewClientWaitSyncAPPLE = NULL; +PFNGLDELETESYNCAPPLEPROC __glewDeleteSyncAPPLE = NULL; +PFNGLFENCESYNCAPPLEPROC __glewFenceSyncAPPLE = NULL; +PFNGLGETINTEGER64VAPPLEPROC __glewGetInteger64vAPPLE = NULL; +PFNGLGETSYNCIVAPPLEPROC __glewGetSyncivAPPLE = NULL; +PFNGLISSYNCAPPLEPROC __glewIsSyncAPPLE = NULL; +PFNGLWAITSYNCAPPLEPROC __glewWaitSyncAPPLE = NULL; + PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL; PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL; @@ -751,7 +785,6 @@ PFNGLBINDFRAGDATALOCATIONINDEXEDPROC __glewBindFragDataLocationIndexed = NULL; PFNGLGETFRAGDATAINDEXPROC __glewGetFragDataIndex = NULL; PFNGLBUFFERSTORAGEPROC __glewBufferStorage = NULL; -PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL; PFNGLCREATESYNCFROMCLEVENTARBPROC __glewCreateSyncFromCLeventARB = NULL; @@ -1111,6 +1144,8 @@ PFNGLMAXSHADERCOMPILERTHREADSARBPROC __glewMaxShaderCompilerThreadsARB = NULL; PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL; PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL; +PFNGLPOLYGONOFFSETCLAMPPROC __glewPolygonOffsetClamp = NULL; + PFNGLGETPROGRAMINTERFACEIVPROC __glewGetProgramInterfaceiv = NULL; PFNGLGETPROGRAMRESOURCEINDEXPROC __glewGetProgramResourceIndex = NULL; PFNGLGETPROGRAMRESOURCELOCATIONPROC __glewGetProgramResourceLocation = NULL; @@ -1288,7 +1323,6 @@ PFNGLNAMEDSTRINGARBPROC __glewNamedStringARB = NULL; PFNGLBUFFERPAGECOMMITMENTARBPROC __glewBufferPageCommitmentARB = NULL; PFNGLTEXPAGECOMMITMENTARBPROC __glewTexPageCommitmentARB = NULL; -PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL; PFNGLCLIENTWAITSYNCPROC __glewClientWaitSync = NULL; PFNGLDELETESYNCPROC __glewDeleteSync = NULL; @@ -1324,9 +1358,6 @@ PFNGLTEXIMAGE3DMULTISAMPLEPROC __glewTexImage3DMultisample = NULL; PFNGLTEXSTORAGE1DPROC __glewTexStorage1D = NULL; PFNGLTEXSTORAGE2DPROC __glewTexStorage2D = NULL; PFNGLTEXSTORAGE3DPROC __glewTexStorage3D = NULL; -PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL; -PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL; -PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL; PFNGLTEXSTORAGE2DMULTISAMPLEPROC __glewTexStorage2DMultisample = NULL; PFNGLTEXSTORAGE3DMULTISAMPLEPROC __glewTexStorage3DMultisample = NULL; @@ -1655,6 +1686,10 @@ PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL; PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL; PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL; +PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC __glewDrawArraysInstancedBaseInstanceEXT = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseInstanceEXT = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC __glewDrawElementsInstancedBaseVertexBaseInstanceEXT = NULL; + PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL; PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL; PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL; @@ -1663,10 +1698,20 @@ PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL; PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC __glewBindFragDataLocationIndexedEXT = NULL; +PFNGLGETFRAGDATAINDEXEXTPROC __glewGetFragDataIndexEXT = NULL; +PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC __glewGetProgramResourceLocationIndexEXT = NULL; + PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL; PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL; +PFNGLBUFFERSTORAGEEXTPROC __glewBufferStorageEXT = NULL; +PFNGLNAMEDBUFFERSTORAGEEXTPROC __glewNamedBufferStorageEXT = NULL; + +PFNGLCLEARTEXIMAGEEXTPROC __glewClearTexImageEXT = NULL; +PFNGLCLEARTEXSUBIMAGEEXTPROC __glewClearTexSubImageEXT = NULL; + PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL; PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL; @@ -1690,6 +1735,8 @@ PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL; PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL; PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL; +PFNGLCOPYIMAGESUBDATAEXTPROC __glewCopyImageSubDataEXT = NULL; + PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL; PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL; PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL; @@ -1923,6 +1970,10 @@ PFNGLVERTEXARRAYVERTEXATTRIBIOFFSETEXTPROC __glewVertexArrayVertexAttribIOffsetE PFNGLVERTEXARRAYVERTEXATTRIBOFFSETEXTPROC __glewVertexArrayVertexAttribOffsetEXT = NULL; PFNGLVERTEXARRAYVERTEXOFFSETEXTPROC __glewVertexArrayVertexOffsetEXT = NULL; +PFNGLDISCARDFRAMEBUFFEREXTPROC __glewDiscardFramebufferEXT = NULL; + +PFNGLDRAWBUFFERSEXTPROC __glewDrawBuffersEXT = NULL; + PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL; PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL; PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL; @@ -1930,11 +1981,28 @@ PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL; PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL; PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL; +PFNGLBLENDEQUATIONSEPARATEIEXTPROC __glewBlendEquationSeparateiEXT = NULL; +PFNGLBLENDEQUATIONIEXTPROC __glewBlendEquationiEXT = NULL; +PFNGLBLENDFUNCSEPARATEIEXTPROC __glewBlendFuncSeparateiEXT = NULL; +PFNGLBLENDFUNCIEXTPROC __glewBlendFunciEXT = NULL; +PFNGLCOLORMASKIEXTPROC __glewColorMaskiEXT = NULL; +PFNGLDISABLEIEXTPROC __glewDisableiEXT = NULL; +PFNGLENABLEIEXTPROC __glewEnableiEXT = NULL; +PFNGLISENABLEDIEXTPROC __glewIsEnablediEXT = NULL; + +PFNGLDRAWELEMENTSBASEVERTEXEXTPROC __glewDrawElementsBaseVertexEXT = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC __glewDrawElementsInstancedBaseVertexEXT = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC __glewDrawRangeElementsBaseVertexEXT = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC __glewMultiDrawElementsBaseVertexEXT = NULL; + PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL; PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL; PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL; +PFNGLBUFFERSTORAGEEXTERNALEXTPROC __glewBufferStorageExternalEXT = NULL; +PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC __glewNamedBufferStorageExternalEXT = NULL; + PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL; PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL; PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL; @@ -2039,16 +2107,55 @@ PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL; PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL; +PFNGLVERTEXATTRIBDIVISOREXTPROC __glewVertexAttribDivisorEXT = NULL; + PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL; PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL; PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC __glewFlushMappedBufferRangeEXT = NULL; +PFNGLMAPBUFFERRANGEEXTPROC __glewMapBufferRangeEXT = NULL; + +PFNGLBUFFERSTORAGEMEMEXTPROC __glewBufferStorageMemEXT = NULL; +PFNGLCREATEMEMORYOBJECTSEXTPROC __glewCreateMemoryObjectsEXT = NULL; +PFNGLDELETEMEMORYOBJECTSEXTPROC __glewDeleteMemoryObjectsEXT = NULL; +PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC __glewGetMemoryObjectParameterivEXT = NULL; +PFNGLGETUNSIGNEDBYTEI_VEXTPROC __glewGetUnsignedBytei_vEXT = NULL; +PFNGLGETUNSIGNEDBYTEVEXTPROC __glewGetUnsignedBytevEXT = NULL; +PFNGLISMEMORYOBJECTEXTPROC __glewIsMemoryObjectEXT = NULL; +PFNGLMEMORYOBJECTPARAMETERIVEXTPROC __glewMemoryObjectParameterivEXT = NULL; +PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC __glewNamedBufferStorageMemEXT = NULL; +PFNGLTEXSTORAGEMEM1DEXTPROC __glewTexStorageMem1DEXT = NULL; +PFNGLTEXSTORAGEMEM2DEXTPROC __glewTexStorageMem2DEXT = NULL; +PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC __glewTexStorageMem2DMultisampleEXT = NULL; +PFNGLTEXSTORAGEMEM3DEXTPROC __glewTexStorageMem3DEXT = NULL; +PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC __glewTexStorageMem3DMultisampleEXT = NULL; +PFNGLTEXTURESTORAGEMEM1DEXTPROC __glewTextureStorageMem1DEXT = NULL; +PFNGLTEXTURESTORAGEMEM2DEXTPROC __glewTextureStorageMem2DEXT = NULL; +PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC __glewTextureStorageMem2DMultisampleEXT = NULL; +PFNGLTEXTURESTORAGEMEM3DEXTPROC __glewTextureStorageMem3DEXT = NULL; +PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC __glewTextureStorageMem3DMultisampleEXT = NULL; + +PFNGLIMPORTMEMORYFDEXTPROC __glewImportMemoryFdEXT = NULL; + +PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC __glewImportMemoryWin32HandleEXT = NULL; +PFNGLIMPORTMEMORYWIN32NAMEEXTPROC __glewImportMemoryWin32NameEXT = NULL; + PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL; PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL; +PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC __glewMultiDrawArraysIndirectEXT = NULL; +PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC __glewMultiDrawElementsIndirectEXT = NULL; + PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL; PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC __glewFramebufferTexture2DMultisampleEXT = NULL; + +PFNGLDRAWBUFFERSINDEXEDEXTPROC __glewDrawBuffersIndexedEXT = NULL; +PFNGLGETINTEGERI_VEXTPROC __glewGetIntegeri_vEXT = NULL; +PFNGLREADBUFFERINDEXEDEXTPROC __glewReadBufferIndexedEXT = NULL; + PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL; PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL; PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL; @@ -2096,6 +2203,19 @@ PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL; PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL; PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL; +PFNGLDELETESEMAPHORESEXTPROC __glewDeleteSemaphoresEXT = NULL; +PFNGLGENSEMAPHORESEXTPROC __glewGenSemaphoresEXT = NULL; +PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC __glewGetSemaphoreParameterui64vEXT = NULL; +PFNGLISSEMAPHOREEXTPROC __glewIsSemaphoreEXT = NULL; +PFNGLSEMAPHOREPARAMETERUI64VEXTPROC __glewSemaphoreParameterui64vEXT = NULL; +PFNGLSIGNALSEMAPHOREEXTPROC __glewSignalSemaphoreEXT = NULL; +PFNGLWAITSEMAPHOREEXTPROC __glewWaitSemaphoreEXT = NULL; + +PFNGLIMPORTSEMAPHOREFDEXTPROC __glewImportSemaphoreFdEXT = NULL; + +PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC __glewImportSemaphoreWin32HandleEXT = NULL; +PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC __glewImportSemaphoreWin32NameEXT = NULL; + PFNGLACTIVEPROGRAMEXTPROC __glewActiveProgramEXT = NULL; PFNGLCREATESHADERPROGRAMEXTPROC __glewCreateShaderProgramEXT = NULL; PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL; @@ -2103,6 +2223,13 @@ PFNGLUSESHADERPROGRAMEXTPROC __glewUseShaderProgramEXT = NULL; PFNGLBINDIMAGETEXTUREEXTPROC __glewBindImageTextureEXT = NULL; PFNGLMEMORYBARRIEREXTPROC __glewMemoryBarrierEXT = NULL; +PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC __glewClearPixelLocalStorageuiEXT = NULL; +PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewFramebufferPixelLocalStorageSizeEXT = NULL; +PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC __glewGetFramebufferPixelLocalStorageSizeEXT = NULL; + +PFNGLTEXPAGECOMMITMENTEXTPROC __glewTexPageCommitmentEXT = NULL; +PFNGLTEXTUREPAGECOMMITMENTEXTPROC __glewTexturePageCommitmentEXT = NULL; + PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL; PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL; @@ -2131,6 +2258,15 @@ PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL; PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL; +PFNGLTEXSTORAGE1DEXTPROC __glewTexStorage1DEXT = NULL; +PFNGLTEXSTORAGE2DEXTPROC __glewTexStorage2DEXT = NULL; +PFNGLTEXSTORAGE3DEXTPROC __glewTexStorage3DEXT = NULL; +PFNGLTEXTURESTORAGE1DEXTPROC __glewTextureStorage1DEXT = NULL; +PFNGLTEXTURESTORAGE2DEXTPROC __glewTextureStorage2DEXT = NULL; +PFNGLTEXTURESTORAGE3DEXTPROC __glewTextureStorage3DEXT = NULL; + +PFNGLTEXTUREVIEWEXTPROC __glewTextureViewEXT = NULL; + PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL; PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL; @@ -2151,6 +2287,10 @@ PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL; PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL; PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL; +PFNGLBINDARRAYSETEXTPROC __glewBindArraySetEXT = NULL; +PFNGLCREATEARRAYSETEXTPROC __glewCreateArraySetExt = NULL; +PFNGLDELETEARRAYSETSEXTPROC __glewDeleteArraySetsEXT = NULL; + PFNGLGETVERTEXATTRIBLDVEXTPROC __glewGetVertexAttribLdvEXT = NULL; PFNGLVERTEXARRAYVERTEXATTRIBLOFFSETEXTPROC __glewVertexArrayVertexAttribLOffsetEXT = NULL; PFNGLVERTEXATTRIBL1DEXTPROC __glewVertexAttribL1dEXT = NULL; @@ -2210,6 +2350,9 @@ PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL; PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL; PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL; +PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC __glewAcquireKeyedMutexWin32EXT = NULL; +PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC __glewReleaseKeyedMutexWin32EXT = NULL; + PFNGLWINDOWRECTANGLESEXTPROC __glewWindowRectanglesEXT = NULL; PFNGLIMPORTSYNCEXTPROC __glewImportSyncEXT = NULL; @@ -2273,6 +2416,8 @@ PFNGLOBJECTPTRLABELPROC __glewObjectPtrLabel = NULL; PFNGLPOPDEBUGGROUPPROC __glewPopDebugGroup = NULL; PFNGLPUSHDEBUGGROUPPROC __glewPushDebugGroup = NULL; +PFNGLMAXSHADERCOMPILERTHREADSKHRPROC __glewMaxShaderCompilerThreadsKHR = NULL; + PFNGLGETNUNIFORMFVPROC __glewGetnUniformfv = NULL; PFNGLGETNUNIFORMIVPROC __glewGetnUniformiv = NULL; PFNGLGETNUNIFORMUIVPROC __glewGetnUniformuiv = NULL; @@ -2318,6 +2463,9 @@ PFNGLLGPUCOPYIMAGESUBDATANVXPROC __glewLGPUCopyImageSubDataNVX = NULL; PFNGLLGPUINTERLOCKNVXPROC __glewLGPUInterlockNVX = NULL; PFNGLLGPUNAMEDBUFFERSUBDATANVXPROC __glewLGPUNamedBufferSubDataNVX = NULL; +PFNGLSTEREOPARAMETERFNVPROC __glewStereoParameterfNV = NULL; +PFNGLSTEREOPARAMETERINVPROC __glewStereoParameteriNV = NULL; + PFNGLMULTIDRAWARRAYSINDIRECTBINDLESSNVPROC __glewMultiDrawArraysIndirectBindlessNV = NULL; PFNGLMULTIDRAWELEMENTSINDIRECTBINDLESSNVPROC __glewMultiDrawElementsIndirectBindlessNV = NULL; @@ -2370,12 +2518,19 @@ PFNGLCONSERVATIVERASTERPARAMETERFNVPROC __glewConservativeRasterParameterfNV = N PFNGLCONSERVATIVERASTERPARAMETERINVPROC __glewConservativeRasterParameteriNV = NULL; +PFNGLCOPYBUFFERSUBDATANVPROC __glewCopyBufferSubDataNV = NULL; + PFNGLCOPYIMAGESUBDATANVPROC __glewCopyImageSubDataNV = NULL; PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL; PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL; PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL; +PFNGLDRAWBUFFERSNVPROC __glewDrawBuffersNV = NULL; + +PFNGLDRAWARRAYSINSTANCEDNVPROC __glewDrawArraysInstancedNV = NULL; +PFNGLDRAWELEMENTSINSTANCEDNVPROC __glewDrawElementsInstancedNV = NULL; + PFNGLDRAWTEXTURENVPROC __glewDrawTextureNV = NULL; PFNGLDRAWVKIMAGENVPROC __glewDrawVkImageNV = NULL; @@ -2415,6 +2570,10 @@ PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL; PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL; +PFNGLBLITFRAMEBUFFERNVPROC __glewBlitFramebufferNV = NULL; + +PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC __glewRenderbufferStorageMultisampleNV = NULL; + PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL; PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL; @@ -2527,8 +2686,17 @@ PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL; PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL; PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL; +PFNGLVERTEXATTRIBDIVISORNVPROC __glewVertexAttribDivisorNV = NULL; + PFNGLGETINTERNALFORMATSAMPLEIVNVPROC __glewGetInternalformatSampleivNV = NULL; +PFNGLUNIFORMMATRIX2X3FVNVPROC __glewUniformMatrix2x3fvNV = NULL; +PFNGLUNIFORMMATRIX2X4FVNVPROC __glewUniformMatrix2x4fvNV = NULL; +PFNGLUNIFORMMATRIX3X2FVNVPROC __glewUniformMatrix3x2fvNV = NULL; +PFNGLUNIFORMMATRIX3X4FVNVPROC __glewUniformMatrix3x4fvNV = NULL; +PFNGLUNIFORMMATRIX4X2FVNVPROC __glewUniformMatrix4x2fvNV = NULL; +PFNGLUNIFORMMATRIX4X3FVNVPROC __glewUniformMatrix4x3fvNV = NULL; + PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL; PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL; PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL; @@ -2612,6 +2780,8 @@ PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL; PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL; PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL; +PFNGLPOLYGONMODENVPROC __glewPolygonModeNV = NULL; + PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL; PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL; PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL; @@ -2656,6 +2826,13 @@ PFNGLPROGRAMUNIFORMUI64VNVPROC __glewProgramUniformui64vNV = NULL; PFNGLUNIFORMUI64NVPROC __glewUniformui64NV = NULL; PFNGLUNIFORMUI64VNVPROC __glewUniformui64vNV = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DNVPROC __glewCompressedTexImage3DNV = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC __glewCompressedTexSubImage3DNV = NULL; +PFNGLCOPYTEXSUBIMAGE3DNVPROC __glewCopyTexSubImage3DNV = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERNVPROC __glewFramebufferTextureLayerNV = NULL; +PFNGLTEXIMAGE3DNVPROC __glewTexImage3DNV = NULL; +PFNGLTEXSUBIMAGE3DNVPROC __glewTexSubImage3DNV = NULL; + PFNGLTEXTUREBARRIERNVPROC __glewTextureBarrierNV = NULL; PFNGLTEXIMAGE2DMULTISAMPLECOVERAGENVPROC __glewTexImage2DMultisampleCoverageNV = NULL; @@ -2810,17 +2987,54 @@ PFNGLVIDEOCAPTURESTREAMPARAMETERDVNVPROC __glewVideoCaptureStreamParameterdvNV = PFNGLVIDEOCAPTURESTREAMPARAMETERFVNVPROC __glewVideoCaptureStreamParameterfvNV = NULL; PFNGLVIDEOCAPTURESTREAMPARAMETERIVNVPROC __glewVideoCaptureStreamParameterivNV = NULL; +PFNGLDEPTHRANGEARRAYFVNVPROC __glewDepthRangeArrayfvNV = NULL; +PFNGLDEPTHRANGEINDEXEDFNVPROC __glewDepthRangeIndexedfNV = NULL; +PFNGLDISABLEINVPROC __glewDisableiNV = NULL; +PFNGLENABLEINVPROC __glewEnableiNV = NULL; +PFNGLGETFLOATI_VNVPROC __glewGetFloati_vNV = NULL; +PFNGLISENABLEDINVPROC __glewIsEnablediNV = NULL; +PFNGLSCISSORARRAYVNVPROC __glewScissorArrayvNV = NULL; +PFNGLSCISSORINDEXEDNVPROC __glewScissorIndexedNV = NULL; +PFNGLSCISSORINDEXEDVNVPROC __glewScissorIndexedvNV = NULL; +PFNGLVIEWPORTARRAYVNVPROC __glewViewportArrayvNV = NULL; +PFNGLVIEWPORTINDEXEDFNVPROC __glewViewportIndexedfNV = NULL; +PFNGLVIEWPORTINDEXEDFVNVPROC __glewViewportIndexedfvNV = NULL; + PFNGLVIEWPORTSWIZZLENVPROC __glewViewportSwizzleNV = NULL; -PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL; -PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL; -PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL; -PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL; -PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL; -PFNGLORTHOFOESPROC __glewOrthofOES = NULL; - PFNGLFRAMEBUFFERTEXTUREMULTIVIEWOVRPROC __glewFramebufferTextureMultiviewOVR = NULL; +PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC __glewFramebufferTextureMultisampleMultiviewOVR = NULL; + +PFNGLALPHAFUNCQCOMPROC __glewAlphaFuncQCOM = NULL; + +PFNGLDISABLEDRIVERCONTROLQCOMPROC __glewDisableDriverControlQCOM = NULL; +PFNGLENABLEDRIVERCONTROLQCOMPROC __glewEnableDriverControlQCOM = NULL; +PFNGLGETDRIVERCONTROLSTRINGQCOMPROC __glewGetDriverControlStringQCOM = NULL; +PFNGLGETDRIVERCONTROLSQCOMPROC __glewGetDriverControlsQCOM = NULL; + +PFNGLEXTGETBUFFERPOINTERVQCOMPROC __glewExtGetBufferPointervQCOM = NULL; +PFNGLEXTGETBUFFERSQCOMPROC __glewExtGetBuffersQCOM = NULL; +PFNGLEXTGETFRAMEBUFFERSQCOMPROC __glewExtGetFramebuffersQCOM = NULL; +PFNGLEXTGETRENDERBUFFERSQCOMPROC __glewExtGetRenderbuffersQCOM = NULL; +PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC __glewExtGetTexLevelParameterivQCOM = NULL; +PFNGLEXTGETTEXSUBIMAGEQCOMPROC __glewExtGetTexSubImageQCOM = NULL; +PFNGLEXTGETTEXTURESQCOMPROC __glewExtGetTexturesQCOM = NULL; +PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC __glewExtTexObjectStateOverrideiQCOM = NULL; + +PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC __glewExtGetProgramBinarySourceQCOM = NULL; +PFNGLEXTGETPROGRAMSQCOMPROC __glewExtGetProgramsQCOM = NULL; +PFNGLEXTGETSHADERSQCOMPROC __glewExtGetShadersQCOM = NULL; +PFNGLEXTISPROGRAMBINARYQCOMPROC __glewExtIsProgramBinaryQCOM = NULL; + +PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC __glewFramebufferFoveationConfigQCOM = NULL; +PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC __glewFramebufferFoveationParametersQCOM = NULL; + +PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC __glewFramebufferFetchBarrierQCOM = NULL; + +PFNGLENDTILINGQCOMPROC __glewEndTilingQCOM = NULL; +PFNGLSTARTTILINGQCOMPROC __glewStartTilingQCOM = NULL; + PFNGLALPHAFUNCXPROC __glewAlphaFuncx = NULL; PFNGLCLEARCOLORXPROC __glewClearColorx = NULL; PFNGLCLEARDEPTHXPROC __glewClearDepthx = NULL; @@ -2885,6 +3099,13 @@ PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL; PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL; PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL; +PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC __glewInterleavedTextureCoordSetsSGIS = NULL; +PFNGLSELECTTEXTURECOORDSETSGISPROC __glewSelectTextureCoordSetSGIS = NULL; +PFNGLSELECTTEXTURESGISPROC __glewSelectTextureSGIS = NULL; +PFNGLSELECTTEXTURETRANSFORMSGISPROC __glewSelectTextureTransformSGIS = NULL; + +PFNGLMULTISAMPLESUBRECTPOSSGISPROC __glewMultisampleSubRectPosSGIS = NULL; + PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL; PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL; @@ -2901,8 +3122,14 @@ PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL; PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL; PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL; +PFNGLADDRESSSPACEPROC __glewAddressSpace = NULL; +PFNGLDATAPIPEPROC __glewDataPipe = NULL; + PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL; +PFNGLFOGLAYERSSGIXPROC __glewFogLayersSGIX = NULL; +PFNGLGETFOGLAYERSSGIXPROC __glewGetFogLayersSGIX = NULL; + PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL; PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL; @@ -2925,8 +3152,33 @@ PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL; PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL; +PFNGLIGLOOINTERFACESGIXPROC __glewIglooInterfaceSGIX = NULL; + +PFNGLALLOCMPEGPREDICTORSSGIXPROC __glewAllocMPEGPredictorsSGIX = NULL; +PFNGLDELETEMPEGPREDICTORSSGIXPROC __glewDeleteMPEGPredictorsSGIX = NULL; +PFNGLGENMPEGPREDICTORSSGIXPROC __glewGenMPEGPredictorsSGIX = NULL; +PFNGLGETMPEGPARAMETERFVSGIXPROC __glewGetMPEGParameterfvSGIX = NULL; +PFNGLGETMPEGPARAMETERIVSGIXPROC __glewGetMPEGParameterivSGIX = NULL; +PFNGLGETMPEGPREDICTORSGIXPROC __glewGetMPEGPredictorSGIX = NULL; +PFNGLGETMPEGQUANTTABLEUBVPROC __glewGetMPEGQuantTableubv = NULL; +PFNGLISMPEGPREDICTORSGIXPROC __glewIsMPEGPredictorSGIX = NULL; +PFNGLMPEGPREDICTORSGIXPROC __glewMPEGPredictorSGIX = NULL; +PFNGLMPEGQUANTTABLEUBVPROC __glewMPEGQuantTableubv = NULL; +PFNGLSWAPMPEGPREDICTORSSGIXPROC __glewSwapMPEGPredictorsSGIX = NULL; + +PFNGLGETNONLINLIGHTFVSGIXPROC __glewGetNonlinLightfvSGIX = NULL; +PFNGLGETNONLINMATERIALFVSGIXPROC __glewGetNonlinMaterialfvSGIX = NULL; +PFNGLNONLINLIGHTFVSGIXPROC __glewNonlinLightfvSGIX = NULL; +PFNGLNONLINMATERIALFVSGIXPROC __glewNonlinMaterialfvSGIX = NULL; + PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL; +PFNGLDEFORMSGIXPROC __glewDeformSGIX = NULL; +PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC __glewLoadIdentityDeformationMapSGIX = NULL; + +PFNGLMESHBREADTHSGIXPROC __glewMeshBreadthSGIX = NULL; +PFNGLMESHSTRIDESGIXPROC __glewMeshStrideSGIX = NULL; + PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL; PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL; @@ -2936,6 +3188,16 @@ PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL; PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL; +PFNGLGETVECTOROPERATIONSGIXPROC __glewGetVectorOperationSGIX = NULL; +PFNGLVECTOROPERATIONSGIXPROC __glewVectorOperationSGIX = NULL; + +PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC __glewAreVertexArraysResidentSGIX = NULL; +PFNGLBINDVERTEXARRAYSGIXPROC __glewBindVertexArraySGIX = NULL; +PFNGLDELETEVERTEXARRAYSSGIXPROC __glewDeleteVertexArraysSGIX = NULL; +PFNGLGENVERTEXARRAYSSGIXPROC __glewGenVertexArraysSGIX = NULL; +PFNGLISVERTEXARRAYSGIXPROC __glewIsVertexArraySGIX = NULL; +PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC __glewPrioritizeVertexArraysSGIX = NULL; + PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL; PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL; PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL; @@ -2944,6 +3206,14 @@ PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL; PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL; PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL; +PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC __glewGetPixelTransformParameterfvSGI = NULL; +PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC __glewGetPixelTransformParameterivSGI = NULL; +PFNGLPIXELTRANSFORMPARAMETERFSGIPROC __glewPixelTransformParameterfSGI = NULL; +PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC __glewPixelTransformParameterfvSGI = NULL; +PFNGLPIXELTRANSFORMPARAMETERISGIPROC __glewPixelTransformParameteriSGI = NULL; +PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC __glewPixelTransformParameterivSGI = NULL; +PFNGLPIXELTRANSFORMSGIPROC __glewPixelTransformSGI = NULL; + PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL; PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL; @@ -3026,15 +3296,21 @@ GLboolean __GLEW_VERSION_4_2 = GL_FALSE; GLboolean __GLEW_VERSION_4_3 = GL_FALSE; GLboolean __GLEW_VERSION_4_4 = GL_FALSE; GLboolean __GLEW_VERSION_4_5 = GL_FALSE; +GLboolean __GLEW_VERSION_4_6 = GL_FALSE; GLboolean __GLEW_3DFX_multisample = GL_FALSE; GLboolean __GLEW_3DFX_tbuffer = GL_FALSE; GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE; GLboolean __GLEW_AMD_blend_minmax_factor = GL_FALSE; +GLboolean __GLEW_AMD_compressed_3DC_texture = GL_FALSE; +GLboolean __GLEW_AMD_compressed_ATC_texture = GL_FALSE; 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_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_int16 = GL_FALSE; GLboolean __GLEW_AMD_gpu_shader_int64 = GL_FALSE; GLboolean __GLEW_AMD_interleaved_elements = GL_FALSE; GLboolean __GLEW_AMD_multi_draw_indirect = GL_FALSE; @@ -3042,22 +3318,26 @@ GLboolean __GLEW_AMD_name_gen_delete = GL_FALSE; GLboolean __GLEW_AMD_occlusion_query_event = GL_FALSE; GLboolean __GLEW_AMD_performance_monitor = GL_FALSE; GLboolean __GLEW_AMD_pinned_memory = GL_FALSE; +GLboolean __GLEW_AMD_program_binary_Z400 = GL_FALSE; GLboolean __GLEW_AMD_query_buffer_object = GL_FALSE; GLboolean __GLEW_AMD_sample_positions = GL_FALSE; 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_stencil_export = GL_FALSE; GLboolean __GLEW_AMD_shader_stencil_value_export = GL_FALSE; GLboolean __GLEW_AMD_shader_trinary_minmax = GL_FALSE; GLboolean __GLEW_AMD_sparse_texture = GL_FALSE; GLboolean __GLEW_AMD_stencil_operation_extended = GL_FALSE; +GLboolean __GLEW_AMD_texture_gather_bias_lod = GL_FALSE; GLboolean __GLEW_AMD_texture_texture4 = GL_FALSE; GLboolean __GLEW_AMD_transform_feedback3_lines_triangles = GL_FALSE; GLboolean __GLEW_AMD_transform_feedback4 = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_layer = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_tessellator = GL_FALSE; GLboolean __GLEW_AMD_vertex_shader_viewport_index = GL_FALSE; +GLboolean __GLEW_ANDROID_extension_pack_es31a = GL_FALSE; GLboolean __GLEW_ANGLE_depth_texture = GL_FALSE; GLboolean __GLEW_ANGLE_framebuffer_blit = GL_FALSE; GLboolean __GLEW_ANGLE_framebuffer_multisample = GL_FALSE; @@ -3072,15 +3352,24 @@ GLboolean __GLEW_ANGLE_timer_query = GL_FALSE; GLboolean __GLEW_ANGLE_translated_shader_source = GL_FALSE; GLboolean __GLEW_APPLE_aux_depth_stencil = GL_FALSE; GLboolean __GLEW_APPLE_client_storage = GL_FALSE; +GLboolean __GLEW_APPLE_clip_distance = GL_FALSE; +GLboolean __GLEW_APPLE_color_buffer_packed_float = GL_FALSE; +GLboolean __GLEW_APPLE_copy_texture_levels = GL_FALSE; GLboolean __GLEW_APPLE_element_array = GL_FALSE; GLboolean __GLEW_APPLE_fence = GL_FALSE; GLboolean __GLEW_APPLE_float_pixels = GL_FALSE; GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE; +GLboolean __GLEW_APPLE_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_APPLE_object_purgeable = GL_FALSE; GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE; GLboolean __GLEW_APPLE_rgb_422 = GL_FALSE; GLboolean __GLEW_APPLE_row_bytes = GL_FALSE; GLboolean __GLEW_APPLE_specular_vector = GL_FALSE; +GLboolean __GLEW_APPLE_sync = GL_FALSE; +GLboolean __GLEW_APPLE_texture_2D_limited_npot = GL_FALSE; +GLboolean __GLEW_APPLE_texture_format_BGRA8888 = GL_FALSE; +GLboolean __GLEW_APPLE_texture_max_level = GL_FALSE; +GLboolean __GLEW_APPLE_texture_packed_float = GL_FALSE; GLboolean __GLEW_APPLE_texture_range = GL_FALSE; GLboolean __GLEW_APPLE_transform_hint = GL_FALSE; GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE; @@ -3162,6 +3451,7 @@ GLboolean __GLEW_ARB_pipeline_statistics_query = GL_FALSE; GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE; GLboolean __GLEW_ARB_point_parameters = GL_FALSE; GLboolean __GLEW_ARB_point_sprite = GL_FALSE; +GLboolean __GLEW_ARB_polygon_offset_clamp = GL_FALSE; GLboolean __GLEW_ARB_post_depth_coverage = GL_FALSE; GLboolean __GLEW_ARB_program_interface_query = GL_FALSE; GLboolean __GLEW_ARB_provoking_vertex = GL_FALSE; @@ -3203,6 +3493,7 @@ GLboolean __GLEW_ARB_sparse_buffer = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture2 = GL_FALSE; GLboolean __GLEW_ARB_sparse_texture_clamp = GL_FALSE; +GLboolean __GLEW_ARB_spirv_extensions = GL_FALSE; GLboolean __GLEW_ARB_stencil_texturing = GL_FALSE; GLboolean __GLEW_ARB_sync = GL_FALSE; GLboolean __GLEW_ARB_tessellation_shader = GL_FALSE; @@ -3220,6 +3511,7 @@ GLboolean __GLEW_ARB_texture_env_add = GL_FALSE; GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE; GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE; GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE; +GLboolean __GLEW_ARB_texture_filter_anisotropic = GL_FALSE; GLboolean __GLEW_ARB_texture_filter_minmax = GL_FALSE; GLboolean __GLEW_ARB_texture_float = GL_FALSE; GLboolean __GLEW_ARB_texture_gather = GL_FALSE; @@ -3256,6 +3548,11 @@ GLboolean __GLEW_ARB_vertex_type_10f_11f_11f_rev = GL_FALSE; GLboolean __GLEW_ARB_vertex_type_2_10_10_10_rev = GL_FALSE; GLboolean __GLEW_ARB_viewport_array = GL_FALSE; GLboolean __GLEW_ARB_window_pos = GL_FALSE; +GLboolean __GLEW_ARM_mali_program_binary = GL_FALSE; +GLboolean __GLEW_ARM_mali_shader_binary = GL_FALSE; +GLboolean __GLEW_ARM_rgba8 = GL_FALSE; +GLboolean __GLEW_ARM_shader_framebuffer_fetch = GL_FALSE; +GLboolean __GLEW_ARM_shader_framebuffer_fetch_depth_stencil = GL_FALSE; GLboolean __GLEW_ATIX_point_sprites = GL_FALSE; GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE; GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE; @@ -3277,52 +3574,86 @@ 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_EXT_422_pixels = GL_FALSE; GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; +GLboolean __GLEW_EXT_EGL_image_array = GL_FALSE; +GLboolean __GLEW_EXT_YUV_target = GL_FALSE; GLboolean __GLEW_EXT_abgr = GL_FALSE; +GLboolean __GLEW_EXT_base_instance = GL_FALSE; GLboolean __GLEW_EXT_bgra = GL_FALSE; GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE; GLboolean __GLEW_EXT_blend_color = GL_FALSE; GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE; +GLboolean __GLEW_EXT_blend_func_extended = GL_FALSE; GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE; GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE; 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_cull_distance = GL_FALSE; GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE; GLboolean __GLEW_EXT_cmyka = GL_FALSE; +GLboolean __GLEW_EXT_color_buffer_float = GL_FALSE; +GLboolean __GLEW_EXT_color_buffer_half_float = GL_FALSE; GLboolean __GLEW_EXT_color_subtable = GL_FALSE; GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE; +GLboolean __GLEW_EXT_compressed_ETC1_RGB8_sub_texture = GL_FALSE; +GLboolean __GLEW_EXT_conservative_depth = GL_FALSE; GLboolean __GLEW_EXT_convolution = GL_FALSE; GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE; +GLboolean __GLEW_EXT_copy_image = GL_FALSE; GLboolean __GLEW_EXT_copy_texture = GL_FALSE; GLboolean __GLEW_EXT_cull_vertex = GL_FALSE; GLboolean __GLEW_EXT_debug_label = GL_FALSE; 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_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_external_buffer = GL_FALSE; +GLboolean __GLEW_EXT_float_blend = GL_FALSE; GLboolean __GLEW_EXT_fog_coord = GL_FALSE; +GLboolean __GLEW_EXT_frag_depth = GL_FALSE; GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_multisample_blit_scaled = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE; GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_geometry_point_size = GL_FALSE; +GLboolean __GLEW_EXT_geometry_shader = GL_FALSE; GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE; GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE; GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE; +GLboolean __GLEW_EXT_gpu_shader5 = GL_FALSE; GLboolean __GLEW_EXT_histogram = GL_FALSE; GLboolean __GLEW_EXT_index_array_formats = GL_FALSE; GLboolean __GLEW_EXT_index_func = GL_FALSE; GLboolean __GLEW_EXT_index_material = GL_FALSE; GLboolean __GLEW_EXT_index_texture = GL_FALSE; +GLboolean __GLEW_EXT_instanced_arrays = GL_FALSE; GLboolean __GLEW_EXT_light_texture = GL_FALSE; +GLboolean __GLEW_EXT_map_buffer_range = GL_FALSE; +GLboolean __GLEW_EXT_memory_object = GL_FALSE; +GLboolean __GLEW_EXT_memory_object_fd = GL_FALSE; +GLboolean __GLEW_EXT_memory_object_win32 = GL_FALSE; GLboolean __GLEW_EXT_misc_attribute = GL_FALSE; GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE; +GLboolean __GLEW_EXT_multi_draw_indirect = GL_FALSE; +GLboolean __GLEW_EXT_multiple_textures = GL_FALSE; GLboolean __GLEW_EXT_multisample = GL_FALSE; +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_packed_depth_stencil = GL_FALSE; GLboolean __GLEW_EXT_packed_float = GL_FALSE; GLboolean __GLEW_EXT_packed_pixels = GL_FALSE; @@ -3335,17 +3666,35 @@ 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_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_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_sRGB_write_control = GL_FALSE; GLboolean __GLEW_EXT_scene_marker = GL_FALSE; GLboolean __GLEW_EXT_secondary_color = GL_FALSE; +GLboolean __GLEW_EXT_semaphore = GL_FALSE; +GLboolean __GLEW_EXT_semaphore_fd = GL_FALSE; +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_group_vote = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_formatted = GL_FALSE; GLboolean __GLEW_EXT_shader_image_load_store = GL_FALSE; +GLboolean __GLEW_EXT_shader_implicit_conversions = GL_FALSE; GLboolean __GLEW_EXT_shader_integer_mix = GL_FALSE; +GLboolean __GLEW_EXT_shader_io_blocks = GL_FALSE; +GLboolean __GLEW_EXT_shader_non_constant_global_initializers = GL_FALSE; +GLboolean __GLEW_EXT_shader_pixel_local_storage = GL_FALSE; +GLboolean __GLEW_EXT_shader_pixel_local_storage2 = GL_FALSE; +GLboolean __GLEW_EXT_shader_texture_lod = GL_FALSE; GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE; +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_stencil_clear_tag = GL_FALSE; GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE; @@ -3355,11 +3704,15 @@ GLboolean __GLEW_EXT_texture = GL_FALSE; GLboolean __GLEW_EXT_texture3D = GL_FALSE; GLboolean __GLEW_EXT_texture_array = 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; +GLboolean __GLEW_EXT_texture_compression_bptc = GL_FALSE; 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_cube_map = GL_FALSE; +GLboolean __GLEW_EXT_texture_cube_map_array = GL_FALSE; GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE; GLboolean __GLEW_EXT_texture_env = GL_FALSE; GLboolean __GLEW_EXT_texture_env_add = GL_FALSE; @@ -3367,24 +3720,35 @@ GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE; 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_integer = GL_FALSE; GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE; GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_norm16 = GL_FALSE; GLboolean __GLEW_EXT_texture_object = GL_FALSE; GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE; GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE; +GLboolean __GLEW_EXT_texture_rg = GL_FALSE; GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_texture_sRGB_R8 = GL_FALSE; +GLboolean __GLEW_EXT_texture_sRGB_RG8 = GL_FALSE; GLboolean __GLEW_EXT_texture_sRGB_decode = GL_FALSE; GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE; GLboolean __GLEW_EXT_texture_snorm = GL_FALSE; +GLboolean __GLEW_EXT_texture_storage = GL_FALSE; GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE; +GLboolean __GLEW_EXT_texture_type_2_10_10_10_REV = GL_FALSE; +GLboolean __GLEW_EXT_texture_view = GL_FALSE; GLboolean __GLEW_EXT_timer_query = GL_FALSE; GLboolean __GLEW_EXT_transform_feedback = GL_FALSE; +GLboolean __GLEW_EXT_unpack_subimage = GL_FALSE; GLboolean __GLEW_EXT_vertex_array = GL_FALSE; GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE; +GLboolean __GLEW_EXT_vertex_array_setXXX = GL_FALSE; GLboolean __GLEW_EXT_vertex_attrib_64bit = GL_FALSE; GLboolean __GLEW_EXT_vertex_shader = GL_FALSE; 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_GREMEDY_frame_terminator = GL_FALSE; @@ -3413,6 +3777,7 @@ GLboolean __GLEW_KHR_blend_equation_advanced_coherent = GL_FALSE; GLboolean __GLEW_KHR_context_flush_control = GL_FALSE; GLboolean __GLEW_KHR_debug = GL_FALSE; GLboolean __GLEW_KHR_no_error = GL_FALSE; +GLboolean __GLEW_KHR_parallel_shader_compile = GL_FALSE; GLboolean __GLEW_KHR_robust_buffer_access_behavior = GL_FALSE; GLboolean __GLEW_KHR_robustness = GL_FALSE; GLboolean __GLEW_KHR_texture_compression_astc_hdr = GL_FALSE; @@ -3429,11 +3794,16 @@ GLboolean __GLEW_NVX_blend_equation_advanced_multi_draw_buffers = GL_FALSE; GLboolean __GLEW_NVX_conditional_render = GL_FALSE; GLboolean __GLEW_NVX_gpu_memory_info = GL_FALSE; GLboolean __GLEW_NVX_linked_gpu_multicast = GL_FALSE; +GLboolean __GLEW_NV_3dvision_settings = GL_FALSE; +GLboolean __GLEW_NV_EGL_stream_consumer_external = GL_FALSE; +GLboolean __GLEW_NV_alpha_to_coverage_dither_control = GL_FALSE; +GLboolean __GLEW_NV_bgr = GL_FALSE; GLboolean __GLEW_NV_bindless_multi_draw_indirect = GL_FALSE; GLboolean __GLEW_NV_bindless_multi_draw_indirect_count = GL_FALSE; GLboolean __GLEW_NV_bindless_texture = GL_FALSE; GLboolean __GLEW_NV_blend_equation_advanced = GL_FALSE; GLboolean __GLEW_NV_blend_equation_advanced_coherent = GL_FALSE; +GLboolean __GLEW_NV_blend_minmax_factor = GL_FALSE; GLboolean __GLEW_NV_blend_square = GL_FALSE; GLboolean __GLEW_NV_clip_space_w_scaling = GL_FALSE; GLboolean __GLEW_NV_command_list = GL_FALSE; @@ -3442,16 +3812,21 @@ 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_triangles = 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_range_unclamped = GL_FALSE; +GLboolean __GLEW_NV_draw_buffers = GL_FALSE; +GLboolean __GLEW_NV_draw_instanced = GL_FALSE; GLboolean __GLEW_NV_draw_texture = GL_FALSE; GLboolean __GLEW_NV_draw_vulkan_image = GL_FALSE; GLboolean __GLEW_NV_evaluators = GL_FALSE; +GLboolean __GLEW_NV_explicit_attrib_location = GL_FALSE; GLboolean __GLEW_NV_explicit_multisample = GL_FALSE; +GLboolean __GLEW_NV_fbo_color_attachments = GL_FALSE; GLboolean __GLEW_NV_fence = GL_FALSE; GLboolean __GLEW_NV_fill_rectangle = GL_FALSE; GLboolean __GLEW_NV_float_buffer = GL_FALSE; @@ -3462,8 +3837,11 @@ 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_interlock = GL_FALSE; +GLboolean __GLEW_NV_framebuffer_blit = GL_FALSE; GLboolean __GLEW_NV_framebuffer_mixed_samples = GL_FALSE; +GLboolean __GLEW_NV_framebuffer_multisample = GL_FALSE; GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE; +GLboolean __GLEW_NV_generate_mipmap_sRGB = GL_FALSE; GLboolean __GLEW_NV_geometry_program4 = GL_FALSE; GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE; GLboolean __GLEW_NV_geometry_shader_passthrough = GL_FALSE; @@ -3474,23 +3852,36 @@ GLboolean __GLEW_NV_gpu_program5_mem_extended = GL_FALSE; GLboolean __GLEW_NV_gpu_program_fp64 = GL_FALSE; GLboolean __GLEW_NV_gpu_shader5 = GL_FALSE; GLboolean __GLEW_NV_half_float = GL_FALSE; +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_multisample_coverage = GL_FALSE; GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; +GLboolean __GLEW_NV_non_square_matrices = GL_FALSE; GLboolean __GLEW_NV_occlusion_query = GL_FALSE; +GLboolean __GLEW_NV_pack_subimage = GL_FALSE; GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_NV_packed_float = GL_FALSE; +GLboolean __GLEW_NV_packed_float_linear = GL_FALSE; GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE; GLboolean __GLEW_NV_parameter_buffer_object2 = GL_FALSE; GLboolean __GLEW_NV_path_rendering = GL_FALSE; GLboolean __GLEW_NV_path_rendering_shared_edge = GL_FALSE; +GLboolean __GLEW_NV_pixel_buffer_object = GL_FALSE; GLboolean __GLEW_NV_pixel_data_range = GL_FALSE; +GLboolean __GLEW_NV_platform_binary = GL_FALSE; 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_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_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_shader_atomic_counters = GL_FALSE; @@ -3499,19 +3890,29 @@ GLboolean __GLEW_NV_shader_atomic_float64 = GL_FALSE; GLboolean __GLEW_NV_shader_atomic_fp16_vector = GL_FALSE; 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_thread_group = GL_FALSE; GLboolean __GLEW_NV_shader_thread_shuffle = 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; GLboolean __GLEW_NV_tessellation_program5 = GL_FALSE; GLboolean __GLEW_NV_texgen_emboss = GL_FALSE; GLboolean __GLEW_NV_texgen_reflection = GL_FALSE; +GLboolean __GLEW_NV_texture_array = GL_FALSE; GLboolean __GLEW_NV_texture_barrier = GL_FALSE; +GLboolean __GLEW_NV_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_NV_texture_compression_latc = GL_FALSE; +GLboolean __GLEW_NV_texture_compression_s3tc = GL_FALSE; +GLboolean __GLEW_NV_texture_compression_s3tc_update = GL_FALSE; GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE; GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE; GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE; GLboolean __GLEW_NV_texture_multisample = GL_FALSE; +GLboolean __GLEW_NV_texture_npot_2D_mipmap = GL_FALSE; GLboolean __GLEW_NV_texture_rectangle = GL_FALSE; +GLboolean __GLEW_NV_texture_rectangle_compressed = GL_FALSE; GLboolean __GLEW_NV_texture_shader = GL_FALSE; GLboolean __GLEW_NV_texture_shader2 = GL_FALSE; GLboolean __GLEW_NV_texture_shader3 = GL_FALSE; @@ -3530,19 +3931,28 @@ GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE; GLboolean __GLEW_NV_vertex_program3 = GL_FALSE; GLboolean __GLEW_NV_vertex_program4 = GL_FALSE; 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_byte_coordinates = GL_FALSE; -GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE; -GLboolean __GLEW_OES_read_format = GL_FALSE; -GLboolean __GLEW_OES_single_precision = GL_FALSE; GLboolean __GLEW_OML_interlace = GL_FALSE; GLboolean __GLEW_OML_resample = GL_FALSE; GLboolean __GLEW_OML_subsample = GL_FALSE; GLboolean __GLEW_OVR_multiview = GL_FALSE; GLboolean __GLEW_OVR_multiview2 = GL_FALSE; +GLboolean __GLEW_OVR_multiview_multisampled_render_to_texture = GL_FALSE; GLboolean __GLEW_PGI_misc_hints = GL_FALSE; GLboolean __GLEW_PGI_vertex_hints = GL_FALSE; +GLboolean __GLEW_QCOM_alpha_test = GL_FALSE; +GLboolean __GLEW_QCOM_binning_control = GL_FALSE; +GLboolean __GLEW_QCOM_driver_control = GL_FALSE; +GLboolean __GLEW_QCOM_extended_get = GL_FALSE; +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_tiled_rendering = GL_FALSE; +GLboolean __GLEW_QCOM_writeonly_rendering = GL_FALSE; GLboolean __GLEW_REGAL_ES1_0_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_ES1_1_compatibility = GL_FALSE; GLboolean __GLEW_REGAL_enable = GL_FALSE; @@ -3552,13 +3962,17 @@ GLboolean __GLEW_REGAL_log = GL_FALSE; GLboolean __GLEW_REGAL_proc_address = GL_FALSE; GLboolean __GLEW_REND_screen_coordinates = GL_FALSE; GLboolean __GLEW_S3_s3tc = GL_FALSE; +GLboolean __GLEW_SGIS_clip_band_hint = GL_FALSE; GLboolean __GLEW_SGIS_color_range = GL_FALSE; GLboolean __GLEW_SGIS_detail_texture = GL_FALSE; GLboolean __GLEW_SGIS_fog_function = GL_FALSE; GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE; +GLboolean __GLEW_SGIS_line_texgen = GL_FALSE; GLboolean __GLEW_SGIS_multisample = GL_FALSE; +GLboolean __GLEW_SGIS_multitexture = GL_FALSE; GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE; GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE; +GLboolean __GLEW_SGIS_shared_multisample = GL_FALSE; GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE; GLboolean __GLEW_SGIS_texture4D = GL_FALSE; GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE; @@ -3569,37 +3983,90 @@ GLboolean __GLEW_SGIS_texture_select = GL_FALSE; GLboolean __GLEW_SGIX_async = GL_FALSE; GLboolean __GLEW_SGIX_async_histogram = GL_FALSE; GLboolean __GLEW_SGIX_async_pixel = GL_FALSE; +GLboolean __GLEW_SGIX_bali_g_instruments = GL_FALSE; +GLboolean __GLEW_SGIX_bali_r_instruments = GL_FALSE; +GLboolean __GLEW_SGIX_bali_timer_instruments = GL_FALSE; GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE; +GLboolean __GLEW_SGIX_blend_cadd = GL_FALSE; +GLboolean __GLEW_SGIX_blend_cmultiply = GL_FALSE; +GLboolean __GLEW_SGIX_calligraphic_fragment = GL_FALSE; GLboolean __GLEW_SGIX_clipmap = GL_FALSE; +GLboolean __GLEW_SGIX_color_matrix_accuracy = GL_FALSE; +GLboolean __GLEW_SGIX_color_table_index_mode = GL_FALSE; +GLboolean __GLEW_SGIX_complex_polar = GL_FALSE; GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE; +GLboolean __GLEW_SGIX_cube_map = GL_FALSE; +GLboolean __GLEW_SGIX_cylinder_texgen = GL_FALSE; +GLboolean __GLEW_SGIX_datapipe = GL_FALSE; +GLboolean __GLEW_SGIX_decimation = GL_FALSE; +GLboolean __GLEW_SGIX_depth_pass_instrument = GL_FALSE; GLboolean __GLEW_SGIX_depth_texture = GL_FALSE; +GLboolean __GLEW_SGIX_dvc = GL_FALSE; GLboolean __GLEW_SGIX_flush_raster = GL_FALSE; +GLboolean __GLEW_SGIX_fog_blend = GL_FALSE; +GLboolean __GLEW_SGIX_fog_factor_to_alpha = GL_FALSE; +GLboolean __GLEW_SGIX_fog_layers = GL_FALSE; GLboolean __GLEW_SGIX_fog_offset = GL_FALSE; +GLboolean __GLEW_SGIX_fog_patchy = GL_FALSE; +GLboolean __GLEW_SGIX_fog_scale = GL_FALSE; GLboolean __GLEW_SGIX_fog_texture = GL_FALSE; +GLboolean __GLEW_SGIX_fragment_lighting_space = GL_FALSE; GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE; +GLboolean __GLEW_SGIX_fragments_instrument = GL_FALSE; GLboolean __GLEW_SGIX_framezoom = GL_FALSE; +GLboolean __GLEW_SGIX_icc_texture = GL_FALSE; +GLboolean __GLEW_SGIX_igloo_interface = GL_FALSE; +GLboolean __GLEW_SGIX_image_compression = GL_FALSE; +GLboolean __GLEW_SGIX_impact_pixel_texture = GL_FALSE; +GLboolean __GLEW_SGIX_instrument_error = GL_FALSE; GLboolean __GLEW_SGIX_interlace = GL_FALSE; GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE; +GLboolean __GLEW_SGIX_line_quality_hint = GL_FALSE; GLboolean __GLEW_SGIX_list_priority = GL_FALSE; +GLboolean __GLEW_SGIX_mpeg1 = GL_FALSE; +GLboolean __GLEW_SGIX_mpeg2 = GL_FALSE; +GLboolean __GLEW_SGIX_nonlinear_lighting_pervertex = GL_FALSE; +GLboolean __GLEW_SGIX_nurbs_eval = GL_FALSE; +GLboolean __GLEW_SGIX_occlusion_instrument = GL_FALSE; +GLboolean __GLEW_SGIX_packed_6bytes = GL_FALSE; GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE; GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_texture_lod = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_tiles = GL_FALSE; +GLboolean __GLEW_SGIX_polynomial_ffd = GL_FALSE; +GLboolean __GLEW_SGIX_quad_mesh = GL_FALSE; GLboolean __GLEW_SGIX_reference_plane = GL_FALSE; GLboolean __GLEW_SGIX_resample = GL_FALSE; +GLboolean __GLEW_SGIX_scalebias_hint = GL_FALSE; GLboolean __GLEW_SGIX_shadow = GL_FALSE; GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE; +GLboolean __GLEW_SGIX_slim = GL_FALSE; +GLboolean __GLEW_SGIX_spotlight_cutoff = GL_FALSE; GLboolean __GLEW_SGIX_sprite = GL_FALSE; +GLboolean __GLEW_SGIX_subdiv_patch = GL_FALSE; +GLboolean __GLEW_SGIX_subsample = GL_FALSE; GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE; GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE; GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE; GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE; +GLboolean __GLEW_SGIX_texture_mipmap_anisotropic = GL_FALSE; GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE; +GLboolean __GLEW_SGIX_texture_phase = GL_FALSE; GLboolean __GLEW_SGIX_texture_range = GL_FALSE; GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE; +GLboolean __GLEW_SGIX_texture_supersample = GL_FALSE; +GLboolean __GLEW_SGIX_vector_ops = GL_FALSE; +GLboolean __GLEW_SGIX_vertex_array_object = GL_FALSE; GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE; GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE; GLboolean __GLEW_SGIX_ycrcb = GL_FALSE; +GLboolean __GLEW_SGIX_ycrcb_subsample = GL_FALSE; +GLboolean __GLEW_SGIX_ycrcba = GL_FALSE; GLboolean __GLEW_SGI_color_matrix = GL_FALSE; GLboolean __GLEW_SGI_color_table = GL_FALSE; +GLboolean __GLEW_SGI_complex = GL_FALSE; +GLboolean __GLEW_SGI_complex_type = GL_FALSE; +GLboolean __GLEW_SGI_fft = GL_FALSE; GLboolean __GLEW_SGI_texture_color_table = GL_FALSE; GLboolean __GLEW_SUNX_constant_data = GL_FALSE; GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE; @@ -3610,6 +4077,7 @@ GLboolean __GLEW_SUN_slice_accum = GL_FALSE; GLboolean __GLEW_SUN_triangle_list = GL_FALSE; GLboolean __GLEW_SUN_vertex = 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; @@ -3665,6 +4133,9 @@ static const char * _glewExtensionLookup[] = { #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 @@ -3677,6 +4148,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_blend_minmax_factor "GL_AMD_blend_minmax_factor", #endif +#ifdef GL_AMD_compressed_3DC_texture + "GL_AMD_compressed_3DC_texture", +#endif +#ifdef GL_AMD_compressed_ATC_texture + "GL_AMD_compressed_ATC_texture", +#endif #ifdef GL_AMD_conservative_depth "GL_AMD_conservative_depth", #endif @@ -3689,9 +4166,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_draw_buffers_blend "GL_AMD_draw_buffers_blend", #endif +#ifdef GL_AMD_framebuffer_sample_positions + "GL_AMD_framebuffer_sample_positions", +#endif #ifdef GL_AMD_gcn_shader "GL_AMD_gcn_shader", #endif +#ifdef GL_AMD_gpu_shader_half_float + "GL_AMD_gpu_shader_half_float", +#endif +#ifdef GL_AMD_gpu_shader_int16 + "GL_AMD_gpu_shader_int16", +#endif #ifdef GL_AMD_gpu_shader_int64 "GL_AMD_gpu_shader_int64", #endif @@ -3713,6 +4199,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_pinned_memory "GL_AMD_pinned_memory", #endif +#ifdef GL_AMD_program_binary_Z400 + "GL_AMD_program_binary_Z400", +#endif #ifdef GL_AMD_query_buffer_object "GL_AMD_query_buffer_object", #endif @@ -3725,6 +4214,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_shader_atomic_counter_ops "GL_AMD_shader_atomic_counter_ops", #endif +#ifdef GL_AMD_shader_ballot + "GL_AMD_shader_ballot", +#endif #ifdef GL_AMD_shader_explicit_vertex_parameter "GL_AMD_shader_explicit_vertex_parameter", #endif @@ -3743,6 +4235,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_stencil_operation_extended "GL_AMD_stencil_operation_extended", #endif +#ifdef GL_AMD_texture_gather_bias_lod + "GL_AMD_texture_gather_bias_lod", +#endif #ifdef GL_AMD_texture_texture4 "GL_AMD_texture_texture4", #endif @@ -3761,6 +4256,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_AMD_vertex_shader_viewport_index "GL_AMD_vertex_shader_viewport_index", #endif +#ifdef GL_ANDROID_extension_pack_es31a + "GL_ANDROID_extension_pack_es31a", +#endif #ifdef GL_ANGLE_depth_texture "GL_ANGLE_depth_texture", #endif @@ -3803,6 +4301,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_APPLE_client_storage "GL_APPLE_client_storage", #endif +#ifdef GL_APPLE_clip_distance + "GL_APPLE_clip_distance", +#endif +#ifdef GL_APPLE_color_buffer_packed_float + "GL_APPLE_color_buffer_packed_float", +#endif +#ifdef GL_APPLE_copy_texture_levels + "GL_APPLE_copy_texture_levels", +#endif #ifdef GL_APPLE_element_array "GL_APPLE_element_array", #endif @@ -3815,6 +4322,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_APPLE_flush_buffer_range "GL_APPLE_flush_buffer_range", #endif +#ifdef GL_APPLE_framebuffer_multisample + "GL_APPLE_framebuffer_multisample", +#endif #ifdef GL_APPLE_object_purgeable "GL_APPLE_object_purgeable", #endif @@ -3830,6 +4340,21 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_APPLE_specular_vector "GL_APPLE_specular_vector", #endif +#ifdef GL_APPLE_sync + "GL_APPLE_sync", +#endif +#ifdef GL_APPLE_texture_2D_limited_npot + "GL_APPLE_texture_2D_limited_npot", +#endif +#ifdef GL_APPLE_texture_format_BGRA8888 + "GL_APPLE_texture_format_BGRA8888", +#endif +#ifdef GL_APPLE_texture_max_level + "GL_APPLE_texture_max_level", +#endif +#ifdef GL_APPLE_texture_packed_float + "GL_APPLE_texture_packed_float", +#endif #ifdef GL_APPLE_texture_range "GL_APPLE_texture_range", #endif @@ -4073,6 +4598,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ARB_point_sprite "GL_ARB_point_sprite", #endif +#ifdef GL_ARB_polygon_offset_clamp + "GL_ARB_polygon_offset_clamp", +#endif #ifdef GL_ARB_post_depth_coverage "GL_ARB_post_depth_coverage", #endif @@ -4196,6 +4724,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ARB_sparse_texture_clamp "GL_ARB_sparse_texture_clamp", #endif +#ifdef GL_ARB_spirv_extensions + "GL_ARB_spirv_extensions", +#endif #ifdef GL_ARB_stencil_texturing "GL_ARB_stencil_texturing", #endif @@ -4247,6 +4778,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ARB_texture_env_dot3 "GL_ARB_texture_env_dot3", #endif +#ifdef GL_ARB_texture_filter_anisotropic + "GL_ARB_texture_filter_anisotropic", +#endif #ifdef GL_ARB_texture_filter_minmax "GL_ARB_texture_filter_minmax", #endif @@ -4355,6 +4889,21 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_ARB_window_pos "GL_ARB_window_pos", #endif +#ifdef GL_ARM_mali_program_binary + "GL_ARM_mali_program_binary", +#endif +#ifdef GL_ARM_mali_shader_binary + "GL_ARM_mali_shader_binary", +#endif +#ifdef GL_ARM_rgba8 + "GL_ARM_rgba8", +#endif +#ifdef GL_ARM_shader_framebuffer_fetch + "GL_ARM_shader_framebuffer_fetch", +#endif +#ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil + "GL_ARM_shader_framebuffer_fetch_depth_stencil", +#endif #ifdef GL_ATIX_point_sprites "GL_ATIX_point_sprites", #endif @@ -4418,6 +4967,9 @@ 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", +#endif #ifdef GL_EGL_NV_robustness_video_memory_purge "GL_EGL_NV_robustness_video_memory_purge", #endif @@ -4427,9 +4979,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_Cg_shader "GL_EXT_Cg_shader", #endif +#ifdef GL_EXT_EGL_image_array + "GL_EXT_EGL_image_array", +#endif +#ifdef GL_EXT_YUV_target + "GL_EXT_YUV_target", +#endif #ifdef GL_EXT_abgr "GL_EXT_abgr", #endif +#ifdef GL_EXT_base_instance + "GL_EXT_base_instance", +#endif #ifdef GL_EXT_bgra "GL_EXT_bgra", #endif @@ -4442,6 +5003,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_blend_equation_separate "GL_EXT_blend_equation_separate", #endif +#ifdef GL_EXT_blend_func_extended + "GL_EXT_blend_func_extended", +#endif #ifdef GL_EXT_blend_func_separate "GL_EXT_blend_func_separate", #endif @@ -4454,24 +5018,48 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_blend_subtract "GL_EXT_blend_subtract", #endif +#ifdef GL_EXT_buffer_storage + "GL_EXT_buffer_storage", +#endif +#ifdef GL_EXT_clear_texture + "GL_EXT_clear_texture", +#endif +#ifdef GL_EXT_clip_cull_distance + "GL_EXT_clip_cull_distance", +#endif #ifdef GL_EXT_clip_volume_hint "GL_EXT_clip_volume_hint", #endif #ifdef GL_EXT_cmyka "GL_EXT_cmyka", #endif +#ifdef GL_EXT_color_buffer_float + "GL_EXT_color_buffer_float", +#endif +#ifdef GL_EXT_color_buffer_half_float + "GL_EXT_color_buffer_half_float", +#endif #ifdef GL_EXT_color_subtable "GL_EXT_color_subtable", #endif #ifdef GL_EXT_compiled_vertex_array "GL_EXT_compiled_vertex_array", #endif +#ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture + "GL_EXT_compressed_ETC1_RGB8_sub_texture", +#endif +#ifdef GL_EXT_conservative_depth + "GL_EXT_conservative_depth", +#endif #ifdef GL_EXT_convolution "GL_EXT_convolution", #endif #ifdef GL_EXT_coordinate_frame "GL_EXT_coordinate_frame", #endif +#ifdef GL_EXT_copy_image + "GL_EXT_copy_image", +#endif #ifdef GL_EXT_copy_texture "GL_EXT_copy_texture", #endif @@ -4490,18 +5078,39 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_direct_state_access "GL_EXT_direct_state_access", #endif +#ifdef GL_EXT_discard_framebuffer + "GL_EXT_discard_framebuffer", +#endif +#ifdef GL_EXT_draw_buffers + "GL_EXT_draw_buffers", +#endif #ifdef GL_EXT_draw_buffers2 "GL_EXT_draw_buffers2", #endif +#ifdef GL_EXT_draw_buffers_indexed + "GL_EXT_draw_buffers_indexed", +#endif +#ifdef GL_EXT_draw_elements_base_vertex + "GL_EXT_draw_elements_base_vertex", +#endif #ifdef GL_EXT_draw_instanced "GL_EXT_draw_instanced", #endif #ifdef GL_EXT_draw_range_elements "GL_EXT_draw_range_elements", #endif +#ifdef GL_EXT_external_buffer + "GL_EXT_external_buffer", +#endif +#ifdef GL_EXT_float_blend + "GL_EXT_float_blend", +#endif #ifdef GL_EXT_fog_coord "GL_EXT_fog_coord", #endif +#ifdef GL_EXT_frag_depth + "GL_EXT_frag_depth", +#endif #ifdef GL_EXT_fragment_lighting "GL_EXT_fragment_lighting", #endif @@ -4520,6 +5129,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_framebuffer_sRGB "GL_EXT_framebuffer_sRGB", #endif +#ifdef GL_EXT_geometry_point_size + "GL_EXT_geometry_point_size", +#endif +#ifdef GL_EXT_geometry_shader + "GL_EXT_geometry_shader", +#endif #ifdef GL_EXT_geometry_shader4 "GL_EXT_geometry_shader4", #endif @@ -4529,6 +5144,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_gpu_shader4 "GL_EXT_gpu_shader4", #endif +#ifdef GL_EXT_gpu_shader5 + "GL_EXT_gpu_shader5", +#endif #ifdef GL_EXT_histogram "GL_EXT_histogram", #endif @@ -4544,18 +5162,51 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_index_texture "GL_EXT_index_texture", #endif +#ifdef GL_EXT_instanced_arrays + "GL_EXT_instanced_arrays", +#endif #ifdef GL_EXT_light_texture "GL_EXT_light_texture", #endif +#ifdef GL_EXT_map_buffer_range + "GL_EXT_map_buffer_range", +#endif +#ifdef GL_EXT_memory_object + "GL_EXT_memory_object", +#endif +#ifdef GL_EXT_memory_object_fd + "GL_EXT_memory_object_fd", +#endif +#ifdef GL_EXT_memory_object_win32 + "GL_EXT_memory_object_win32", +#endif #ifdef GL_EXT_misc_attribute "GL_EXT_misc_attribute", #endif #ifdef GL_EXT_multi_draw_arrays "GL_EXT_multi_draw_arrays", #endif +#ifdef GL_EXT_multi_draw_indirect + "GL_EXT_multi_draw_indirect", +#endif +#ifdef GL_EXT_multiple_textures + "GL_EXT_multiple_textures", +#endif #ifdef GL_EXT_multisample "GL_EXT_multisample", #endif +#ifdef GL_EXT_multisample_compatibility + "GL_EXT_multisample_compatibility", +#endif +#ifdef GL_EXT_multisampled_render_to_texture + "GL_EXT_multisampled_render_to_texture", +#endif +#ifdef GL_EXT_multisampled_render_to_texture2 + "GL_EXT_multisampled_render_to_texture2", +#endif +#ifdef GL_EXT_multiview_draw_buffers + "GL_EXT_multiview_draw_buffers", +#endif #ifdef GL_EXT_packed_depth_stencil "GL_EXT_packed_depth_stencil", #endif @@ -4592,39 +5243,93 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_provoking_vertex "GL_EXT_provoking_vertex", #endif +#ifdef GL_EXT_pvrtc_sRGB + "GL_EXT_pvrtc_sRGB", +#endif #ifdef GL_EXT_raster_multisample "GL_EXT_raster_multisample", #endif +#ifdef GL_EXT_read_format_bgra + "GL_EXT_read_format_bgra", +#endif +#ifdef GL_EXT_render_snorm + "GL_EXT_render_snorm", +#endif #ifdef GL_EXT_rescale_normal "GL_EXT_rescale_normal", #endif +#ifdef GL_EXT_sRGB + "GL_EXT_sRGB", +#endif +#ifdef GL_EXT_sRGB_write_control + "GL_EXT_sRGB_write_control", +#endif #ifdef GL_EXT_scene_marker "GL_EXT_scene_marker", #endif #ifdef GL_EXT_secondary_color "GL_EXT_secondary_color", #endif +#ifdef GL_EXT_semaphore + "GL_EXT_semaphore", +#endif +#ifdef GL_EXT_semaphore_fd + "GL_EXT_semaphore_fd", +#endif +#ifdef GL_EXT_semaphore_win32 + "GL_EXT_semaphore_win32", +#endif #ifdef GL_EXT_separate_shader_objects "GL_EXT_separate_shader_objects", #endif #ifdef GL_EXT_separate_specular_color "GL_EXT_separate_specular_color", #endif +#ifdef GL_EXT_shader_framebuffer_fetch + "GL_EXT_shader_framebuffer_fetch", +#endif +#ifdef GL_EXT_shader_group_vote + "GL_EXT_shader_group_vote", +#endif #ifdef GL_EXT_shader_image_load_formatted "GL_EXT_shader_image_load_formatted", #endif #ifdef GL_EXT_shader_image_load_store "GL_EXT_shader_image_load_store", #endif +#ifdef GL_EXT_shader_implicit_conversions + "GL_EXT_shader_implicit_conversions", +#endif #ifdef GL_EXT_shader_integer_mix "GL_EXT_shader_integer_mix", #endif +#ifdef GL_EXT_shader_io_blocks + "GL_EXT_shader_io_blocks", +#endif +#ifdef GL_EXT_shader_non_constant_global_initializers + "GL_EXT_shader_non_constant_global_initializers", +#endif +#ifdef GL_EXT_shader_pixel_local_storage + "GL_EXT_shader_pixel_local_storage", +#endif +#ifdef GL_EXT_shader_pixel_local_storage2 + "GL_EXT_shader_pixel_local_storage2", +#endif +#ifdef GL_EXT_shader_texture_lod + "GL_EXT_shader_texture_lod", +#endif #ifdef GL_EXT_shadow_funcs "GL_EXT_shadow_funcs", #endif +#ifdef GL_EXT_shadow_samplers + "GL_EXT_shadow_samplers", +#endif #ifdef GL_EXT_shared_texture_palette "GL_EXT_shared_texture_palette", #endif +#ifdef GL_EXT_sparse_texture + "GL_EXT_sparse_texture", +#endif #ifdef GL_EXT_sparse_texture2 "GL_EXT_sparse_texture2", #endif @@ -4652,6 +5357,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_buffer_object "GL_EXT_texture_buffer_object", #endif +#ifdef GL_EXT_texture_compression_astc_decode_mode + "GL_EXT_texture_compression_astc_decode_mode", +#endif +#ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 + "GL_EXT_texture_compression_astc_decode_mode_rgb9e5", +#endif +#ifdef GL_EXT_texture_compression_bptc + "GL_EXT_texture_compression_bptc", +#endif #ifdef GL_EXT_texture_compression_dxt1 "GL_EXT_texture_compression_dxt1", #endif @@ -4667,6 +5381,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_cube_map "GL_EXT_texture_cube_map", #endif +#ifdef GL_EXT_texture_cube_map_array + "GL_EXT_texture_cube_map_array", +#endif #ifdef GL_EXT_texture_edge_clamp "GL_EXT_texture_edge_clamp", #endif @@ -4688,6 +5405,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_filter_minmax "GL_EXT_texture_filter_minmax", #endif +#ifdef GL_EXT_texture_format_BGRA8888 + "GL_EXT_texture_format_BGRA8888", +#endif #ifdef GL_EXT_texture_integer "GL_EXT_texture_integer", #endif @@ -4697,6 +5417,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_mirror_clamp "GL_EXT_texture_mirror_clamp", #endif +#ifdef GL_EXT_texture_norm16 + "GL_EXT_texture_norm16", +#endif #ifdef GL_EXT_texture_object "GL_EXT_texture_object", #endif @@ -4706,9 +5429,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_rectangle "GL_EXT_texture_rectangle", #endif +#ifdef GL_EXT_texture_rg + "GL_EXT_texture_rg", +#endif #ifdef GL_EXT_texture_sRGB "GL_EXT_texture_sRGB", #endif +#ifdef GL_EXT_texture_sRGB_R8 + "GL_EXT_texture_sRGB_R8", +#endif +#ifdef GL_EXT_texture_sRGB_RG8 + "GL_EXT_texture_sRGB_RG8", +#endif #ifdef GL_EXT_texture_sRGB_decode "GL_EXT_texture_sRGB_decode", #endif @@ -4718,21 +5450,36 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_texture_snorm "GL_EXT_texture_snorm", #endif +#ifdef GL_EXT_texture_storage + "GL_EXT_texture_storage", +#endif #ifdef GL_EXT_texture_swizzle "GL_EXT_texture_swizzle", #endif +#ifdef GL_EXT_texture_type_2_10_10_10_REV + "GL_EXT_texture_type_2_10_10_10_REV", +#endif +#ifdef GL_EXT_texture_view + "GL_EXT_texture_view", +#endif #ifdef GL_EXT_timer_query "GL_EXT_timer_query", #endif #ifdef GL_EXT_transform_feedback "GL_EXT_transform_feedback", #endif +#ifdef GL_EXT_unpack_subimage + "GL_EXT_unpack_subimage", +#endif #ifdef GL_EXT_vertex_array "GL_EXT_vertex_array", #endif #ifdef GL_EXT_vertex_array_bgra "GL_EXT_vertex_array_bgra", #endif +#ifdef GL_EXT_vertex_array_setXXX + "GL_EXT_vertex_array_setXXX", +#endif #ifdef GL_EXT_vertex_attrib_64bit "GL_EXT_vertex_attrib_64bit", #endif @@ -4742,6 +5489,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_EXT_vertex_weighting "GL_EXT_vertex_weighting", #endif +#ifdef GL_EXT_win32_keyed_mutex + "GL_EXT_win32_keyed_mutex", +#endif #ifdef GL_EXT_window_rectangles "GL_EXT_window_rectangles", #endif @@ -4826,6 +5576,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_KHR_no_error "GL_KHR_no_error", #endif +#ifdef GL_KHR_parallel_shader_compile + "GL_KHR_parallel_shader_compile", +#endif #ifdef GL_KHR_robust_buffer_access_behavior "GL_KHR_robust_buffer_access_behavior", #endif @@ -4874,6 +5627,18 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NVX_linked_gpu_multicast "GL_NVX_linked_gpu_multicast", #endif +#ifdef GL_NV_3dvision_settings + "GL_NV_3dvision_settings", +#endif +#ifdef GL_NV_EGL_stream_consumer_external + "GL_NV_EGL_stream_consumer_external", +#endif +#ifdef GL_NV_alpha_to_coverage_dither_control + "GL_NV_alpha_to_coverage_dither_control", +#endif +#ifdef GL_NV_bgr + "GL_NV_bgr", +#endif #ifdef GL_NV_bindless_multi_draw_indirect "GL_NV_bindless_multi_draw_indirect", #endif @@ -4889,6 +5654,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_blend_equation_advanced_coherent "GL_NV_blend_equation_advanced_coherent", #endif +#ifdef GL_NV_blend_minmax_factor + "GL_NV_blend_minmax_factor", +#endif #ifdef GL_NV_blend_square "GL_NV_blend_square", #endif @@ -4913,6 +5681,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_conservative_raster_pre_snap_triangles "GL_NV_conservative_raster_pre_snap_triangles", #endif +#ifdef GL_NV_copy_buffer + "GL_NV_copy_buffer", +#endif #ifdef GL_NV_copy_depth_to_color "GL_NV_copy_depth_to_color", #endif @@ -4931,6 +5702,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_depth_range_unclamped "GL_NV_depth_range_unclamped", #endif +#ifdef GL_NV_draw_buffers + "GL_NV_draw_buffers", +#endif +#ifdef GL_NV_draw_instanced + "GL_NV_draw_instanced", +#endif #ifdef GL_NV_draw_texture "GL_NV_draw_texture", #endif @@ -4940,9 +5717,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_evaluators "GL_NV_evaluators", #endif +#ifdef GL_NV_explicit_attrib_location + "GL_NV_explicit_attrib_location", +#endif #ifdef GL_NV_explicit_multisample "GL_NV_explicit_multisample", #endif +#ifdef GL_NV_fbo_color_attachments + "GL_NV_fbo_color_attachments", +#endif #ifdef GL_NV_fence "GL_NV_fence", #endif @@ -4973,12 +5756,21 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_fragment_shader_interlock "GL_NV_fragment_shader_interlock", #endif +#ifdef GL_NV_framebuffer_blit + "GL_NV_framebuffer_blit", +#endif #ifdef GL_NV_framebuffer_mixed_samples "GL_NV_framebuffer_mixed_samples", #endif +#ifdef GL_NV_framebuffer_multisample + "GL_NV_framebuffer_multisample", +#endif #ifdef GL_NV_framebuffer_multisample_coverage "GL_NV_framebuffer_multisample_coverage", #endif +#ifdef GL_NV_generate_mipmap_sRGB + "GL_NV_generate_mipmap_sRGB", +#endif #ifdef GL_NV_geometry_program4 "GL_NV_geometry_program4", #endif @@ -5009,6 +5801,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_half_float "GL_NV_half_float", #endif +#ifdef GL_NV_image_formats + "GL_NV_image_formats", +#endif +#ifdef GL_NV_instanced_arrays + "GL_NV_instanced_arrays", +#endif #ifdef GL_NV_internalformat_sample_query "GL_NV_internalformat_sample_query", #endif @@ -5021,12 +5819,24 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_multisample_filter_hint "GL_NV_multisample_filter_hint", #endif +#ifdef GL_NV_non_square_matrices + "GL_NV_non_square_matrices", +#endif #ifdef GL_NV_occlusion_query "GL_NV_occlusion_query", #endif +#ifdef GL_NV_pack_subimage + "GL_NV_pack_subimage", +#endif #ifdef GL_NV_packed_depth_stencil "GL_NV_packed_depth_stencil", #endif +#ifdef GL_NV_packed_float + "GL_NV_packed_float", +#endif +#ifdef GL_NV_packed_float_linear + "GL_NV_packed_float_linear", +#endif #ifdef GL_NV_parameter_buffer_object "GL_NV_parameter_buffer_object", #endif @@ -5039,18 +5849,36 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_path_rendering_shared_edge "GL_NV_path_rendering_shared_edge", #endif +#ifdef GL_NV_pixel_buffer_object + "GL_NV_pixel_buffer_object", +#endif #ifdef GL_NV_pixel_data_range "GL_NV_pixel_data_range", #endif +#ifdef GL_NV_platform_binary + "GL_NV_platform_binary", +#endif #ifdef GL_NV_point_sprite "GL_NV_point_sprite", #endif +#ifdef GL_NV_polygon_mode + "GL_NV_polygon_mode", +#endif #ifdef GL_NV_present_video "GL_NV_present_video", #endif #ifdef GL_NV_primitive_restart "GL_NV_primitive_restart", #endif +#ifdef GL_NV_read_depth + "GL_NV_read_depth", +#endif +#ifdef GL_NV_read_depth_stencil + "GL_NV_read_depth_stencil", +#endif +#ifdef GL_NV_read_stencil + "GL_NV_read_stencil", +#endif #ifdef GL_NV_register_combiners "GL_NV_register_combiners", #endif @@ -5060,6 +5888,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_robustness_video_memory_purge "GL_NV_robustness_video_memory_purge", #endif +#ifdef GL_NV_sRGB_formats + "GL_NV_sRGB_formats", +#endif #ifdef GL_NV_sample_locations "GL_NV_sample_locations", #endif @@ -5084,6 +5915,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_shader_buffer_load "GL_NV_shader_buffer_load", #endif +#ifdef GL_NV_shader_noperspective_interpolation + "GL_NV_shader_noperspective_interpolation", +#endif #ifdef GL_NV_shader_storage_buffer_object "GL_NV_shader_storage_buffer_object", #endif @@ -5093,6 +5927,12 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_shader_thread_shuffle "GL_NV_shader_thread_shuffle", #endif +#ifdef GL_NV_shadow_samplers_array + "GL_NV_shadow_samplers_array", +#endif +#ifdef GL_NV_shadow_samplers_cube + "GL_NV_shadow_samplers_cube", +#endif #ifdef GL_NV_stereo_view_rendering "GL_NV_stereo_view_rendering", #endif @@ -5105,9 +5945,24 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_texgen_reflection "GL_NV_texgen_reflection", #endif +#ifdef GL_NV_texture_array + "GL_NV_texture_array", +#endif #ifdef GL_NV_texture_barrier "GL_NV_texture_barrier", #endif +#ifdef GL_NV_texture_border_clamp + "GL_NV_texture_border_clamp", +#endif +#ifdef GL_NV_texture_compression_latc + "GL_NV_texture_compression_latc", +#endif +#ifdef GL_NV_texture_compression_s3tc + "GL_NV_texture_compression_s3tc", +#endif +#ifdef GL_NV_texture_compression_s3tc_update + "GL_NV_texture_compression_s3tc_update", +#endif #ifdef GL_NV_texture_compression_vtc "GL_NV_texture_compression_vtc", #endif @@ -5120,9 +5975,15 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_texture_multisample "GL_NV_texture_multisample", #endif +#ifdef GL_NV_texture_npot_2D_mipmap + "GL_NV_texture_npot_2D_mipmap", +#endif #ifdef GL_NV_texture_rectangle "GL_NV_texture_rectangle", #endif +#ifdef GL_NV_texture_rectangle_compressed + "GL_NV_texture_rectangle_compressed", +#endif #ifdef GL_NV_texture_shader "GL_NV_texture_shader", #endif @@ -5177,6 +6038,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_NV_video_capture "GL_NV_video_capture", #endif +#ifdef GL_NV_viewport_array + "GL_NV_viewport_array", +#endif #ifdef GL_NV_viewport_array2 "GL_NV_viewport_array2", #endif @@ -5186,15 +6050,6 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_OES_byte_coordinates "GL_OES_byte_coordinates", #endif -#ifdef GL_OES_compressed_paletted_texture - "GL_OES_compressed_paletted_texture", -#endif -#ifdef GL_OES_read_format - "GL_OES_read_format", -#endif -#ifdef GL_OES_single_precision - "GL_OES_single_precision", -#endif #ifdef GL_OML_interlace "GL_OML_interlace", #endif @@ -5210,12 +6065,45 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_OVR_multiview2 "GL_OVR_multiview2", #endif +#ifdef GL_OVR_multiview_multisampled_render_to_texture + "GL_OVR_multiview_multisampled_render_to_texture", +#endif #ifdef GL_PGI_misc_hints "GL_PGI_misc_hints", #endif #ifdef GL_PGI_vertex_hints "GL_PGI_vertex_hints", #endif +#ifdef GL_QCOM_alpha_test + "GL_QCOM_alpha_test", +#endif +#ifdef GL_QCOM_binning_control + "GL_QCOM_binning_control", +#endif +#ifdef GL_QCOM_driver_control + "GL_QCOM_driver_control", +#endif +#ifdef GL_QCOM_extended_get + "GL_QCOM_extended_get", +#endif +#ifdef GL_QCOM_extended_get2 + "GL_QCOM_extended_get2", +#endif +#ifdef GL_QCOM_framebuffer_foveated + "GL_QCOM_framebuffer_foveated", +#endif +#ifdef GL_QCOM_perfmon_global_mode + "GL_QCOM_perfmon_global_mode", +#endif +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + "GL_QCOM_shader_framebuffer_fetch_noncoherent", +#endif +#ifdef GL_QCOM_tiled_rendering + "GL_QCOM_tiled_rendering", +#endif +#ifdef GL_QCOM_writeonly_rendering + "GL_QCOM_writeonly_rendering", +#endif #ifdef GL_REGAL_ES1_0_compatibility "GL_REGAL_ES1_0_compatibility", #endif @@ -5243,6 +6131,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_S3_s3tc "GL_S3_s3tc", #endif +#ifdef GL_SGIS_clip_band_hint + "GL_SGIS_clip_band_hint", +#endif #ifdef GL_SGIS_color_range "GL_SGIS_color_range", #endif @@ -5255,15 +6146,24 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_SGIS_generate_mipmap "GL_SGIS_generate_mipmap", #endif +#ifdef GL_SGIS_line_texgen + "GL_SGIS_line_texgen", +#endif #ifdef GL_SGIS_multisample "GL_SGIS_multisample", #endif +#ifdef GL_SGIS_multitexture + "GL_SGIS_multitexture", +#endif #ifdef GL_SGIS_pixel_texture "GL_SGIS_pixel_texture", #endif #ifdef GL_SGIS_point_line_texgen "GL_SGIS_point_line_texgen", #endif +#ifdef GL_SGIS_shared_multisample + "GL_SGIS_shared_multisample", +#endif #ifdef GL_SGIS_sharpen_texture "GL_SGIS_sharpen_texture", #endif @@ -5294,63 +6194,192 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_SGIX_async_pixel "GL_SGIX_async_pixel", #endif +#ifdef GL_SGIX_bali_g_instruments + "GL_SGIX_bali_g_instruments", +#endif +#ifdef GL_SGIX_bali_r_instruments + "GL_SGIX_bali_r_instruments", +#endif +#ifdef GL_SGIX_bali_timer_instruments + "GL_SGIX_bali_timer_instruments", +#endif #ifdef GL_SGIX_blend_alpha_minmax "GL_SGIX_blend_alpha_minmax", #endif +#ifdef GL_SGIX_blend_cadd + "GL_SGIX_blend_cadd", +#endif +#ifdef GL_SGIX_blend_cmultiply + "GL_SGIX_blend_cmultiply", +#endif +#ifdef GL_SGIX_calligraphic_fragment + "GL_SGIX_calligraphic_fragment", +#endif #ifdef GL_SGIX_clipmap "GL_SGIX_clipmap", #endif +#ifdef GL_SGIX_color_matrix_accuracy + "GL_SGIX_color_matrix_accuracy", +#endif +#ifdef GL_SGIX_color_table_index_mode + "GL_SGIX_color_table_index_mode", +#endif +#ifdef GL_SGIX_complex_polar + "GL_SGIX_complex_polar", +#endif #ifdef GL_SGIX_convolution_accuracy "GL_SGIX_convolution_accuracy", #endif +#ifdef GL_SGIX_cube_map + "GL_SGIX_cube_map", +#endif +#ifdef GL_SGIX_cylinder_texgen + "GL_SGIX_cylinder_texgen", +#endif +#ifdef GL_SGIX_datapipe + "GL_SGIX_datapipe", +#endif +#ifdef GL_SGIX_decimation + "GL_SGIX_decimation", +#endif +#ifdef GL_SGIX_depth_pass_instrument + "GL_SGIX_depth_pass_instrument", +#endif #ifdef GL_SGIX_depth_texture "GL_SGIX_depth_texture", #endif +#ifdef GL_SGIX_dvc + "GL_SGIX_dvc", +#endif #ifdef GL_SGIX_flush_raster "GL_SGIX_flush_raster", #endif +#ifdef GL_SGIX_fog_blend + "GL_SGIX_fog_blend", +#endif +#ifdef GL_SGIX_fog_factor_to_alpha + "GL_SGIX_fog_factor_to_alpha", +#endif +#ifdef GL_SGIX_fog_layers + "GL_SGIX_fog_layers", +#endif #ifdef GL_SGIX_fog_offset "GL_SGIX_fog_offset", #endif +#ifdef GL_SGIX_fog_patchy + "GL_SGIX_fog_patchy", +#endif +#ifdef GL_SGIX_fog_scale + "GL_SGIX_fog_scale", +#endif #ifdef GL_SGIX_fog_texture "GL_SGIX_fog_texture", #endif +#ifdef GL_SGIX_fragment_lighting_space + "GL_SGIX_fragment_lighting_space", +#endif #ifdef GL_SGIX_fragment_specular_lighting "GL_SGIX_fragment_specular_lighting", #endif +#ifdef GL_SGIX_fragments_instrument + "GL_SGIX_fragments_instrument", +#endif #ifdef GL_SGIX_framezoom "GL_SGIX_framezoom", #endif +#ifdef GL_SGIX_icc_texture + "GL_SGIX_icc_texture", +#endif +#ifdef GL_SGIX_igloo_interface + "GL_SGIX_igloo_interface", +#endif +#ifdef GL_SGIX_image_compression + "GL_SGIX_image_compression", +#endif +#ifdef GL_SGIX_impact_pixel_texture + "GL_SGIX_impact_pixel_texture", +#endif +#ifdef GL_SGIX_instrument_error + "GL_SGIX_instrument_error", +#endif #ifdef GL_SGIX_interlace "GL_SGIX_interlace", #endif #ifdef GL_SGIX_ir_instrument1 "GL_SGIX_ir_instrument1", #endif +#ifdef GL_SGIX_line_quality_hint + "GL_SGIX_line_quality_hint", +#endif #ifdef GL_SGIX_list_priority "GL_SGIX_list_priority", #endif +#ifdef GL_SGIX_mpeg1 + "GL_SGIX_mpeg1", +#endif +#ifdef GL_SGIX_mpeg2 + "GL_SGIX_mpeg2", +#endif +#ifdef GL_SGIX_nonlinear_lighting_pervertex + "GL_SGIX_nonlinear_lighting_pervertex", +#endif +#ifdef GL_SGIX_nurbs_eval + "GL_SGIX_nurbs_eval", +#endif +#ifdef GL_SGIX_occlusion_instrument + "GL_SGIX_occlusion_instrument", +#endif +#ifdef GL_SGIX_packed_6bytes + "GL_SGIX_packed_6bytes", +#endif #ifdef GL_SGIX_pixel_texture "GL_SGIX_pixel_texture", #endif #ifdef GL_SGIX_pixel_texture_bits "GL_SGIX_pixel_texture_bits", #endif +#ifdef GL_SGIX_pixel_texture_lod + "GL_SGIX_pixel_texture_lod", +#endif +#ifdef GL_SGIX_pixel_tiles + "GL_SGIX_pixel_tiles", +#endif +#ifdef GL_SGIX_polynomial_ffd + "GL_SGIX_polynomial_ffd", +#endif +#ifdef GL_SGIX_quad_mesh + "GL_SGIX_quad_mesh", +#endif #ifdef GL_SGIX_reference_plane "GL_SGIX_reference_plane", #endif #ifdef GL_SGIX_resample "GL_SGIX_resample", #endif +#ifdef GL_SGIX_scalebias_hint + "GL_SGIX_scalebias_hint", +#endif #ifdef GL_SGIX_shadow "GL_SGIX_shadow", #endif #ifdef GL_SGIX_shadow_ambient "GL_SGIX_shadow_ambient", #endif +#ifdef GL_SGIX_slim + "GL_SGIX_slim", +#endif +#ifdef GL_SGIX_spotlight_cutoff + "GL_SGIX_spotlight_cutoff", +#endif #ifdef GL_SGIX_sprite "GL_SGIX_sprite", #endif +#ifdef GL_SGIX_subdiv_patch + "GL_SGIX_subdiv_patch", +#endif +#ifdef GL_SGIX_subsample + "GL_SGIX_subsample", +#endif #ifdef GL_SGIX_tag_sample_buffer "GL_SGIX_tag_sample_buffer", #endif @@ -5363,15 +6392,30 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_SGIX_texture_lod_bias "GL_SGIX_texture_lod_bias", #endif +#ifdef GL_SGIX_texture_mipmap_anisotropic + "GL_SGIX_texture_mipmap_anisotropic", +#endif #ifdef GL_SGIX_texture_multi_buffer "GL_SGIX_texture_multi_buffer", #endif +#ifdef GL_SGIX_texture_phase + "GL_SGIX_texture_phase", +#endif #ifdef GL_SGIX_texture_range "GL_SGIX_texture_range", #endif #ifdef GL_SGIX_texture_scale_bias "GL_SGIX_texture_scale_bias", #endif +#ifdef GL_SGIX_texture_supersample + "GL_SGIX_texture_supersample", +#endif +#ifdef GL_SGIX_vector_ops + "GL_SGIX_vector_ops", +#endif +#ifdef GL_SGIX_vertex_array_object + "GL_SGIX_vertex_array_object", +#endif #ifdef GL_SGIX_vertex_preclip "GL_SGIX_vertex_preclip", #endif @@ -5381,12 +6425,27 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_SGIX_ycrcb "GL_SGIX_ycrcb", #endif +#ifdef GL_SGIX_ycrcb_subsample + "GL_SGIX_ycrcb_subsample", +#endif +#ifdef GL_SGIX_ycrcba + "GL_SGIX_ycrcba", +#endif #ifdef GL_SGI_color_matrix "GL_SGI_color_matrix", #endif #ifdef GL_SGI_color_table "GL_SGI_color_table", #endif +#ifdef GL_SGI_complex + "GL_SGI_complex", +#endif +#ifdef GL_SGI_complex_type + "GL_SGI_complex_type", +#endif +#ifdef GL_SGI_fft + "GL_SGI_fft", +#endif #ifdef GL_SGI_texture_color_table "GL_SGI_texture_color_table", #endif @@ -5417,6 +6476,9 @@ static const char * _glewExtensionLookup[] = { #ifdef GL_WIN_phong_shading "GL_WIN_phong_shading", #endif +#ifdef GL_WIN_scene_markerXXX + "GL_WIN_scene_markerXXX", +#endif #ifdef GL_WIN_specular_fog "GL_WIN_specular_fog", #endif @@ -5427,7 +6489,7 @@ static const char * _glewExtensionLookup[] = { }; /* Detected in the extension string or strings */ -static GLboolean _glewExtensionString[603]; +static GLboolean _glewExtensionString[801]; /* Detected via extension string or experimental mode */ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_VERSION_1_2 @@ -5481,6 +6543,9 @@ static GLboolean* _glewExtensionEnabled[] = { #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 @@ -5493,6 +6558,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_blend_minmax_factor &__GLEW_AMD_blend_minmax_factor, #endif +#ifdef GL_AMD_compressed_3DC_texture + &__GLEW_AMD_compressed_3DC_texture, +#endif +#ifdef GL_AMD_compressed_ATC_texture + &__GLEW_AMD_compressed_ATC_texture, +#endif #ifdef GL_AMD_conservative_depth &__GLEW_AMD_conservative_depth, #endif @@ -5505,9 +6576,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_draw_buffers_blend &__GLEW_AMD_draw_buffers_blend, #endif +#ifdef GL_AMD_framebuffer_sample_positions + &__GLEW_AMD_framebuffer_sample_positions, +#endif #ifdef GL_AMD_gcn_shader &__GLEW_AMD_gcn_shader, #endif +#ifdef GL_AMD_gpu_shader_half_float + &__GLEW_AMD_gpu_shader_half_float, +#endif +#ifdef GL_AMD_gpu_shader_int16 + &__GLEW_AMD_gpu_shader_int16, +#endif #ifdef GL_AMD_gpu_shader_int64 &__GLEW_AMD_gpu_shader_int64, #endif @@ -5529,6 +6609,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_pinned_memory &__GLEW_AMD_pinned_memory, #endif +#ifdef GL_AMD_program_binary_Z400 + &__GLEW_AMD_program_binary_Z400, +#endif #ifdef GL_AMD_query_buffer_object &__GLEW_AMD_query_buffer_object, #endif @@ -5541,6 +6624,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_shader_atomic_counter_ops &__GLEW_AMD_shader_atomic_counter_ops, #endif +#ifdef GL_AMD_shader_ballot + &__GLEW_AMD_shader_ballot, +#endif #ifdef GL_AMD_shader_explicit_vertex_parameter &__GLEW_AMD_shader_explicit_vertex_parameter, #endif @@ -5559,6 +6645,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_stencil_operation_extended &__GLEW_AMD_stencil_operation_extended, #endif +#ifdef GL_AMD_texture_gather_bias_lod + &__GLEW_AMD_texture_gather_bias_lod, +#endif #ifdef GL_AMD_texture_texture4 &__GLEW_AMD_texture_texture4, #endif @@ -5577,6 +6666,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_AMD_vertex_shader_viewport_index &__GLEW_AMD_vertex_shader_viewport_index, #endif +#ifdef GL_ANDROID_extension_pack_es31a + &__GLEW_ANDROID_extension_pack_es31a, +#endif #ifdef GL_ANGLE_depth_texture &__GLEW_ANGLE_depth_texture, #endif @@ -5619,6 +6711,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_APPLE_client_storage &__GLEW_APPLE_client_storage, #endif +#ifdef GL_APPLE_clip_distance + &__GLEW_APPLE_clip_distance, +#endif +#ifdef GL_APPLE_color_buffer_packed_float + &__GLEW_APPLE_color_buffer_packed_float, +#endif +#ifdef GL_APPLE_copy_texture_levels + &__GLEW_APPLE_copy_texture_levels, +#endif #ifdef GL_APPLE_element_array &__GLEW_APPLE_element_array, #endif @@ -5631,6 +6732,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_APPLE_flush_buffer_range &__GLEW_APPLE_flush_buffer_range, #endif +#ifdef GL_APPLE_framebuffer_multisample + &__GLEW_APPLE_framebuffer_multisample, +#endif #ifdef GL_APPLE_object_purgeable &__GLEW_APPLE_object_purgeable, #endif @@ -5646,6 +6750,21 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_APPLE_specular_vector &__GLEW_APPLE_specular_vector, #endif +#ifdef GL_APPLE_sync + &__GLEW_APPLE_sync, +#endif +#ifdef GL_APPLE_texture_2D_limited_npot + &__GLEW_APPLE_texture_2D_limited_npot, +#endif +#ifdef GL_APPLE_texture_format_BGRA8888 + &__GLEW_APPLE_texture_format_BGRA8888, +#endif +#ifdef GL_APPLE_texture_max_level + &__GLEW_APPLE_texture_max_level, +#endif +#ifdef GL_APPLE_texture_packed_float + &__GLEW_APPLE_texture_packed_float, +#endif #ifdef GL_APPLE_texture_range &__GLEW_APPLE_texture_range, #endif @@ -5889,6 +7008,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ARB_point_sprite &__GLEW_ARB_point_sprite, #endif +#ifdef GL_ARB_polygon_offset_clamp + &__GLEW_ARB_polygon_offset_clamp, +#endif #ifdef GL_ARB_post_depth_coverage &__GLEW_ARB_post_depth_coverage, #endif @@ -6012,6 +7134,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ARB_sparse_texture_clamp &__GLEW_ARB_sparse_texture_clamp, #endif +#ifdef GL_ARB_spirv_extensions + &__GLEW_ARB_spirv_extensions, +#endif #ifdef GL_ARB_stencil_texturing &__GLEW_ARB_stencil_texturing, #endif @@ -6063,6 +7188,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ARB_texture_env_dot3 &__GLEW_ARB_texture_env_dot3, #endif +#ifdef GL_ARB_texture_filter_anisotropic + &__GLEW_ARB_texture_filter_anisotropic, +#endif #ifdef GL_ARB_texture_filter_minmax &__GLEW_ARB_texture_filter_minmax, #endif @@ -6171,6 +7299,21 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_ARB_window_pos &__GLEW_ARB_window_pos, #endif +#ifdef GL_ARM_mali_program_binary + &__GLEW_ARM_mali_program_binary, +#endif +#ifdef GL_ARM_mali_shader_binary + &__GLEW_ARM_mali_shader_binary, +#endif +#ifdef GL_ARM_rgba8 + &__GLEW_ARM_rgba8, +#endif +#ifdef GL_ARM_shader_framebuffer_fetch + &__GLEW_ARM_shader_framebuffer_fetch, +#endif +#ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil + &__GLEW_ARM_shader_framebuffer_fetch_depth_stencil, +#endif #ifdef GL_ATIX_point_sprites &__GLEW_ATIX_point_sprites, #endif @@ -6234,6 +7377,9 @@ 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, +#endif #ifdef GL_EGL_NV_robustness_video_memory_purge &__GLEW_EGL_NV_robustness_video_memory_purge, #endif @@ -6243,9 +7389,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_Cg_shader &__GLEW_EXT_Cg_shader, #endif +#ifdef GL_EXT_EGL_image_array + &__GLEW_EXT_EGL_image_array, +#endif +#ifdef GL_EXT_YUV_target + &__GLEW_EXT_YUV_target, +#endif #ifdef GL_EXT_abgr &__GLEW_EXT_abgr, #endif +#ifdef GL_EXT_base_instance + &__GLEW_EXT_base_instance, +#endif #ifdef GL_EXT_bgra &__GLEW_EXT_bgra, #endif @@ -6258,6 +7413,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_blend_equation_separate &__GLEW_EXT_blend_equation_separate, #endif +#ifdef GL_EXT_blend_func_extended + &__GLEW_EXT_blend_func_extended, +#endif #ifdef GL_EXT_blend_func_separate &__GLEW_EXT_blend_func_separate, #endif @@ -6270,24 +7428,48 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_blend_subtract &__GLEW_EXT_blend_subtract, #endif +#ifdef GL_EXT_buffer_storage + &__GLEW_EXT_buffer_storage, +#endif +#ifdef GL_EXT_clear_texture + &__GLEW_EXT_clear_texture, +#endif +#ifdef GL_EXT_clip_cull_distance + &__GLEW_EXT_clip_cull_distance, +#endif #ifdef GL_EXT_clip_volume_hint &__GLEW_EXT_clip_volume_hint, #endif #ifdef GL_EXT_cmyka &__GLEW_EXT_cmyka, #endif +#ifdef GL_EXT_color_buffer_float + &__GLEW_EXT_color_buffer_float, +#endif +#ifdef GL_EXT_color_buffer_half_float + &__GLEW_EXT_color_buffer_half_float, +#endif #ifdef GL_EXT_color_subtable &__GLEW_EXT_color_subtable, #endif #ifdef GL_EXT_compiled_vertex_array &__GLEW_EXT_compiled_vertex_array, #endif +#ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture + &__GLEW_EXT_compressed_ETC1_RGB8_sub_texture, +#endif +#ifdef GL_EXT_conservative_depth + &__GLEW_EXT_conservative_depth, +#endif #ifdef GL_EXT_convolution &__GLEW_EXT_convolution, #endif #ifdef GL_EXT_coordinate_frame &__GLEW_EXT_coordinate_frame, #endif +#ifdef GL_EXT_copy_image + &__GLEW_EXT_copy_image, +#endif #ifdef GL_EXT_copy_texture &__GLEW_EXT_copy_texture, #endif @@ -6306,18 +7488,39 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_direct_state_access &__GLEW_EXT_direct_state_access, #endif +#ifdef GL_EXT_discard_framebuffer + &__GLEW_EXT_discard_framebuffer, +#endif +#ifdef GL_EXT_draw_buffers + &__GLEW_EXT_draw_buffers, +#endif #ifdef GL_EXT_draw_buffers2 &__GLEW_EXT_draw_buffers2, #endif +#ifdef GL_EXT_draw_buffers_indexed + &__GLEW_EXT_draw_buffers_indexed, +#endif +#ifdef GL_EXT_draw_elements_base_vertex + &__GLEW_EXT_draw_elements_base_vertex, +#endif #ifdef GL_EXT_draw_instanced &__GLEW_EXT_draw_instanced, #endif #ifdef GL_EXT_draw_range_elements &__GLEW_EXT_draw_range_elements, #endif +#ifdef GL_EXT_external_buffer + &__GLEW_EXT_external_buffer, +#endif +#ifdef GL_EXT_float_blend + &__GLEW_EXT_float_blend, +#endif #ifdef GL_EXT_fog_coord &__GLEW_EXT_fog_coord, #endif +#ifdef GL_EXT_frag_depth + &__GLEW_EXT_frag_depth, +#endif #ifdef GL_EXT_fragment_lighting &__GLEW_EXT_fragment_lighting, #endif @@ -6336,6 +7539,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_framebuffer_sRGB &__GLEW_EXT_framebuffer_sRGB, #endif +#ifdef GL_EXT_geometry_point_size + &__GLEW_EXT_geometry_point_size, +#endif +#ifdef GL_EXT_geometry_shader + &__GLEW_EXT_geometry_shader, +#endif #ifdef GL_EXT_geometry_shader4 &__GLEW_EXT_geometry_shader4, #endif @@ -6345,6 +7554,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_gpu_shader4 &__GLEW_EXT_gpu_shader4, #endif +#ifdef GL_EXT_gpu_shader5 + &__GLEW_EXT_gpu_shader5, +#endif #ifdef GL_EXT_histogram &__GLEW_EXT_histogram, #endif @@ -6360,18 +7572,51 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_index_texture &__GLEW_EXT_index_texture, #endif +#ifdef GL_EXT_instanced_arrays + &__GLEW_EXT_instanced_arrays, +#endif #ifdef GL_EXT_light_texture &__GLEW_EXT_light_texture, #endif +#ifdef GL_EXT_map_buffer_range + &__GLEW_EXT_map_buffer_range, +#endif +#ifdef GL_EXT_memory_object + &__GLEW_EXT_memory_object, +#endif +#ifdef GL_EXT_memory_object_fd + &__GLEW_EXT_memory_object_fd, +#endif +#ifdef GL_EXT_memory_object_win32 + &__GLEW_EXT_memory_object_win32, +#endif #ifdef GL_EXT_misc_attribute &__GLEW_EXT_misc_attribute, #endif #ifdef GL_EXT_multi_draw_arrays &__GLEW_EXT_multi_draw_arrays, #endif +#ifdef GL_EXT_multi_draw_indirect + &__GLEW_EXT_multi_draw_indirect, +#endif +#ifdef GL_EXT_multiple_textures + &__GLEW_EXT_multiple_textures, +#endif #ifdef GL_EXT_multisample &__GLEW_EXT_multisample, #endif +#ifdef GL_EXT_multisample_compatibility + &__GLEW_EXT_multisample_compatibility, +#endif +#ifdef GL_EXT_multisampled_render_to_texture + &__GLEW_EXT_multisampled_render_to_texture, +#endif +#ifdef GL_EXT_multisampled_render_to_texture2 + &__GLEW_EXT_multisampled_render_to_texture2, +#endif +#ifdef GL_EXT_multiview_draw_buffers + &__GLEW_EXT_multiview_draw_buffers, +#endif #ifdef GL_EXT_packed_depth_stencil &__GLEW_EXT_packed_depth_stencil, #endif @@ -6408,39 +7653,93 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_provoking_vertex &__GLEW_EXT_provoking_vertex, #endif +#ifdef GL_EXT_pvrtc_sRGB + &__GLEW_EXT_pvrtc_sRGB, +#endif #ifdef GL_EXT_raster_multisample &__GLEW_EXT_raster_multisample, #endif +#ifdef GL_EXT_read_format_bgra + &__GLEW_EXT_read_format_bgra, +#endif +#ifdef GL_EXT_render_snorm + &__GLEW_EXT_render_snorm, +#endif #ifdef GL_EXT_rescale_normal &__GLEW_EXT_rescale_normal, #endif +#ifdef GL_EXT_sRGB + &__GLEW_EXT_sRGB, +#endif +#ifdef GL_EXT_sRGB_write_control + &__GLEW_EXT_sRGB_write_control, +#endif #ifdef GL_EXT_scene_marker &__GLEW_EXT_scene_marker, #endif #ifdef GL_EXT_secondary_color &__GLEW_EXT_secondary_color, #endif +#ifdef GL_EXT_semaphore + &__GLEW_EXT_semaphore, +#endif +#ifdef GL_EXT_semaphore_fd + &__GLEW_EXT_semaphore_fd, +#endif +#ifdef GL_EXT_semaphore_win32 + &__GLEW_EXT_semaphore_win32, +#endif #ifdef GL_EXT_separate_shader_objects &__GLEW_EXT_separate_shader_objects, #endif #ifdef GL_EXT_separate_specular_color &__GLEW_EXT_separate_specular_color, #endif +#ifdef GL_EXT_shader_framebuffer_fetch + &__GLEW_EXT_shader_framebuffer_fetch, +#endif +#ifdef GL_EXT_shader_group_vote + &__GLEW_EXT_shader_group_vote, +#endif #ifdef GL_EXT_shader_image_load_formatted &__GLEW_EXT_shader_image_load_formatted, #endif #ifdef GL_EXT_shader_image_load_store &__GLEW_EXT_shader_image_load_store, #endif +#ifdef GL_EXT_shader_implicit_conversions + &__GLEW_EXT_shader_implicit_conversions, +#endif #ifdef GL_EXT_shader_integer_mix &__GLEW_EXT_shader_integer_mix, #endif +#ifdef GL_EXT_shader_io_blocks + &__GLEW_EXT_shader_io_blocks, +#endif +#ifdef GL_EXT_shader_non_constant_global_initializers + &__GLEW_EXT_shader_non_constant_global_initializers, +#endif +#ifdef GL_EXT_shader_pixel_local_storage + &__GLEW_EXT_shader_pixel_local_storage, +#endif +#ifdef GL_EXT_shader_pixel_local_storage2 + &__GLEW_EXT_shader_pixel_local_storage2, +#endif +#ifdef GL_EXT_shader_texture_lod + &__GLEW_EXT_shader_texture_lod, +#endif #ifdef GL_EXT_shadow_funcs &__GLEW_EXT_shadow_funcs, #endif +#ifdef GL_EXT_shadow_samplers + &__GLEW_EXT_shadow_samplers, +#endif #ifdef GL_EXT_shared_texture_palette &__GLEW_EXT_shared_texture_palette, #endif +#ifdef GL_EXT_sparse_texture + &__GLEW_EXT_sparse_texture, +#endif #ifdef GL_EXT_sparse_texture2 &__GLEW_EXT_sparse_texture2, #endif @@ -6468,6 +7767,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_buffer_object &__GLEW_EXT_texture_buffer_object, #endif +#ifdef GL_EXT_texture_compression_astc_decode_mode + &__GLEW_EXT_texture_compression_astc_decode_mode, +#endif +#ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 + &__GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5, +#endif +#ifdef GL_EXT_texture_compression_bptc + &__GLEW_EXT_texture_compression_bptc, +#endif #ifdef GL_EXT_texture_compression_dxt1 &__GLEW_EXT_texture_compression_dxt1, #endif @@ -6483,6 +7791,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_cube_map &__GLEW_EXT_texture_cube_map, #endif +#ifdef GL_EXT_texture_cube_map_array + &__GLEW_EXT_texture_cube_map_array, +#endif #ifdef GL_EXT_texture_edge_clamp &__GLEW_EXT_texture_edge_clamp, #endif @@ -6504,6 +7815,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_filter_minmax &__GLEW_EXT_texture_filter_minmax, #endif +#ifdef GL_EXT_texture_format_BGRA8888 + &__GLEW_EXT_texture_format_BGRA8888, +#endif #ifdef GL_EXT_texture_integer &__GLEW_EXT_texture_integer, #endif @@ -6513,6 +7827,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_mirror_clamp &__GLEW_EXT_texture_mirror_clamp, #endif +#ifdef GL_EXT_texture_norm16 + &__GLEW_EXT_texture_norm16, +#endif #ifdef GL_EXT_texture_object &__GLEW_EXT_texture_object, #endif @@ -6522,9 +7839,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_rectangle &__GLEW_EXT_texture_rectangle, #endif +#ifdef GL_EXT_texture_rg + &__GLEW_EXT_texture_rg, +#endif #ifdef GL_EXT_texture_sRGB &__GLEW_EXT_texture_sRGB, #endif +#ifdef GL_EXT_texture_sRGB_R8 + &__GLEW_EXT_texture_sRGB_R8, +#endif +#ifdef GL_EXT_texture_sRGB_RG8 + &__GLEW_EXT_texture_sRGB_RG8, +#endif #ifdef GL_EXT_texture_sRGB_decode &__GLEW_EXT_texture_sRGB_decode, #endif @@ -6534,21 +7860,36 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_texture_snorm &__GLEW_EXT_texture_snorm, #endif +#ifdef GL_EXT_texture_storage + &__GLEW_EXT_texture_storage, +#endif #ifdef GL_EXT_texture_swizzle &__GLEW_EXT_texture_swizzle, #endif +#ifdef GL_EXT_texture_type_2_10_10_10_REV + &__GLEW_EXT_texture_type_2_10_10_10_REV, +#endif +#ifdef GL_EXT_texture_view + &__GLEW_EXT_texture_view, +#endif #ifdef GL_EXT_timer_query &__GLEW_EXT_timer_query, #endif #ifdef GL_EXT_transform_feedback &__GLEW_EXT_transform_feedback, #endif +#ifdef GL_EXT_unpack_subimage + &__GLEW_EXT_unpack_subimage, +#endif #ifdef GL_EXT_vertex_array &__GLEW_EXT_vertex_array, #endif #ifdef GL_EXT_vertex_array_bgra &__GLEW_EXT_vertex_array_bgra, #endif +#ifdef GL_EXT_vertex_array_setXXX + &__GLEW_EXT_vertex_array_setXXX, +#endif #ifdef GL_EXT_vertex_attrib_64bit &__GLEW_EXT_vertex_attrib_64bit, #endif @@ -6558,6 +7899,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_EXT_vertex_weighting &__GLEW_EXT_vertex_weighting, #endif +#ifdef GL_EXT_win32_keyed_mutex + &__GLEW_EXT_win32_keyed_mutex, +#endif #ifdef GL_EXT_window_rectangles &__GLEW_EXT_window_rectangles, #endif @@ -6642,6 +7986,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_KHR_no_error &__GLEW_KHR_no_error, #endif +#ifdef GL_KHR_parallel_shader_compile + &__GLEW_KHR_parallel_shader_compile, +#endif #ifdef GL_KHR_robust_buffer_access_behavior &__GLEW_KHR_robust_buffer_access_behavior, #endif @@ -6690,6 +8037,18 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NVX_linked_gpu_multicast &__GLEW_NVX_linked_gpu_multicast, #endif +#ifdef GL_NV_3dvision_settings + &__GLEW_NV_3dvision_settings, +#endif +#ifdef GL_NV_EGL_stream_consumer_external + &__GLEW_NV_EGL_stream_consumer_external, +#endif +#ifdef GL_NV_alpha_to_coverage_dither_control + &__GLEW_NV_alpha_to_coverage_dither_control, +#endif +#ifdef GL_NV_bgr + &__GLEW_NV_bgr, +#endif #ifdef GL_NV_bindless_multi_draw_indirect &__GLEW_NV_bindless_multi_draw_indirect, #endif @@ -6705,6 +8064,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_blend_equation_advanced_coherent &__GLEW_NV_blend_equation_advanced_coherent, #endif +#ifdef GL_NV_blend_minmax_factor + &__GLEW_NV_blend_minmax_factor, +#endif #ifdef GL_NV_blend_square &__GLEW_NV_blend_square, #endif @@ -6729,6 +8091,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_conservative_raster_pre_snap_triangles &__GLEW_NV_conservative_raster_pre_snap_triangles, #endif +#ifdef GL_NV_copy_buffer + &__GLEW_NV_copy_buffer, +#endif #ifdef GL_NV_copy_depth_to_color &__GLEW_NV_copy_depth_to_color, #endif @@ -6747,6 +8112,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_depth_range_unclamped &__GLEW_NV_depth_range_unclamped, #endif +#ifdef GL_NV_draw_buffers + &__GLEW_NV_draw_buffers, +#endif +#ifdef GL_NV_draw_instanced + &__GLEW_NV_draw_instanced, +#endif #ifdef GL_NV_draw_texture &__GLEW_NV_draw_texture, #endif @@ -6756,9 +8127,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_evaluators &__GLEW_NV_evaluators, #endif +#ifdef GL_NV_explicit_attrib_location + &__GLEW_NV_explicit_attrib_location, +#endif #ifdef GL_NV_explicit_multisample &__GLEW_NV_explicit_multisample, #endif +#ifdef GL_NV_fbo_color_attachments + &__GLEW_NV_fbo_color_attachments, +#endif #ifdef GL_NV_fence &__GLEW_NV_fence, #endif @@ -6789,12 +8166,21 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_fragment_shader_interlock &__GLEW_NV_fragment_shader_interlock, #endif +#ifdef GL_NV_framebuffer_blit + &__GLEW_NV_framebuffer_blit, +#endif #ifdef GL_NV_framebuffer_mixed_samples &__GLEW_NV_framebuffer_mixed_samples, #endif +#ifdef GL_NV_framebuffer_multisample + &__GLEW_NV_framebuffer_multisample, +#endif #ifdef GL_NV_framebuffer_multisample_coverage &__GLEW_NV_framebuffer_multisample_coverage, #endif +#ifdef GL_NV_generate_mipmap_sRGB + &__GLEW_NV_generate_mipmap_sRGB, +#endif #ifdef GL_NV_geometry_program4 &__GLEW_NV_geometry_program4, #endif @@ -6825,6 +8211,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_half_float &__GLEW_NV_half_float, #endif +#ifdef GL_NV_image_formats + &__GLEW_NV_image_formats, +#endif +#ifdef GL_NV_instanced_arrays + &__GLEW_NV_instanced_arrays, +#endif #ifdef GL_NV_internalformat_sample_query &__GLEW_NV_internalformat_sample_query, #endif @@ -6837,12 +8229,24 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_multisample_filter_hint &__GLEW_NV_multisample_filter_hint, #endif +#ifdef GL_NV_non_square_matrices + &__GLEW_NV_non_square_matrices, +#endif #ifdef GL_NV_occlusion_query &__GLEW_NV_occlusion_query, #endif +#ifdef GL_NV_pack_subimage + &__GLEW_NV_pack_subimage, +#endif #ifdef GL_NV_packed_depth_stencil &__GLEW_NV_packed_depth_stencil, #endif +#ifdef GL_NV_packed_float + &__GLEW_NV_packed_float, +#endif +#ifdef GL_NV_packed_float_linear + &__GLEW_NV_packed_float_linear, +#endif #ifdef GL_NV_parameter_buffer_object &__GLEW_NV_parameter_buffer_object, #endif @@ -6855,18 +8259,36 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_path_rendering_shared_edge &__GLEW_NV_path_rendering_shared_edge, #endif +#ifdef GL_NV_pixel_buffer_object + &__GLEW_NV_pixel_buffer_object, +#endif #ifdef GL_NV_pixel_data_range &__GLEW_NV_pixel_data_range, #endif +#ifdef GL_NV_platform_binary + &__GLEW_NV_platform_binary, +#endif #ifdef GL_NV_point_sprite &__GLEW_NV_point_sprite, #endif +#ifdef GL_NV_polygon_mode + &__GLEW_NV_polygon_mode, +#endif #ifdef GL_NV_present_video &__GLEW_NV_present_video, #endif #ifdef GL_NV_primitive_restart &__GLEW_NV_primitive_restart, #endif +#ifdef GL_NV_read_depth + &__GLEW_NV_read_depth, +#endif +#ifdef GL_NV_read_depth_stencil + &__GLEW_NV_read_depth_stencil, +#endif +#ifdef GL_NV_read_stencil + &__GLEW_NV_read_stencil, +#endif #ifdef GL_NV_register_combiners &__GLEW_NV_register_combiners, #endif @@ -6876,6 +8298,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_robustness_video_memory_purge &__GLEW_NV_robustness_video_memory_purge, #endif +#ifdef GL_NV_sRGB_formats + &__GLEW_NV_sRGB_formats, +#endif #ifdef GL_NV_sample_locations &__GLEW_NV_sample_locations, #endif @@ -6900,6 +8325,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_shader_buffer_load &__GLEW_NV_shader_buffer_load, #endif +#ifdef GL_NV_shader_noperspective_interpolation + &__GLEW_NV_shader_noperspective_interpolation, +#endif #ifdef GL_NV_shader_storage_buffer_object &__GLEW_NV_shader_storage_buffer_object, #endif @@ -6909,6 +8337,12 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_shader_thread_shuffle &__GLEW_NV_shader_thread_shuffle, #endif +#ifdef GL_NV_shadow_samplers_array + &__GLEW_NV_shadow_samplers_array, +#endif +#ifdef GL_NV_shadow_samplers_cube + &__GLEW_NV_shadow_samplers_cube, +#endif #ifdef GL_NV_stereo_view_rendering &__GLEW_NV_stereo_view_rendering, #endif @@ -6921,9 +8355,24 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_texgen_reflection &__GLEW_NV_texgen_reflection, #endif +#ifdef GL_NV_texture_array + &__GLEW_NV_texture_array, +#endif #ifdef GL_NV_texture_barrier &__GLEW_NV_texture_barrier, #endif +#ifdef GL_NV_texture_border_clamp + &__GLEW_NV_texture_border_clamp, +#endif +#ifdef GL_NV_texture_compression_latc + &__GLEW_NV_texture_compression_latc, +#endif +#ifdef GL_NV_texture_compression_s3tc + &__GLEW_NV_texture_compression_s3tc, +#endif +#ifdef GL_NV_texture_compression_s3tc_update + &__GLEW_NV_texture_compression_s3tc_update, +#endif #ifdef GL_NV_texture_compression_vtc &__GLEW_NV_texture_compression_vtc, #endif @@ -6936,9 +8385,15 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_texture_multisample &__GLEW_NV_texture_multisample, #endif +#ifdef GL_NV_texture_npot_2D_mipmap + &__GLEW_NV_texture_npot_2D_mipmap, +#endif #ifdef GL_NV_texture_rectangle &__GLEW_NV_texture_rectangle, #endif +#ifdef GL_NV_texture_rectangle_compressed + &__GLEW_NV_texture_rectangle_compressed, +#endif #ifdef GL_NV_texture_shader &__GLEW_NV_texture_shader, #endif @@ -6993,6 +8448,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_NV_video_capture &__GLEW_NV_video_capture, #endif +#ifdef GL_NV_viewport_array + &__GLEW_NV_viewport_array, +#endif #ifdef GL_NV_viewport_array2 &__GLEW_NV_viewport_array2, #endif @@ -7002,15 +8460,6 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_OES_byte_coordinates &__GLEW_OES_byte_coordinates, #endif -#ifdef GL_OES_compressed_paletted_texture - &__GLEW_OES_compressed_paletted_texture, -#endif -#ifdef GL_OES_read_format - &__GLEW_OES_read_format, -#endif -#ifdef GL_OES_single_precision - &__GLEW_OES_single_precision, -#endif #ifdef GL_OML_interlace &__GLEW_OML_interlace, #endif @@ -7026,12 +8475,45 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_OVR_multiview2 &__GLEW_OVR_multiview2, #endif +#ifdef GL_OVR_multiview_multisampled_render_to_texture + &__GLEW_OVR_multiview_multisampled_render_to_texture, +#endif #ifdef GL_PGI_misc_hints &__GLEW_PGI_misc_hints, #endif #ifdef GL_PGI_vertex_hints &__GLEW_PGI_vertex_hints, #endif +#ifdef GL_QCOM_alpha_test + &__GLEW_QCOM_alpha_test, +#endif +#ifdef GL_QCOM_binning_control + &__GLEW_QCOM_binning_control, +#endif +#ifdef GL_QCOM_driver_control + &__GLEW_QCOM_driver_control, +#endif +#ifdef GL_QCOM_extended_get + &__GLEW_QCOM_extended_get, +#endif +#ifdef GL_QCOM_extended_get2 + &__GLEW_QCOM_extended_get2, +#endif +#ifdef GL_QCOM_framebuffer_foveated + &__GLEW_QCOM_framebuffer_foveated, +#endif +#ifdef GL_QCOM_perfmon_global_mode + &__GLEW_QCOM_perfmon_global_mode, +#endif +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + &__GLEW_QCOM_shader_framebuffer_fetch_noncoherent, +#endif +#ifdef GL_QCOM_tiled_rendering + &__GLEW_QCOM_tiled_rendering, +#endif +#ifdef GL_QCOM_writeonly_rendering + &__GLEW_QCOM_writeonly_rendering, +#endif #ifdef GL_REGAL_ES1_0_compatibility &__GLEW_REGAL_ES1_0_compatibility, #endif @@ -7059,6 +8541,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_S3_s3tc &__GLEW_S3_s3tc, #endif +#ifdef GL_SGIS_clip_band_hint + &__GLEW_SGIS_clip_band_hint, +#endif #ifdef GL_SGIS_color_range &__GLEW_SGIS_color_range, #endif @@ -7071,15 +8556,24 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_SGIS_generate_mipmap &__GLEW_SGIS_generate_mipmap, #endif +#ifdef GL_SGIS_line_texgen + &__GLEW_SGIS_line_texgen, +#endif #ifdef GL_SGIS_multisample &__GLEW_SGIS_multisample, #endif +#ifdef GL_SGIS_multitexture + &__GLEW_SGIS_multitexture, +#endif #ifdef GL_SGIS_pixel_texture &__GLEW_SGIS_pixel_texture, #endif #ifdef GL_SGIS_point_line_texgen &__GLEW_SGIS_point_line_texgen, #endif +#ifdef GL_SGIS_shared_multisample + &__GLEW_SGIS_shared_multisample, +#endif #ifdef GL_SGIS_sharpen_texture &__GLEW_SGIS_sharpen_texture, #endif @@ -7110,63 +8604,192 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_SGIX_async_pixel &__GLEW_SGIX_async_pixel, #endif +#ifdef GL_SGIX_bali_g_instruments + &__GLEW_SGIX_bali_g_instruments, +#endif +#ifdef GL_SGIX_bali_r_instruments + &__GLEW_SGIX_bali_r_instruments, +#endif +#ifdef GL_SGIX_bali_timer_instruments + &__GLEW_SGIX_bali_timer_instruments, +#endif #ifdef GL_SGIX_blend_alpha_minmax &__GLEW_SGIX_blend_alpha_minmax, #endif +#ifdef GL_SGIX_blend_cadd + &__GLEW_SGIX_blend_cadd, +#endif +#ifdef GL_SGIX_blend_cmultiply + &__GLEW_SGIX_blend_cmultiply, +#endif +#ifdef GL_SGIX_calligraphic_fragment + &__GLEW_SGIX_calligraphic_fragment, +#endif #ifdef GL_SGIX_clipmap &__GLEW_SGIX_clipmap, #endif +#ifdef GL_SGIX_color_matrix_accuracy + &__GLEW_SGIX_color_matrix_accuracy, +#endif +#ifdef GL_SGIX_color_table_index_mode + &__GLEW_SGIX_color_table_index_mode, +#endif +#ifdef GL_SGIX_complex_polar + &__GLEW_SGIX_complex_polar, +#endif #ifdef GL_SGIX_convolution_accuracy &__GLEW_SGIX_convolution_accuracy, #endif +#ifdef GL_SGIX_cube_map + &__GLEW_SGIX_cube_map, +#endif +#ifdef GL_SGIX_cylinder_texgen + &__GLEW_SGIX_cylinder_texgen, +#endif +#ifdef GL_SGIX_datapipe + &__GLEW_SGIX_datapipe, +#endif +#ifdef GL_SGIX_decimation + &__GLEW_SGIX_decimation, +#endif +#ifdef GL_SGIX_depth_pass_instrument + &__GLEW_SGIX_depth_pass_instrument, +#endif #ifdef GL_SGIX_depth_texture &__GLEW_SGIX_depth_texture, #endif +#ifdef GL_SGIX_dvc + &__GLEW_SGIX_dvc, +#endif #ifdef GL_SGIX_flush_raster &__GLEW_SGIX_flush_raster, #endif +#ifdef GL_SGIX_fog_blend + &__GLEW_SGIX_fog_blend, +#endif +#ifdef GL_SGIX_fog_factor_to_alpha + &__GLEW_SGIX_fog_factor_to_alpha, +#endif +#ifdef GL_SGIX_fog_layers + &__GLEW_SGIX_fog_layers, +#endif #ifdef GL_SGIX_fog_offset &__GLEW_SGIX_fog_offset, #endif +#ifdef GL_SGIX_fog_patchy + &__GLEW_SGIX_fog_patchy, +#endif +#ifdef GL_SGIX_fog_scale + &__GLEW_SGIX_fog_scale, +#endif #ifdef GL_SGIX_fog_texture &__GLEW_SGIX_fog_texture, #endif +#ifdef GL_SGIX_fragment_lighting_space + &__GLEW_SGIX_fragment_lighting_space, +#endif #ifdef GL_SGIX_fragment_specular_lighting &__GLEW_SGIX_fragment_specular_lighting, #endif +#ifdef GL_SGIX_fragments_instrument + &__GLEW_SGIX_fragments_instrument, +#endif #ifdef GL_SGIX_framezoom &__GLEW_SGIX_framezoom, #endif +#ifdef GL_SGIX_icc_texture + &__GLEW_SGIX_icc_texture, +#endif +#ifdef GL_SGIX_igloo_interface + &__GLEW_SGIX_igloo_interface, +#endif +#ifdef GL_SGIX_image_compression + &__GLEW_SGIX_image_compression, +#endif +#ifdef GL_SGIX_impact_pixel_texture + &__GLEW_SGIX_impact_pixel_texture, +#endif +#ifdef GL_SGIX_instrument_error + &__GLEW_SGIX_instrument_error, +#endif #ifdef GL_SGIX_interlace &__GLEW_SGIX_interlace, #endif #ifdef GL_SGIX_ir_instrument1 &__GLEW_SGIX_ir_instrument1, #endif +#ifdef GL_SGIX_line_quality_hint + &__GLEW_SGIX_line_quality_hint, +#endif #ifdef GL_SGIX_list_priority &__GLEW_SGIX_list_priority, #endif +#ifdef GL_SGIX_mpeg1 + &__GLEW_SGIX_mpeg1, +#endif +#ifdef GL_SGIX_mpeg2 + &__GLEW_SGIX_mpeg2, +#endif +#ifdef GL_SGIX_nonlinear_lighting_pervertex + &__GLEW_SGIX_nonlinear_lighting_pervertex, +#endif +#ifdef GL_SGIX_nurbs_eval + &__GLEW_SGIX_nurbs_eval, +#endif +#ifdef GL_SGIX_occlusion_instrument + &__GLEW_SGIX_occlusion_instrument, +#endif +#ifdef GL_SGIX_packed_6bytes + &__GLEW_SGIX_packed_6bytes, +#endif #ifdef GL_SGIX_pixel_texture &__GLEW_SGIX_pixel_texture, #endif #ifdef GL_SGIX_pixel_texture_bits &__GLEW_SGIX_pixel_texture_bits, #endif +#ifdef GL_SGIX_pixel_texture_lod + &__GLEW_SGIX_pixel_texture_lod, +#endif +#ifdef GL_SGIX_pixel_tiles + &__GLEW_SGIX_pixel_tiles, +#endif +#ifdef GL_SGIX_polynomial_ffd + &__GLEW_SGIX_polynomial_ffd, +#endif +#ifdef GL_SGIX_quad_mesh + &__GLEW_SGIX_quad_mesh, +#endif #ifdef GL_SGIX_reference_plane &__GLEW_SGIX_reference_plane, #endif #ifdef GL_SGIX_resample &__GLEW_SGIX_resample, #endif +#ifdef GL_SGIX_scalebias_hint + &__GLEW_SGIX_scalebias_hint, +#endif #ifdef GL_SGIX_shadow &__GLEW_SGIX_shadow, #endif #ifdef GL_SGIX_shadow_ambient &__GLEW_SGIX_shadow_ambient, #endif +#ifdef GL_SGIX_slim + &__GLEW_SGIX_slim, +#endif +#ifdef GL_SGIX_spotlight_cutoff + &__GLEW_SGIX_spotlight_cutoff, +#endif #ifdef GL_SGIX_sprite &__GLEW_SGIX_sprite, #endif +#ifdef GL_SGIX_subdiv_patch + &__GLEW_SGIX_subdiv_patch, +#endif +#ifdef GL_SGIX_subsample + &__GLEW_SGIX_subsample, +#endif #ifdef GL_SGIX_tag_sample_buffer &__GLEW_SGIX_tag_sample_buffer, #endif @@ -7179,15 +8802,30 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_SGIX_texture_lod_bias &__GLEW_SGIX_texture_lod_bias, #endif +#ifdef GL_SGIX_texture_mipmap_anisotropic + &__GLEW_SGIX_texture_mipmap_anisotropic, +#endif #ifdef GL_SGIX_texture_multi_buffer &__GLEW_SGIX_texture_multi_buffer, #endif +#ifdef GL_SGIX_texture_phase + &__GLEW_SGIX_texture_phase, +#endif #ifdef GL_SGIX_texture_range &__GLEW_SGIX_texture_range, #endif #ifdef GL_SGIX_texture_scale_bias &__GLEW_SGIX_texture_scale_bias, #endif +#ifdef GL_SGIX_texture_supersample + &__GLEW_SGIX_texture_supersample, +#endif +#ifdef GL_SGIX_vector_ops + &__GLEW_SGIX_vector_ops, +#endif +#ifdef GL_SGIX_vertex_array_object + &__GLEW_SGIX_vertex_array_object, +#endif #ifdef GL_SGIX_vertex_preclip &__GLEW_SGIX_vertex_preclip, #endif @@ -7197,12 +8835,27 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_SGIX_ycrcb &__GLEW_SGIX_ycrcb, #endif +#ifdef GL_SGIX_ycrcb_subsample + &__GLEW_SGIX_ycrcb_subsample, +#endif +#ifdef GL_SGIX_ycrcba + &__GLEW_SGIX_ycrcba, +#endif #ifdef GL_SGI_color_matrix &__GLEW_SGI_color_matrix, #endif #ifdef GL_SGI_color_table &__GLEW_SGI_color_table, #endif +#ifdef GL_SGI_complex + &__GLEW_SGI_complex, +#endif +#ifdef GL_SGI_complex_type + &__GLEW_SGI_complex_type, +#endif +#ifdef GL_SGI_fft + &__GLEW_SGI_fft, +#endif #ifdef GL_SGI_texture_color_table &__GLEW_SGI_texture_color_table, #endif @@ -7233,6 +8886,9 @@ static GLboolean* _glewExtensionEnabled[] = { #ifdef GL_WIN_phong_shading &__GLEW_WIN_phong_shading, #endif +#ifdef GL_WIN_scene_markerXXX + &__GLEW_WIN_scene_markerXXX, +#endif #ifdef GL_WIN_specular_fog &__GLEW_WIN_specular_fog, #endif @@ -7253,9 +8909,11 @@ static GLboolean _glewInit_GL_VERSION_3_2 (); static GLboolean _glewInit_GL_VERSION_3_3 (); static GLboolean _glewInit_GL_VERSION_4_0 (); static GLboolean _glewInit_GL_VERSION_4_5 (); +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_sample_positions (); static GLboolean _glewInit_GL_AMD_interleaved_elements (); static GLboolean _glewInit_GL_AMD_multi_draw_indirect (); static GLboolean _glewInit_GL_AMD_name_gen_delete (); @@ -7270,10 +8928,13 @@ static GLboolean _glewInit_GL_ANGLE_framebuffer_multisample (); static GLboolean _glewInit_GL_ANGLE_instanced_arrays (); static GLboolean _glewInit_GL_ANGLE_timer_query (); static GLboolean _glewInit_GL_ANGLE_translated_shader_source (); +static GLboolean _glewInit_GL_APPLE_copy_texture_levels (); static GLboolean _glewInit_GL_APPLE_element_array (); static GLboolean _glewInit_GL_APPLE_fence (); static GLboolean _glewInit_GL_APPLE_flush_buffer_range (); +static GLboolean _glewInit_GL_APPLE_framebuffer_multisample (); static GLboolean _glewInit_GL_APPLE_object_purgeable (); +static GLboolean _glewInit_GL_APPLE_sync (); static GLboolean _glewInit_GL_APPLE_texture_range (); static GLboolean _glewInit_GL_APPLE_vertex_array_object (); static GLboolean _glewInit_GL_APPLE_vertex_array_range (); @@ -7323,6 +8984,7 @@ static GLboolean _glewInit_GL_ARB_multitexture (); static GLboolean _glewInit_GL_ARB_occlusion_query (); static GLboolean _glewInit_GL_ARB_parallel_shader_compile (); static GLboolean _glewInit_GL_ARB_point_parameters (); +static GLboolean _glewInit_GL_ARB_polygon_offset_clamp (); static GLboolean _glewInit_GL_ARB_program_interface_query (); static GLboolean _glewInit_GL_ARB_provoking_vertex (); static GLboolean _glewInit_GL_ARB_robustness (); @@ -7374,24 +9036,34 @@ 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_base_instance (); static GLboolean _glewInit_GL_EXT_bindable_uniform (); static GLboolean _glewInit_GL_EXT_blend_color (); static GLboolean _glewInit_GL_EXT_blend_equation_separate (); +static GLboolean _glewInit_GL_EXT_blend_func_extended (); 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_color_subtable (); static GLboolean _glewInit_GL_EXT_compiled_vertex_array (); static GLboolean _glewInit_GL_EXT_convolution (); static GLboolean _glewInit_GL_EXT_coordinate_frame (); +static GLboolean _glewInit_GL_EXT_copy_image (); static GLboolean _glewInit_GL_EXT_copy_texture (); static GLboolean _glewInit_GL_EXT_cull_vertex (); static GLboolean _glewInit_GL_EXT_debug_label (); 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_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_external_buffer (); static GLboolean _glewInit_GL_EXT_fog_coord (); static GLboolean _glewInit_GL_EXT_fragment_lighting (); static GLboolean _glewInit_GL_EXT_framebuffer_blit (); @@ -7403,9 +9075,17 @@ static GLboolean _glewInit_GL_EXT_gpu_shader4 (); static GLboolean _glewInit_GL_EXT_histogram (); static GLboolean _glewInit_GL_EXT_index_func (); static GLboolean _glewInit_GL_EXT_index_material (); +static GLboolean _glewInit_GL_EXT_instanced_arrays (); static GLboolean _glewInit_GL_EXT_light_texture (); +static GLboolean _glewInit_GL_EXT_map_buffer_range (); +static GLboolean _glewInit_GL_EXT_memory_object (); +static GLboolean _glewInit_GL_EXT_memory_object_fd (); +static GLboolean _glewInit_GL_EXT_memory_object_win32 (); static GLboolean _glewInit_GL_EXT_multi_draw_arrays (); +static GLboolean _glewInit_GL_EXT_multi_draw_indirect (); static GLboolean _glewInit_GL_EXT_multisample (); +static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture (); +static GLboolean _glewInit_GL_EXT_multiview_draw_buffers (); static GLboolean _glewInit_GL_EXT_paletted_texture (); static GLboolean _glewInit_GL_EXT_pixel_transform (); static GLboolean _glewInit_GL_EXT_point_parameters (); @@ -7415,8 +9095,13 @@ static GLboolean _glewInit_GL_EXT_provoking_vertex (); static GLboolean _glewInit_GL_EXT_raster_multisample (); 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_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_texture3D (); @@ -7425,12 +9110,16 @@ static GLboolean _glewInit_GL_EXT_texture_buffer_object (); static GLboolean _glewInit_GL_EXT_texture_integer (); static GLboolean _glewInit_GL_EXT_texture_object (); static GLboolean _glewInit_GL_EXT_texture_perturb_normal (); +static GLboolean _glewInit_GL_EXT_texture_storage (); +static GLboolean _glewInit_GL_EXT_texture_view (); static GLboolean _glewInit_GL_EXT_timer_query (); static GLboolean _glewInit_GL_EXT_transform_feedback (); static GLboolean _glewInit_GL_EXT_vertex_array (); +static GLboolean _glewInit_GL_EXT_vertex_array_setXXX (); static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit (); static GLboolean _glewInit_GL_EXT_vertex_shader (); 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_GREMEDY_frame_terminator (); @@ -7444,12 +9133,14 @@ static GLboolean _glewInit_GL_INTEL_performance_query (); static GLboolean _glewInit_GL_INTEL_texture_scissor (); static GLboolean _glewInit_GL_KHR_blend_equation_advanced (); static GLboolean _glewInit_GL_KHR_debug (); +static GLboolean _glewInit_GL_KHR_parallel_shader_compile (); static GLboolean _glewInit_GL_KHR_robustness (); static GLboolean _glewInit_GL_KTX_buffer_region (); static GLboolean _glewInit_GL_MESA_resize_buffers (); static GLboolean _glewInit_GL_MESA_window_pos (); static GLboolean _glewInit_GL_NVX_conditional_render (); static GLboolean _glewInit_GL_NVX_linked_gpu_multicast (); +static GLboolean _glewInit_GL_NV_3dvision_settings (); static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect (); static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect_count (); static GLboolean _glewInit_GL_NV_bindless_texture (); @@ -7460,8 +9151,11 @@ static GLboolean _glewInit_GL_NV_conditional_render (); static GLboolean _glewInit_GL_NV_conservative_raster (); static GLboolean _glewInit_GL_NV_conservative_raster_dilate (); static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles (); +static GLboolean _glewInit_GL_NV_copy_buffer (); static GLboolean _glewInit_GL_NV_copy_image (); static GLboolean _glewInit_GL_NV_depth_buffer_float (); +static GLboolean _glewInit_GL_NV_draw_buffers (); +static GLboolean _glewInit_GL_NV_draw_instanced (); static GLboolean _glewInit_GL_NV_draw_texture (); static GLboolean _glewInit_GL_NV_draw_vulkan_image (); static GLboolean _glewInit_GL_NV_evaluators (); @@ -7469,24 +9163,30 @@ static GLboolean _glewInit_GL_NV_explicit_multisample (); static GLboolean _glewInit_GL_NV_fence (); static GLboolean _glewInit_GL_NV_fragment_coverage_to_color (); static GLboolean _glewInit_GL_NV_fragment_program (); +static GLboolean _glewInit_GL_NV_framebuffer_blit (); +static GLboolean _glewInit_GL_NV_framebuffer_multisample (); static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (); static GLboolean _glewInit_GL_NV_geometry_program4 (); static GLboolean _glewInit_GL_NV_gpu_multicast (); static GLboolean _glewInit_GL_NV_gpu_program4 (); 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_non_square_matrices (); static GLboolean _glewInit_GL_NV_occlusion_query (); static GLboolean _glewInit_GL_NV_parameter_buffer_object (); static GLboolean _glewInit_GL_NV_path_rendering (); static GLboolean _glewInit_GL_NV_pixel_data_range (); 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_register_combiners (); static GLboolean _glewInit_GL_NV_register_combiners2 (); static GLboolean _glewInit_GL_NV_sample_locations (); static GLboolean _glewInit_GL_NV_shader_buffer_load (); +static GLboolean _glewInit_GL_NV_texture_array (); static GLboolean _glewInit_GL_NV_texture_barrier (); static GLboolean _glewInit_GL_NV_texture_multisample (); static GLboolean _glewInit_GL_NV_transform_feedback (); @@ -7497,9 +9197,17 @@ static GLboolean _glewInit_GL_NV_vertex_attrib_integer_64bit (); static GLboolean _glewInit_GL_NV_vertex_buffer_unified_memory (); 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_single_precision (); static GLboolean _glewInit_GL_OVR_multiview (); +static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture (); +static GLboolean _glewInit_GL_QCOM_alpha_test (); +static GLboolean _glewInit_GL_QCOM_driver_control (); +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_tiled_rendering (); static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility (); static GLboolean _glewInit_GL_REGAL_ES1_1_compatibility (); static GLboolean _glewInit_GL_REGAL_error_string (); @@ -7509,19 +9217,31 @@ static GLboolean _glewInit_GL_REGAL_proc_address (); static GLboolean _glewInit_GL_SGIS_detail_texture (); static GLboolean _glewInit_GL_SGIS_fog_function (); static GLboolean _glewInit_GL_SGIS_multisample (); +static GLboolean _glewInit_GL_SGIS_multitexture (); +static GLboolean _glewInit_GL_SGIS_shared_multisample (); static GLboolean _glewInit_GL_SGIS_sharpen_texture (); static GLboolean _glewInit_GL_SGIS_texture4D (); static GLboolean _glewInit_GL_SGIS_texture_filter4 (); static GLboolean _glewInit_GL_SGIX_async (); +static GLboolean _glewInit_GL_SGIX_datapipe (); static GLboolean _glewInit_GL_SGIX_flush_raster (); +static GLboolean _glewInit_GL_SGIX_fog_layers (); static GLboolean _glewInit_GL_SGIX_fog_texture (); static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (); static GLboolean _glewInit_GL_SGIX_framezoom (); +static GLboolean _glewInit_GL_SGIX_igloo_interface (); +static GLboolean _glewInit_GL_SGIX_mpeg1 (); +static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex (); static GLboolean _glewInit_GL_SGIX_pixel_texture (); +static GLboolean _glewInit_GL_SGIX_polynomial_ffd (); +static GLboolean _glewInit_GL_SGIX_quad_mesh (); static GLboolean _glewInit_GL_SGIX_reference_plane (); static GLboolean _glewInit_GL_SGIX_sprite (); static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (); +static GLboolean _glewInit_GL_SGIX_vector_ops (); +static GLboolean _glewInit_GL_SGIX_vertex_array_object (); static GLboolean _glewInit_GL_SGI_color_table (); +static GLboolean _glewInit_GL_SGI_fft (); static GLboolean _glewInit_GL_SUNX_constant_data (); static GLboolean _glewInit_GL_SUN_global_alpha (); static GLboolean _glewInit_GL_SUN_read_video_pixels (); @@ -7972,6 +9692,21 @@ static GLboolean _glewInit_GL_VERSION_4_5 () #endif /* GL_VERSION_4_5 */ +#ifdef GL_VERSION_4_6 + +static GLboolean _glewInit_GL_VERSION_4_6 () +{ + GLboolean r = GL_FALSE; + + r = ((glMultiDrawArraysIndirectCount = (PFNGLMULTIDRAWARRAYSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectCount")) == NULL) || r; + r = ((glMultiDrawElementsIndirectCount = (PFNGLMULTIDRAWELEMENTSINDIRECTCOUNTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectCount")) == NULL) || r; + r = ((glSpecializeShader = (PFNGLSPECIALIZESHADERPROC)glewGetProcAddress((const GLubyte*)"glSpecializeShader")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_4_6 */ + #ifdef GL_3DFX_tbuffer static GLboolean _glewInit_GL_3DFX_tbuffer () @@ -8017,6 +9752,22 @@ static GLboolean _glewInit_GL_AMD_draw_buffers_blend () #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_sample_positions + +static GLboolean _glewInit_GL_AMD_framebuffer_sample_positions () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferSamplePositionsfvAMD = (PFNGLFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)glewGetProcAddress((const GLubyte*)"glFramebufferSamplePositionsfvAMD")) == NULL) || r; + r = ((glGetFramebufferParameterfvAMD = (PFNGLGETFRAMEBUFFERPARAMETERFVAMDPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterfvAMD")) == NULL) || r; + r = ((glGetNamedFramebufferParameterfvAMD = (PFNGLGETNAMEDFRAMEBUFFERPARAMETERFVAMDPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferParameterfvAMD")) == NULL) || r; + r = ((glNamedFramebufferSamplePositionsfvAMD = (PFNGLNAMEDFRAMEBUFFERSAMPLEPOSITIONSFVAMDPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferSamplePositionsfvAMD")) == NULL) || r; + + return r; +} + +#endif /* GL_AMD_framebuffer_sample_positions */ + #ifdef GL_AMD_interleaved_elements static GLboolean _glewInit_GL_AMD_interleaved_elements () @@ -8226,6 +9977,19 @@ static GLboolean _glewInit_GL_ANGLE_translated_shader_source () #endif /* GL_ANGLE_translated_shader_source */ +#ifdef GL_APPLE_copy_texture_levels + +static GLboolean _glewInit_GL_APPLE_copy_texture_levels () +{ + GLboolean r = GL_FALSE; + + r = ((glCopyTextureLevelsAPPLE = (PFNGLCOPYTEXTURELEVELSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureLevelsAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_copy_texture_levels */ + #ifdef GL_APPLE_element_array static GLboolean _glewInit_GL_APPLE_element_array () @@ -8277,6 +10041,20 @@ static GLboolean _glewInit_GL_APPLE_flush_buffer_range () #endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_framebuffer_multisample + +static GLboolean _glewInit_GL_APPLE_framebuffer_multisample () +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleAPPLE = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleAPPLE")) == NULL) || r; + r = ((glResolveMultisampleFramebufferAPPLE = (PFNGLRESOLVEMULTISAMPLEFRAMEBUFFERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glResolveMultisampleFramebufferAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_framebuffer_multisample */ + #ifdef GL_APPLE_object_purgeable static GLboolean _glewInit_GL_APPLE_object_purgeable () @@ -8292,6 +10070,25 @@ static GLboolean _glewInit_GL_APPLE_object_purgeable () #endif /* GL_APPLE_object_purgeable */ +#ifdef GL_APPLE_sync + +static GLboolean _glewInit_GL_APPLE_sync () +{ + GLboolean r = GL_FALSE; + + r = ((glClientWaitSyncAPPLE = (PFNGLCLIENTWAITSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glClientWaitSyncAPPLE")) == NULL) || r; + r = ((glDeleteSyncAPPLE = (PFNGLDELETESYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteSyncAPPLE")) == NULL) || r; + r = ((glFenceSyncAPPLE = (PFNGLFENCESYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFenceSyncAPPLE")) == NULL) || r; + r = ((glGetInteger64vAPPLE = (PFNGLGETINTEGER64VAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetInteger64vAPPLE")) == NULL) || r; + r = ((glGetSyncivAPPLE = (PFNGLGETSYNCIVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetSyncivAPPLE")) == NULL) || r; + r = ((glIsSyncAPPLE = (PFNGLISSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsSyncAPPLE")) == NULL) || r; + r = ((glWaitSyncAPPLE = (PFNGLWAITSYNCAPPLEPROC)glewGetProcAddress((const GLubyte*)"glWaitSyncAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_sync */ + #ifdef GL_APPLE_texture_range static GLboolean _glewInit_GL_APPLE_texture_range () @@ -8463,7 +10260,6 @@ static GLboolean _glewInit_GL_ARB_buffer_storage () GLboolean r = GL_FALSE; r = ((glBufferStorage = (PFNGLBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glBufferStorage")) == NULL) || r; - r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r; return r; } @@ -9247,6 +11043,19 @@ static GLboolean _glewInit_GL_ARB_point_parameters () #endif /* GL_ARB_point_parameters */ +#ifdef GL_ARB_polygon_offset_clamp + +static GLboolean _glewInit_GL_ARB_polygon_offset_clamp () +{ + GLboolean r = GL_FALSE; + + r = ((glPolygonOffsetClamp = (PFNGLPOLYGONOFFSETCLAMPPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetClamp")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_polygon_offset_clamp */ + #ifdef GL_ARB_program_interface_query static GLboolean _glewInit_GL_ARB_program_interface_query () @@ -9584,7 +11393,6 @@ static GLboolean _glewInit_GL_ARB_sparse_texture () GLboolean r = GL_FALSE; r = ((glTexPageCommitmentARB = (PFNGLTEXPAGECOMMITMENTARBPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentARB")) == NULL) || r; - r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r; return r; } @@ -9708,9 +11516,6 @@ static GLboolean _glewInit_GL_ARB_texture_storage () r = ((glTexStorage1D = (PFNGLTEXSTORAGE1DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1D")) == NULL) || r; r = ((glTexStorage2D = (PFNGLTEXSTORAGE2DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2D")) == NULL) || r; r = ((glTexStorage3D = (PFNGLTEXSTORAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3D")) == NULL) || r; - r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r; - r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r; - r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r; return r; } @@ -10352,6 +12157,21 @@ static GLboolean _glewInit_GL_ATI_vertex_streams () #endif /* GL_ATI_vertex_streams */ +#ifdef GL_EXT_base_instance + +static GLboolean _glewInit_GL_EXT_base_instance () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedBaseInstanceEXT = (PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedBaseInstanceEXT")) == NULL) || r; + r = ((glDrawElementsInstancedBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseInstanceEXT")) == NULL) || r; + r = ((glDrawElementsInstancedBaseVertexBaseInstanceEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexBaseInstanceEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_base_instance */ + #ifdef GL_EXT_bindable_uniform static GLboolean _glewInit_GL_EXT_bindable_uniform () @@ -10393,6 +12213,21 @@ static GLboolean _glewInit_GL_EXT_blend_equation_separate () #endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_extended + +static GLboolean _glewInit_GL_EXT_blend_func_extended () +{ + GLboolean r = GL_FALSE; + + r = ((glBindFragDataLocationIndexedEXT = (PFNGLBINDFRAGDATALOCATIONINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationIndexedEXT")) == NULL) || r; + r = ((glGetFragDataIndexEXT = (PFNGLGETFRAGDATAINDEXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataIndexEXT")) == NULL) || r; + r = ((glGetProgramResourceLocationIndexEXT = (PFNGLGETPROGRAMRESOURCELOCATIONINDEXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetProgramResourceLocationIndexEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_func_extended */ + #ifdef GL_EXT_blend_func_separate static GLboolean _glewInit_GL_EXT_blend_func_separate () @@ -10419,6 +12254,34 @@ static GLboolean _glewInit_GL_EXT_blend_minmax () #endif /* GL_EXT_blend_minmax */ +#ifdef GL_EXT_buffer_storage + +static GLboolean _glewInit_GL_EXT_buffer_storage () +{ + GLboolean r = GL_FALSE; + + r = ((glBufferStorageEXT = (PFNGLBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageEXT")) == NULL) || r; + r = ((glNamedBufferStorageEXT = (PFNGLNAMEDBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_buffer_storage */ + +#ifdef GL_EXT_clear_texture + +static GLboolean _glewInit_GL_EXT_clear_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glClearTexImageEXT = (PFNGLCLEARTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glClearTexImageEXT")) == NULL) || r; + r = ((glClearTexSubImageEXT = (PFNGLCLEARTEXSUBIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glClearTexSubImageEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_clear_texture */ + #ifdef GL_EXT_color_subtable static GLboolean _glewInit_GL_EXT_color_subtable () @@ -10486,6 +12349,19 @@ static GLboolean _glewInit_GL_EXT_coordinate_frame () #endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_image + +static GLboolean _glewInit_GL_EXT_copy_image () +{ + GLboolean r = GL_FALSE; + + r = ((glCopyImageSubDataEXT = (PFNGLCOPYIMAGESUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyImageSubDataEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_copy_image */ + #ifdef GL_EXT_copy_texture static GLboolean _glewInit_GL_EXT_copy_texture () @@ -10785,6 +12661,32 @@ static GLboolean _glewInit_GL_EXT_direct_state_access () #endif /* GL_EXT_direct_state_access */ +#ifdef GL_EXT_discard_framebuffer + +static GLboolean _glewInit_GL_EXT_discard_framebuffer () +{ + GLboolean r = GL_FALSE; + + r = ((glDiscardFramebufferEXT = (PFNGLDISCARDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glDiscardFramebufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_discard_framebuffer */ + +#ifdef GL_EXT_draw_buffers + +static GLboolean _glewInit_GL_EXT_draw_buffers () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersEXT = (PFNGLDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_buffers */ + #ifdef GL_EXT_draw_buffers2 static GLboolean _glewInit_GL_EXT_draw_buffers2 () @@ -10803,6 +12705,42 @@ static GLboolean _glewInit_GL_EXT_draw_buffers2 () #endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_buffers_indexed + +static GLboolean _glewInit_GL_EXT_draw_buffers_indexed () +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateiEXT = (PFNGLBLENDEQUATIONSEPARATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateiEXT")) == NULL) || r; + r = ((glBlendEquationiEXT = (PFNGLBLENDEQUATIONIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationiEXT")) == NULL) || r; + r = ((glBlendFuncSeparateiEXT = (PFNGLBLENDFUNCSEPARATEIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateiEXT")) == NULL) || r; + r = ((glBlendFunciEXT = (PFNGLBLENDFUNCIEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFunciEXT")) == NULL) || r; + r = ((glColorMaskiEXT = (PFNGLCOLORMASKIEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskiEXT")) == NULL) || r; + r = ((glDisableiEXT = (PFNGLDISABLEIEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableiEXT")) == NULL) || r; + r = ((glEnableiEXT = (PFNGLENABLEIEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableiEXT")) == NULL) || r; + r = ((glIsEnablediEXT = (PFNGLISENABLEDIEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnablediEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_buffers_indexed */ + +#ifdef GL_EXT_draw_elements_base_vertex + +static GLboolean _glewInit_GL_EXT_draw_elements_base_vertex () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementsBaseVertexEXT = (PFNGLDRAWELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsBaseVertexEXT")) == NULL) || r; + r = ((glDrawElementsInstancedBaseVertexEXT = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedBaseVertexEXT")) == NULL) || r; + r = ((glDrawRangeElementsBaseVertexEXT = (PFNGLDRAWRANGEELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsBaseVertexEXT")) == NULL) || r; + r = ((glMultiDrawElementsBaseVertexEXT = (PFNGLMULTIDRAWELEMENTSBASEVERTEXEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsBaseVertexEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_elements_base_vertex */ + #ifdef GL_EXT_draw_instanced static GLboolean _glewInit_GL_EXT_draw_instanced () @@ -10830,6 +12768,20 @@ static GLboolean _glewInit_GL_EXT_draw_range_elements () #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_external_buffer + +static GLboolean _glewInit_GL_EXT_external_buffer () +{ + GLboolean r = GL_FALSE; + + r = ((glBufferStorageExternalEXT = (PFNGLBUFFERSTORAGEEXTERNALEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageExternalEXT")) == NULL) || r; + r = ((glNamedBufferStorageExternalEXT = (PFNGLNAMEDBUFFERSTORAGEEXTERNALEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageExternalEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_external_buffer */ + #ifdef GL_EXT_fog_coord static GLboolean _glewInit_GL_EXT_fog_coord () @@ -11055,6 +13007,19 @@ static GLboolean _glewInit_GL_EXT_index_material () #endif /* GL_EXT_index_material */ +#ifdef GL_EXT_instanced_arrays + +static GLboolean _glewInit_GL_EXT_instanced_arrays () +{ + GLboolean r = GL_FALSE; + + r = ((glVertexAttribDivisorEXT = (PFNGLVERTEXATTRIBDIVISOREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_instanced_arrays */ + #ifdef GL_EXT_light_texture static GLboolean _glewInit_GL_EXT_light_texture () @@ -11070,6 +13035,78 @@ static GLboolean _glewInit_GL_EXT_light_texture () #endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_map_buffer_range + +static GLboolean _glewInit_GL_EXT_map_buffer_range () +{ + GLboolean r = GL_FALSE; + + r = ((glFlushMappedBufferRangeEXT = (PFNGLFLUSHMAPPEDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeEXT")) == NULL) || r; + r = ((glMapBufferRangeEXT = (PFNGLMAPBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRangeEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_map_buffer_range */ + +#ifdef GL_EXT_memory_object + +static GLboolean _glewInit_GL_EXT_memory_object () +{ + GLboolean r = GL_FALSE; + + r = ((glBufferStorageMemEXT = (PFNGLBUFFERSTORAGEMEMEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferStorageMemEXT")) == NULL) || r; + r = ((glCreateMemoryObjectsEXT = (PFNGLCREATEMEMORYOBJECTSEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateMemoryObjectsEXT")) == NULL) || r; + r = ((glDeleteMemoryObjectsEXT = (PFNGLDELETEMEMORYOBJECTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteMemoryObjectsEXT")) == NULL) || r; + r = ((glGetMemoryObjectParameterivEXT = (PFNGLGETMEMORYOBJECTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMemoryObjectParameterivEXT")) == NULL) || r; + r = ((glGetUnsignedBytei_vEXT = (PFNGLGETUNSIGNEDBYTEI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUnsignedBytei_vEXT")) == NULL) || r; + r = ((glGetUnsignedBytevEXT = (PFNGLGETUNSIGNEDBYTEVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUnsignedBytevEXT")) == NULL) || r; + r = ((glIsMemoryObjectEXT = (PFNGLISMEMORYOBJECTEXTPROC)glewGetProcAddress((const GLubyte*)"glIsMemoryObjectEXT")) == NULL) || r; + r = ((glMemoryObjectParameterivEXT = (PFNGLMEMORYOBJECTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMemoryObjectParameterivEXT")) == NULL) || r; + r = ((glNamedBufferStorageMemEXT = (PFNGLNAMEDBUFFERSTORAGEMEMEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferStorageMemEXT")) == NULL) || r; + r = ((glTexStorageMem1DEXT = (PFNGLTEXSTORAGEMEM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem1DEXT")) == NULL) || r; + r = ((glTexStorageMem2DEXT = (PFNGLTEXSTORAGEMEM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem2DEXT")) == NULL) || r; + r = ((glTexStorageMem2DMultisampleEXT = (PFNGLTEXSTORAGEMEM2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem2DMultisampleEXT")) == NULL) || r; + r = ((glTexStorageMem3DEXT = (PFNGLTEXSTORAGEMEM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem3DEXT")) == NULL) || r; + r = ((glTexStorageMem3DMultisampleEXT = (PFNGLTEXSTORAGEMEM3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorageMem3DMultisampleEXT")) == NULL) || r; + r = ((glTextureStorageMem1DEXT = (PFNGLTEXTURESTORAGEMEM1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem1DEXT")) == NULL) || r; + r = ((glTextureStorageMem2DEXT = (PFNGLTEXTURESTORAGEMEM2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem2DEXT")) == NULL) || r; + r = ((glTextureStorageMem2DMultisampleEXT = (PFNGLTEXTURESTORAGEMEM2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem2DMultisampleEXT")) == NULL) || r; + r = ((glTextureStorageMem3DEXT = (PFNGLTEXTURESTORAGEMEM3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem3DEXT")) == NULL) || r; + r = ((glTextureStorageMem3DMultisampleEXT = (PFNGLTEXTURESTORAGEMEM3DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorageMem3DMultisampleEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_memory_object */ + +#ifdef GL_EXT_memory_object_fd + +static GLboolean _glewInit_GL_EXT_memory_object_fd () +{ + GLboolean r = GL_FALSE; + + r = ((glImportMemoryFdEXT = (PFNGLIMPORTMEMORYFDEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryFdEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_memory_object_fd */ + +#ifdef GL_EXT_memory_object_win32 + +static GLboolean _glewInit_GL_EXT_memory_object_win32 () +{ + GLboolean r = GL_FALSE; + + r = ((glImportMemoryWin32HandleEXT = (PFNGLIMPORTMEMORYWIN32HANDLEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryWin32HandleEXT")) == NULL) || r; + r = ((glImportMemoryWin32NameEXT = (PFNGLIMPORTMEMORYWIN32NAMEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportMemoryWin32NameEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_memory_object_win32 */ + #ifdef GL_EXT_multi_draw_arrays static GLboolean _glewInit_GL_EXT_multi_draw_arrays () @@ -11084,6 +13121,20 @@ static GLboolean _glewInit_GL_EXT_multi_draw_arrays () #endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multi_draw_indirect + +static GLboolean _glewInit_GL_EXT_multi_draw_indirect () +{ + GLboolean r = GL_FALSE; + + r = ((glMultiDrawArraysIndirectEXT = (PFNGLMULTIDRAWARRAYSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysIndirectEXT")) == NULL) || r; + r = ((glMultiDrawElementsIndirectEXT = (PFNGLMULTIDRAWELEMENTSINDIRECTEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsIndirectEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multi_draw_indirect */ + #ifdef GL_EXT_multisample static GLboolean _glewInit_GL_EXT_multisample () @@ -11098,6 +13149,34 @@ static GLboolean _glewInit_GL_EXT_multisample () #endif /* GL_EXT_multisample */ +#ifdef GL_EXT_multisampled_render_to_texture + +static GLboolean _glewInit_GL_EXT_multisampled_render_to_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTexture2DMultisampleEXT = (PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DMultisampleEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multisampled_render_to_texture */ + +#ifdef GL_EXT_multiview_draw_buffers + +static GLboolean _glewInit_GL_EXT_multiview_draw_buffers () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersIndexedEXT = (PFNGLDRAWBUFFERSINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersIndexedEXT")) == NULL) || r; + r = ((glGetIntegeri_vEXT = (PFNGLGETINTEGERI_VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_vEXT")) == NULL) || r; + r = ((glReadBufferIndexedEXT = (PFNGLREADBUFFERINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferIndexedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multiview_draw_buffers */ + #ifdef GL_EXT_paletted_texture static GLboolean _glewInit_GL_EXT_paletted_texture () @@ -11244,6 +13323,52 @@ static GLboolean _glewInit_GL_EXT_secondary_color () #endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_semaphore + +static GLboolean _glewInit_GL_EXT_semaphore () +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteSemaphoresEXT = (PFNGLDELETESEMAPHORESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteSemaphoresEXT")) == NULL) || r; + r = ((glGenSemaphoresEXT = (PFNGLGENSEMAPHORESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSemaphoresEXT")) == NULL) || r; + r = ((glGetSemaphoreParameterui64vEXT = (PFNGLGETSEMAPHOREPARAMETERUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetSemaphoreParameterui64vEXT")) == NULL) || r; + r = ((glIsSemaphoreEXT = (PFNGLISSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsSemaphoreEXT")) == NULL) || r; + r = ((glSemaphoreParameterui64vEXT = (PFNGLSEMAPHOREPARAMETERUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glSemaphoreParameterui64vEXT")) == NULL) || r; + r = ((glSignalSemaphoreEXT = (PFNGLSIGNALSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glSignalSemaphoreEXT")) == NULL) || r; + r = ((glWaitSemaphoreEXT = (PFNGLWAITSEMAPHOREEXTPROC)glewGetProcAddress((const GLubyte*)"glWaitSemaphoreEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_semaphore */ + +#ifdef GL_EXT_semaphore_fd + +static GLboolean _glewInit_GL_EXT_semaphore_fd () +{ + GLboolean r = GL_FALSE; + + r = ((glImportSemaphoreFdEXT = (PFNGLIMPORTSEMAPHOREFDEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreFdEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_semaphore_fd */ + +#ifdef GL_EXT_semaphore_win32 + +static GLboolean _glewInit_GL_EXT_semaphore_win32 () +{ + GLboolean r = GL_FALSE; + + r = ((glImportSemaphoreWin32HandleEXT = (PFNGLIMPORTSEMAPHOREWIN32HANDLEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreWin32HandleEXT")) == NULL) || r; + r = ((glImportSemaphoreWin32NameEXT = (PFNGLIMPORTSEMAPHOREWIN32NAMEEXTPROC)glewGetProcAddress((const GLubyte*)"glImportSemaphoreWin32NameEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_semaphore_win32 */ + #ifdef GL_EXT_separate_shader_objects static GLboolean _glewInit_GL_EXT_separate_shader_objects () @@ -11273,6 +13398,35 @@ static GLboolean _glewInit_GL_EXT_shader_image_load_store () #endif /* GL_EXT_shader_image_load_store */ +#ifdef GL_EXT_shader_pixel_local_storage2 + +static GLboolean _glewInit_GL_EXT_shader_pixel_local_storage2 () +{ + GLboolean r = GL_FALSE; + + r = ((glClearPixelLocalStorageuiEXT = (PFNGLCLEARPIXELLOCALSTORAGEUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearPixelLocalStorageuiEXT")) == NULL) || r; + r = ((glFramebufferPixelLocalStorageSizeEXT = (PFNGLFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferPixelLocalStorageSizeEXT")) == NULL) || r; + r = ((glGetFramebufferPixelLocalStorageSizeEXT = (PFNGLGETFRAMEBUFFERPIXELLOCALSTORAGESIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferPixelLocalStorageSizeEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_shader_pixel_local_storage2 */ + +#ifdef GL_EXT_sparse_texture + +static GLboolean _glewInit_GL_EXT_sparse_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glTexPageCommitmentEXT = (PFNGLTEXPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexPageCommitmentEXT")) == NULL) || r; + r = ((glTexturePageCommitmentEXT = (PFNGLTEXTUREPAGECOMMITMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glTexturePageCommitmentEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_sparse_texture */ + #ifdef GL_EXT_stencil_two_side static GLboolean _glewInit_GL_EXT_stencil_two_side () @@ -11389,6 +13543,37 @@ static GLboolean _glewInit_GL_EXT_texture_perturb_normal () #endif /* GL_EXT_texture_perturb_normal */ +#ifdef GL_EXT_texture_storage + +static GLboolean _glewInit_GL_EXT_texture_storage () +{ + GLboolean r = GL_FALSE; + + r = ((glTexStorage1DEXT = (PFNGLTEXSTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage1DEXT")) == NULL) || r; + r = ((glTexStorage2DEXT = (PFNGLTEXSTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage2DEXT")) == NULL) || r; + r = ((glTexStorage3DEXT = (PFNGLTEXSTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexStorage3DEXT")) == NULL) || r; + r = ((glTextureStorage1DEXT = (PFNGLTEXTURESTORAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage1DEXT")) == NULL) || r; + r = ((glTextureStorage2DEXT = (PFNGLTEXTURESTORAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage2DEXT")) == NULL) || r; + r = ((glTextureStorage3DEXT = (PFNGLTEXTURESTORAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureStorage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_storage */ + +#ifdef GL_EXT_texture_view + +static GLboolean _glewInit_GL_EXT_texture_view () +{ + GLboolean r = GL_FALSE; + + r = ((glTextureViewEXT = (PFNGLTEXTUREVIEWEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureViewEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_view */ + #ifdef GL_EXT_timer_query static GLboolean _glewInit_GL_EXT_timer_query () @@ -11442,6 +13627,21 @@ static GLboolean _glewInit_GL_EXT_vertex_array () #endif /* GL_EXT_vertex_array */ +#ifdef GL_EXT_vertex_array_setXXX + +static GLboolean _glewInit_GL_EXT_vertex_array_setXXX () +{ + GLboolean r = GL_FALSE; + + r = ((glBindArraySetEXT = (PFNGLBINDARRAYSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindArraySetEXT")) == NULL) || r; + r = ((glCreateArraySetExt = (PFNGLCREATEARRAYSETEXTPROC)glewGetProcAddress((const GLubyte*)"glCreateArraySetExt")) == NULL) || r; + r = ((glDeleteArraySetsEXT = (PFNGLDELETEARRAYSETSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteArraySetsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_array_setXXX */ + #ifdef GL_EXT_vertex_attrib_64bit static GLboolean _glewInit_GL_EXT_vertex_attrib_64bit () @@ -11534,6 +13734,20 @@ static GLboolean _glewInit_GL_EXT_vertex_weighting () #endif /* GL_EXT_vertex_weighting */ +#ifdef GL_EXT_win32_keyed_mutex + +static GLboolean _glewInit_GL_EXT_win32_keyed_mutex () +{ + GLboolean r = GL_FALSE; + + r = ((glAcquireKeyedMutexWin32EXT = (PFNGLACQUIREKEYEDMUTEXWIN32EXTPROC)glewGetProcAddress((const GLubyte*)"glAcquireKeyedMutexWin32EXT")) == NULL) || r; + r = ((glReleaseKeyedMutexWin32EXT = (PFNGLRELEASEKEYEDMUTEXWIN32EXTPROC)glewGetProcAddress((const GLubyte*)"glReleaseKeyedMutexWin32EXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_win32_keyed_mutex */ + #ifdef GL_EXT_window_rectangles static GLboolean _glewInit_GL_EXT_window_rectangles () @@ -11740,6 +13954,19 @@ static GLboolean _glewInit_GL_KHR_debug () #endif /* GL_KHR_debug */ +#ifdef GL_KHR_parallel_shader_compile + +static GLboolean _glewInit_GL_KHR_parallel_shader_compile () +{ + GLboolean r = GL_FALSE; + + r = ((glMaxShaderCompilerThreadsKHR = (PFNGLMAXSHADERCOMPILERTHREADSKHRPROC)glewGetProcAddress((const GLubyte*)"glMaxShaderCompilerThreadsKHR")) == NULL) || r; + + return r; +} + +#endif /* GL_KHR_parallel_shader_compile */ + #ifdef GL_KHR_robustness static GLboolean _glewInit_GL_KHR_robustness () @@ -11851,6 +14078,20 @@ static GLboolean _glewInit_GL_NVX_linked_gpu_multicast () #endif /* GL_NVX_linked_gpu_multicast */ +#ifdef GL_NV_3dvision_settings + +static GLboolean _glewInit_GL_NV_3dvision_settings () +{ + GLboolean r = GL_FALSE; + + r = ((glStereoParameterfNV = (PFNGLSTEREOPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glStereoParameterfNV")) == NULL) || r; + r = ((glStereoParameteriNV = (PFNGLSTEREOPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glStereoParameteriNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_3dvision_settings */ + #ifdef GL_NV_bindless_multi_draw_indirect static GLboolean _glewInit_GL_NV_bindless_multi_draw_indirect () @@ -12013,6 +14254,19 @@ static GLboolean _glewInit_GL_NV_conservative_raster_pre_snap_triangles () #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +#ifdef GL_NV_copy_buffer + +static GLboolean _glewInit_GL_NV_copy_buffer () +{ + GLboolean r = GL_FALSE; + + r = ((glCopyBufferSubDataNV = (PFNGLCOPYBUFFERSUBDATANVPROC)glewGetProcAddress((const GLubyte*)"glCopyBufferSubDataNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_copy_buffer */ + #ifdef GL_NV_copy_image static GLboolean _glewInit_GL_NV_copy_image () @@ -12041,6 +14295,33 @@ static GLboolean _glewInit_GL_NV_depth_buffer_float () #endif /* GL_NV_depth_buffer_float */ +#ifdef GL_NV_draw_buffers + +static GLboolean _glewInit_GL_NV_draw_buffers () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersNV = (PFNGLDRAWBUFFERSNVPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_draw_buffers */ + +#ifdef GL_NV_draw_instanced + +static GLboolean _glewInit_GL_NV_draw_instanced () +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedNV = (PFNGLDRAWARRAYSINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedNV")) == NULL) || r; + r = ((glDrawElementsInstancedNV = (PFNGLDRAWELEMENTSINSTANCEDNVPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_draw_instanced */ + #ifdef GL_NV_draw_texture static GLboolean _glewInit_GL_NV_draw_texture () @@ -12157,6 +14438,32 @@ static GLboolean _glewInit_GL_NV_fragment_program () #endif /* GL_NV_fragment_program */ +#ifdef GL_NV_framebuffer_blit + +static GLboolean _glewInit_GL_NV_framebuffer_blit () +{ + GLboolean r = GL_FALSE; + + r = ((glBlitFramebufferNV = (PFNGLBLITFRAMEBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_framebuffer_blit */ + +#ifdef GL_NV_framebuffer_multisample + +static GLboolean _glewInit_GL_NV_framebuffer_multisample () +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_framebuffer_multisample */ + #ifdef GL_NV_framebuffer_multisample_coverage static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage () @@ -12335,6 +14642,19 @@ static GLboolean _glewInit_GL_NV_half_float () #endif /* GL_NV_half_float */ +#ifdef GL_NV_instanced_arrays + +static GLboolean _glewInit_GL_NV_instanced_arrays () +{ + GLboolean r = GL_FALSE; + + r = ((glVertexAttribDivisorNV = (PFNGLVERTEXATTRIBDIVISORNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_instanced_arrays */ + #ifdef GL_NV_internalformat_sample_query static GLboolean _glewInit_GL_NV_internalformat_sample_query () @@ -12348,6 +14668,24 @@ static GLboolean _glewInit_GL_NV_internalformat_sample_query () #endif /* GL_NV_internalformat_sample_query */ +#ifdef GL_NV_non_square_matrices + +static GLboolean _glewInit_GL_NV_non_square_matrices () +{ + GLboolean r = GL_FALSE; + + r = ((glUniformMatrix2x3fvNV = (PFNGLUNIFORMMATRIX2X3FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fvNV")) == NULL) || r; + r = ((glUniformMatrix2x4fvNV = (PFNGLUNIFORMMATRIX2X4FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fvNV")) == NULL) || r; + r = ((glUniformMatrix3x2fvNV = (PFNGLUNIFORMMATRIX3X2FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fvNV")) == NULL) || r; + r = ((glUniformMatrix3x4fvNV = (PFNGLUNIFORMMATRIX3X4FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fvNV")) == NULL) || r; + r = ((glUniformMatrix4x2fvNV = (PFNGLUNIFORMMATRIX4X2FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fvNV")) == NULL) || r; + r = ((glUniformMatrix4x3fvNV = (PFNGLUNIFORMMATRIX4X3FVNVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_non_square_matrices */ + #ifdef GL_NV_occlusion_query static GLboolean _glewInit_GL_NV_occlusion_query () @@ -12486,6 +14824,19 @@ static GLboolean _glewInit_GL_NV_point_sprite () #endif /* GL_NV_point_sprite */ +#ifdef GL_NV_polygon_mode + +static GLboolean _glewInit_GL_NV_polygon_mode () +{ + GLboolean r = GL_FALSE; + + r = ((glPolygonModeNV = (PFNGLPOLYGONMODENVPROC)glewGetProcAddress((const GLubyte*)"glPolygonModeNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_polygon_mode */ + #ifdef GL_NV_present_video static GLboolean _glewInit_GL_NV_present_video () @@ -12596,6 +14947,24 @@ static GLboolean _glewInit_GL_NV_shader_buffer_load () #endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_texture_array + +static GLboolean _glewInit_GL_NV_texture_array () +{ + GLboolean r = GL_FALSE; + + r = ((glCompressedTexImage3DNV = (PFNGLCOMPRESSEDTEXIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DNV")) == NULL) || r; + r = ((glCompressedTexSubImage3DNV = (PFNGLCOMPRESSEDTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DNV")) == NULL) || r; + r = ((glCopyTexSubImage3DNV = (PFNGLCOPYTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DNV")) == NULL) || r; + r = ((glFramebufferTextureLayerNV = (PFNGLFRAMEBUFFERTEXTURELAYERNVPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerNV")) == NULL) || r; + r = ((glTexImage3DNV = (PFNGLTEXIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DNV")) == NULL) || r; + r = ((glTexSubImage3DNV = (PFNGLTEXSUBIMAGE3DNVPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_texture_array */ + #ifdef GL_NV_texture_barrier static GLboolean _glewInit_GL_NV_texture_barrier () @@ -12860,6 +15229,30 @@ static GLboolean _glewInit_GL_NV_video_capture () #endif /* GL_NV_video_capture */ +#ifdef GL_NV_viewport_array + +static GLboolean _glewInit_GL_NV_viewport_array () +{ + GLboolean r = GL_FALSE; + + r = ((glDepthRangeArrayfvNV = (PFNGLDEPTHRANGEARRAYFVNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeArrayfvNV")) == NULL) || r; + r = ((glDepthRangeIndexedfNV = (PFNGLDEPTHRANGEINDEXEDFNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangeIndexedfNV")) == NULL) || r; + r = ((glDisableiNV = (PFNGLDISABLEINVPROC)glewGetProcAddress((const GLubyte*)"glDisableiNV")) == NULL) || r; + r = ((glEnableiNV = (PFNGLENABLEINVPROC)glewGetProcAddress((const GLubyte*)"glEnableiNV")) == NULL) || r; + r = ((glGetFloati_vNV = (PFNGLGETFLOATI_VNVPROC)glewGetProcAddress((const GLubyte*)"glGetFloati_vNV")) == NULL) || r; + r = ((glIsEnablediNV = (PFNGLISENABLEDINVPROC)glewGetProcAddress((const GLubyte*)"glIsEnablediNV")) == NULL) || r; + r = ((glScissorArrayvNV = (PFNGLSCISSORARRAYVNVPROC)glewGetProcAddress((const GLubyte*)"glScissorArrayvNV")) == NULL) || r; + r = ((glScissorIndexedNV = (PFNGLSCISSORINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedNV")) == NULL) || r; + r = ((glScissorIndexedvNV = (PFNGLSCISSORINDEXEDVNVPROC)glewGetProcAddress((const GLubyte*)"glScissorIndexedvNV")) == NULL) || r; + r = ((glViewportArrayvNV = (PFNGLVIEWPORTARRAYVNVPROC)glewGetProcAddress((const GLubyte*)"glViewportArrayvNV")) == NULL) || r; + r = ((glViewportIndexedfNV = (PFNGLVIEWPORTINDEXEDFNVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfNV")) == NULL) || r; + r = ((glViewportIndexedfvNV = (PFNGLVIEWPORTINDEXEDFVNVPROC)glewGetProcAddress((const GLubyte*)"glViewportIndexedfvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_viewport_array */ + #ifdef GL_NV_viewport_swizzle static GLboolean _glewInit_GL_NV_viewport_swizzle () @@ -12873,24 +15266,6 @@ static GLboolean _glewInit_GL_NV_viewport_swizzle () #endif /* GL_NV_viewport_swizzle */ -#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_OVR_multiview static GLboolean _glewInit_GL_OVR_multiview () @@ -12904,6 +15279,125 @@ static GLboolean _glewInit_GL_OVR_multiview () #endif /* GL_OVR_multiview */ +#ifdef GL_OVR_multiview_multisampled_render_to_texture + +static GLboolean _glewInit_GL_OVR_multiview_multisampled_render_to_texture () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureMultisampleMultiviewOVR = (PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureMultisampleMultiviewOVR")) == NULL) || r; + + return r; +} + +#endif /* GL_OVR_multiview_multisampled_render_to_texture */ + +#ifdef GL_QCOM_alpha_test + +static GLboolean _glewInit_GL_QCOM_alpha_test () +{ + GLboolean r = GL_FALSE; + + r = ((glAlphaFuncQCOM = (PFNGLALPHAFUNCQCOMPROC)glewGetProcAddress((const GLubyte*)"glAlphaFuncQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_alpha_test */ + +#ifdef GL_QCOM_driver_control + +static GLboolean _glewInit_GL_QCOM_driver_control () +{ + GLboolean r = GL_FALSE; + + r = ((glDisableDriverControlQCOM = (PFNGLDISABLEDRIVERCONTROLQCOMPROC)glewGetProcAddress((const GLubyte*)"glDisableDriverControlQCOM")) == NULL) || r; + r = ((glEnableDriverControlQCOM = (PFNGLENABLEDRIVERCONTROLQCOMPROC)glewGetProcAddress((const GLubyte*)"glEnableDriverControlQCOM")) == NULL) || r; + r = ((glGetDriverControlStringQCOM = (PFNGLGETDRIVERCONTROLSTRINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glGetDriverControlStringQCOM")) == NULL) || r; + r = ((glGetDriverControlsQCOM = (PFNGLGETDRIVERCONTROLSQCOMPROC)glewGetProcAddress((const GLubyte*)"glGetDriverControlsQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_driver_control */ + +#ifdef GL_QCOM_extended_get + +static GLboolean _glewInit_GL_QCOM_extended_get () +{ + GLboolean r = GL_FALSE; + + r = ((glExtGetBufferPointervQCOM = (PFNGLEXTGETBUFFERPOINTERVQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetBufferPointervQCOM")) == NULL) || r; + r = ((glExtGetBuffersQCOM = (PFNGLEXTGETBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetBuffersQCOM")) == NULL) || r; + r = ((glExtGetFramebuffersQCOM = (PFNGLEXTGETFRAMEBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetFramebuffersQCOM")) == NULL) || r; + r = ((glExtGetRenderbuffersQCOM = (PFNGLEXTGETRENDERBUFFERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetRenderbuffersQCOM")) == NULL) || r; + r = ((glExtGetTexLevelParameterivQCOM = (PFNGLEXTGETTEXLEVELPARAMETERIVQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexLevelParameterivQCOM")) == NULL) || r; + r = ((glExtGetTexSubImageQCOM = (PFNGLEXTGETTEXSUBIMAGEQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexSubImageQCOM")) == NULL) || r; + r = ((glExtGetTexturesQCOM = (PFNGLEXTGETTEXTURESQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetTexturesQCOM")) == NULL) || r; + r = ((glExtTexObjectStateOverrideiQCOM = (PFNGLEXTTEXOBJECTSTATEOVERRIDEIQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtTexObjectStateOverrideiQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_extended_get */ + +#ifdef GL_QCOM_extended_get2 + +static GLboolean _glewInit_GL_QCOM_extended_get2 () +{ + GLboolean r = GL_FALSE; + + r = ((glExtGetProgramBinarySourceQCOM = (PFNGLEXTGETPROGRAMBINARYSOURCEQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetProgramBinarySourceQCOM")) == NULL) || r; + r = ((glExtGetProgramsQCOM = (PFNGLEXTGETPROGRAMSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetProgramsQCOM")) == NULL) || r; + r = ((glExtGetShadersQCOM = (PFNGLEXTGETSHADERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtGetShadersQCOM")) == NULL) || r; + r = ((glExtIsProgramBinaryQCOM = (PFNGLEXTISPROGRAMBINARYQCOMPROC)glewGetProcAddress((const GLubyte*)"glExtIsProgramBinaryQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_extended_get2 */ + +#ifdef GL_QCOM_framebuffer_foveated + +static GLboolean _glewInit_GL_QCOM_framebuffer_foveated () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferFoveationConfigQCOM = (PFNGLFRAMEBUFFERFOVEATIONCONFIGQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFoveationConfigQCOM")) == NULL) || r; + r = ((glFramebufferFoveationParametersQCOM = (PFNGLFRAMEBUFFERFOVEATIONPARAMETERSQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFoveationParametersQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_framebuffer_foveated */ + +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + +static GLboolean _glewInit_GL_QCOM_shader_framebuffer_fetch_noncoherent () +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferFetchBarrierQCOM = (PFNGLFRAMEBUFFERFETCHBARRIERQCOMPROC)glewGetProcAddress((const GLubyte*)"glFramebufferFetchBarrierQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ + +#ifdef GL_QCOM_tiled_rendering + +static GLboolean _glewInit_GL_QCOM_tiled_rendering () +{ + GLboolean r = GL_FALSE; + + r = ((glEndTilingQCOM = (PFNGLENDTILINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glEndTilingQCOM")) == NULL) || r; + r = ((glStartTilingQCOM = (PFNGLSTARTTILINGQCOMPROC)glewGetProcAddress((const GLubyte*)"glStartTilingQCOM")) == NULL) || r; + + return r; +} + +#endif /* GL_QCOM_tiled_rendering */ + #ifdef GL_REGAL_ES1_0_compatibility static GLboolean _glewInit_GL_REGAL_ES1_0_compatibility () @@ -13067,6 +15561,35 @@ static GLboolean _glewInit_GL_SGIS_multisample () #endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_multitexture + +static GLboolean _glewInit_GL_SGIS_multitexture () +{ + GLboolean r = GL_FALSE; + + r = ((glInterleavedTextureCoordSetsSGIS = (PFNGLINTERLEAVEDTEXTURECOORDSETSSGISPROC)glewGetProcAddress((const GLubyte*)"glInterleavedTextureCoordSetsSGIS")) == NULL) || r; + r = ((glSelectTextureCoordSetSGIS = (PFNGLSELECTTEXTURECOORDSETSGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureCoordSetSGIS")) == NULL) || r; + r = ((glSelectTextureSGIS = (PFNGLSELECTTEXTURESGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureSGIS")) == NULL) || r; + r = ((glSelectTextureTransformSGIS = (PFNGLSELECTTEXTURETRANSFORMSGISPROC)glewGetProcAddress((const GLubyte*)"glSelectTextureTransformSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_multitexture */ + +#ifdef GL_SGIS_shared_multisample + +static GLboolean _glewInit_GL_SGIS_shared_multisample () +{ + GLboolean r = GL_FALSE; + + r = ((glMultisampleSubRectPosSGIS = (PFNGLMULTISAMPLESUBRECTPOSSGISPROC)glewGetProcAddress((const GLubyte*)"glMultisampleSubRectPosSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_shared_multisample */ + #ifdef GL_SGIS_sharpen_texture static GLboolean _glewInit_GL_SGIS_sharpen_texture () @@ -13127,6 +15650,20 @@ static GLboolean _glewInit_GL_SGIX_async () #endif /* GL_SGIX_async */ +#ifdef GL_SGIX_datapipe + +static GLboolean _glewInit_GL_SGIX_datapipe () +{ + GLboolean r = GL_FALSE; + + r = ((glAddressSpace = (PFNGLADDRESSSPACEPROC)glewGetProcAddress((const GLubyte*)"glAddressSpace")) == NULL) || r; + r = ((glDataPipe = (PFNGLDATAPIPEPROC)glewGetProcAddress((const GLubyte*)"glDataPipe")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_datapipe */ + #ifdef GL_SGIX_flush_raster static GLboolean _glewInit_GL_SGIX_flush_raster () @@ -13140,6 +15677,20 @@ static GLboolean _glewInit_GL_SGIX_flush_raster () #endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_layers + +static GLboolean _glewInit_GL_SGIX_fog_layers () +{ + GLboolean r = GL_FALSE; + + r = ((glFogLayersSGIX = (PFNGLFOGLAYERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glFogLayersSGIX")) == NULL) || r; + r = ((glGetFogLayersSGIX = (PFNGLGETFOGLAYERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFogLayersSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_fog_layers */ + #ifdef GL_SGIX_fog_texture static GLboolean _glewInit_GL_SGIX_fog_texture () @@ -13195,6 +15746,58 @@ static GLboolean _glewInit_GL_SGIX_framezoom () #endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_igloo_interface + +static GLboolean _glewInit_GL_SGIX_igloo_interface () +{ + GLboolean r = GL_FALSE; + + r = ((glIglooInterfaceSGIX = (PFNGLIGLOOINTERFACESGIXPROC)glewGetProcAddress((const GLubyte*)"glIglooInterfaceSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_igloo_interface */ + +#ifdef GL_SGIX_mpeg1 + +static GLboolean _glewInit_GL_SGIX_mpeg1 () +{ + GLboolean r = GL_FALSE; + + r = ((glAllocMPEGPredictorsSGIX = (PFNGLALLOCMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glAllocMPEGPredictorsSGIX")) == NULL) || r; + r = ((glDeleteMPEGPredictorsSGIX = (PFNGLDELETEMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteMPEGPredictorsSGIX")) == NULL) || r; + r = ((glGenMPEGPredictorsSGIX = (PFNGLGENMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenMPEGPredictorsSGIX")) == NULL) || r; + r = ((glGetMPEGParameterfvSGIX = (PFNGLGETMPEGPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGParameterfvSGIX")) == NULL) || r; + r = ((glGetMPEGParameterivSGIX = (PFNGLGETMPEGPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGParameterivSGIX")) == NULL) || r; + r = ((glGetMPEGPredictorSGIX = (PFNGLGETMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGPredictorSGIX")) == NULL) || r; + r = ((glGetMPEGQuantTableubv = (PFNGLGETMPEGQUANTTABLEUBVPROC)glewGetProcAddress((const GLubyte*)"glGetMPEGQuantTableubv")) == NULL) || r; + r = ((glIsMPEGPredictorSGIX = (PFNGLISMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsMPEGPredictorSGIX")) == NULL) || r; + r = ((glMPEGPredictorSGIX = (PFNGLMPEGPREDICTORSGIXPROC)glewGetProcAddress((const GLubyte*)"glMPEGPredictorSGIX")) == NULL) || r; + r = ((glMPEGQuantTableubv = (PFNGLMPEGQUANTTABLEUBVPROC)glewGetProcAddress((const GLubyte*)"glMPEGQuantTableubv")) == NULL) || r; + r = ((glSwapMPEGPredictorsSGIX = (PFNGLSWAPMPEGPREDICTORSSGIXPROC)glewGetProcAddress((const GLubyte*)"glSwapMPEGPredictorsSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_mpeg1 */ + +#ifdef GL_SGIX_nonlinear_lighting_pervertex + +static GLboolean _glewInit_GL_SGIX_nonlinear_lighting_pervertex () +{ + GLboolean r = GL_FALSE; + + r = ((glGetNonlinLightfvSGIX = (PFNGLGETNONLINLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetNonlinLightfvSGIX")) == NULL) || r; + r = ((glGetNonlinMaterialfvSGIX = (PFNGLGETNONLINMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetNonlinMaterialfvSGIX")) == NULL) || r; + r = ((glNonlinLightfvSGIX = (PFNGLNONLINLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glNonlinLightfvSGIX")) == NULL) || r; + r = ((glNonlinMaterialfvSGIX = (PFNGLNONLINMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glNonlinMaterialfvSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_nonlinear_lighting_pervertex */ + #ifdef GL_SGIX_pixel_texture static GLboolean _glewInit_GL_SGIX_pixel_texture () @@ -13208,6 +15811,34 @@ static GLboolean _glewInit_GL_SGIX_pixel_texture () #endif /* GL_SGIX_pixel_texture */ +#ifdef GL_SGIX_polynomial_ffd + +static GLboolean _glewInit_GL_SGIX_polynomial_ffd () +{ + GLboolean r = GL_FALSE; + + r = ((glDeformSGIX = (PFNGLDEFORMSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeformSGIX")) == NULL) || r; + r = ((glLoadIdentityDeformationMapSGIX = (PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC)glewGetProcAddress((const GLubyte*)"glLoadIdentityDeformationMapSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_polynomial_ffd */ + +#ifdef GL_SGIX_quad_mesh + +static GLboolean _glewInit_GL_SGIX_quad_mesh () +{ + GLboolean r = GL_FALSE; + + r = ((glMeshBreadthSGIX = (PFNGLMESHBREADTHSGIXPROC)glewGetProcAddress((const GLubyte*)"glMeshBreadthSGIX")) == NULL) || r; + r = ((glMeshStrideSGIX = (PFNGLMESHSTRIDESGIXPROC)glewGetProcAddress((const GLubyte*)"glMeshStrideSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_quad_mesh */ + #ifdef GL_SGIX_reference_plane static GLboolean _glewInit_GL_SGIX_reference_plane () @@ -13250,6 +15881,38 @@ static GLboolean _glewInit_GL_SGIX_tag_sample_buffer () #endif /* GL_SGIX_tag_sample_buffer */ +#ifdef GL_SGIX_vector_ops + +static GLboolean _glewInit_GL_SGIX_vector_ops () +{ + GLboolean r = GL_FALSE; + + r = ((glGetVectorOperationSGIX = (PFNGLGETVECTOROPERATIONSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetVectorOperationSGIX")) == NULL) || r; + r = ((glVectorOperationSGIX = (PFNGLVECTOROPERATIONSGIXPROC)glewGetProcAddress((const GLubyte*)"glVectorOperationSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_vector_ops */ + +#ifdef GL_SGIX_vertex_array_object + +static GLboolean _glewInit_GL_SGIX_vertex_array_object () +{ + GLboolean r = GL_FALSE; + + r = ((glAreVertexArraysResidentSGIX = (PFNGLAREVERTEXARRAYSRESIDENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glAreVertexArraysResidentSGIX")) == NULL) || r; + r = ((glBindVertexArraySGIX = (PFNGLBINDVERTEXARRAYSGIXPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArraySGIX")) == NULL) || r; + r = ((glDeleteVertexArraysSGIX = (PFNGLDELETEVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysSGIX")) == NULL) || r; + r = ((glGenVertexArraysSGIX = (PFNGLGENVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysSGIX")) == NULL) || r; + r = ((glIsVertexArraySGIX = (PFNGLISVERTEXARRAYSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArraySGIX")) == NULL) || r; + r = ((glPrioritizeVertexArraysSGIX = (PFNGLPRIORITIZEVERTEXARRAYSSGIXPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeVertexArraysSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_vertex_array_object */ + #ifdef GL_SGI_color_table static GLboolean _glewInit_GL_SGI_color_table () @@ -13269,6 +15932,25 @@ static GLboolean _glewInit_GL_SGI_color_table () #endif /* GL_SGI_color_table */ +#ifdef GL_SGI_fft + +static GLboolean _glewInit_GL_SGI_fft () +{ + GLboolean r = GL_FALSE; + + r = ((glGetPixelTransformParameterfvSGI = (PFNGLGETPIXELTRANSFORMPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvSGI")) == NULL) || r; + r = ((glGetPixelTransformParameterivSGI = (PFNGLGETPIXELTRANSFORMPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivSGI")) == NULL) || r; + r = ((glPixelTransformParameterfSGI = (PFNGLPIXELTRANSFORMPARAMETERFSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfSGI")) == NULL) || r; + r = ((glPixelTransformParameterfvSGI = (PFNGLPIXELTRANSFORMPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvSGI")) == NULL) || r; + r = ((glPixelTransformParameteriSGI = (PFNGLPIXELTRANSFORMPARAMETERISGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriSGI")) == NULL) || r; + r = ((glPixelTransformParameterivSGI = (PFNGLPIXELTRANSFORMPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivSGI")) == NULL) || r; + r = ((glPixelTransformSGI = (PFNGLPIXELTRANSFORMSGIPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformSGI")) == NULL) || r; + + return r; +} + +#endif /* GL_SGI_fft */ + #ifdef GL_SUNX_constant_data static GLboolean _glewInit_GL_SUNX_constant_data () @@ -13510,7 +16192,8 @@ static GLenum GLEWAPIENTRY glewContextInit () } else { - GLEW_VERSION_4_5 = ( major > 4 ) || ( major == 4 && minor >= 5 ) ? GL_TRUE : GL_FALSE; + GLEW_VERSION_4_6 = ( major > 4 ) || ( major == 4 && minor >= 6 ) ? GL_TRUE : GL_FALSE; + GLEW_VERSION_4_5 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 5 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_4 = GLEW_VERSION_4_5 == GL_TRUE || ( major == 4 && minor >= 4 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_3 = GLEW_VERSION_4_4 == GL_TRUE || ( major == 4 && minor >= 3 ) ? GL_TRUE : GL_FALSE; GLEW_VERSION_4_2 = GLEW_VERSION_4_3 == GL_TRUE || ( major == 4 && minor >= 2 ) ? GL_TRUE : GL_FALSE; @@ -13641,6 +16324,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_VERSION_4_5 if (glewExperimental || GLEW_VERSION_4_5) GLEW_VERSION_4_5 = !_glewInit_GL_VERSION_4_5(); #endif /* GL_VERSION_4_5 */ +#ifdef GL_VERSION_4_6 + if (glewExperimental || GLEW_VERSION_4_6) GLEW_VERSION_4_6 = !_glewInit_GL_VERSION_4_6(); +#endif /* GL_VERSION_4_6 */ #ifdef GL_3DFX_tbuffer if (glewExperimental || GLEW_3DFX_tbuffer) GLEW_3DFX_tbuffer = !_glewInit_GL_3DFX_tbuffer(); #endif /* GL_3DFX_tbuffer */ @@ -13650,6 +16336,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_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 */ #ifdef GL_AMD_interleaved_elements if (glewExperimental || GLEW_AMD_interleaved_elements) GLEW_AMD_interleaved_elements = !_glewInit_GL_AMD_interleaved_elements(); #endif /* GL_AMD_interleaved_elements */ @@ -13692,6 +16381,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_ANGLE_translated_shader_source if (glewExperimental || GLEW_ANGLE_translated_shader_source) GLEW_ANGLE_translated_shader_source = !_glewInit_GL_ANGLE_translated_shader_source(); #endif /* GL_ANGLE_translated_shader_source */ +#ifdef GL_APPLE_copy_texture_levels + if (glewExperimental || GLEW_APPLE_copy_texture_levels) GLEW_APPLE_copy_texture_levels = !_glewInit_GL_APPLE_copy_texture_levels(); +#endif /* GL_APPLE_copy_texture_levels */ #ifdef GL_APPLE_element_array if (glewExperimental || GLEW_APPLE_element_array) GLEW_APPLE_element_array = !_glewInit_GL_APPLE_element_array(); #endif /* GL_APPLE_element_array */ @@ -13701,9 +16393,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_APPLE_flush_buffer_range if (glewExperimental || GLEW_APPLE_flush_buffer_range) GLEW_APPLE_flush_buffer_range = !_glewInit_GL_APPLE_flush_buffer_range(); #endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_framebuffer_multisample + if (glewExperimental || GLEW_APPLE_framebuffer_multisample) GLEW_APPLE_framebuffer_multisample = !_glewInit_GL_APPLE_framebuffer_multisample(); +#endif /* GL_APPLE_framebuffer_multisample */ #ifdef GL_APPLE_object_purgeable if (glewExperimental || GLEW_APPLE_object_purgeable) GLEW_APPLE_object_purgeable = !_glewInit_GL_APPLE_object_purgeable(); #endif /* GL_APPLE_object_purgeable */ +#ifdef GL_APPLE_sync + if (glewExperimental || GLEW_APPLE_sync) GLEW_APPLE_sync = !_glewInit_GL_APPLE_sync(); +#endif /* GL_APPLE_sync */ #ifdef GL_APPLE_texture_range if (glewExperimental || GLEW_APPLE_texture_range) GLEW_APPLE_texture_range = !_glewInit_GL_APPLE_texture_range(); #endif /* GL_APPLE_texture_range */ @@ -13851,6 +16549,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_ARB_point_parameters if (glewExperimental || GLEW_ARB_point_parameters) GLEW_ARB_point_parameters = !_glewInit_GL_ARB_point_parameters(); #endif /* GL_ARB_point_parameters */ +#ifdef GL_ARB_polygon_offset_clamp + if (glewExperimental || GLEW_ARB_polygon_offset_clamp) GLEW_ARB_polygon_offset_clamp = !_glewInit_GL_ARB_polygon_offset_clamp(); +#endif /* GL_ARB_polygon_offset_clamp */ #ifdef GL_ARB_program_interface_query if (glewExperimental || GLEW_ARB_program_interface_query) GLEW_ARB_program_interface_query = !_glewInit_GL_ARB_program_interface_query(); #endif /* GL_ARB_program_interface_query */ @@ -14004,6 +16705,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_base_instance + if (glewExperimental || GLEW_EXT_base_instance) GLEW_EXT_base_instance = !_glewInit_GL_EXT_base_instance(); +#endif /* GL_EXT_base_instance */ #ifdef GL_EXT_bindable_uniform if (glewExperimental || GLEW_EXT_bindable_uniform) GLEW_EXT_bindable_uniform = !_glewInit_GL_EXT_bindable_uniform(); #endif /* GL_EXT_bindable_uniform */ @@ -14013,12 +16717,21 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_blend_equation_separate if (glewExperimental || GLEW_EXT_blend_equation_separate) GLEW_EXT_blend_equation_separate = !_glewInit_GL_EXT_blend_equation_separate(); #endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_extended + if (glewExperimental || GLEW_EXT_blend_func_extended) GLEW_EXT_blend_func_extended = !_glewInit_GL_EXT_blend_func_extended(); +#endif /* GL_EXT_blend_func_extended */ #ifdef GL_EXT_blend_func_separate if (glewExperimental || GLEW_EXT_blend_func_separate) GLEW_EXT_blend_func_separate = !_glewInit_GL_EXT_blend_func_separate(); #endif /* GL_EXT_blend_func_separate */ #ifdef GL_EXT_blend_minmax if (glewExperimental || GLEW_EXT_blend_minmax) GLEW_EXT_blend_minmax = !_glewInit_GL_EXT_blend_minmax(); #endif /* GL_EXT_blend_minmax */ +#ifdef GL_EXT_buffer_storage + if (glewExperimental || GLEW_EXT_buffer_storage) GLEW_EXT_buffer_storage = !_glewInit_GL_EXT_buffer_storage(); +#endif /* GL_EXT_buffer_storage */ +#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_color_subtable if (glewExperimental || GLEW_EXT_color_subtable) GLEW_EXT_color_subtable = !_glewInit_GL_EXT_color_subtable(); #endif /* GL_EXT_color_subtable */ @@ -14031,6 +16744,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_coordinate_frame if (glewExperimental || GLEW_EXT_coordinate_frame) GLEW_EXT_coordinate_frame = !_glewInit_GL_EXT_coordinate_frame(); #endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_image + if (glewExperimental || GLEW_EXT_copy_image) GLEW_EXT_copy_image = !_glewInit_GL_EXT_copy_image(); +#endif /* GL_EXT_copy_image */ #ifdef GL_EXT_copy_texture if (glewExperimental || GLEW_EXT_copy_texture) GLEW_EXT_copy_texture = !_glewInit_GL_EXT_copy_texture(); #endif /* GL_EXT_copy_texture */ @@ -14049,15 +16765,30 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_direct_state_access if (glewExperimental || GLEW_EXT_direct_state_access) GLEW_EXT_direct_state_access = !_glewInit_GL_EXT_direct_state_access(); #endif /* GL_EXT_direct_state_access */ +#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_draw_buffers + if (glewExperimental || GLEW_EXT_draw_buffers) GLEW_EXT_draw_buffers = !_glewInit_GL_EXT_draw_buffers(); +#endif /* GL_EXT_draw_buffers */ #ifdef GL_EXT_draw_buffers2 if (glewExperimental || GLEW_EXT_draw_buffers2) GLEW_EXT_draw_buffers2 = !_glewInit_GL_EXT_draw_buffers2(); #endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_buffers_indexed + if (glewExperimental || GLEW_EXT_draw_buffers_indexed) GLEW_EXT_draw_buffers_indexed = !_glewInit_GL_EXT_draw_buffers_indexed(); +#endif /* GL_EXT_draw_buffers_indexed */ +#ifdef GL_EXT_draw_elements_base_vertex + if (glewExperimental || GLEW_EXT_draw_elements_base_vertex) GLEW_EXT_draw_elements_base_vertex = !_glewInit_GL_EXT_draw_elements_base_vertex(); +#endif /* GL_EXT_draw_elements_base_vertex */ #ifdef GL_EXT_draw_instanced if (glewExperimental || GLEW_EXT_draw_instanced) GLEW_EXT_draw_instanced = !_glewInit_GL_EXT_draw_instanced(); #endif /* GL_EXT_draw_instanced */ #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_external_buffer + if (glewExperimental || GLEW_EXT_external_buffer) GLEW_EXT_external_buffer = !_glewInit_GL_EXT_external_buffer(); +#endif /* GL_EXT_external_buffer */ #ifdef GL_EXT_fog_coord if (glewExperimental || GLEW_EXT_fog_coord) GLEW_EXT_fog_coord = !_glewInit_GL_EXT_fog_coord(); #endif /* GL_EXT_fog_coord */ @@ -14091,15 +16822,39 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_index_material if (glewExperimental || GLEW_EXT_index_material) GLEW_EXT_index_material = !_glewInit_GL_EXT_index_material(); #endif /* GL_EXT_index_material */ +#ifdef GL_EXT_instanced_arrays + if (glewExperimental || GLEW_EXT_instanced_arrays) GLEW_EXT_instanced_arrays = !_glewInit_GL_EXT_instanced_arrays(); +#endif /* GL_EXT_instanced_arrays */ #ifdef GL_EXT_light_texture if (glewExperimental || GLEW_EXT_light_texture) GLEW_EXT_light_texture = !_glewInit_GL_EXT_light_texture(); #endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_map_buffer_range + if (glewExperimental || GLEW_EXT_map_buffer_range) GLEW_EXT_map_buffer_range = !_glewInit_GL_EXT_map_buffer_range(); +#endif /* GL_EXT_map_buffer_range */ +#ifdef GL_EXT_memory_object + if (glewExperimental || GLEW_EXT_memory_object) GLEW_EXT_memory_object = !_glewInit_GL_EXT_memory_object(); +#endif /* GL_EXT_memory_object */ +#ifdef GL_EXT_memory_object_fd + if (glewExperimental || GLEW_EXT_memory_object_fd) GLEW_EXT_memory_object_fd = !_glewInit_GL_EXT_memory_object_fd(); +#endif /* GL_EXT_memory_object_fd */ +#ifdef GL_EXT_memory_object_win32 + if (glewExperimental || GLEW_EXT_memory_object_win32) GLEW_EXT_memory_object_win32 = !_glewInit_GL_EXT_memory_object_win32(); +#endif /* GL_EXT_memory_object_win32 */ #ifdef GL_EXT_multi_draw_arrays if (glewExperimental || GLEW_EXT_multi_draw_arrays) GLEW_EXT_multi_draw_arrays = !_glewInit_GL_EXT_multi_draw_arrays(); #endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multi_draw_indirect + if (glewExperimental || GLEW_EXT_multi_draw_indirect) GLEW_EXT_multi_draw_indirect = !_glewInit_GL_EXT_multi_draw_indirect(); +#endif /* GL_EXT_multi_draw_indirect */ #ifdef GL_EXT_multisample if (glewExperimental || GLEW_EXT_multisample) GLEW_EXT_multisample = !_glewInit_GL_EXT_multisample(); #endif /* GL_EXT_multisample */ +#ifdef GL_EXT_multisampled_render_to_texture + if (glewExperimental || GLEW_EXT_multisampled_render_to_texture) GLEW_EXT_multisampled_render_to_texture = !_glewInit_GL_EXT_multisampled_render_to_texture(); +#endif /* GL_EXT_multisampled_render_to_texture */ +#ifdef GL_EXT_multiview_draw_buffers + if (glewExperimental || GLEW_EXT_multiview_draw_buffers) GLEW_EXT_multiview_draw_buffers = !_glewInit_GL_EXT_multiview_draw_buffers(); +#endif /* GL_EXT_multiview_draw_buffers */ #ifdef GL_EXT_paletted_texture if (glewExperimental || GLEW_EXT_paletted_texture) GLEW_EXT_paletted_texture = !_glewInit_GL_EXT_paletted_texture(); #endif /* GL_EXT_paletted_texture */ @@ -14127,12 +16882,27 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_secondary_color if (glewExperimental || GLEW_EXT_secondary_color) GLEW_EXT_secondary_color = !_glewInit_GL_EXT_secondary_color(); #endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_semaphore + if (glewExperimental || GLEW_EXT_semaphore) GLEW_EXT_semaphore = !_glewInit_GL_EXT_semaphore(); +#endif /* GL_EXT_semaphore */ +#ifdef GL_EXT_semaphore_fd + if (glewExperimental || GLEW_EXT_semaphore_fd) GLEW_EXT_semaphore_fd = !_glewInit_GL_EXT_semaphore_fd(); +#endif /* GL_EXT_semaphore_fd */ +#ifdef GL_EXT_semaphore_win32 + if (glewExperimental || GLEW_EXT_semaphore_win32) GLEW_EXT_semaphore_win32 = !_glewInit_GL_EXT_semaphore_win32(); +#endif /* GL_EXT_semaphore_win32 */ #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_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 */ +#ifdef GL_EXT_shader_pixel_local_storage2 + if (glewExperimental || GLEW_EXT_shader_pixel_local_storage2) GLEW_EXT_shader_pixel_local_storage2 = !_glewInit_GL_EXT_shader_pixel_local_storage2(); +#endif /* GL_EXT_shader_pixel_local_storage2 */ +#ifdef GL_EXT_sparse_texture + if (glewExperimental || GLEW_EXT_sparse_texture) GLEW_EXT_sparse_texture = !_glewInit_GL_EXT_sparse_texture(); +#endif /* GL_EXT_sparse_texture */ #ifdef GL_EXT_stencil_two_side if (glewExperimental || GLEW_EXT_stencil_two_side) GLEW_EXT_stencil_two_side = !_glewInit_GL_EXT_stencil_two_side(); #endif /* GL_EXT_stencil_two_side */ @@ -14157,6 +16927,12 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_texture_perturb_normal if (glewExperimental || GLEW_EXT_texture_perturb_normal) GLEW_EXT_texture_perturb_normal = !_glewInit_GL_EXT_texture_perturb_normal(); #endif /* GL_EXT_texture_perturb_normal */ +#ifdef GL_EXT_texture_storage + if (glewExperimental || GLEW_EXT_texture_storage) GLEW_EXT_texture_storage = !_glewInit_GL_EXT_texture_storage(); +#endif /* GL_EXT_texture_storage */ +#ifdef GL_EXT_texture_view + if (glewExperimental || GLEW_EXT_texture_view) GLEW_EXT_texture_view = !_glewInit_GL_EXT_texture_view(); +#endif /* GL_EXT_texture_view */ #ifdef GL_EXT_timer_query if (glewExperimental || GLEW_EXT_timer_query) GLEW_EXT_timer_query = !_glewInit_GL_EXT_timer_query(); #endif /* GL_EXT_timer_query */ @@ -14166,6 +16942,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_vertex_array if (glewExperimental || GLEW_EXT_vertex_array) GLEW_EXT_vertex_array = !_glewInit_GL_EXT_vertex_array(); #endif /* GL_EXT_vertex_array */ +#ifdef GL_EXT_vertex_array_setXXX + if (glewExperimental || GLEW_EXT_vertex_array_setXXX) GLEW_EXT_vertex_array_setXXX = !_glewInit_GL_EXT_vertex_array_setXXX(); +#endif /* GL_EXT_vertex_array_setXXX */ #ifdef GL_EXT_vertex_attrib_64bit if (glewExperimental || GLEW_EXT_vertex_attrib_64bit) GLEW_EXT_vertex_attrib_64bit = !_glewInit_GL_EXT_vertex_attrib_64bit(); #endif /* GL_EXT_vertex_attrib_64bit */ @@ -14175,6 +16954,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_EXT_vertex_weighting if (glewExperimental || GLEW_EXT_vertex_weighting) GLEW_EXT_vertex_weighting = !_glewInit_GL_EXT_vertex_weighting(); #endif /* GL_EXT_vertex_weighting */ +#ifdef GL_EXT_win32_keyed_mutex + if (glewExperimental || GLEW_EXT_win32_keyed_mutex) GLEW_EXT_win32_keyed_mutex = !_glewInit_GL_EXT_win32_keyed_mutex(); +#endif /* GL_EXT_win32_keyed_mutex */ #ifdef GL_EXT_window_rectangles if (glewExperimental || GLEW_EXT_window_rectangles) GLEW_EXT_window_rectangles = !_glewInit_GL_EXT_window_rectangles(); #endif /* GL_EXT_window_rectangles */ @@ -14214,6 +16996,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_KHR_debug if (glewExperimental || GLEW_KHR_debug) GLEW_KHR_debug = !_glewInit_GL_KHR_debug(); #endif /* GL_KHR_debug */ +#ifdef GL_KHR_parallel_shader_compile + if (glewExperimental || GLEW_KHR_parallel_shader_compile) GLEW_KHR_parallel_shader_compile = !_glewInit_GL_KHR_parallel_shader_compile(); +#endif /* GL_KHR_parallel_shader_compile */ #ifdef GL_KHR_robustness if (glewExperimental || GLEW_KHR_robustness) GLEW_KHR_robustness = !_glewInit_GL_KHR_robustness(); #endif /* GL_KHR_robustness */ @@ -14232,6 +17017,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NVX_linked_gpu_multicast if (glewExperimental || GLEW_NVX_linked_gpu_multicast) GLEW_NVX_linked_gpu_multicast = !_glewInit_GL_NVX_linked_gpu_multicast(); #endif /* GL_NVX_linked_gpu_multicast */ +#ifdef GL_NV_3dvision_settings + if (glewExperimental || GLEW_NV_3dvision_settings) GLEW_NV_3dvision_settings = !_glewInit_GL_NV_3dvision_settings(); +#endif /* GL_NV_3dvision_settings */ #ifdef GL_NV_bindless_multi_draw_indirect if (glewExperimental || GLEW_NV_bindless_multi_draw_indirect) GLEW_NV_bindless_multi_draw_indirect = !_glewInit_GL_NV_bindless_multi_draw_indirect(); #endif /* GL_NV_bindless_multi_draw_indirect */ @@ -14262,12 +17050,21 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_conservative_raster_pre_snap_triangles if (glewExperimental || GLEW_NV_conservative_raster_pre_snap_triangles) GLEW_NV_conservative_raster_pre_snap_triangles = !_glewInit_GL_NV_conservative_raster_pre_snap_triangles(); #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +#ifdef GL_NV_copy_buffer + if (glewExperimental || GLEW_NV_copy_buffer) GLEW_NV_copy_buffer = !_glewInit_GL_NV_copy_buffer(); +#endif /* GL_NV_copy_buffer */ #ifdef GL_NV_copy_image if (glewExperimental || GLEW_NV_copy_image) GLEW_NV_copy_image = !_glewInit_GL_NV_copy_image(); #endif /* GL_NV_copy_image */ #ifdef GL_NV_depth_buffer_float if (glewExperimental || GLEW_NV_depth_buffer_float) GLEW_NV_depth_buffer_float = !_glewInit_GL_NV_depth_buffer_float(); #endif /* GL_NV_depth_buffer_float */ +#ifdef GL_NV_draw_buffers + if (glewExperimental || GLEW_NV_draw_buffers) GLEW_NV_draw_buffers = !_glewInit_GL_NV_draw_buffers(); +#endif /* GL_NV_draw_buffers */ +#ifdef GL_NV_draw_instanced + if (glewExperimental || GLEW_NV_draw_instanced) GLEW_NV_draw_instanced = !_glewInit_GL_NV_draw_instanced(); +#endif /* GL_NV_draw_instanced */ #ifdef GL_NV_draw_texture if (glewExperimental || GLEW_NV_draw_texture) GLEW_NV_draw_texture = !_glewInit_GL_NV_draw_texture(); #endif /* GL_NV_draw_texture */ @@ -14289,6 +17086,12 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_fragment_program if (glewExperimental || GLEW_NV_fragment_program) GLEW_NV_fragment_program = !_glewInit_GL_NV_fragment_program(); #endif /* GL_NV_fragment_program */ +#ifdef GL_NV_framebuffer_blit + if (glewExperimental || GLEW_NV_framebuffer_blit) GLEW_NV_framebuffer_blit = !_glewInit_GL_NV_framebuffer_blit(); +#endif /* GL_NV_framebuffer_blit */ +#ifdef GL_NV_framebuffer_multisample + if (glewExperimental || GLEW_NV_framebuffer_multisample) GLEW_NV_framebuffer_multisample = !_glewInit_GL_NV_framebuffer_multisample(); +#endif /* GL_NV_framebuffer_multisample */ #ifdef GL_NV_framebuffer_multisample_coverage if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) GLEW_NV_framebuffer_multisample_coverage = !_glewInit_GL_NV_framebuffer_multisample_coverage(); #endif /* GL_NV_framebuffer_multisample_coverage */ @@ -14307,9 +17110,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_half_float if (glewExperimental || GLEW_NV_half_float) GLEW_NV_half_float = !_glewInit_GL_NV_half_float(); #endif /* GL_NV_half_float */ +#ifdef GL_NV_instanced_arrays + if (glewExperimental || GLEW_NV_instanced_arrays) GLEW_NV_instanced_arrays = !_glewInit_GL_NV_instanced_arrays(); +#endif /* GL_NV_instanced_arrays */ #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_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 */ #ifdef GL_NV_occlusion_query if (glewExperimental || GLEW_NV_occlusion_query) GLEW_NV_occlusion_query = !_glewInit_GL_NV_occlusion_query(); #endif /* GL_NV_occlusion_query */ @@ -14325,6 +17134,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_point_sprite if (glewExperimental || GLEW_NV_point_sprite) GLEW_NV_point_sprite = !_glewInit_GL_NV_point_sprite(); #endif /* GL_NV_point_sprite */ +#ifdef GL_NV_polygon_mode + if (glewExperimental || GLEW_NV_polygon_mode) GLEW_NV_polygon_mode = !_glewInit_GL_NV_polygon_mode(); +#endif /* GL_NV_polygon_mode */ #ifdef GL_NV_present_video if (glewExperimental || GLEW_NV_present_video) GLEW_NV_present_video = !_glewInit_GL_NV_present_video(); #endif /* GL_NV_present_video */ @@ -14343,6 +17155,9 @@ static GLenum GLEWAPIENTRY glewContextInit () #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_texture_array + if (glewExperimental || GLEW_NV_texture_array) GLEW_NV_texture_array = !_glewInit_GL_NV_texture_array(); +#endif /* GL_NV_texture_array */ #ifdef GL_NV_texture_barrier if (glewExperimental || GLEW_NV_texture_barrier) GLEW_NV_texture_barrier = !_glewInit_GL_NV_texture_barrier(); #endif /* GL_NV_texture_barrier */ @@ -14373,15 +17188,39 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_NV_video_capture if (glewExperimental || GLEW_NV_video_capture) GLEW_NV_video_capture = !_glewInit_GL_NV_video_capture(); #endif /* GL_NV_video_capture */ +#ifdef GL_NV_viewport_array + if (glewExperimental || GLEW_NV_viewport_array) GLEW_NV_viewport_array = !_glewInit_GL_NV_viewport_array(); +#endif /* GL_NV_viewport_array */ #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_single_precision - if (glewExperimental || GLEW_OES_single_precision) GLEW_OES_single_precision = !_glewInit_GL_OES_single_precision(); -#endif /* GL_OES_single_precision */ #ifdef GL_OVR_multiview if (glewExperimental || GLEW_OVR_multiview) GLEW_OVR_multiview = !_glewInit_GL_OVR_multiview(); #endif /* GL_OVR_multiview */ +#ifdef GL_OVR_multiview_multisampled_render_to_texture + if (glewExperimental || GLEW_OVR_multiview_multisampled_render_to_texture) GLEW_OVR_multiview_multisampled_render_to_texture = !_glewInit_GL_OVR_multiview_multisampled_render_to_texture(); +#endif /* GL_OVR_multiview_multisampled_render_to_texture */ +#ifdef GL_QCOM_alpha_test + if (glewExperimental || GLEW_QCOM_alpha_test) GLEW_QCOM_alpha_test = !_glewInit_GL_QCOM_alpha_test(); +#endif /* GL_QCOM_alpha_test */ +#ifdef GL_QCOM_driver_control + if (glewExperimental || GLEW_QCOM_driver_control) GLEW_QCOM_driver_control = !_glewInit_GL_QCOM_driver_control(); +#endif /* GL_QCOM_driver_control */ +#ifdef GL_QCOM_extended_get + if (glewExperimental || GLEW_QCOM_extended_get) GLEW_QCOM_extended_get = !_glewInit_GL_QCOM_extended_get(); +#endif /* GL_QCOM_extended_get */ +#ifdef GL_QCOM_extended_get2 + if (glewExperimental || GLEW_QCOM_extended_get2) GLEW_QCOM_extended_get2 = !_glewInit_GL_QCOM_extended_get2(); +#endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_framebuffer_foveated + if (glewExperimental || GLEW_QCOM_framebuffer_foveated) GLEW_QCOM_framebuffer_foveated = !_glewInit_GL_QCOM_framebuffer_foveated(); +#endif /* GL_QCOM_framebuffer_foveated */ +#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_tiled_rendering + if (glewExperimental || GLEW_QCOM_tiled_rendering) GLEW_QCOM_tiled_rendering = !_glewInit_GL_QCOM_tiled_rendering(); +#endif /* GL_QCOM_tiled_rendering */ #ifdef GL_REGAL_ES1_0_compatibility if (glewExperimental || GLEW_REGAL_ES1_0_compatibility) GLEW_REGAL_ES1_0_compatibility = !_glewInit_GL_REGAL_ES1_0_compatibility(); #endif /* GL_REGAL_ES1_0_compatibility */ @@ -14409,6 +17248,12 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_SGIS_multisample if (glewExperimental || GLEW_SGIS_multisample) GLEW_SGIS_multisample = !_glewInit_GL_SGIS_multisample(); #endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_multitexture + if (glewExperimental || GLEW_SGIS_multitexture) GLEW_SGIS_multitexture = !_glewInit_GL_SGIS_multitexture(); +#endif /* GL_SGIS_multitexture */ +#ifdef GL_SGIS_shared_multisample + if (glewExperimental || GLEW_SGIS_shared_multisample) GLEW_SGIS_shared_multisample = !_glewInit_GL_SGIS_shared_multisample(); +#endif /* GL_SGIS_shared_multisample */ #ifdef GL_SGIS_sharpen_texture if (glewExperimental || GLEW_SGIS_sharpen_texture) GLEW_SGIS_sharpen_texture = !_glewInit_GL_SGIS_sharpen_texture(); #endif /* GL_SGIS_sharpen_texture */ @@ -14421,9 +17266,15 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_SGIX_async if (glewExperimental || GLEW_SGIX_async) GLEW_SGIX_async = !_glewInit_GL_SGIX_async(); #endif /* GL_SGIX_async */ +#ifdef GL_SGIX_datapipe + if (glewExperimental || GLEW_SGIX_datapipe) GLEW_SGIX_datapipe = !_glewInit_GL_SGIX_datapipe(); +#endif /* GL_SGIX_datapipe */ #ifdef GL_SGIX_flush_raster if (glewExperimental || GLEW_SGIX_flush_raster) GLEW_SGIX_flush_raster = !_glewInit_GL_SGIX_flush_raster(); #endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_layers + if (glewExperimental || GLEW_SGIX_fog_layers) GLEW_SGIX_fog_layers = !_glewInit_GL_SGIX_fog_layers(); +#endif /* GL_SGIX_fog_layers */ #ifdef GL_SGIX_fog_texture if (glewExperimental || GLEW_SGIX_fog_texture) GLEW_SGIX_fog_texture = !_glewInit_GL_SGIX_fog_texture(); #endif /* GL_SGIX_fog_texture */ @@ -14433,9 +17284,24 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_SGIX_framezoom if (glewExperimental || GLEW_SGIX_framezoom) GLEW_SGIX_framezoom = !_glewInit_GL_SGIX_framezoom(); #endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_igloo_interface + if (glewExperimental || GLEW_SGIX_igloo_interface) GLEW_SGIX_igloo_interface = !_glewInit_GL_SGIX_igloo_interface(); +#endif /* GL_SGIX_igloo_interface */ +#ifdef GL_SGIX_mpeg1 + if (glewExperimental || GLEW_SGIX_mpeg1) GLEW_SGIX_mpeg1 = !_glewInit_GL_SGIX_mpeg1(); +#endif /* GL_SGIX_mpeg1 */ +#ifdef GL_SGIX_nonlinear_lighting_pervertex + if (glewExperimental || GLEW_SGIX_nonlinear_lighting_pervertex) GLEW_SGIX_nonlinear_lighting_pervertex = !_glewInit_GL_SGIX_nonlinear_lighting_pervertex(); +#endif /* GL_SGIX_nonlinear_lighting_pervertex */ #ifdef GL_SGIX_pixel_texture if (glewExperimental || GLEW_SGIX_pixel_texture) GLEW_SGIX_pixel_texture = !_glewInit_GL_SGIX_pixel_texture(); #endif /* GL_SGIX_pixel_texture */ +#ifdef GL_SGIX_polynomial_ffd + if (glewExperimental || GLEW_SGIX_polynomial_ffd) GLEW_SGIX_polynomial_ffd = !_glewInit_GL_SGIX_polynomial_ffd(); +#endif /* GL_SGIX_polynomial_ffd */ +#ifdef GL_SGIX_quad_mesh + if (glewExperimental || GLEW_SGIX_quad_mesh) GLEW_SGIX_quad_mesh = !_glewInit_GL_SGIX_quad_mesh(); +#endif /* GL_SGIX_quad_mesh */ #ifdef GL_SGIX_reference_plane if (glewExperimental || GLEW_SGIX_reference_plane) GLEW_SGIX_reference_plane = !_glewInit_GL_SGIX_reference_plane(); #endif /* GL_SGIX_reference_plane */ @@ -14445,9 +17311,18 @@ static GLenum GLEWAPIENTRY glewContextInit () #ifdef GL_SGIX_tag_sample_buffer if (glewExperimental || GLEW_SGIX_tag_sample_buffer) GLEW_SGIX_tag_sample_buffer = !_glewInit_GL_SGIX_tag_sample_buffer(); #endif /* GL_SGIX_tag_sample_buffer */ +#ifdef GL_SGIX_vector_ops + if (glewExperimental || GLEW_SGIX_vector_ops) GLEW_SGIX_vector_ops = !_glewInit_GL_SGIX_vector_ops(); +#endif /* GL_SGIX_vector_ops */ +#ifdef GL_SGIX_vertex_array_object + if (glewExperimental || GLEW_SGIX_vertex_array_object) GLEW_SGIX_vertex_array_object = !_glewInit_GL_SGIX_vertex_array_object(); +#endif /* GL_SGIX_vertex_array_object */ #ifdef GL_SGI_color_table if (glewExperimental || GLEW_SGI_color_table) GLEW_SGI_color_table = !_glewInit_GL_SGI_color_table(); #endif /* GL_SGI_color_table */ +#ifdef GL_SGI_fft + if (glewExperimental || GLEW_SGI_fft) GLEW_SGI_fft = !_glewInit_GL_SGI_fft(); +#endif /* GL_SGI_fft */ #ifdef GL_SUNX_constant_data if (glewExperimental || GLEW_SUNX_constant_data) GLEW_SUNX_constant_data = !_glewInit_GL_SUNX_constant_data(); #endif /* GL_SUNX_constant_data */ @@ -14551,6 +17426,9 @@ PFNEGLQUERYDEVICEATTRIBEXTPROC __eglewQueryDeviceAttribEXT = NULL; PFNEGLQUERYDEVICESTRINGEXTPROC __eglewQueryDeviceStringEXT = NULL; PFNEGLQUERYDISPLAYATTRIBEXTPROC __eglewQueryDisplayAttribEXT = NULL; +PFNEGLQUERYDMABUFFORMATSEXTPROC __eglewQueryDmaBufFormatsEXT = NULL; +PFNEGLQUERYDMABUFMODIFIERSEXTPROC __eglewQueryDmaBufModifiersEXT = NULL; + PFNEGLGETOUTPUTLAYERSEXTPROC __eglewGetOutputLayersEXT = NULL; PFNEGLGETOUTPUTPORTSEXTPROC __eglewGetOutputPortsEXT = NULL; PFNEGLOUTPUTLAYERATTRIBEXTPROC __eglewOutputLayerAttribEXT = NULL; @@ -14598,6 +17476,12 @@ PFNEGLQUERYSTREAMKHRPROC __eglewQueryStreamKHR = NULL; PFNEGLQUERYSTREAMU64KHRPROC __eglewQueryStreamu64KHR = NULL; PFNEGLSTREAMATTRIBKHRPROC __eglewStreamAttribKHR = NULL; +PFNEGLCREATESTREAMATTRIBKHRPROC __eglewCreateStreamAttribKHR = NULL; +PFNEGLQUERYSTREAMATTRIBKHRPROC __eglewQueryStreamAttribKHR = NULL; +PFNEGLSETSTREAMATTRIBKHRPROC __eglewSetStreamAttribKHR = NULL; +PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC __eglewStreamConsumerAcquireAttribKHR = NULL; +PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC __eglewStreamConsumerReleaseAttribKHR = NULL; + PFNEGLSTREAMCONSUMERACQUIREKHRPROC __eglewStreamConsumerAcquireKHR = NULL; PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHRPROC __eglewStreamConsumerGLTextureExternalKHR = NULL; PFNEGLSTREAMCONSUMERRELEASEKHRPROC __eglewStreamConsumerReleaseKHR = NULL; @@ -14635,6 +17519,8 @@ PFNEGLQUERYDISPLAYATTRIBNVPROC __eglewQueryDisplayAttribNV = NULL; PFNEGLQUERYSTREAMMETADATANVPROC __eglewQueryStreamMetadataNV = NULL; PFNEGLSETSTREAMMETADATANVPROC __eglewSetStreamMetadataNV = NULL; +PFNEGLRESETSTREAMNVPROC __eglewResetStreamNV = NULL; + PFNEGLCREATESTREAMSYNCNVPROC __eglewCreateStreamSyncNV = NULL; PFNEGLCLIENTWAITSYNCNVPROC __eglewClientWaitSyncNV = NULL; @@ -14665,6 +17551,7 @@ GLboolean __EGLEW_ANGLE_device_d3d = GL_FALSE; GLboolean __EGLEW_ANGLE_query_surface_pointer = GL_FALSE; 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_buffer_age = GL_FALSE; GLboolean __EGLEW_EXT_client_extensions = GL_FALSE; @@ -14674,11 +17561,16 @@ GLboolean __EGLEW_EXT_device_drm = GL_FALSE; GLboolean __EGLEW_EXT_device_enumeration = GL_FALSE; 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_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_multiview_window = GL_FALSE; GLboolean __EGLEW_EXT_output_base = GL_FALSE; GLboolean __EGLEW_EXT_output_drm = GL_FALSE; GLboolean __EGLEW_EXT_output_openwf = GL_FALSE; +GLboolean __EGLEW_EXT_pixel_format_float = GL_FALSE; GLboolean __EGLEW_EXT_platform_base = GL_FALSE; GLboolean __EGLEW_EXT_platform_device = GL_FALSE; GLboolean __EGLEW_EXT_platform_wayland = GL_FALSE; @@ -14686,6 +17578,7 @@ 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_SMPTE2086_metadata = GL_FALSE; GLboolean __EGLEW_EXT_swap_buffers_with_damage = GL_FALSE; GLboolean __EGLEW_EXT_yuv_surface = GL_FALSE; GLboolean __EGLEW_HI_clientpixmap = GL_FALSE; @@ -14696,6 +17589,7 @@ GLboolean __EGLEW_KHR_cl_event = GL_FALSE; GLboolean __EGLEW_KHR_cl_event2 = GL_FALSE; GLboolean __EGLEW_KHR_client_get_all_proc_addresses = GL_FALSE; GLboolean __EGLEW_KHR_config_attribs = GL_FALSE; +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; @@ -14713,6 +17607,7 @@ GLboolean __EGLEW_KHR_lock_surface = GL_FALSE; GLboolean __EGLEW_KHR_lock_surface2 = GL_FALSE; GLboolean __EGLEW_KHR_lock_surface3 = GL_FALSE; GLboolean __EGLEW_KHR_mutable_render_buffer = GL_FALSE; +GLboolean __EGLEW_KHR_no_config_context = GL_FALSE; GLboolean __EGLEW_KHR_partial_update = GL_FALSE; GLboolean __EGLEW_KHR_platform_android = GL_FALSE; GLboolean __EGLEW_KHR_platform_gbm = GL_FALSE; @@ -14720,6 +17615,7 @@ GLboolean __EGLEW_KHR_platform_wayland = GL_FALSE; GLboolean __EGLEW_KHR_platform_x11 = GL_FALSE; GLboolean __EGLEW_KHR_reusable_sync = GL_FALSE; GLboolean __EGLEW_KHR_stream = GL_FALSE; +GLboolean __EGLEW_KHR_stream_attrib = GL_FALSE; GLboolean __EGLEW_KHR_stream_consumer_gltexture = GL_FALSE; GLboolean __EGLEW_KHR_stream_cross_process_fd = GL_FALSE; GLboolean __EGLEW_KHR_stream_fifo = GL_FALSE; @@ -14732,6 +17628,7 @@ GLboolean __EGLEW_KHR_wait_sync = GL_FALSE; GLboolean __EGLEW_MESA_drm_image = GL_FALSE; GLboolean __EGLEW_MESA_image_dma_buf_export = GL_FALSE; GLboolean __EGLEW_MESA_platform_gbm = GL_FALSE; +GLboolean __EGLEW_MESA_platform_surfaceless = GL_FALSE; GLboolean __EGLEW_NOK_swap_region = GL_FALSE; GLboolean __EGLEW_NOK_swap_region2 = GL_FALSE; GLboolean __EGLEW_NOK_texture_from_pixmap = GL_FALSE; @@ -14746,7 +17643,20 @@ GLboolean __EGLEW_NV_post_convert_rounding = GL_FALSE; GLboolean __EGLEW_NV_post_sub_buffer = GL_FALSE; GLboolean __EGLEW_NV_robustness_video_memory_purge = GL_FALSE; GLboolean __EGLEW_NV_stream_consumer_gltexture_yuv = GL_FALSE; +GLboolean __EGLEW_NV_stream_cross_display = GL_FALSE; +GLboolean __EGLEW_NV_stream_cross_object = GL_FALSE; +GLboolean __EGLEW_NV_stream_cross_partition = GL_FALSE; +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_frame_limits = GL_FALSE; GLboolean __EGLEW_NV_stream_metadata = GL_FALSE; +GLboolean __EGLEW_NV_stream_remote = GL_FALSE; +GLboolean __EGLEW_NV_stream_reset = GL_FALSE; +GLboolean __EGLEW_NV_stream_socket = GL_FALSE; +GLboolean __EGLEW_NV_stream_socket_inet = GL_FALSE; +GLboolean __EGLEW_NV_stream_socket_unix = GL_FALSE; GLboolean __EGLEW_NV_stream_sync = GL_FALSE; GLboolean __EGLEW_NV_sync = GL_FALSE; GLboolean __EGLEW_NV_system_time = GL_FALSE; @@ -14948,6 +17858,20 @@ static GLboolean _glewInit_EGL_EXT_device_query () #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_image_dma_buf_import_modifiers + +static GLboolean _glewInit_EGL_EXT_image_dma_buf_import_modifiers () +{ + GLboolean r = GL_FALSE; + + r = ((eglQueryDmaBufFormatsEXT = (PFNEGLQUERYDMABUFFORMATSEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDmaBufFormatsEXT")) == NULL) || r; + r = ((eglQueryDmaBufModifiersEXT = (PFNEGLQUERYDMABUFMODIFIERSEXTPROC)glewGetProcAddress((const GLubyte*)"eglQueryDmaBufModifiersEXT")) == NULL) || r; + + return r; +} + +#endif /* EGL_EXT_image_dma_buf_import_modifiers */ + #ifdef EGL_EXT_output_base static GLboolean _glewInit_EGL_EXT_output_base () @@ -15138,6 +18062,23 @@ static GLboolean _glewInit_EGL_KHR_stream () #endif /* EGL_KHR_stream */ +#ifdef EGL_KHR_stream_attrib + +static GLboolean _glewInit_EGL_KHR_stream_attrib () +{ + GLboolean r = GL_FALSE; + + r = ((eglCreateStreamAttribKHR = (PFNEGLCREATESTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglCreateStreamAttribKHR")) == NULL) || r; + r = ((eglQueryStreamAttribKHR = (PFNEGLQUERYSTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglQueryStreamAttribKHR")) == NULL) || r; + r = ((eglSetStreamAttribKHR = (PFNEGLSETSTREAMATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglSetStreamAttribKHR")) == NULL) || r; + r = ((eglStreamConsumerAcquireAttribKHR = (PFNEGLSTREAMCONSUMERACQUIREATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerAcquireAttribKHR")) == NULL) || r; + r = ((eglStreamConsumerReleaseAttribKHR = (PFNEGLSTREAMCONSUMERRELEASEATTRIBKHRPROC)glewGetProcAddress((const GLubyte*)"eglStreamConsumerReleaseAttribKHR")) == NULL) || r; + + return r; +} + +#endif /* EGL_KHR_stream_attrib */ + #ifdef EGL_KHR_stream_consumer_gltexture static GLboolean _glewInit_EGL_KHR_stream_consumer_gltexture () @@ -15329,6 +18270,19 @@ static GLboolean _glewInit_EGL_NV_stream_metadata () #endif /* EGL_NV_stream_metadata */ +#ifdef EGL_NV_stream_reset + +static GLboolean _glewInit_EGL_NV_stream_reset () +{ + GLboolean r = GL_FALSE; + + r = ((eglResetStreamNV = (PFNEGLRESETSTREAMNVPROC)glewGetProcAddress((const GLubyte*)"eglResetStreamNV")) == NULL) || r; + + return r; +} + +#endif /* EGL_NV_stream_reset */ + #ifdef EGL_NV_stream_sync static GLboolean _glewInit_EGL_NV_stream_sync () @@ -15478,6 +18432,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_ANGLE_window_fixed_size EGLEW_ANGLE_window_fixed_size = _glewSearchExtension("EGL_ANGLE_window_fixed_size", extStart, extEnd); #endif /* EGL_ANGLE_window_fixed_size */ +#ifdef EGL_ARM_implicit_external_sync + EGLEW_ARM_implicit_external_sync = _glewSearchExtension("EGL_ARM_implicit_external_sync", extStart, extEnd); +#endif /* EGL_ARM_implicit_external_sync */ #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 */ @@ -15507,9 +18464,22 @@ GLenum eglewInit (EGLDisplay display) EGLEW_EXT_device_query = _glewSearchExtension("EGL_EXT_device_query", extStart, extEnd); if (glewExperimental || EGLEW_EXT_device_query) EGLEW_EXT_device_query = !_glewInit_EGL_EXT_device_query(); #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_gl_colorspace_bt2020_linear + EGLEW_EXT_gl_colorspace_bt2020_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_bt2020_linear", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_bt2020_linear */ +#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_scrgb_linear + EGLEW_EXT_gl_colorspace_scrgb_linear = _glewSearchExtension("EGL_EXT_gl_colorspace_scrgb_linear", extStart, extEnd); +#endif /* EGL_EXT_gl_colorspace_scrgb_linear */ #ifdef EGL_EXT_image_dma_buf_import EGLEW_EXT_image_dma_buf_import = _glewSearchExtension("EGL_EXT_image_dma_buf_import", extStart, extEnd); #endif /* EGL_EXT_image_dma_buf_import */ +#ifdef EGL_EXT_image_dma_buf_import_modifiers + 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_multiview_window EGLEW_EXT_multiview_window = _glewSearchExtension("EGL_EXT_multiview_window", extStart, extEnd); #endif /* EGL_EXT_multiview_window */ @@ -15523,6 +18493,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_EXT_output_openwf EGLEW_EXT_output_openwf = _glewSearchExtension("EGL_EXT_output_openwf", extStart, extEnd); #endif /* EGL_EXT_output_openwf */ +#ifdef EGL_EXT_pixel_format_float + EGLEW_EXT_pixel_format_float = _glewSearchExtension("EGL_EXT_pixel_format_float", extStart, extEnd); +#endif /* EGL_EXT_pixel_format_float */ #ifdef EGL_EXT_platform_base EGLEW_EXT_platform_base = _glewSearchExtension("EGL_EXT_platform_base", extStart, extEnd); if (glewExperimental || EGLEW_EXT_platform_base) EGLEW_EXT_platform_base = !_glewInit_EGL_EXT_platform_base(); @@ -15546,6 +18519,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_SMPTE2086_metadata + EGLEW_EXT_surface_SMPTE2086_metadata = _glewSearchExtension("EGL_EXT_surface_SMPTE2086_metadata", extStart, extEnd); +#endif /* EGL_EXT_surface_SMPTE2086_metadata */ #ifdef EGL_EXT_swap_buffers_with_damage 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(); @@ -15579,6 +18555,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_KHR_config_attribs EGLEW_KHR_config_attribs = _glewSearchExtension("EGL_KHR_config_attribs", extStart, extEnd); #endif /* EGL_KHR_config_attribs */ +#ifdef EGL_KHR_context_flush_control + EGLEW_KHR_context_flush_control = _glewSearchExtension("EGL_KHR_context_flush_control", extStart, extEnd); +#endif /* EGL_KHR_context_flush_control */ #ifdef EGL_KHR_create_context EGLEW_KHR_create_context = _glewSearchExtension("EGL_KHR_create_context", extStart, extEnd); #endif /* EGL_KHR_create_context */ @@ -15634,6 +18613,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_KHR_mutable_render_buffer EGLEW_KHR_mutable_render_buffer = _glewSearchExtension("EGL_KHR_mutable_render_buffer", extStart, extEnd); #endif /* EGL_KHR_mutable_render_buffer */ +#ifdef EGL_KHR_no_config_context + EGLEW_KHR_no_config_context = _glewSearchExtension("EGL_KHR_no_config_context", extStart, extEnd); +#endif /* EGL_KHR_no_config_context */ #ifdef EGL_KHR_partial_update EGLEW_KHR_partial_update = _glewSearchExtension("EGL_KHR_partial_update", extStart, extEnd); if (glewExperimental || EGLEW_KHR_partial_update) EGLEW_KHR_partial_update = !_glewInit_EGL_KHR_partial_update(); @@ -15658,6 +18640,10 @@ GLenum eglewInit (EGLDisplay display) EGLEW_KHR_stream = _glewSearchExtension("EGL_KHR_stream", extStart, extEnd); if (glewExperimental || EGLEW_KHR_stream) EGLEW_KHR_stream = !_glewInit_EGL_KHR_stream(); #endif /* EGL_KHR_stream */ +#ifdef EGL_KHR_stream_attrib + EGLEW_KHR_stream_attrib = _glewSearchExtension("EGL_KHR_stream_attrib", extStart, extEnd); + if (glewExperimental || EGLEW_KHR_stream_attrib) EGLEW_KHR_stream_attrib = !_glewInit_EGL_KHR_stream_attrib(); +#endif /* EGL_KHR_stream_attrib */ #ifdef EGL_KHR_stream_consumer_gltexture EGLEW_KHR_stream_consumer_gltexture = _glewSearchExtension("EGL_KHR_stream_consumer_gltexture", extStart, extEnd); if (glewExperimental || EGLEW_KHR_stream_consumer_gltexture) EGLEW_KHR_stream_consumer_gltexture = !_glewInit_EGL_KHR_stream_consumer_gltexture(); @@ -15702,6 +18688,9 @@ GLenum eglewInit (EGLDisplay display) #ifdef EGL_MESA_platform_gbm EGLEW_MESA_platform_gbm = _glewSearchExtension("EGL_MESA_platform_gbm", extStart, extEnd); #endif /* EGL_MESA_platform_gbm */ +#ifdef EGL_MESA_platform_surfaceless + EGLEW_MESA_platform_surfaceless = _glewSearchExtension("EGL_MESA_platform_surfaceless", extStart, extEnd); +#endif /* EGL_MESA_platform_surfaceless */ #ifdef EGL_NOK_swap_region EGLEW_NOK_swap_region = _glewSearchExtension("EGL_NOK_swap_region", extStart, extEnd); if (glewExperimental || EGLEW_NOK_swap_region) EGLEW_NOK_swap_region = !_glewInit_EGL_NOK_swap_region(); @@ -15749,10 +18738,50 @@ GLenum eglewInit (EGLDisplay display) EGLEW_NV_stream_consumer_gltexture_yuv = _glewSearchExtension("EGL_NV_stream_consumer_gltexture_yuv", extStart, extEnd); if (glewExperimental || EGLEW_NV_stream_consumer_gltexture_yuv) EGLEW_NV_stream_consumer_gltexture_yuv = !_glewInit_EGL_NV_stream_consumer_gltexture_yuv(); #endif /* EGL_NV_stream_consumer_gltexture_yuv */ +#ifdef EGL_NV_stream_cross_display + EGLEW_NV_stream_cross_display = _glewSearchExtension("EGL_NV_stream_cross_display", extStart, extEnd); +#endif /* EGL_NV_stream_cross_display */ +#ifdef EGL_NV_stream_cross_object + EGLEW_NV_stream_cross_object = _glewSearchExtension("EGL_NV_stream_cross_object", extStart, extEnd); +#endif /* EGL_NV_stream_cross_object */ +#ifdef EGL_NV_stream_cross_partition + EGLEW_NV_stream_cross_partition = _glewSearchExtension("EGL_NV_stream_cross_partition", extStart, extEnd); +#endif /* EGL_NV_stream_cross_partition */ +#ifdef EGL_NV_stream_cross_process + EGLEW_NV_stream_cross_process = _glewSearchExtension("EGL_NV_stream_cross_process", extStart, extEnd); +#endif /* EGL_NV_stream_cross_process */ +#ifdef EGL_NV_stream_cross_system + EGLEW_NV_stream_cross_system = _glewSearchExtension("EGL_NV_stream_cross_system", extStart, extEnd); +#endif /* EGL_NV_stream_cross_system */ +#ifdef EGL_NV_stream_fifo_next + EGLEW_NV_stream_fifo_next = _glewSearchExtension("EGL_NV_stream_fifo_next", extStart, extEnd); +#endif /* EGL_NV_stream_fifo_next */ +#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_frame_limits + EGLEW_NV_stream_frame_limits = _glewSearchExtension("EGL_NV_stream_frame_limits", extStart, extEnd); +#endif /* EGL_NV_stream_frame_limits */ #ifdef EGL_NV_stream_metadata EGLEW_NV_stream_metadata = _glewSearchExtension("EGL_NV_stream_metadata", extStart, extEnd); if (glewExperimental || EGLEW_NV_stream_metadata) EGLEW_NV_stream_metadata = !_glewInit_EGL_NV_stream_metadata(); #endif /* EGL_NV_stream_metadata */ +#ifdef EGL_NV_stream_remote + EGLEW_NV_stream_remote = _glewSearchExtension("EGL_NV_stream_remote", extStart, extEnd); +#endif /* EGL_NV_stream_remote */ +#ifdef EGL_NV_stream_reset + EGLEW_NV_stream_reset = _glewSearchExtension("EGL_NV_stream_reset", extStart, extEnd); + if (glewExperimental || EGLEW_NV_stream_reset) EGLEW_NV_stream_reset = !_glewInit_EGL_NV_stream_reset(); +#endif /* EGL_NV_stream_reset */ +#ifdef EGL_NV_stream_socket + EGLEW_NV_stream_socket = _glewSearchExtension("EGL_NV_stream_socket", extStart, extEnd); +#endif /* EGL_NV_stream_socket */ +#ifdef EGL_NV_stream_socket_inet + EGLEW_NV_stream_socket_inet = _glewSearchExtension("EGL_NV_stream_socket_inet", extStart, extEnd); +#endif /* EGL_NV_stream_socket_inet */ +#ifdef EGL_NV_stream_socket_unix + EGLEW_NV_stream_socket_unix = _glewSearchExtension("EGL_NV_stream_socket_unix", extStart, extEnd); +#endif /* EGL_NV_stream_socket_unix */ #ifdef EGL_NV_stream_sync EGLEW_NV_stream_sync = _glewSearchExtension("EGL_NV_stream_sync", extStart, extEnd); if (glewExperimental || EGLEW_NV_stream_sync) EGLEW_NV_stream_sync = !_glewInit_EGL_NV_stream_sync(); @@ -15932,6 +18961,7 @@ GLboolean __WGLEW_AMD_gpu_association = GL_FALSE; GLboolean __WGLEW_ARB_buffer_region = GL_FALSE; GLboolean __WGLEW_ARB_context_flush_control = GL_FALSE; GLboolean __WGLEW_ARB_create_context = GL_FALSE; +GLboolean __WGLEW_ARB_create_context_no_error = GL_FALSE; GLboolean __WGLEW_ARB_create_context_profile = GL_FALSE; GLboolean __WGLEW_ARB_create_context_robustness = GL_FALSE; GLboolean __WGLEW_ARB_extensions_string = GL_FALSE; @@ -15946,6 +18976,7 @@ GLboolean __WGLEW_ARB_robustness_application_isolation = GL_FALSE; GLboolean __WGLEW_ARB_robustness_share_group_isolation = GL_FALSE; GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE; GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE; +GLboolean __WGLEW_EXT_colorspace = GL_FALSE; GLboolean __WGLEW_EXT_create_context_es2_profile = GL_FALSE; GLboolean __WGLEW_EXT_create_context_es_profile = GL_FALSE; GLboolean __WGLEW_EXT_depth_float = GL_FALSE; @@ -16534,6 +19565,9 @@ GLenum GLEWAPIENTRY wglewInit () WGLEW_ARB_create_context = _glewSearchExtension("WGL_ARB_create_context", extStart, extEnd); if (glewExperimental || WGLEW_ARB_create_context|| crippled) WGLEW_ARB_create_context= !_glewInit_WGL_ARB_create_context(); #endif /* WGL_ARB_create_context */ +#ifdef WGL_ARB_create_context_no_error + WGLEW_ARB_create_context_no_error = _glewSearchExtension("WGL_ARB_create_context_no_error", extStart, extEnd); +#endif /* WGL_ARB_create_context_no_error */ #ifdef WGL_ARB_create_context_profile WGLEW_ARB_create_context_profile = _glewSearchExtension("WGL_ARB_create_context_profile", extStart, extEnd); #endif /* WGL_ARB_create_context_profile */ @@ -16581,6 +19615,9 @@ GLenum GLEWAPIENTRY wglewInit () #ifdef WGL_ATI_render_texture_rectangle WGLEW_ATI_render_texture_rectangle = _glewSearchExtension("WGL_ATI_render_texture_rectangle", extStart, extEnd); #endif /* WGL_ATI_render_texture_rectangle */ +#ifdef WGL_EXT_colorspace + WGLEW_EXT_colorspace = _glewSearchExtension("WGL_EXT_colorspace", extStart, extEnd); +#endif /* WGL_EXT_colorspace */ #ifdef WGL_EXT_create_context_es2_profile WGLEW_EXT_create_context_es2_profile = _glewSearchExtension("WGL_EXT_create_context_es2_profile", extStart, extEnd); #endif /* WGL_EXT_create_context_es2_profile */ @@ -16871,6 +19908,7 @@ GLboolean __GLXEW_3DFX_multisample = GL_FALSE; GLboolean __GLXEW_AMD_gpu_association = GL_FALSE; GLboolean __GLXEW_ARB_context_flush_control = GL_FALSE; GLboolean __GLXEW_ARB_create_context = GL_FALSE; +GLboolean __GLXEW_ARB_create_context_no_error = GL_FALSE; GLboolean __GLXEW_ARB_create_context_profile = GL_FALSE; GLboolean __GLXEW_ARB_create_context_robustness = GL_FALSE; GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE; @@ -17497,11 +20535,15 @@ GLboolean glxewGetExtension (const char* name) GLenum glxewInit () { + Display* display; int major, minor; const GLubyte* extStart; const GLubyte* extEnd; /* initialize core GLX 1.2 */ if (_glewInit_GLX_VERSION_1_2()) return GLEW_ERROR_GLX_VERSION_11_ONLY; + /* check for a display */ + display = glXGetCurrentDisplay(); + if (display == NULL) return GLEW_ERROR_NO_GLX_DISPLAY; /* initialize flags */ GLXEW_VERSION_1_0 = GL_TRUE; GLXEW_VERSION_1_1 = GL_TRUE; @@ -17509,7 +20551,7 @@ GLenum glxewInit () GLXEW_VERSION_1_3 = GL_TRUE; GLXEW_VERSION_1_4 = GL_TRUE; /* query GLX version */ - glXQueryVersion(glXGetCurrentDisplay(), &major, &minor); + glXQueryVersion(display, &major, &minor); if (major == 1 && minor <= 3) { switch (minor) @@ -17529,7 +20571,7 @@ GLenum glxewInit () /* query GLX extension string */ extStart = 0; if (glXGetCurrentDisplay != NULL) - extStart = (const GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); + extStart = (const GLubyte*)glXGetClientString(display, GLX_EXTENSIONS); if (extStart == 0) extStart = (const GLubyte *)""; extEnd = extStart + _glewStrLen(extStart); @@ -17551,6 +20593,9 @@ GLenum glxewInit () GLXEW_ARB_create_context = _glewSearchExtension("GLX_ARB_create_context", extStart, extEnd); if (glewExperimental || GLXEW_ARB_create_context) GLXEW_ARB_create_context = !_glewInit_GLX_ARB_create_context(); #endif /* GLX_ARB_create_context */ +#ifdef GLX_ARB_create_context_no_error + GLXEW_ARB_create_context_no_error = _glewSearchExtension("GLX_ARB_create_context_no_error", extStart, extEnd); +#endif /* GLX_ARB_create_context_no_error */ #ifdef GLX_ARB_create_context_profile GLXEW_ARB_create_context_profile = _glewSearchExtension("GLX_ARB_create_context_profile", extStart, extEnd); #endif /* GLX_ARB_create_context_profile */ @@ -17799,9 +20844,9 @@ const GLubyte * GLEWAPIENTRY glewGetString (GLenum name) static const GLubyte* _glewString[] = { (const GLubyte*)NULL, - (const GLubyte*)"2.0.0", + (const GLubyte*)"2.1.0", (const GLubyte*)"2", - (const GLubyte*)"0", + (const GLubyte*)"1", (const GLubyte*)"0" }; const size_t max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; @@ -17974,6 +21019,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_VERSION_4_5; continue; } +#endif +#ifdef GL_VERSION_4_6 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"4_6", 3)) + { + ret = GLEW_VERSION_4_6; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) @@ -18009,6 +21061,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_compressed_3DC_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_3DC_texture", 22)) + { + ret = GLEW_AMD_compressed_3DC_texture; + continue; + } +#endif +#ifdef GL_AMD_compressed_ATC_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_ATC_texture", 22)) + { + ret = GLEW_AMD_compressed_ATC_texture; + continue; + } +#endif #ifdef GL_AMD_conservative_depth if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) { @@ -18037,6 +21103,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_framebuffer_sample_positions + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sample_positions", 28)) + { + ret = GLEW_AMD_framebuffer_sample_positions; + continue; + } +#endif #ifdef GL_AMD_gcn_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"gcn_shader", 10)) { @@ -18044,6 +21117,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_gpu_shader_half_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_half_float", 21)) + { + ret = GLEW_AMD_gpu_shader_half_float; + continue; + } +#endif +#ifdef GL_AMD_gpu_shader_int16 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int16", 16)) + { + ret = GLEW_AMD_gpu_shader_int16; + continue; + } +#endif #ifdef GL_AMD_gpu_shader_int64 if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader_int64", 16)) { @@ -18093,6 +21180,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_program_binary_Z400 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"program_binary_Z400", 19)) + { + ret = GLEW_AMD_program_binary_Z400; + continue; + } +#endif #ifdef GL_AMD_query_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"query_buffer_object", 19)) { @@ -18121,6 +21215,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_shader_ballot + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_ballot", 13)) + { + ret = GLEW_AMD_shader_ballot; + continue; + } +#endif #ifdef GL_AMD_shader_explicit_vertex_parameter if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_explicit_vertex_parameter", 32)) { @@ -18163,6 +21264,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_AMD_texture_gather_bias_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_gather_bias_lod", 23)) + { + ret = GLEW_AMD_texture_gather_bias_lod; + continue; + } +#endif #ifdef GL_AMD_texture_texture4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_texture4", 16)) { @@ -18204,6 +21312,16 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_AMD_vertex_shader_viewport_index; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANDROID_", 8)) + { +#ifdef GL_ANDROID_extension_pack_es31a + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extension_pack_es31a", 20)) + { + ret = GLEW_ANDROID_extension_pack_es31a; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ANGLE_", 6)) @@ -18309,6 +21427,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_APPLE_clip_distance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_distance", 13)) + { + ret = GLEW_APPLE_clip_distance; + continue; + } +#endif +#ifdef GL_APPLE_color_buffer_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_packed_float", 25)) + { + ret = GLEW_APPLE_color_buffer_packed_float; + continue; + } +#endif +#ifdef GL_APPLE_copy_texture_levels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture_levels", 19)) + { + ret = GLEW_APPLE_copy_texture_levels; + continue; + } +#endif #ifdef GL_APPLE_element_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) { @@ -18337,6 +21476,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_APPLE_framebuffer_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) + { + ret = GLEW_APPLE_framebuffer_multisample; + continue; + } +#endif #ifdef GL_APPLE_object_purgeable if (_glewStrSame3(&pos, &len, (const GLubyte*)"object_purgeable", 16)) { @@ -18372,6 +21518,41 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_APPLE_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync", 4)) + { + ret = GLEW_APPLE_sync; + continue; + } +#endif +#ifdef GL_APPLE_texture_2D_limited_npot + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_2D_limited_npot", 23)) + { + ret = GLEW_APPLE_texture_2D_limited_npot; + continue; + } +#endif +#ifdef GL_APPLE_texture_format_BGRA8888 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_format_BGRA8888", 23)) + { + ret = GLEW_APPLE_texture_format_BGRA8888; + continue; + } +#endif +#ifdef GL_APPLE_texture_max_level + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_max_level", 17)) + { + ret = GLEW_APPLE_texture_max_level; + continue; + } +#endif +#ifdef GL_APPLE_texture_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_packed_float", 20)) + { + ret = GLEW_APPLE_texture_packed_float; + continue; + } +#endif #ifdef GL_APPLE_texture_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) { @@ -18942,6 +22123,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_ARB_polygon_offset_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset_clamp", 20)) + { + ret = GLEW_ARB_polygon_offset_clamp; + continue; + } +#endif #ifdef GL_ARB_post_depth_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"post_depth_coverage", 19)) { @@ -19229,6 +22417,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_ARB_spirv_extensions + if (_glewStrSame3(&pos, &len, (const GLubyte*)"spirv_extensions", 16)) + { + ret = GLEW_ARB_spirv_extensions; + continue; + } +#endif #ifdef GL_ARB_stencil_texturing if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_texturing", 17)) { @@ -19348,6 +22543,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_ARB_texture_filter_anisotropic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26)) + { + ret = GLEW_ARB_texture_filter_anisotropic; + continue; + } +#endif #ifdef GL_ARB_texture_filter_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_minmax", 21)) { @@ -19599,6 +22801,44 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_ARB_window_pos; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARM_", 4)) + { +#ifdef GL_ARM_mali_program_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mali_program_binary", 19)) + { + ret = GLEW_ARM_mali_program_binary; + continue; + } +#endif +#ifdef GL_ARM_mali_shader_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mali_shader_binary", 18)) + { + ret = GLEW_ARM_mali_shader_binary; + continue; + } +#endif +#ifdef GL_ARM_rgba8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rgba8", 5)) + { + ret = GLEW_ARM_rgba8; + continue; + } +#endif +#ifdef GL_ARM_shader_framebuffer_fetch + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24)) + { + ret = GLEW_ARM_shader_framebuffer_fetch; + continue; + } +#endif +#ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_depth_stencil", 38)) + { + ret = GLEW_ARM_shader_framebuffer_fetch_depth_stencil; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5)) @@ -19756,6 +22996,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EGL_", 4)) { +#ifdef GL_EGL_KHR_context_flush_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"KHR_context_flush_control", 25)) + { + ret = GLEW_EGL_KHR_context_flush_control; + continue; + } +#endif #ifdef GL_EGL_NV_robustness_video_memory_purge if (_glewStrSame3(&pos, &len, (const GLubyte*)"NV_robustness_video_memory_purge", 32)) { @@ -19780,6 +23027,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_EGL_image_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_image_array", 15)) + { + ret = GLEW_EXT_EGL_image_array; + continue; + } +#endif +#ifdef GL_EXT_YUV_target + if (_glewStrSame3(&pos, &len, (const GLubyte*)"YUV_target", 10)) + { + ret = GLEW_EXT_YUV_target; + continue; + } +#endif #ifdef GL_EXT_abgr if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4)) { @@ -19787,6 +23048,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_base_instance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"base_instance", 13)) + { + ret = GLEW_EXT_base_instance; + continue; + } +#endif #ifdef GL_EXT_bgra if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4)) { @@ -19815,6 +23083,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_blend_func_extended + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_extended", 19)) + { + ret = GLEW_EXT_blend_func_extended; + continue; + } +#endif #ifdef GL_EXT_blend_func_separate if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19)) { @@ -19843,6 +23118,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_buffer_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_storage", 14)) + { + ret = GLEW_EXT_buffer_storage; + continue; + } +#endif +#ifdef GL_EXT_clear_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clear_texture", 13)) + { + ret = GLEW_EXT_clear_texture; + continue; + } +#endif +#ifdef GL_EXT_clip_cull_distance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_cull_distance", 18)) + { + ret = GLEW_EXT_clip_cull_distance; + continue; + } +#endif #ifdef GL_EXT_clip_volume_hint if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16)) { @@ -19857,6 +23153,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_color_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18)) + { + ret = GLEW_EXT_color_buffer_float; + continue; + } +#endif +#ifdef GL_EXT_color_buffer_half_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_half_float", 23)) + { + ret = GLEW_EXT_color_buffer_half_float; + continue; + } +#endif #ifdef GL_EXT_color_subtable if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14)) { @@ -19871,6 +23181,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_ETC1_RGB8_sub_texture", 32)) + { + ret = GLEW_EXT_compressed_ETC1_RGB8_sub_texture; + continue; + } +#endif +#ifdef GL_EXT_conservative_depth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conservative_depth", 18)) + { + ret = GLEW_EXT_conservative_depth; + continue; + } +#endif #ifdef GL_EXT_convolution if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11)) { @@ -19885,6 +23209,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_copy_image + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_image", 10)) + { + ret = GLEW_EXT_copy_image; + continue; + } +#endif #ifdef GL_EXT_copy_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12)) { @@ -19927,6 +23258,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_discard_framebuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"discard_framebuffer", 19)) + { + ret = GLEW_EXT_discard_framebuffer; + continue; + } +#endif +#ifdef GL_EXT_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_EXT_draw_buffers; + continue; + } +#endif #ifdef GL_EXT_draw_buffers2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13)) { @@ -19934,6 +23279,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_draw_buffers_indexed + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers_indexed", 20)) + { + ret = GLEW_EXT_draw_buffers_indexed; + continue; + } +#endif +#ifdef GL_EXT_draw_elements_base_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_elements_base_vertex", 25)) + { + ret = GLEW_EXT_draw_elements_base_vertex; + continue; + } +#endif #ifdef GL_EXT_draw_instanced if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) { @@ -19948,6 +23307,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_external_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"external_buffer", 15)) + { + ret = GLEW_EXT_external_buffer; + continue; + } +#endif +#ifdef GL_EXT_float_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_blend", 11)) + { + ret = GLEW_EXT_float_blend; + continue; + } +#endif #ifdef GL_EXT_fog_coord if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9)) { @@ -19955,6 +23328,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_frag_depth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"frag_depth", 10)) + { + ret = GLEW_EXT_frag_depth; + continue; + } +#endif #ifdef GL_EXT_fragment_lighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17)) { @@ -19997,6 +23377,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_geometry_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_point_size", 19)) + { + ret = GLEW_EXT_geometry_point_size; + continue; + } +#endif +#ifdef GL_EXT_geometry_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader", 15)) + { + ret = GLEW_EXT_geometry_shader; + continue; + } +#endif #ifdef GL_EXT_geometry_shader4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) { @@ -20018,6 +23412,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_gpu_shader5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader5", 11)) + { + ret = GLEW_EXT_gpu_shader5; + continue; + } +#endif #ifdef GL_EXT_histogram if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9)) { @@ -20053,6 +23454,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_instanced_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) + { + ret = GLEW_EXT_instanced_arrays; + continue; + } +#endif #ifdef GL_EXT_light_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13)) { @@ -20060,6 +23468,34 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_map_buffer_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16)) + { + ret = GLEW_EXT_map_buffer_range; + continue; + } +#endif +#ifdef GL_EXT_memory_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object", 13)) + { + ret = GLEW_EXT_memory_object; + continue; + } +#endif +#ifdef GL_EXT_memory_object_fd + if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_fd", 16)) + { + ret = GLEW_EXT_memory_object_fd; + continue; + } +#endif +#ifdef GL_EXT_memory_object_win32 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"memory_object_win32", 19)) + { + ret = GLEW_EXT_memory_object_win32; + continue; + } +#endif #ifdef GL_EXT_misc_attribute if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14)) { @@ -20074,6 +23510,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_multi_draw_indirect + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_indirect", 19)) + { + ret = GLEW_EXT_multi_draw_indirect; + continue; + } +#endif +#ifdef GL_EXT_multiple_textures + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiple_textures", 17)) + { + ret = GLEW_EXT_multiple_textures; + continue; + } +#endif #ifdef GL_EXT_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { @@ -20081,6 +23531,34 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_multisample_compatibility + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_compatibility", 25)) + { + ret = GLEW_EXT_multisample_compatibility; + continue; + } +#endif +#ifdef GL_EXT_multisampled_render_to_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisampled_render_to_texture", 30)) + { + ret = GLEW_EXT_multisampled_render_to_texture; + continue; + } +#endif +#ifdef GL_EXT_multisampled_render_to_texture2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisampled_render_to_texture2", 31)) + { + ret = GLEW_EXT_multisampled_render_to_texture2; + continue; + } +#endif +#ifdef GL_EXT_multiview_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_draw_buffers", 22)) + { + ret = GLEW_EXT_multiview_draw_buffers; + continue; + } +#endif #ifdef GL_EXT_packed_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) { @@ -20165,6 +23643,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_pvrtc_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pvrtc_sRGB", 10)) + { + ret = GLEW_EXT_pvrtc_sRGB; + continue; + } +#endif #ifdef GL_EXT_raster_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"raster_multisample", 18)) { @@ -20172,6 +23657,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_read_format_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format_bgra", 16)) + { + ret = GLEW_EXT_read_format_bgra; + continue; + } +#endif +#ifdef GL_EXT_render_snorm + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_snorm", 12)) + { + ret = GLEW_EXT_render_snorm; + continue; + } +#endif #ifdef GL_EXT_rescale_normal if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14)) { @@ -20179,6 +23678,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB", 4)) + { + ret = GLEW_EXT_sRGB; + continue; + } +#endif +#ifdef GL_EXT_sRGB_write_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB_write_control", 18)) + { + ret = GLEW_EXT_sRGB_write_control; + continue; + } +#endif #ifdef GL_EXT_scene_marker if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) { @@ -20193,6 +23706,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_semaphore + if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore", 9)) + { + ret = GLEW_EXT_semaphore; + continue; + } +#endif +#ifdef GL_EXT_semaphore_fd + if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore_fd", 12)) + { + ret = GLEW_EXT_semaphore_fd; + continue; + } +#endif +#ifdef GL_EXT_semaphore_win32 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"semaphore_win32", 15)) + { + ret = GLEW_EXT_semaphore_win32; + continue; + } +#endif #ifdef GL_EXT_separate_shader_objects if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_shader_objects", 23)) { @@ -20207,6 +23741,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_framebuffer_fetch + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch", 24)) + { + ret = GLEW_EXT_shader_framebuffer_fetch; + continue; + } +#endif +#ifdef GL_EXT_shader_group_vote + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_group_vote", 17)) + { + ret = GLEW_EXT_shader_group_vote; + continue; + } +#endif #ifdef GL_EXT_shader_image_load_formatted if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_image_load_formatted", 27)) { @@ -20221,6 +23769,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_implicit_conversions + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_implicit_conversions", 27)) + { + ret = GLEW_EXT_shader_implicit_conversions; + continue; + } +#endif #ifdef GL_EXT_shader_integer_mix if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_integer_mix", 18)) { @@ -20228,6 +23783,41 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shader_io_blocks + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_io_blocks", 16)) + { + ret = GLEW_EXT_shader_io_blocks; + continue; + } +#endif +#ifdef GL_EXT_shader_non_constant_global_initializers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_non_constant_global_initializers", 39)) + { + ret = GLEW_EXT_shader_non_constant_global_initializers; + continue; + } +#endif +#ifdef GL_EXT_shader_pixel_local_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_pixel_local_storage", 26)) + { + ret = GLEW_EXT_shader_pixel_local_storage; + continue; + } +#endif +#ifdef GL_EXT_shader_pixel_local_storage2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_pixel_local_storage2", 27)) + { + ret = GLEW_EXT_shader_pixel_local_storage2; + continue; + } +#endif +#ifdef GL_EXT_shader_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) + { + ret = GLEW_EXT_shader_texture_lod; + continue; + } +#endif #ifdef GL_EXT_shadow_funcs if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12)) { @@ -20235,6 +23825,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_shadow_samplers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers", 15)) + { + ret = GLEW_EXT_shadow_samplers; + continue; + } +#endif #ifdef GL_EXT_shared_texture_palette if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22)) { @@ -20242,6 +23839,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_sparse_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture", 14)) + { + ret = GLEW_EXT_sparse_texture; + continue; + } +#endif #ifdef GL_EXT_sparse_texture2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"sparse_texture2", 15)) { @@ -20305,6 +23909,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_compression_astc_decode_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_decode_mode", 36)) + { + ret = GLEW_EXT_texture_compression_astc_decode_mode; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_astc_decode_mode_rgb9e5", 43)) + { + ret = GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_bptc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_bptc", 24)) + { + ret = GLEW_EXT_texture_compression_bptc; + continue; + } +#endif #ifdef GL_EXT_texture_compression_dxt1 if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24)) { @@ -20340,6 +23965,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_cube_map_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map_array", 22)) + { + ret = GLEW_EXT_texture_cube_map_array; + continue; + } +#endif #ifdef GL_EXT_texture_edge_clamp if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) { @@ -20389,6 +24021,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_format_BGRA8888 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_format_BGRA8888", 23)) + { + ret = GLEW_EXT_texture_format_BGRA8888; + continue; + } +#endif #ifdef GL_EXT_texture_integer if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15)) { @@ -20410,6 +24049,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_norm16 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_norm16", 14)) + { + ret = GLEW_EXT_texture_norm16; + continue; + } +#endif #ifdef GL_EXT_texture_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14)) { @@ -20431,6 +24077,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_rg + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10)) + { + ret = GLEW_EXT_texture_rg; + continue; + } +#endif #ifdef GL_EXT_texture_sRGB if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12)) { @@ -20438,6 +24091,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_sRGB_R8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_R8", 15)) + { + ret = GLEW_EXT_texture_sRGB_R8; + continue; + } +#endif +#ifdef GL_EXT_texture_sRGB_RG8 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_RG8", 16)) + { + ret = GLEW_EXT_texture_sRGB_RG8; + continue; + } +#endif #ifdef GL_EXT_texture_sRGB_decode if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB_decode", 19)) { @@ -20459,6 +24126,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_storage", 15)) + { + ret = GLEW_EXT_texture_storage; + continue; + } +#endif #ifdef GL_EXT_texture_swizzle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) { @@ -20466,6 +24140,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_texture_type_2_10_10_10_REV + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_type_2_10_10_10_REV", 27)) + { + ret = GLEW_EXT_texture_type_2_10_10_10_REV; + continue; + } +#endif +#ifdef GL_EXT_texture_view + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_view", 12)) + { + ret = GLEW_EXT_texture_view; + continue; + } +#endif #ifdef GL_EXT_timer_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) { @@ -20480,6 +24168,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_unpack_subimage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"unpack_subimage", 15)) + { + ret = GLEW_EXT_unpack_subimage; + continue; + } +#endif #ifdef GL_EXT_vertex_array if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12)) { @@ -20494,6 +24189,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_vertex_array_setXXX + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_setXXX", 19)) + { + ret = GLEW_EXT_vertex_array_setXXX; + continue; + } +#endif #ifdef GL_EXT_vertex_attrib_64bit if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_64bit", 19)) { @@ -20515,6 +24217,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_EXT_win32_keyed_mutex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"win32_keyed_mutex", 17)) + { + ret = GLEW_EXT_win32_keyed_mutex; + continue; + } +#endif #ifdef GL_EXT_window_rectangles if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_rectangles", 17)) { @@ -20729,6 +24438,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_KHR_parallel_shader_compile + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_shader_compile", 23)) + { + ret = GLEW_KHR_parallel_shader_compile; + continue; + } +#endif #ifdef GL_KHR_robust_buffer_access_behavior if (_glewStrSame3(&pos, &len, (const GLubyte*)"robust_buffer_access_behavior", 29)) { @@ -20856,6 +24572,34 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) { +#ifdef GL_NV_3dvision_settings + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3dvision_settings", 17)) + { + ret = GLEW_NV_3dvision_settings; + continue; + } +#endif +#ifdef GL_NV_EGL_stream_consumer_external + if (_glewStrSame3(&pos, &len, (const GLubyte*)"EGL_stream_consumer_external", 28)) + { + ret = GLEW_NV_EGL_stream_consumer_external; + continue; + } +#endif +#ifdef GL_NV_alpha_to_coverage_dither_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"alpha_to_coverage_dither_control", 32)) + { + ret = GLEW_NV_alpha_to_coverage_dither_control; + continue; + } +#endif +#ifdef GL_NV_bgr + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgr", 3)) + { + ret = GLEW_NV_bgr; + continue; + } +#endif #ifdef GL_NV_bindless_multi_draw_indirect if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindless_multi_draw_indirect", 28)) { @@ -20891,6 +24635,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_blend_minmax_factor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax_factor", 19)) + { + ret = GLEW_NV_blend_minmax_factor; + continue; + } +#endif #ifdef GL_NV_blend_square if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12)) { @@ -20947,6 +24698,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_copy_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_buffer", 11)) + { + ret = GLEW_NV_copy_buffer; + continue; + } +#endif #ifdef GL_NV_copy_depth_to_color if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19)) { @@ -20989,6 +24747,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_NV_draw_buffers; + continue; + } +#endif +#ifdef GL_NV_draw_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) + { + ret = GLEW_NV_draw_instanced; + continue; + } +#endif #ifdef GL_NV_draw_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_texture", 12)) { @@ -21010,6 +24782,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_explicit_attrib_location + if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_attrib_location", 24)) + { + ret = GLEW_NV_explicit_attrib_location; + continue; + } +#endif #ifdef GL_NV_explicit_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20)) { @@ -21017,6 +24796,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_fbo_color_attachments + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbo_color_attachments", 21)) + { + ret = GLEW_NV_fbo_color_attachments; + continue; + } +#endif #ifdef GL_NV_fence if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) { @@ -21087,6 +24873,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_framebuffer_blit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) + { + ret = GLEW_NV_framebuffer_blit; + continue; + } +#endif #ifdef GL_NV_framebuffer_mixed_samples if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_mixed_samples", 25)) { @@ -21094,6 +24887,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_framebuffer_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) + { + ret = GLEW_NV_framebuffer_multisample; + continue; + } +#endif #ifdef GL_NV_framebuffer_multisample_coverage if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32)) { @@ -21101,6 +24901,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_generate_mipmap_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap_sRGB", 20)) + { + ret = GLEW_NV_generate_mipmap_sRGB; + continue; + } +#endif #ifdef GL_NV_geometry_program4 if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17)) { @@ -21171,6 +24978,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_image_formats + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_formats", 13)) + { + ret = GLEW_NV_image_formats; + continue; + } +#endif +#ifdef GL_NV_instanced_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) + { + ret = GLEW_NV_instanced_arrays; + continue; + } +#endif #ifdef GL_NV_internalformat_sample_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"internalformat_sample_query", 27)) { @@ -21199,6 +25020,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_non_square_matrices + if (_glewStrSame3(&pos, &len, (const GLubyte*)"non_square_matrices", 19)) + { + ret = GLEW_NV_non_square_matrices; + continue; + } +#endif #ifdef GL_NV_occlusion_query if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) { @@ -21206,6 +25034,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_pack_subimage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_subimage", 13)) + { + ret = GLEW_NV_pack_subimage; + continue; + } +#endif #ifdef GL_NV_packed_depth_stencil if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) { @@ -21213,6 +25048,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12)) + { + ret = GLEW_NV_packed_float; + continue; + } +#endif +#ifdef GL_NV_packed_float_linear + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float_linear", 19)) + { + ret = GLEW_NV_packed_float_linear; + continue; + } +#endif #ifdef GL_NV_parameter_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23)) { @@ -21241,6 +25090,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_pixel_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) + { + ret = GLEW_NV_pixel_buffer_object; + continue; + } +#endif #ifdef GL_NV_pixel_data_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16)) { @@ -21248,6 +25104,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_platform_binary + if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_binary", 15)) + { + ret = GLEW_NV_platform_binary; + continue; + } +#endif #ifdef GL_NV_point_sprite if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) { @@ -21255,6 +25118,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_polygon_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_mode", 12)) + { + ret = GLEW_NV_polygon_mode; + continue; + } +#endif #ifdef GL_NV_present_video if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) { @@ -21269,6 +25139,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_read_depth + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_depth", 10)) + { + ret = GLEW_NV_read_depth; + continue; + } +#endif +#ifdef GL_NV_read_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_depth_stencil", 18)) + { + ret = GLEW_NV_read_depth_stencil; + continue; + } +#endif +#ifdef GL_NV_read_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_stencil", 12)) + { + ret = GLEW_NV_read_stencil; + continue; + } +#endif #ifdef GL_NV_register_combiners if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18)) { @@ -21290,6 +25181,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_sRGB_formats + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sRGB_formats", 12)) + { + ret = GLEW_NV_sRGB_formats; + continue; + } +#endif #ifdef GL_NV_sample_locations if (_glewStrSame3(&pos, &len, (const GLubyte*)"sample_locations", 16)) { @@ -21346,6 +25244,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_shader_noperspective_interpolation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_noperspective_interpolation", 34)) + { + ret = GLEW_NV_shader_noperspective_interpolation; + continue; + } +#endif #ifdef GL_NV_shader_storage_buffer_object if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_storage_buffer_object", 28)) { @@ -21367,6 +25272,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_shadow_samplers_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers_array", 21)) + { + ret = GLEW_NV_shadow_samplers_array; + continue; + } +#endif +#ifdef GL_NV_shadow_samplers_cube + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_samplers_cube", 20)) + { + ret = GLEW_NV_shadow_samplers_cube; + continue; + } +#endif #ifdef GL_NV_stereo_view_rendering if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_view_rendering", 21)) { @@ -21395,6 +25314,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_texture_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13)) + { + ret = GLEW_NV_texture_array; + continue; + } +#endif #ifdef GL_NV_texture_barrier if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_barrier", 15)) { @@ -21402,6 +25328,34 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_NV_texture_border_clamp; + continue; + } +#endif +#ifdef GL_NV_texture_compression_latc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24)) + { + ret = GLEW_NV_texture_compression_latc; + continue; + } +#endif +#ifdef GL_NV_texture_compression_s3tc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24)) + { + ret = GLEW_NV_texture_compression_s3tc; + continue; + } +#endif +#ifdef GL_NV_texture_compression_s3tc_update + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc_update", 31)) + { + ret = GLEW_NV_texture_compression_s3tc_update; + continue; + } +#endif #ifdef GL_NV_texture_compression_vtc if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23)) { @@ -21430,6 +25384,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_texture_npot_2D_mipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_npot_2D_mipmap", 22)) + { + ret = GLEW_NV_texture_npot_2D_mipmap; + continue; + } +#endif #ifdef GL_NV_texture_rectangle if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) { @@ -21437,6 +25398,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_texture_rectangle_compressed + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle_compressed", 28)) + { + ret = GLEW_NV_texture_rectangle_compressed; + continue; + } +#endif #ifdef GL_NV_texture_shader if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14)) { @@ -21563,6 +25531,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_NV_viewport_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array", 14)) + { + ret = GLEW_NV_viewport_array; + continue; + } +#endif #ifdef GL_NV_viewport_array2 if (_glewStrSame3(&pos, &len, (const GLubyte*)"viewport_array2", 15)) { @@ -21586,27 +25561,6 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_OES_byte_coordinates; 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_read_format - if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) - { - ret = GLEW_OES_read_format; - continue; - } -#endif -#ifdef GL_OES_single_precision - if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16)) - { - ret = GLEW_OES_single_precision; - continue; - } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) @@ -21648,6 +25602,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_OVR_multiview2; continue; } +#endif +#ifdef GL_OVR_multiview_multisampled_render_to_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_multisampled_render_to_texture", 40)) + { + ret = GLEW_OVR_multiview_multisampled_render_to_texture; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4)) @@ -21665,6 +25626,79 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_PGI_vertex_hints; continue; } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"QCOM_", 5)) + { +#ifdef GL_QCOM_alpha_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"alpha_test", 10)) + { + ret = GLEW_QCOM_alpha_test; + continue; + } +#endif +#ifdef GL_QCOM_binning_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"binning_control", 15)) + { + ret = GLEW_QCOM_binning_control; + continue; + } +#endif +#ifdef GL_QCOM_driver_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"driver_control", 14)) + { + ret = GLEW_QCOM_driver_control; + continue; + } +#endif +#ifdef GL_QCOM_extended_get + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extended_get", 12)) + { + ret = GLEW_QCOM_extended_get; + continue; + } +#endif +#ifdef GL_QCOM_extended_get2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extended_get2", 13)) + { + ret = GLEW_QCOM_extended_get2; + continue; + } +#endif +#ifdef GL_QCOM_framebuffer_foveated + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_foveated", 20)) + { + ret = GLEW_QCOM_framebuffer_foveated; + continue; + } +#endif +#ifdef GL_QCOM_perfmon_global_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"perfmon_global_mode", 19)) + { + ret = GLEW_QCOM_perfmon_global_mode; + continue; + } +#endif +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_framebuffer_fetch_noncoherent", 36)) + { + ret = GLEW_QCOM_shader_framebuffer_fetch_noncoherent; + continue; + } +#endif +#ifdef GL_QCOM_tiled_rendering + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tiled_rendering", 15)) + { + ret = GLEW_QCOM_tiled_rendering; + continue; + } +#endif +#ifdef GL_QCOM_writeonly_rendering + if (_glewStrSame3(&pos, &len, (const GLubyte*)"writeonly_rendering", 19)) + { + ret = GLEW_QCOM_writeonly_rendering; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"REGAL_", 6)) @@ -21741,6 +25775,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) { +#ifdef GL_SGIS_clip_band_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_band_hint", 14)) + { + ret = GLEW_SGIS_clip_band_hint; + continue; + } +#endif #ifdef GL_SGIS_color_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) { @@ -21769,6 +25810,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIS_line_texgen + if (_glewStrSame3(&pos, &len, (const GLubyte*)"line_texgen", 11)) + { + ret = GLEW_SGIS_line_texgen; + continue; + } +#endif #ifdef GL_SGIS_multisample if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) { @@ -21776,6 +25824,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIS_multitexture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12)) + { + ret = GLEW_SGIS_multitexture; + continue; + } +#endif #ifdef GL_SGIS_pixel_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) { @@ -21790,6 +25845,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIS_shared_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18)) + { + ret = GLEW_SGIS_shared_multisample; + continue; + } +#endif #ifdef GL_SGIS_sharpen_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15)) { @@ -21863,6 +25925,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_bali_g_instruments + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_g_instruments", 18)) + { + ret = GLEW_SGIX_bali_g_instruments; + continue; + } +#endif +#ifdef GL_SGIX_bali_r_instruments + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_r_instruments", 18)) + { + ret = GLEW_SGIX_bali_r_instruments; + continue; + } +#endif +#ifdef GL_SGIX_bali_timer_instruments + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bali_timer_instruments", 22)) + { + ret = GLEW_SGIX_bali_timer_instruments; + continue; + } +#endif #ifdef GL_SGIX_blend_alpha_minmax if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18)) { @@ -21870,6 +25953,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_blend_cadd + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_cadd", 10)) + { + ret = GLEW_SGIX_blend_cadd; + continue; + } +#endif +#ifdef GL_SGIX_blend_cmultiply + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_cmultiply", 15)) + { + ret = GLEW_SGIX_blend_cmultiply; + continue; + } +#endif +#ifdef GL_SGIX_calligraphic_fragment + if (_glewStrSame3(&pos, &len, (const GLubyte*)"calligraphic_fragment", 21)) + { + ret = GLEW_SGIX_calligraphic_fragment; + continue; + } +#endif #ifdef GL_SGIX_clipmap if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7)) { @@ -21877,6 +25981,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_color_matrix_accuracy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix_accuracy", 21)) + { + ret = GLEW_SGIX_color_matrix_accuracy; + continue; + } +#endif +#ifdef GL_SGIX_color_table_index_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table_index_mode", 22)) + { + ret = GLEW_SGIX_color_table_index_mode; + continue; + } +#endif +#ifdef GL_SGIX_complex_polar + if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex_polar", 13)) + { + ret = GLEW_SGIX_complex_polar; + continue; + } +#endif #ifdef GL_SGIX_convolution_accuracy if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20)) { @@ -21884,6 +26009,41 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cube_map", 8)) + { + ret = GLEW_SGIX_cube_map; + continue; + } +#endif +#ifdef GL_SGIX_cylinder_texgen + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cylinder_texgen", 15)) + { + ret = GLEW_SGIX_cylinder_texgen; + continue; + } +#endif +#ifdef GL_SGIX_datapipe + if (_glewStrSame3(&pos, &len, (const GLubyte*)"datapipe", 8)) + { + ret = GLEW_SGIX_datapipe; + continue; + } +#endif +#ifdef GL_SGIX_decimation + if (_glewStrSame3(&pos, &len, (const GLubyte*)"decimation", 10)) + { + ret = GLEW_SGIX_decimation; + continue; + } +#endif +#ifdef GL_SGIX_depth_pass_instrument + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_pass_instrument", 21)) + { + ret = GLEW_SGIX_depth_pass_instrument; + continue; + } +#endif #ifdef GL_SGIX_depth_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) { @@ -21891,6 +26051,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_dvc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"dvc", 3)) + { + ret = GLEW_SGIX_dvc; + continue; + } +#endif #ifdef GL_SGIX_flush_raster if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12)) { @@ -21898,6 +26065,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_fog_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_blend", 9)) + { + ret = GLEW_SGIX_fog_blend; + continue; + } +#endif +#ifdef GL_SGIX_fog_factor_to_alpha + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_factor_to_alpha", 19)) + { + ret = GLEW_SGIX_fog_factor_to_alpha; + continue; + } +#endif +#ifdef GL_SGIX_fog_layers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_layers", 10)) + { + ret = GLEW_SGIX_fog_layers; + continue; + } +#endif #ifdef GL_SGIX_fog_offset if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10)) { @@ -21905,6 +26093,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_fog_patchy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_patchy", 10)) + { + ret = GLEW_SGIX_fog_patchy; + continue; + } +#endif +#ifdef GL_SGIX_fog_scale + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_scale", 9)) + { + ret = GLEW_SGIX_fog_scale; + continue; + } +#endif #ifdef GL_SGIX_fog_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11)) { @@ -21912,6 +26114,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_fragment_lighting_space + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting_space", 23)) + { + ret = GLEW_SGIX_fragment_lighting_space; + continue; + } +#endif #ifdef GL_SGIX_fragment_specular_lighting if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26)) { @@ -21919,6 +26128,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_fragments_instrument + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragments_instrument", 20)) + { + ret = GLEW_SGIX_fragments_instrument; + continue; + } +#endif #ifdef GL_SGIX_framezoom if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9)) { @@ -21926,6 +26142,41 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_icc_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"icc_texture", 11)) + { + ret = GLEW_SGIX_icc_texture; + continue; + } +#endif +#ifdef GL_SGIX_igloo_interface + if (_glewStrSame3(&pos, &len, (const GLubyte*)"igloo_interface", 15)) + { + ret = GLEW_SGIX_igloo_interface; + continue; + } +#endif +#ifdef GL_SGIX_image_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_compression", 17)) + { + ret = GLEW_SGIX_image_compression; + continue; + } +#endif +#ifdef GL_SGIX_impact_pixel_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"impact_pixel_texture", 20)) + { + ret = GLEW_SGIX_impact_pixel_texture; + continue; + } +#endif +#ifdef GL_SGIX_instrument_error + if (_glewStrSame3(&pos, &len, (const GLubyte*)"instrument_error", 16)) + { + ret = GLEW_SGIX_instrument_error; + continue; + } +#endif #ifdef GL_SGIX_interlace if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) { @@ -21940,6 +26191,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_line_quality_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"line_quality_hint", 17)) + { + ret = GLEW_SGIX_line_quality_hint; + continue; + } +#endif #ifdef GL_SGIX_list_priority if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13)) { @@ -21947,6 +26205,48 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_mpeg1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mpeg1", 5)) + { + ret = GLEW_SGIX_mpeg1; + continue; + } +#endif +#ifdef GL_SGIX_mpeg2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mpeg2", 5)) + { + ret = GLEW_SGIX_mpeg2; + continue; + } +#endif +#ifdef GL_SGIX_nonlinear_lighting_pervertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"nonlinear_lighting_pervertex", 28)) + { + ret = GLEW_SGIX_nonlinear_lighting_pervertex; + continue; + } +#endif +#ifdef GL_SGIX_nurbs_eval + if (_glewStrSame3(&pos, &len, (const GLubyte*)"nurbs_eval", 10)) + { + ret = GLEW_SGIX_nurbs_eval; + continue; + } +#endif +#ifdef GL_SGIX_occlusion_instrument + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_instrument", 20)) + { + ret = GLEW_SGIX_occlusion_instrument; + continue; + } +#endif +#ifdef GL_SGIX_packed_6bytes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_6bytes", 13)) + { + ret = GLEW_SGIX_packed_6bytes; + continue; + } +#endif #ifdef GL_SGIX_pixel_texture if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) { @@ -21961,6 +26261,34 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_pixel_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_lod", 17)) + { + ret = GLEW_SGIX_pixel_texture_lod; + continue; + } +#endif +#ifdef GL_SGIX_pixel_tiles + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_tiles", 11)) + { + ret = GLEW_SGIX_pixel_tiles; + continue; + } +#endif +#ifdef GL_SGIX_polynomial_ffd + if (_glewStrSame3(&pos, &len, (const GLubyte*)"polynomial_ffd", 14)) + { + ret = GLEW_SGIX_polynomial_ffd; + continue; + } +#endif +#ifdef GL_SGIX_quad_mesh + if (_glewStrSame3(&pos, &len, (const GLubyte*)"quad_mesh", 9)) + { + ret = GLEW_SGIX_quad_mesh; + continue; + } +#endif #ifdef GL_SGIX_reference_plane if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15)) { @@ -21975,6 +26303,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_scalebias_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scalebias_hint", 14)) + { + ret = GLEW_SGIX_scalebias_hint; + continue; + } +#endif #ifdef GL_SGIX_shadow if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) { @@ -21989,6 +26324,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_slim + if (_glewStrSame3(&pos, &len, (const GLubyte*)"slim", 4)) + { + ret = GLEW_SGIX_slim; + continue; + } +#endif +#ifdef GL_SGIX_spotlight_cutoff + if (_glewStrSame3(&pos, &len, (const GLubyte*)"spotlight_cutoff", 16)) + { + ret = GLEW_SGIX_spotlight_cutoff; + continue; + } +#endif #ifdef GL_SGIX_sprite if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6)) { @@ -21996,6 +26345,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_subdiv_patch + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subdiv_patch", 12)) + { + ret = GLEW_SGIX_subdiv_patch; + continue; + } +#endif +#ifdef GL_SGIX_subsample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9)) + { + ret = GLEW_SGIX_subsample; + continue; + } +#endif #ifdef GL_SGIX_tag_sample_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17)) { @@ -22024,6 +26387,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_texture_mipmap_anisotropic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mipmap_anisotropic", 26)) + { + ret = GLEW_SGIX_texture_mipmap_anisotropic; + continue; + } +#endif #ifdef GL_SGIX_texture_multi_buffer if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20)) { @@ -22031,6 +26401,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_texture_phase + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_phase", 13)) + { + ret = GLEW_SGIX_texture_phase; + continue; + } +#endif #ifdef GL_SGIX_texture_range if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) { @@ -22045,6 +26422,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGIX_texture_supersample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_supersample", 19)) + { + ret = GLEW_SGIX_texture_supersample; + continue; + } +#endif +#ifdef GL_SGIX_vector_ops + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vector_ops", 10)) + { + ret = GLEW_SGIX_vector_ops; + continue; + } +#endif +#ifdef GL_SGIX_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_SGIX_vertex_array_object; + continue; + } +#endif #ifdef GL_SGIX_vertex_preclip if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14)) { @@ -22065,6 +26463,20 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) ret = GLEW_SGIX_ycrcb; continue; } +#endif +#ifdef GL_SGIX_ycrcb_subsample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb_subsample", 15)) + { + ret = GLEW_SGIX_ycrcb_subsample; + continue; + } +#endif +#ifdef GL_SGIX_ycrcba + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcba", 6)) + { + ret = GLEW_SGIX_ycrcba; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) @@ -22083,6 +26495,27 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_SGI_complex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex", 7)) + { + ret = GLEW_SGI_complex; + continue; + } +#endif +#ifdef GL_SGI_complex_type + if (_glewStrSame3(&pos, &len, (const GLubyte*)"complex_type", 12)) + { + ret = GLEW_SGI_complex_type; + continue; + } +#endif +#ifdef GL_SGI_fft + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fft", 3)) + { + ret = GLEW_SGI_fft; + continue; + } +#endif #ifdef GL_SGI_texture_color_table if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19)) { @@ -22162,6 +26595,13 @@ GLboolean GLEWAPIENTRY glewIsSupported (const char* name) continue; } #endif +#ifdef GL_WIN_scene_markerXXX + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_markerXXX", 15)) + { + ret = GLEW_WIN_scene_markerXXX; + continue; + } +#endif #ifdef GL_WIN_specular_fog if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12)) { @@ -22247,6 +26687,13 @@ GLboolean GLEWAPIENTRY wglewIsSupported (const char* name) continue; } #endif +#ifdef WGL_ARB_create_context_no_error + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_no_error", 23)) + { + ret = WGLEW_ARB_create_context_no_error; + continue; + } +#endif #ifdef WGL_ARB_create_context_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) { @@ -22351,6 +26798,13 @@ GLboolean GLEWAPIENTRY wglewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) { +#ifdef WGL_EXT_colorspace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"colorspace", 10)) + { + ret = WGLEW_EXT_colorspace; + continue; + } +#endif #ifdef WGL_EXT_create_context_es2_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_es2_profile", 26)) { @@ -22676,6 +27130,13 @@ GLboolean glxewIsSupported (const char* name) continue; } #endif +#ifdef GLX_ARB_create_context_no_error + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_no_error", 23)) + { + ret = GLXEW_ARB_create_context_no_error; + continue; + } +#endif #ifdef GLX_ARB_create_context_profile if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context_profile", 22)) { @@ -23309,6 +27770,13 @@ GLboolean eglewIsSupported (const char* name) } if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARM_", 4)) { +#ifdef EGL_ARM_implicit_external_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"implicit_external_sync", 22)) + { + ret = EGLEW_ARM_implicit_external_sync; + continue; + } +#endif #ifdef EGL_ARM_pixmap_multisample_discard if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_multisample_discard", 26)) { @@ -23375,6 +27843,27 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_gl_colorspace_bt2020_linear + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_linear", 27)) + { + ret = EGLEW_EXT_gl_colorspace_bt2020_linear; + continue; + } +#endif +#ifdef EGL_EXT_gl_colorspace_bt2020_pq + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_bt2020_pq", 23)) + { + ret = EGLEW_EXT_gl_colorspace_bt2020_pq; + continue; + } +#endif +#ifdef EGL_EXT_gl_colorspace_scrgb_linear + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gl_colorspace_scrgb_linear", 26)) + { + ret = EGLEW_EXT_gl_colorspace_scrgb_linear; + continue; + } +#endif #ifdef EGL_EXT_image_dma_buf_import if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_dma_buf_import", 20)) { @@ -23382,6 +27871,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_image_dma_buf_import_modifiers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_dma_buf_import_modifiers", 30)) + { + ret = EGLEW_EXT_image_dma_buf_import_modifiers; + continue; + } +#endif #ifdef EGL_EXT_multiview_window if (_glewStrSame3(&pos, &len, (const GLubyte*)"multiview_window", 16)) { @@ -23410,6 +27906,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = EGLEW_EXT_pixel_format_float; + continue; + } +#endif #ifdef EGL_EXT_platform_base if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_base", 13)) { @@ -23459,6 +27962,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_EXT_surface_SMPTE2086_metadata + if (_glewStrSame3(&pos, &len, (const GLubyte*)"surface_SMPTE2086_metadata", 26)) + { + ret = EGLEW_EXT_surface_SMPTE2086_metadata; + continue; + } +#endif #ifdef EGL_EXT_swap_buffers_with_damage if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_buffers_with_damage", 24)) { @@ -23538,6 +28048,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_KHR_context_flush_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"context_flush_control", 21)) + { + ret = EGLEW_KHR_context_flush_control; + continue; + } +#endif #ifdef EGL_KHR_create_context if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) { @@ -23657,6 +28174,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_KHR_no_config_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"no_config_context", 17)) + { + ret = EGLEW_KHR_no_config_context; + continue; + } +#endif #ifdef EGL_KHR_partial_update if (_glewStrSame3(&pos, &len, (const GLubyte*)"partial_update", 14)) { @@ -23706,6 +28230,13 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_KHR_stream_attrib + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_attrib", 13)) + { + ret = EGLEW_KHR_stream_attrib; + continue; + } +#endif #ifdef EGL_KHR_stream_consumer_gltexture if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_consumer_gltexture", 25)) { @@ -23792,6 +28323,13 @@ GLboolean eglewIsSupported (const char* name) ret = EGLEW_MESA_platform_gbm; continue; } +#endif +#ifdef EGL_MESA_platform_surfaceless + if (_glewStrSame3(&pos, &len, (const GLubyte*)"platform_surfaceless", 20)) + { + ret = EGLEW_MESA_platform_surfaceless; + continue; + } #endif } if (_glewStrSame2(&pos, &len, (const GLubyte*)"NOK_", 4)) @@ -23897,6 +28435,62 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_NV_stream_cross_display + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_display", 20)) + { + ret = EGLEW_NV_stream_cross_display; + continue; + } +#endif +#ifdef EGL_NV_stream_cross_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_object", 19)) + { + ret = EGLEW_NV_stream_cross_object; + continue; + } +#endif +#ifdef EGL_NV_stream_cross_partition + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_partition", 22)) + { + ret = EGLEW_NV_stream_cross_partition; + continue; + } +#endif +#ifdef EGL_NV_stream_cross_process + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_process", 20)) + { + ret = EGLEW_NV_stream_cross_process; + continue; + } +#endif +#ifdef EGL_NV_stream_cross_system + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_cross_system", 19)) + { + ret = EGLEW_NV_stream_cross_system; + continue; + } +#endif +#ifdef EGL_NV_stream_fifo_next + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_fifo_next", 16)) + { + ret = EGLEW_NV_stream_fifo_next; + continue; + } +#endif +#ifdef EGL_NV_stream_fifo_synchronous + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_fifo_synchronous", 23)) + { + ret = EGLEW_NV_stream_fifo_synchronous; + continue; + } +#endif +#ifdef EGL_NV_stream_frame_limits + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_frame_limits", 19)) + { + ret = EGLEW_NV_stream_frame_limits; + continue; + } +#endif #ifdef EGL_NV_stream_metadata if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_metadata", 15)) { @@ -23904,6 +28498,41 @@ GLboolean eglewIsSupported (const char* name) continue; } #endif +#ifdef EGL_NV_stream_remote + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_remote", 13)) + { + ret = EGLEW_NV_stream_remote; + continue; + } +#endif +#ifdef EGL_NV_stream_reset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_reset", 12)) + { + ret = EGLEW_NV_stream_reset; + continue; + } +#endif +#ifdef EGL_NV_stream_socket + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket", 13)) + { + ret = EGLEW_NV_stream_socket; + continue; + } +#endif +#ifdef EGL_NV_stream_socket_inet + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket_inet", 18)) + { + ret = EGLEW_NV_stream_socket_inet; + continue; + } +#endif +#ifdef EGL_NV_stream_socket_unix + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_socket_unix", 18)) + { + ret = EGLEW_NV_stream_socket_unix; + continue; + } +#endif #ifdef EGL_NV_stream_sync if (_glewStrSame3(&pos, &len, (const GLubyte*)"stream_sync", 11)) { diff --git a/src/glewinfo.c b/src/glewinfo.c index 046a6b8..882654d 100755 --- a/src/glewinfo.c +++ b/src/glewinfo.c @@ -1,6 +1,6 @@ /* ** The OpenGL Extension Wrangler Library -** Copyright (C) 2008-2015, Nigel Stewart +** Copyright (C) 2008-2017, Nigel Stewart ** Copyright (C) 2002-2008, Milan Ikits ** Copyright (C) 2002-2008, Marcelo E. Magallon ** Copyright (C) 2002, Lev Povalahev @@ -571,6 +571,19 @@ static void _glewInfo_GL_VERSION_4_5 (void) #endif /* GL_VERSION_4_5 */ +#ifdef GL_VERSION_4_6 + +static void _glewInfo_GL_VERSION_4_6 (void) +{ + glewPrintExt("GL_VERSION_4_6", GLEW_VERSION_4_6, GLEW_VERSION_4_6, GLEW_VERSION_4_6); + + glewInfoFunc("glMultiDrawArraysIndirectCount", glMultiDrawArraysIndirectCount == NULL); + glewInfoFunc("glMultiDrawElementsIndirectCount", glMultiDrawElementsIndirectCount == NULL); + glewInfoFunc("glSpecializeShader", glSpecializeShader == NULL); +} + +#endif /* GL_VERSION_4_6 */ + #ifdef GL_3DFX_multisample static void _glewInfo_GL_3DFX_multisample (void) @@ -609,6 +622,24 @@ static void _glewInfo_GL_AMD_blend_minmax_factor (void) #endif /* GL_AMD_blend_minmax_factor */ +#ifdef GL_AMD_compressed_3DC_texture + +static void _glewInfo_GL_AMD_compressed_3DC_texture (void) +{ + glewPrintExt("GL_AMD_compressed_3DC_texture", GLEW_AMD_compressed_3DC_texture, glewIsSupported("GL_AMD_compressed_3DC_texture"), glewGetExtension("GL_AMD_compressed_3DC_texture")); +} + +#endif /* GL_AMD_compressed_3DC_texture */ + +#ifdef GL_AMD_compressed_ATC_texture + +static void _glewInfo_GL_AMD_compressed_ATC_texture (void) +{ + glewPrintExt("GL_AMD_compressed_ATC_texture", GLEW_AMD_compressed_ATC_texture, glewIsSupported("GL_AMD_compressed_ATC_texture"), glewGetExtension("GL_AMD_compressed_ATC_texture")); +} + +#endif /* GL_AMD_compressed_ATC_texture */ + #ifdef GL_AMD_conservative_depth static void _glewInfo_GL_AMD_conservative_depth (void) @@ -655,6 +686,20 @@ static void _glewInfo_GL_AMD_draw_buffers_blend (void) #endif /* GL_AMD_draw_buffers_blend */ +#ifdef GL_AMD_framebuffer_sample_positions + +static void _glewInfo_GL_AMD_framebuffer_sample_positions (void) +{ + glewPrintExt("GL_AMD_framebuffer_sample_positions", GLEW_AMD_framebuffer_sample_positions, glewIsSupported("GL_AMD_framebuffer_sample_positions"), glewGetExtension("GL_AMD_framebuffer_sample_positions")); + + glewInfoFunc("glFramebufferSamplePositionsfvAMD", glFramebufferSamplePositionsfvAMD == NULL); + glewInfoFunc("glGetFramebufferParameterfvAMD", glGetFramebufferParameterfvAMD == NULL); + glewInfoFunc("glGetNamedFramebufferParameterfvAMD", glGetNamedFramebufferParameterfvAMD == NULL); + glewInfoFunc("glNamedFramebufferSamplePositionsfvAMD", glNamedFramebufferSamplePositionsfvAMD == NULL); +} + +#endif /* GL_AMD_framebuffer_sample_positions */ + #ifdef GL_AMD_gcn_shader static void _glewInfo_GL_AMD_gcn_shader (void) @@ -664,6 +709,24 @@ static void _glewInfo_GL_AMD_gcn_shader (void) #endif /* GL_AMD_gcn_shader */ +#ifdef GL_AMD_gpu_shader_half_float + +static void _glewInfo_GL_AMD_gpu_shader_half_float (void) +{ + glewPrintExt("GL_AMD_gpu_shader_half_float", GLEW_AMD_gpu_shader_half_float, glewIsSupported("GL_AMD_gpu_shader_half_float"), glewGetExtension("GL_AMD_gpu_shader_half_float")); +} + +#endif /* GL_AMD_gpu_shader_half_float */ + +#ifdef GL_AMD_gpu_shader_int16 + +static void _glewInfo_GL_AMD_gpu_shader_int16 (void) +{ + glewPrintExt("GL_AMD_gpu_shader_int16", GLEW_AMD_gpu_shader_int16, glewIsSupported("GL_AMD_gpu_shader_int16"), glewGetExtension("GL_AMD_gpu_shader_int16")); +} + +#endif /* GL_AMD_gpu_shader_int16 */ + #ifdef GL_AMD_gpu_shader_int64 static void _glewInfo_GL_AMD_gpu_shader_int64 (void) @@ -750,6 +813,15 @@ static void _glewInfo_GL_AMD_pinned_memory (void) #endif /* GL_AMD_pinned_memory */ +#ifdef GL_AMD_program_binary_Z400 + +static void _glewInfo_GL_AMD_program_binary_Z400 (void) +{ + glewPrintExt("GL_AMD_program_binary_Z400", GLEW_AMD_program_binary_Z400, glewIsSupported("GL_AMD_program_binary_Z400"), glewGetExtension("GL_AMD_program_binary_Z400")); +} + +#endif /* GL_AMD_program_binary_Z400 */ + #ifdef GL_AMD_query_buffer_object static void _glewInfo_GL_AMD_query_buffer_object (void) @@ -788,6 +860,15 @@ static void _glewInfo_GL_AMD_shader_atomic_counter_ops (void) #endif /* GL_AMD_shader_atomic_counter_ops */ +#ifdef GL_AMD_shader_ballot + +static void _glewInfo_GL_AMD_shader_ballot (void) +{ + glewPrintExt("GL_AMD_shader_ballot", GLEW_AMD_shader_ballot, glewIsSupported("GL_AMD_shader_ballot"), glewGetExtension("GL_AMD_shader_ballot")); +} + +#endif /* GL_AMD_shader_ballot */ + #ifdef GL_AMD_shader_explicit_vertex_parameter static void _glewInfo_GL_AMD_shader_explicit_vertex_parameter (void) @@ -847,6 +928,15 @@ static void _glewInfo_GL_AMD_stencil_operation_extended (void) #endif /* GL_AMD_stencil_operation_extended */ +#ifdef GL_AMD_texture_gather_bias_lod + +static void _glewInfo_GL_AMD_texture_gather_bias_lod (void) +{ + glewPrintExt("GL_AMD_texture_gather_bias_lod", GLEW_AMD_texture_gather_bias_lod, glewIsSupported("GL_AMD_texture_gather_bias_lod"), glewGetExtension("GL_AMD_texture_gather_bias_lod")); +} + +#endif /* GL_AMD_texture_gather_bias_lod */ + #ifdef GL_AMD_texture_texture4 static void _glewInfo_GL_AMD_texture_texture4 (void) @@ -904,6 +994,15 @@ static void _glewInfo_GL_AMD_vertex_shader_viewport_index (void) #endif /* GL_AMD_vertex_shader_viewport_index */ +#ifdef GL_ANDROID_extension_pack_es31a + +static void _glewInfo_GL_ANDROID_extension_pack_es31a (void) +{ + glewPrintExt("GL_ANDROID_extension_pack_es31a", GLEW_ANDROID_extension_pack_es31a, glewIsSupported("GL_ANDROID_extension_pack_es31a"), glewGetExtension("GL_ANDROID_extension_pack_es31a")); +} + +#endif /* GL_ANDROID_extension_pack_es31a */ + #ifdef GL_ANGLE_depth_texture static void _glewInfo_GL_ANGLE_depth_texture (void) @@ -1052,6 +1151,35 @@ static void _glewInfo_GL_APPLE_client_storage (void) #endif /* GL_APPLE_client_storage */ +#ifdef GL_APPLE_clip_distance + +static void _glewInfo_GL_APPLE_clip_distance (void) +{ + glewPrintExt("GL_APPLE_clip_distance", GLEW_APPLE_clip_distance, glewIsSupported("GL_APPLE_clip_distance"), glewGetExtension("GL_APPLE_clip_distance")); +} + +#endif /* GL_APPLE_clip_distance */ + +#ifdef GL_APPLE_color_buffer_packed_float + +static void _glewInfo_GL_APPLE_color_buffer_packed_float (void) +{ + glewPrintExt("GL_APPLE_color_buffer_packed_float", GLEW_APPLE_color_buffer_packed_float, glewIsSupported("GL_APPLE_color_buffer_packed_float"), glewGetExtension("GL_APPLE_color_buffer_packed_float")); +} + +#endif /* GL_APPLE_color_buffer_packed_float */ + +#ifdef GL_APPLE_copy_texture_levels + +static void _glewInfo_GL_APPLE_copy_texture_levels (void) +{ + glewPrintExt("GL_APPLE_copy_texture_levels", GLEW_APPLE_copy_texture_levels, glewIsSupported("GL_APPLE_copy_texture_levels"), glewGetExtension("GL_APPLE_copy_texture_levels")); + + glewInfoFunc("glCopyTextureLevelsAPPLE", glCopyTextureLevelsAPPLE == NULL); +} + +#endif /* GL_APPLE_copy_texture_levels */ + #ifdef GL_APPLE_element_array static void _glewInfo_GL_APPLE_element_array (void) @@ -1106,6 +1234,18 @@ static void _glewInfo_GL_APPLE_flush_buffer_range (void) #endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_framebuffer_multisample + +static void _glewInfo_GL_APPLE_framebuffer_multisample (void) +{ + glewPrintExt("GL_APPLE_framebuffer_multisample", GLEW_APPLE_framebuffer_multisample, glewIsSupported("GL_APPLE_framebuffer_multisample"), glewGetExtension("GL_APPLE_framebuffer_multisample")); + + glewInfoFunc("glRenderbufferStorageMultisampleAPPLE", glRenderbufferStorageMultisampleAPPLE == NULL); + glewInfoFunc("glResolveMultisampleFramebufferAPPLE", glResolveMultisampleFramebufferAPPLE == NULL); +} + +#endif /* GL_APPLE_framebuffer_multisample */ + #ifdef GL_APPLE_object_purgeable static void _glewInfo_GL_APPLE_object_purgeable (void) @@ -1155,6 +1295,59 @@ static void _glewInfo_GL_APPLE_specular_vector (void) #endif /* GL_APPLE_specular_vector */ +#ifdef GL_APPLE_sync + +static void _glewInfo_GL_APPLE_sync (void) +{ + glewPrintExt("GL_APPLE_sync", GLEW_APPLE_sync, glewIsSupported("GL_APPLE_sync"), glewGetExtension("GL_APPLE_sync")); + + glewInfoFunc("glClientWaitSyncAPPLE", glClientWaitSyncAPPLE == NULL); + glewInfoFunc("glDeleteSyncAPPLE", glDeleteSyncAPPLE == NULL); + glewInfoFunc("glFenceSyncAPPLE", glFenceSyncAPPLE == NULL); + glewInfoFunc("glGetInteger64vAPPLE", glGetInteger64vAPPLE == NULL); + glewInfoFunc("glGetSyncivAPPLE", glGetSyncivAPPLE == NULL); + glewInfoFunc("glIsSyncAPPLE", glIsSyncAPPLE == NULL); + glewInfoFunc("glWaitSyncAPPLE", glWaitSyncAPPLE == NULL); +} + +#endif /* GL_APPLE_sync */ + +#ifdef GL_APPLE_texture_2D_limited_npot + +static void _glewInfo_GL_APPLE_texture_2D_limited_npot (void) +{ + glewPrintExt("GL_APPLE_texture_2D_limited_npot", GLEW_APPLE_texture_2D_limited_npot, glewIsSupported("GL_APPLE_texture_2D_limited_npot"), glewGetExtension("GL_APPLE_texture_2D_limited_npot")); +} + +#endif /* GL_APPLE_texture_2D_limited_npot */ + +#ifdef GL_APPLE_texture_format_BGRA8888 + +static void _glewInfo_GL_APPLE_texture_format_BGRA8888 (void) +{ + glewPrintExt("GL_APPLE_texture_format_BGRA8888", GLEW_APPLE_texture_format_BGRA8888, glewIsSupported("GL_APPLE_texture_format_BGRA8888"), glewGetExtension("GL_APPLE_texture_format_BGRA8888")); +} + +#endif /* GL_APPLE_texture_format_BGRA8888 */ + +#ifdef GL_APPLE_texture_max_level + +static void _glewInfo_GL_APPLE_texture_max_level (void) +{ + glewPrintExt("GL_APPLE_texture_max_level", GLEW_APPLE_texture_max_level, glewIsSupported("GL_APPLE_texture_max_level"), glewGetExtension("GL_APPLE_texture_max_level")); +} + +#endif /* GL_APPLE_texture_max_level */ + +#ifdef GL_APPLE_texture_packed_float + +static void _glewInfo_GL_APPLE_texture_packed_float (void) +{ + glewPrintExt("GL_APPLE_texture_packed_float", GLEW_APPLE_texture_packed_float, glewIsSupported("GL_APPLE_texture_packed_float"), glewGetExtension("GL_APPLE_texture_packed_float")); +} + +#endif /* GL_APPLE_texture_packed_float */ + #ifdef GL_APPLE_texture_range static void _glewInfo_GL_APPLE_texture_range (void) @@ -1342,7 +1535,6 @@ static void _glewInfo_GL_ARB_buffer_storage (void) glewPrintExt("GL_ARB_buffer_storage", GLEW_ARB_buffer_storage, glewIsSupported("GL_ARB_buffer_storage"), glewGetExtension("GL_ARB_buffer_storage")); glewInfoFunc("glBufferStorage", glBufferStorage == NULL); - glewInfoFunc("glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL); } #endif /* GL_ARB_buffer_storage */ @@ -2300,6 +2492,17 @@ static void _glewInfo_GL_ARB_point_sprite (void) #endif /* GL_ARB_point_sprite */ +#ifdef GL_ARB_polygon_offset_clamp + +static void _glewInfo_GL_ARB_polygon_offset_clamp (void) +{ + glewPrintExt("GL_ARB_polygon_offset_clamp", GLEW_ARB_polygon_offset_clamp, glewIsSupported("GL_ARB_polygon_offset_clamp"), glewGetExtension("GL_ARB_polygon_offset_clamp")); + + glewInfoFunc("glPolygonOffsetClamp", glPolygonOffsetClamp == NULL); +} + +#endif /* GL_ARB_polygon_offset_clamp */ + #ifdef GL_ARB_post_depth_coverage static void _glewInfo_GL_ARB_post_depth_coverage (void) @@ -2825,7 +3028,6 @@ static void _glewInfo_GL_ARB_sparse_texture (void) glewPrintExt("GL_ARB_sparse_texture", GLEW_ARB_sparse_texture, glewIsSupported("GL_ARB_sparse_texture"), glewGetExtension("GL_ARB_sparse_texture")); glewInfoFunc("glTexPageCommitmentARB", glTexPageCommitmentARB == NULL); - glewInfoFunc("glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL); } #endif /* GL_ARB_sparse_texture */ @@ -2848,6 +3050,15 @@ static void _glewInfo_GL_ARB_sparse_texture_clamp (void) #endif /* GL_ARB_sparse_texture_clamp */ +#ifdef GL_ARB_spirv_extensions + +static void _glewInfo_GL_ARB_spirv_extensions (void) +{ + glewPrintExt("GL_ARB_spirv_extensions", GLEW_ARB_spirv_extensions, glewIsSupported("GL_ARB_spirv_extensions"), glewGetExtension("GL_ARB_spirv_extensions")); +} + +#endif /* GL_ARB_spirv_extensions */ + #ifdef GL_ARB_stencil_texturing static void _glewInfo_GL_ARB_stencil_texturing (void) @@ -3027,6 +3238,15 @@ static void _glewInfo_GL_ARB_texture_env_dot3 (void) #endif /* GL_ARB_texture_env_dot3 */ +#ifdef GL_ARB_texture_filter_anisotropic + +static void _glewInfo_GL_ARB_texture_filter_anisotropic (void) +{ + glewPrintExt("GL_ARB_texture_filter_anisotropic", GLEW_ARB_texture_filter_anisotropic, glewIsSupported("GL_ARB_texture_filter_anisotropic"), glewGetExtension("GL_ARB_texture_filter_anisotropic")); +} + +#endif /* GL_ARB_texture_filter_anisotropic */ + #ifdef GL_ARB_texture_filter_minmax static void _glewInfo_GL_ARB_texture_filter_minmax (void) @@ -3158,9 +3378,6 @@ static void _glewInfo_GL_ARB_texture_storage (void) glewInfoFunc("glTexStorage1D", glTexStorage1D == NULL); glewInfoFunc("glTexStorage2D", glTexStorage2D == NULL); glewInfoFunc("glTexStorage3D", glTexStorage3D == NULL); - glewInfoFunc("glTextureStorage1DEXT", glTextureStorage1DEXT == NULL); - glewInfoFunc("glTextureStorage2DEXT", glTextureStorage2DEXT == NULL); - glewInfoFunc("glTextureStorage3DEXT", glTextureStorage3DEXT == NULL); } #endif /* GL_ARB_texture_storage */ @@ -3592,6 +3809,51 @@ static void _glewInfo_GL_ARB_window_pos (void) #endif /* GL_ARB_window_pos */ +#ifdef GL_ARM_mali_program_binary + +static void _glewInfo_GL_ARM_mali_program_binary (void) +{ + glewPrintExt("GL_ARM_mali_program_binary", GLEW_ARM_mali_program_binary, glewIsSupported("GL_ARM_mali_program_binary"), glewGetExtension("GL_ARM_mali_program_binary")); +} + +#endif /* GL_ARM_mali_program_binary */ + +#ifdef GL_ARM_mali_shader_binary + +static void _glewInfo_GL_ARM_mali_shader_binary (void) +{ + glewPrintExt("GL_ARM_mali_shader_binary", GLEW_ARM_mali_shader_binary, glewIsSupported("GL_ARM_mali_shader_binary"), glewGetExtension("GL_ARM_mali_shader_binary")); +} + +#endif /* GL_ARM_mali_shader_binary */ + +#ifdef GL_ARM_rgba8 + +static void _glewInfo_GL_ARM_rgba8 (void) +{ + glewPrintExt("GL_ARM_rgba8", GLEW_ARM_rgba8, glewIsSupported("GL_ARM_rgba8"), glewGetExtension("GL_ARM_rgba8")); +} + +#endif /* GL_ARM_rgba8 */ + +#ifdef GL_ARM_shader_framebuffer_fetch + +static void _glewInfo_GL_ARM_shader_framebuffer_fetch (void) +{ + glewPrintExt("GL_ARM_shader_framebuffer_fetch", GLEW_ARM_shader_framebuffer_fetch, glewIsSupported("GL_ARM_shader_framebuffer_fetch"), glewGetExtension("GL_ARM_shader_framebuffer_fetch")); +} + +#endif /* GL_ARM_shader_framebuffer_fetch */ + +#ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil + +static void _glewInfo_GL_ARM_shader_framebuffer_fetch_depth_stencil (void) +{ + glewPrintExt("GL_ARM_shader_framebuffer_fetch_depth_stencil", GLEW_ARM_shader_framebuffer_fetch_depth_stencil, glewIsSupported("GL_ARM_shader_framebuffer_fetch_depth_stencil"), glewGetExtension("GL_ARM_shader_framebuffer_fetch_depth_stencil")); +} + +#endif /* GL_ARM_shader_framebuffer_fetch_depth_stencil */ + #ifdef GL_ATIX_point_sprites static void _glewInfo_GL_ATIX_point_sprites (void) @@ -3879,6 +4141,15 @@ static void _glewInfo_GL_ATI_vertex_streams (void) #endif /* GL_ATI_vertex_streams */ +#ifdef GL_EGL_KHR_context_flush_control + +static void _glewInfo_GL_EGL_KHR_context_flush_control (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")); +} + +#endif /* GL_EGL_KHR_context_flush_control */ + #ifdef GL_EGL_NV_robustness_video_memory_purge static void _glewInfo_GL_EGL_NV_robustness_video_memory_purge (void) @@ -3906,6 +4177,24 @@ static void _glewInfo_GL_EXT_Cg_shader (void) #endif /* GL_EXT_Cg_shader */ +#ifdef GL_EXT_EGL_image_array + +static void _glewInfo_GL_EXT_EGL_image_array (void) +{ + glewPrintExt("GL_EXT_EGL_image_array", GLEW_EXT_EGL_image_array, glewIsSupported("GL_EXT_EGL_image_array"), glewGetExtension("GL_EXT_EGL_image_array")); +} + +#endif /* GL_EXT_EGL_image_array */ + +#ifdef GL_EXT_YUV_target + +static void _glewInfo_GL_EXT_YUV_target (void) +{ + glewPrintExt("GL_EXT_YUV_target", GLEW_EXT_YUV_target, glewIsSupported("GL_EXT_YUV_target"), glewGetExtension("GL_EXT_YUV_target")); +} + +#endif /* GL_EXT_YUV_target */ + #ifdef GL_EXT_abgr static void _glewInfo_GL_EXT_abgr (void) @@ -3915,6 +4204,19 @@ static void _glewInfo_GL_EXT_abgr (void) #endif /* GL_EXT_abgr */ +#ifdef GL_EXT_base_instance + +static void _glewInfo_GL_EXT_base_instance (void) +{ + glewPrintExt("GL_EXT_base_instance", GLEW_EXT_base_instance, glewIsSupported("GL_EXT_base_instance"), glewGetExtension("GL_EXT_base_instance")); + + glewInfoFunc("glDrawArraysInstancedBaseInstanceEXT", glDrawArraysInstancedBaseInstanceEXT == NULL); + glewInfoFunc("glDrawElementsInstancedBaseInstanceEXT", glDrawElementsInstancedBaseInstanceEXT == NULL); + glewInfoFunc("glDrawElementsInstancedBaseVertexBaseInstanceEXT", glDrawElementsInstancedBaseVertexBaseInstanceEXT == NULL); +} + +#endif /* GL_EXT_base_instance */ + #ifdef GL_EXT_bgra static void _glewInfo_GL_EXT_bgra (void) @@ -3959,6 +4261,19 @@ static void _glewInfo_GL_EXT_blend_equation_separate (void) #endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_extended + +static void _glewInfo_GL_EXT_blend_func_extended (void) +{ + glewPrintExt("GL_EXT_blend_func_extended", GLEW_EXT_blend_func_extended, glewIsSupported("GL_EXT_blend_func_extended"), glewGetExtension("GL_EXT_blend_func_extended")); + + glewInfoFunc("glBindFragDataLocationIndexedEXT", glBindFragDataLocationIndexedEXT == NULL); + glewInfoFunc("glGetFragDataIndexEXT", glGetFragDataIndexEXT == NULL); + glewInfoFunc("glGetProgramResourceLocationIndexEXT", glGetProgramResourceLocationIndexEXT == NULL); +} + +#endif /* GL_EXT_blend_func_extended */ + #ifdef GL_EXT_blend_func_separate static void _glewInfo_GL_EXT_blend_func_separate (void) @@ -3999,6 +4314,39 @@ static void _glewInfo_GL_EXT_blend_subtract (void) #endif /* GL_EXT_blend_subtract */ +#ifdef GL_EXT_buffer_storage + +static void _glewInfo_GL_EXT_buffer_storage (void) +{ + glewPrintExt("GL_EXT_buffer_storage", GLEW_EXT_buffer_storage, glewIsSupported("GL_EXT_buffer_storage"), glewGetExtension("GL_EXT_buffer_storage")); + + glewInfoFunc("glBufferStorageEXT", glBufferStorageEXT == NULL); + glewInfoFunc("glNamedBufferStorageEXT", glNamedBufferStorageEXT == NULL); +} + +#endif /* GL_EXT_buffer_storage */ + +#ifdef GL_EXT_clear_texture + +static void _glewInfo_GL_EXT_clear_texture (void) +{ + glewPrintExt("GL_EXT_clear_texture", GLEW_EXT_clear_texture, glewIsSupported("GL_EXT_clear_texture"), glewGetExtension("GL_EXT_clear_texture")); + + glewInfoFunc("glClearTexImageEXT", glClearTexImageEXT == NULL); + glewInfoFunc("glClearTexSubImageEXT", glClearTexSubImageEXT == NULL); +} + +#endif /* GL_EXT_clear_texture */ + +#ifdef GL_EXT_clip_cull_distance + +static void _glewInfo_GL_EXT_clip_cull_distance (void) +{ + glewPrintExt("GL_EXT_clip_cull_distance", GLEW_EXT_clip_cull_distance, glewIsSupported("GL_EXT_clip_cull_distance"), glewGetExtension("GL_EXT_clip_cull_distance")); +} + +#endif /* GL_EXT_clip_cull_distance */ + #ifdef GL_EXT_clip_volume_hint static void _glewInfo_GL_EXT_clip_volume_hint (void) @@ -4017,6 +4365,24 @@ static void _glewInfo_GL_EXT_cmyka (void) #endif /* GL_EXT_cmyka */ +#ifdef GL_EXT_color_buffer_float + +static void _glewInfo_GL_EXT_color_buffer_float (void) +{ + glewPrintExt("GL_EXT_color_buffer_float", GLEW_EXT_color_buffer_float, glewIsSupported("GL_EXT_color_buffer_float"), glewGetExtension("GL_EXT_color_buffer_float")); +} + +#endif /* GL_EXT_color_buffer_float */ + +#ifdef GL_EXT_color_buffer_half_float + +static void _glewInfo_GL_EXT_color_buffer_half_float (void) +{ + glewPrintExt("GL_EXT_color_buffer_half_float", GLEW_EXT_color_buffer_half_float, glewIsSupported("GL_EXT_color_buffer_half_float"), glewGetExtension("GL_EXT_color_buffer_half_float")); +} + +#endif /* GL_EXT_color_buffer_half_float */ + #ifdef GL_EXT_color_subtable static void _glewInfo_GL_EXT_color_subtable (void) @@ -4041,6 +4407,24 @@ static void _glewInfo_GL_EXT_compiled_vertex_array (void) #endif /* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture + +static void _glewInfo_GL_EXT_compressed_ETC1_RGB8_sub_texture (void) +{ + glewPrintExt("GL_EXT_compressed_ETC1_RGB8_sub_texture", GLEW_EXT_compressed_ETC1_RGB8_sub_texture, glewIsSupported("GL_EXT_compressed_ETC1_RGB8_sub_texture"), glewGetExtension("GL_EXT_compressed_ETC1_RGB8_sub_texture")); +} + +#endif /* GL_EXT_compressed_ETC1_RGB8_sub_texture */ + +#ifdef GL_EXT_conservative_depth + +static void _glewInfo_GL_EXT_conservative_depth (void) +{ + glewPrintExt("GL_EXT_conservative_depth", GLEW_EXT_conservative_depth, glewIsSupported("GL_EXT_conservative_depth"), glewGetExtension("GL_EXT_conservative_depth")); +} + +#endif /* GL_EXT_conservative_depth */ + #ifdef GL_EXT_convolution static void _glewInfo_GL_EXT_convolution (void) @@ -4076,6 +4460,17 @@ static void _glewInfo_GL_EXT_coordinate_frame (void) #endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_image + +static void _glewInfo_GL_EXT_copy_image (void) +{ + glewPrintExt("GL_EXT_copy_image", GLEW_EXT_copy_image, glewIsSupported("GL_EXT_copy_image"), glewGetExtension("GL_EXT_copy_image")); + + glewInfoFunc("glCopyImageSubDataEXT", glCopyImageSubDataEXT == NULL); +} + +#endif /* GL_EXT_copy_image */ + #ifdef GL_EXT_copy_texture static void _glewInfo_GL_EXT_copy_texture (void) @@ -4363,6 +4758,28 @@ static void _glewInfo_GL_EXT_direct_state_access (void) #endif /* GL_EXT_direct_state_access */ +#ifdef GL_EXT_discard_framebuffer + +static void _glewInfo_GL_EXT_discard_framebuffer (void) +{ + glewPrintExt("GL_EXT_discard_framebuffer", GLEW_EXT_discard_framebuffer, glewIsSupported("GL_EXT_discard_framebuffer"), glewGetExtension("GL_EXT_discard_framebuffer")); + + glewInfoFunc("glDiscardFramebufferEXT", glDiscardFramebufferEXT == NULL); +} + +#endif /* GL_EXT_discard_framebuffer */ + +#ifdef GL_EXT_draw_buffers + +static void _glewInfo_GL_EXT_draw_buffers (void) +{ + glewPrintExt("GL_EXT_draw_buffers", GLEW_EXT_draw_buffers, glewIsSupported("GL_EXT_draw_buffers"), glewGetExtension("GL_EXT_draw_buffers")); + + glewInfoFunc("glDrawBuffersEXT", glDrawBuffersEXT == NULL); +} + +#endif /* GL_EXT_draw_buffers */ + #ifdef GL_EXT_draw_buffers2 static void _glewInfo_GL_EXT_draw_buffers2 (void) @@ -4379,6 +4796,38 @@ static void _glewInfo_GL_EXT_draw_buffers2 (void) #endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_buffers_indexed + +static void _glewInfo_GL_EXT_draw_buffers_indexed (void) +{ + glewPrintExt("GL_EXT_draw_buffers_indexed", GLEW_EXT_draw_buffers_indexed, glewIsSupported("GL_EXT_draw_buffers_indexed"), glewGetExtension("GL_EXT_draw_buffers_indexed")); + + glewInfoFunc("glBlendEquationSeparateiEXT", glBlendEquationSeparateiEXT == NULL); + glewInfoFunc("glBlendEquationiEXT", glBlendEquationiEXT == NULL); + glewInfoFunc("glBlendFuncSeparateiEXT", glBlendFuncSeparateiEXT == NULL); + glewInfoFunc("glBlendFunciEXT", glBlendFunciEXT == NULL); + glewInfoFunc("glColorMaskiEXT", glColorMaskiEXT == NULL); + glewInfoFunc("glDisableiEXT", glDisableiEXT == NULL); + glewInfoFunc("glEnableiEXT", glEnableiEXT == NULL); + glewInfoFunc("glIsEnablediEXT", glIsEnablediEXT == NULL); +} + +#endif /* GL_EXT_draw_buffers_indexed */ + +#ifdef GL_EXT_draw_elements_base_vertex + +static void _glewInfo_GL_EXT_draw_elements_base_vertex (void) +{ + glewPrintExt("GL_EXT_draw_elements_base_vertex", GLEW_EXT_draw_elements_base_vertex, glewIsSupported("GL_EXT_draw_elements_base_vertex"), glewGetExtension("GL_EXT_draw_elements_base_vertex")); + + glewInfoFunc("glDrawElementsBaseVertexEXT", glDrawElementsBaseVertexEXT == NULL); + glewInfoFunc("glDrawElementsInstancedBaseVertexEXT", glDrawElementsInstancedBaseVertexEXT == NULL); + glewInfoFunc("glDrawRangeElementsBaseVertexEXT", glDrawRangeElementsBaseVertexEXT == NULL); + glewInfoFunc("glMultiDrawElementsBaseVertexEXT", glMultiDrawElementsBaseVertexEXT == NULL); +} + +#endif /* GL_EXT_draw_elements_base_vertex */ + #ifdef GL_EXT_draw_instanced static void _glewInfo_GL_EXT_draw_instanced (void) @@ -4402,6 +4851,27 @@ static void _glewInfo_GL_EXT_draw_range_elements (void) #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_external_buffer + +static void _glewInfo_GL_EXT_external_buffer (void) +{ + glewPrintExt("GL_EXT_external_buffer", GLEW_EXT_external_buffer, glewIsSupported("GL_EXT_external_buffer"), glewGetExtension("GL_EXT_external_buffer")); + + glewInfoFunc("glBufferStorageExternalEXT", glBufferStorageExternalEXT == NULL); + glewInfoFunc("glNamedBufferStorageExternalEXT", glNamedBufferStorageExternalEXT == NULL); +} + +#endif /* GL_EXT_external_buffer */ + +#ifdef GL_EXT_float_blend + +static void _glewInfo_GL_EXT_float_blend (void) +{ + glewPrintExt("GL_EXT_float_blend", GLEW_EXT_float_blend, glewIsSupported("GL_EXT_float_blend"), glewGetExtension("GL_EXT_float_blend")); +} + +#endif /* GL_EXT_float_blend */ + #ifdef GL_EXT_fog_coord static void _glewInfo_GL_EXT_fog_coord (void) @@ -4417,6 +4887,15 @@ static void _glewInfo_GL_EXT_fog_coord (void) #endif /* GL_EXT_fog_coord */ +#ifdef GL_EXT_frag_depth + +static void _glewInfo_GL_EXT_frag_depth (void) +{ + glewPrintExt("GL_EXT_frag_depth", GLEW_EXT_frag_depth, glewIsSupported("GL_EXT_frag_depth"), glewGetExtension("GL_EXT_frag_depth")); +} + +#endif /* GL_EXT_frag_depth */ + #ifdef GL_EXT_fragment_lighting static void _glewInfo_GL_EXT_fragment_lighting (void) @@ -4512,6 +4991,24 @@ static void _glewInfo_GL_EXT_framebuffer_sRGB (void) #endif /* GL_EXT_framebuffer_sRGB */ +#ifdef GL_EXT_geometry_point_size + +static void _glewInfo_GL_EXT_geometry_point_size (void) +{ + glewPrintExt("GL_EXT_geometry_point_size", GLEW_EXT_geometry_point_size, glewIsSupported("GL_EXT_geometry_point_size"), glewGetExtension("GL_EXT_geometry_point_size")); +} + +#endif /* GL_EXT_geometry_point_size */ + +#ifdef GL_EXT_geometry_shader + +static void _glewInfo_GL_EXT_geometry_shader (void) +{ + glewPrintExt("GL_EXT_geometry_shader", GLEW_EXT_geometry_shader, glewIsSupported("GL_EXT_geometry_shader"), glewGetExtension("GL_EXT_geometry_shader")); +} + +#endif /* GL_EXT_geometry_shader */ + #ifdef GL_EXT_geometry_shader4 static void _glewInfo_GL_EXT_geometry_shader4 (void) @@ -4581,6 +5078,15 @@ static void _glewInfo_GL_EXT_gpu_shader4 (void) #endif /* GL_EXT_gpu_shader4 */ +#ifdef GL_EXT_gpu_shader5 + +static void _glewInfo_GL_EXT_gpu_shader5 (void) +{ + glewPrintExt("GL_EXT_gpu_shader5", GLEW_EXT_gpu_shader5, glewIsSupported("GL_EXT_gpu_shader5"), glewGetExtension("GL_EXT_gpu_shader5")); +} + +#endif /* GL_EXT_gpu_shader5 */ + #ifdef GL_EXT_histogram static void _glewInfo_GL_EXT_histogram (void) @@ -4641,6 +5147,17 @@ static void _glewInfo_GL_EXT_index_texture (void) #endif /* GL_EXT_index_texture */ +#ifdef GL_EXT_instanced_arrays + +static void _glewInfo_GL_EXT_instanced_arrays (void) +{ + glewPrintExt("GL_EXT_instanced_arrays", GLEW_EXT_instanced_arrays, glewIsSupported("GL_EXT_instanced_arrays"), glewGetExtension("GL_EXT_instanced_arrays")); + + glewInfoFunc("glVertexAttribDivisorEXT", glVertexAttribDivisorEXT == NULL); +} + +#endif /* GL_EXT_instanced_arrays */ + #ifdef GL_EXT_light_texture static void _glewInfo_GL_EXT_light_texture (void) @@ -4654,6 +5171,70 @@ static void _glewInfo_GL_EXT_light_texture (void) #endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_map_buffer_range + +static void _glewInfo_GL_EXT_map_buffer_range (void) +{ + glewPrintExt("GL_EXT_map_buffer_range", GLEW_EXT_map_buffer_range, glewIsSupported("GL_EXT_map_buffer_range"), glewGetExtension("GL_EXT_map_buffer_range")); + + glewInfoFunc("glFlushMappedBufferRangeEXT", glFlushMappedBufferRangeEXT == NULL); + glewInfoFunc("glMapBufferRangeEXT", glMapBufferRangeEXT == NULL); +} + +#endif /* GL_EXT_map_buffer_range */ + +#ifdef GL_EXT_memory_object + +static void _glewInfo_GL_EXT_memory_object (void) +{ + glewPrintExt("GL_EXT_memory_object", GLEW_EXT_memory_object, glewIsSupported("GL_EXT_memory_object"), glewGetExtension("GL_EXT_memory_object")); + + glewInfoFunc("glBufferStorageMemEXT", glBufferStorageMemEXT == NULL); + glewInfoFunc("glCreateMemoryObjectsEXT", glCreateMemoryObjectsEXT == NULL); + glewInfoFunc("glDeleteMemoryObjectsEXT", glDeleteMemoryObjectsEXT == NULL); + glewInfoFunc("glGetMemoryObjectParameterivEXT", glGetMemoryObjectParameterivEXT == NULL); + glewInfoFunc("glGetUnsignedBytei_vEXT", glGetUnsignedBytei_vEXT == NULL); + glewInfoFunc("glGetUnsignedBytevEXT", glGetUnsignedBytevEXT == NULL); + glewInfoFunc("glIsMemoryObjectEXT", glIsMemoryObjectEXT == NULL); + glewInfoFunc("glMemoryObjectParameterivEXT", glMemoryObjectParameterivEXT == NULL); + glewInfoFunc("glNamedBufferStorageMemEXT", glNamedBufferStorageMemEXT == NULL); + glewInfoFunc("glTexStorageMem1DEXT", glTexStorageMem1DEXT == NULL); + glewInfoFunc("glTexStorageMem2DEXT", glTexStorageMem2DEXT == NULL); + glewInfoFunc("glTexStorageMem2DMultisampleEXT", glTexStorageMem2DMultisampleEXT == NULL); + glewInfoFunc("glTexStorageMem3DEXT", glTexStorageMem3DEXT == NULL); + glewInfoFunc("glTexStorageMem3DMultisampleEXT", glTexStorageMem3DMultisampleEXT == NULL); + glewInfoFunc("glTextureStorageMem1DEXT", glTextureStorageMem1DEXT == NULL); + glewInfoFunc("glTextureStorageMem2DEXT", glTextureStorageMem2DEXT == NULL); + glewInfoFunc("glTextureStorageMem2DMultisampleEXT", glTextureStorageMem2DMultisampleEXT == NULL); + glewInfoFunc("glTextureStorageMem3DEXT", glTextureStorageMem3DEXT == NULL); + glewInfoFunc("glTextureStorageMem3DMultisampleEXT", glTextureStorageMem3DMultisampleEXT == NULL); +} + +#endif /* GL_EXT_memory_object */ + +#ifdef GL_EXT_memory_object_fd + +static void _glewInfo_GL_EXT_memory_object_fd (void) +{ + glewPrintExt("GL_EXT_memory_object_fd", GLEW_EXT_memory_object_fd, glewIsSupported("GL_EXT_memory_object_fd"), glewGetExtension("GL_EXT_memory_object_fd")); + + glewInfoFunc("glImportMemoryFdEXT", glImportMemoryFdEXT == NULL); +} + +#endif /* GL_EXT_memory_object_fd */ + +#ifdef GL_EXT_memory_object_win32 + +static void _glewInfo_GL_EXT_memory_object_win32 (void) +{ + glewPrintExt("GL_EXT_memory_object_win32", GLEW_EXT_memory_object_win32, glewIsSupported("GL_EXT_memory_object_win32"), glewGetExtension("GL_EXT_memory_object_win32")); + + glewInfoFunc("glImportMemoryWin32HandleEXT", glImportMemoryWin32HandleEXT == NULL); + glewInfoFunc("glImportMemoryWin32NameEXT", glImportMemoryWin32NameEXT == NULL); +} + +#endif /* GL_EXT_memory_object_win32 */ + #ifdef GL_EXT_misc_attribute static void _glewInfo_GL_EXT_misc_attribute (void) @@ -4675,6 +5256,27 @@ static void _glewInfo_GL_EXT_multi_draw_arrays (void) #endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multi_draw_indirect + +static void _glewInfo_GL_EXT_multi_draw_indirect (void) +{ + glewPrintExt("GL_EXT_multi_draw_indirect", GLEW_EXT_multi_draw_indirect, glewIsSupported("GL_EXT_multi_draw_indirect"), glewGetExtension("GL_EXT_multi_draw_indirect")); + + glewInfoFunc("glMultiDrawArraysIndirectEXT", glMultiDrawArraysIndirectEXT == NULL); + glewInfoFunc("glMultiDrawElementsIndirectEXT", glMultiDrawElementsIndirectEXT == NULL); +} + +#endif /* GL_EXT_multi_draw_indirect */ + +#ifdef GL_EXT_multiple_textures + +static void _glewInfo_GL_EXT_multiple_textures (void) +{ + glewPrintExt("GL_EXT_multiple_textures", GLEW_EXT_multiple_textures, glewIsSupported("GL_EXT_multiple_textures"), glewGetExtension("GL_EXT_multiple_textures")); +} + +#endif /* GL_EXT_multiple_textures */ + #ifdef GL_EXT_multisample static void _glewInfo_GL_EXT_multisample (void) @@ -4687,6 +5289,48 @@ static void _glewInfo_GL_EXT_multisample (void) #endif /* GL_EXT_multisample */ +#ifdef GL_EXT_multisample_compatibility + +static void _glewInfo_GL_EXT_multisample_compatibility (void) +{ + glewPrintExt("GL_EXT_multisample_compatibility", GLEW_EXT_multisample_compatibility, glewIsSupported("GL_EXT_multisample_compatibility"), glewGetExtension("GL_EXT_multisample_compatibility")); +} + +#endif /* GL_EXT_multisample_compatibility */ + +#ifdef GL_EXT_multisampled_render_to_texture + +static void _glewInfo_GL_EXT_multisampled_render_to_texture (void) +{ + glewPrintExt("GL_EXT_multisampled_render_to_texture", GLEW_EXT_multisampled_render_to_texture, glewIsSupported("GL_EXT_multisampled_render_to_texture"), glewGetExtension("GL_EXT_multisampled_render_to_texture")); + + glewInfoFunc("glFramebufferTexture2DMultisampleEXT", glFramebufferTexture2DMultisampleEXT == NULL); +} + +#endif /* GL_EXT_multisampled_render_to_texture */ + +#ifdef GL_EXT_multisampled_render_to_texture2 + +static void _glewInfo_GL_EXT_multisampled_render_to_texture2 (void) +{ + glewPrintExt("GL_EXT_multisampled_render_to_texture2", GLEW_EXT_multisampled_render_to_texture2, glewIsSupported("GL_EXT_multisampled_render_to_texture2"), glewGetExtension("GL_EXT_multisampled_render_to_texture2")); +} + +#endif /* GL_EXT_multisampled_render_to_texture2 */ + +#ifdef GL_EXT_multiview_draw_buffers + +static void _glewInfo_GL_EXT_multiview_draw_buffers (void) +{ + glewPrintExt("GL_EXT_multiview_draw_buffers", GLEW_EXT_multiview_draw_buffers, glewIsSupported("GL_EXT_multiview_draw_buffers"), glewGetExtension("GL_EXT_multiview_draw_buffers")); + + glewInfoFunc("glDrawBuffersIndexedEXT", glDrawBuffersIndexedEXT == NULL); + glewInfoFunc("glGetIntegeri_vEXT", glGetIntegeri_vEXT == NULL); + glewInfoFunc("glReadBufferIndexedEXT", glReadBufferIndexedEXT == NULL); +} + +#endif /* GL_EXT_multiview_draw_buffers */ + #ifdef GL_EXT_packed_depth_stencil static void _glewInfo_GL_EXT_packed_depth_stencil (void) @@ -4816,6 +5460,15 @@ static void _glewInfo_GL_EXT_provoking_vertex (void) #endif /* GL_EXT_provoking_vertex */ +#ifdef GL_EXT_pvrtc_sRGB + +static void _glewInfo_GL_EXT_pvrtc_sRGB (void) +{ + glewPrintExt("GL_EXT_pvrtc_sRGB", GLEW_EXT_pvrtc_sRGB, glewIsSupported("GL_EXT_pvrtc_sRGB"), glewGetExtension("GL_EXT_pvrtc_sRGB")); +} + +#endif /* GL_EXT_pvrtc_sRGB */ + #ifdef GL_EXT_raster_multisample static void _glewInfo_GL_EXT_raster_multisample (void) @@ -4830,6 +5483,24 @@ static void _glewInfo_GL_EXT_raster_multisample (void) #endif /* GL_EXT_raster_multisample */ +#ifdef GL_EXT_read_format_bgra + +static void _glewInfo_GL_EXT_read_format_bgra (void) +{ + glewPrintExt("GL_EXT_read_format_bgra", GLEW_EXT_read_format_bgra, glewIsSupported("GL_EXT_read_format_bgra"), glewGetExtension("GL_EXT_read_format_bgra")); +} + +#endif /* GL_EXT_read_format_bgra */ + +#ifdef GL_EXT_render_snorm + +static void _glewInfo_GL_EXT_render_snorm (void) +{ + glewPrintExt("GL_EXT_render_snorm", GLEW_EXT_render_snorm, glewIsSupported("GL_EXT_render_snorm"), glewGetExtension("GL_EXT_render_snorm")); +} + +#endif /* GL_EXT_render_snorm */ + #ifdef GL_EXT_rescale_normal static void _glewInfo_GL_EXT_rescale_normal (void) @@ -4839,6 +5510,24 @@ static void _glewInfo_GL_EXT_rescale_normal (void) #endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_sRGB + +static void _glewInfo_GL_EXT_sRGB (void) +{ + glewPrintExt("GL_EXT_sRGB", GLEW_EXT_sRGB, glewIsSupported("GL_EXT_sRGB"), glewGetExtension("GL_EXT_sRGB")); +} + +#endif /* GL_EXT_sRGB */ + +#ifdef GL_EXT_sRGB_write_control + +static void _glewInfo_GL_EXT_sRGB_write_control (void) +{ + glewPrintExt("GL_EXT_sRGB_write_control", GLEW_EXT_sRGB_write_control, glewIsSupported("GL_EXT_sRGB_write_control"), glewGetExtension("GL_EXT_sRGB_write_control")); +} + +#endif /* GL_EXT_sRGB_write_control */ + #ifdef GL_EXT_scene_marker static void _glewInfo_GL_EXT_scene_marker (void) @@ -4878,6 +5567,46 @@ static void _glewInfo_GL_EXT_secondary_color (void) #endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_semaphore + +static void _glewInfo_GL_EXT_semaphore (void) +{ + glewPrintExt("GL_EXT_semaphore", GLEW_EXT_semaphore, glewIsSupported("GL_EXT_semaphore"), glewGetExtension("GL_EXT_semaphore")); + + glewInfoFunc("glDeleteSemaphoresEXT", glDeleteSemaphoresEXT == NULL); + glewInfoFunc("glGenSemaphoresEXT", glGenSemaphoresEXT == NULL); + glewInfoFunc("glGetSemaphoreParameterui64vEXT", glGetSemaphoreParameterui64vEXT == NULL); + glewInfoFunc("glIsSemaphoreEXT", glIsSemaphoreEXT == NULL); + glewInfoFunc("glSemaphoreParameterui64vEXT", glSemaphoreParameterui64vEXT == NULL); + glewInfoFunc("glSignalSemaphoreEXT", glSignalSemaphoreEXT == NULL); + glewInfoFunc("glWaitSemaphoreEXT", glWaitSemaphoreEXT == NULL); +} + +#endif /* GL_EXT_semaphore */ + +#ifdef GL_EXT_semaphore_fd + +static void _glewInfo_GL_EXT_semaphore_fd (void) +{ + glewPrintExt("GL_EXT_semaphore_fd", GLEW_EXT_semaphore_fd, glewIsSupported("GL_EXT_semaphore_fd"), glewGetExtension("GL_EXT_semaphore_fd")); + + glewInfoFunc("glImportSemaphoreFdEXT", glImportSemaphoreFdEXT == NULL); +} + +#endif /* GL_EXT_semaphore_fd */ + +#ifdef GL_EXT_semaphore_win32 + +static void _glewInfo_GL_EXT_semaphore_win32 (void) +{ + glewPrintExt("GL_EXT_semaphore_win32", GLEW_EXT_semaphore_win32, glewIsSupported("GL_EXT_semaphore_win32"), glewGetExtension("GL_EXT_semaphore_win32")); + + glewInfoFunc("glImportSemaphoreWin32HandleEXT", glImportSemaphoreWin32HandleEXT == NULL); + glewInfoFunc("glImportSemaphoreWin32NameEXT", glImportSemaphoreWin32NameEXT == NULL); +} + +#endif /* GL_EXT_semaphore_win32 */ + #ifdef GL_EXT_separate_shader_objects static void _glewInfo_GL_EXT_separate_shader_objects (void) @@ -4900,6 +5629,24 @@ static void _glewInfo_GL_EXT_separate_specular_color (void) #endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shader_framebuffer_fetch + +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")); +} + +#endif /* GL_EXT_shader_framebuffer_fetch */ + +#ifdef GL_EXT_shader_group_vote + +static void _glewInfo_GL_EXT_shader_group_vote (void) +{ + glewPrintExt("GL_EXT_shader_group_vote", GLEW_EXT_shader_group_vote, glewIsSupported("GL_EXT_shader_group_vote"), glewGetExtension("GL_EXT_shader_group_vote")); +} + +#endif /* GL_EXT_shader_group_vote */ + #ifdef GL_EXT_shader_image_load_formatted static void _glewInfo_GL_EXT_shader_image_load_formatted (void) @@ -4921,6 +5668,15 @@ static void _glewInfo_GL_EXT_shader_image_load_store (void) #endif /* GL_EXT_shader_image_load_store */ +#ifdef GL_EXT_shader_implicit_conversions + +static void _glewInfo_GL_EXT_shader_implicit_conversions (void) +{ + glewPrintExt("GL_EXT_shader_implicit_conversions", GLEW_EXT_shader_implicit_conversions, glewIsSupported("GL_EXT_shader_implicit_conversions"), glewGetExtension("GL_EXT_shader_implicit_conversions")); +} + +#endif /* GL_EXT_shader_implicit_conversions */ + #ifdef GL_EXT_shader_integer_mix static void _glewInfo_GL_EXT_shader_integer_mix (void) @@ -4930,6 +5686,55 @@ static void _glewInfo_GL_EXT_shader_integer_mix (void) #endif /* GL_EXT_shader_integer_mix */ +#ifdef GL_EXT_shader_io_blocks + +static void _glewInfo_GL_EXT_shader_io_blocks (void) +{ + glewPrintExt("GL_EXT_shader_io_blocks", GLEW_EXT_shader_io_blocks, glewIsSupported("GL_EXT_shader_io_blocks"), glewGetExtension("GL_EXT_shader_io_blocks")); +} + +#endif /* GL_EXT_shader_io_blocks */ + +#ifdef GL_EXT_shader_non_constant_global_initializers + +static void _glewInfo_GL_EXT_shader_non_constant_global_initializers (void) +{ + glewPrintExt("GL_EXT_shader_non_constant_global_initializers", GLEW_EXT_shader_non_constant_global_initializers, glewIsSupported("GL_EXT_shader_non_constant_global_initializers"), glewGetExtension("GL_EXT_shader_non_constant_global_initializers")); +} + +#endif /* GL_EXT_shader_non_constant_global_initializers */ + +#ifdef GL_EXT_shader_pixel_local_storage + +static void _glewInfo_GL_EXT_shader_pixel_local_storage (void) +{ + glewPrintExt("GL_EXT_shader_pixel_local_storage", GLEW_EXT_shader_pixel_local_storage, glewIsSupported("GL_EXT_shader_pixel_local_storage"), glewGetExtension("GL_EXT_shader_pixel_local_storage")); +} + +#endif /* GL_EXT_shader_pixel_local_storage */ + +#ifdef GL_EXT_shader_pixel_local_storage2 + +static void _glewInfo_GL_EXT_shader_pixel_local_storage2 (void) +{ + glewPrintExt("GL_EXT_shader_pixel_local_storage2", GLEW_EXT_shader_pixel_local_storage2, glewIsSupported("GL_EXT_shader_pixel_local_storage2"), glewGetExtension("GL_EXT_shader_pixel_local_storage2")); + + glewInfoFunc("glClearPixelLocalStorageuiEXT", glClearPixelLocalStorageuiEXT == NULL); + glewInfoFunc("glFramebufferPixelLocalStorageSizeEXT", glFramebufferPixelLocalStorageSizeEXT == NULL); + glewInfoFunc("glGetFramebufferPixelLocalStorageSizeEXT", glGetFramebufferPixelLocalStorageSizeEXT == NULL); +} + +#endif /* GL_EXT_shader_pixel_local_storage2 */ + +#ifdef GL_EXT_shader_texture_lod + +static void _glewInfo_GL_EXT_shader_texture_lod (void) +{ + glewPrintExt("GL_EXT_shader_texture_lod", GLEW_EXT_shader_texture_lod, glewIsSupported("GL_EXT_shader_texture_lod"), glewGetExtension("GL_EXT_shader_texture_lod")); +} + +#endif /* GL_EXT_shader_texture_lod */ + #ifdef GL_EXT_shadow_funcs static void _glewInfo_GL_EXT_shadow_funcs (void) @@ -4939,6 +5744,15 @@ static void _glewInfo_GL_EXT_shadow_funcs (void) #endif /* GL_EXT_shadow_funcs */ +#ifdef GL_EXT_shadow_samplers + +static void _glewInfo_GL_EXT_shadow_samplers (void) +{ + glewPrintExt("GL_EXT_shadow_samplers", GLEW_EXT_shadow_samplers, glewIsSupported("GL_EXT_shadow_samplers"), glewGetExtension("GL_EXT_shadow_samplers")); +} + +#endif /* GL_EXT_shadow_samplers */ + #ifdef GL_EXT_shared_texture_palette static void _glewInfo_GL_EXT_shared_texture_palette (void) @@ -4948,6 +5762,18 @@ static void _glewInfo_GL_EXT_shared_texture_palette (void) #endif /* GL_EXT_shared_texture_palette */ +#ifdef GL_EXT_sparse_texture + +static void _glewInfo_GL_EXT_sparse_texture (void) +{ + glewPrintExt("GL_EXT_sparse_texture", GLEW_EXT_sparse_texture, glewIsSupported("GL_EXT_sparse_texture"), glewGetExtension("GL_EXT_sparse_texture")); + + glewInfoFunc("glTexPageCommitmentEXT", glTexPageCommitmentEXT == NULL); + glewInfoFunc("glTexturePageCommitmentEXT", glTexturePageCommitmentEXT == NULL); +} + +#endif /* GL_EXT_sparse_texture */ + #ifdef GL_EXT_sparse_texture2 static void _glewInfo_GL_EXT_sparse_texture2 (void) @@ -5041,6 +5867,33 @@ static void _glewInfo_GL_EXT_texture_buffer_object (void) #endif /* GL_EXT_texture_buffer_object */ +#ifdef GL_EXT_texture_compression_astc_decode_mode + +static void _glewInfo_GL_EXT_texture_compression_astc_decode_mode (void) +{ + glewPrintExt("GL_EXT_texture_compression_astc_decode_mode", GLEW_EXT_texture_compression_astc_decode_mode, glewIsSupported("GL_EXT_texture_compression_astc_decode_mode"), glewGetExtension("GL_EXT_texture_compression_astc_decode_mode")); +} + +#endif /* GL_EXT_texture_compression_astc_decode_mode */ + +#ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 + +static void _glewInfo_GL_EXT_texture_compression_astc_decode_mode_rgb9e5 (void) +{ + glewPrintExt("GL_EXT_texture_compression_astc_decode_mode_rgb9e5", GLEW_EXT_texture_compression_astc_decode_mode_rgb9e5, glewIsSupported("GL_EXT_texture_compression_astc_decode_mode_rgb9e5"), glewGetExtension("GL_EXT_texture_compression_astc_decode_mode_rgb9e5")); +} + +#endif /* GL_EXT_texture_compression_astc_decode_mode_rgb9e5 */ + +#ifdef GL_EXT_texture_compression_bptc + +static void _glewInfo_GL_EXT_texture_compression_bptc (void) +{ + glewPrintExt("GL_EXT_texture_compression_bptc", GLEW_EXT_texture_compression_bptc, glewIsSupported("GL_EXT_texture_compression_bptc"), glewGetExtension("GL_EXT_texture_compression_bptc")); +} + +#endif /* GL_EXT_texture_compression_bptc */ + #ifdef GL_EXT_texture_compression_dxt1 static void _glewInfo_GL_EXT_texture_compression_dxt1 (void) @@ -5086,6 +5939,15 @@ static void _glewInfo_GL_EXT_texture_cube_map (void) #endif /* GL_EXT_texture_cube_map */ +#ifdef GL_EXT_texture_cube_map_array + +static void _glewInfo_GL_EXT_texture_cube_map_array (void) +{ + glewPrintExt("GL_EXT_texture_cube_map_array", GLEW_EXT_texture_cube_map_array, glewIsSupported("GL_EXT_texture_cube_map_array"), glewGetExtension("GL_EXT_texture_cube_map_array")); +} + +#endif /* GL_EXT_texture_cube_map_array */ + #ifdef GL_EXT_texture_edge_clamp static void _glewInfo_GL_EXT_texture_edge_clamp (void) @@ -5149,6 +6011,15 @@ static void _glewInfo_GL_EXT_texture_filter_minmax (void) #endif /* GL_EXT_texture_filter_minmax */ +#ifdef GL_EXT_texture_format_BGRA8888 + +static void _glewInfo_GL_EXT_texture_format_BGRA8888 (void) +{ + glewPrintExt("GL_EXT_texture_format_BGRA8888", GLEW_EXT_texture_format_BGRA8888, glewIsSupported("GL_EXT_texture_format_BGRA8888"), glewGetExtension("GL_EXT_texture_format_BGRA8888")); +} + +#endif /* GL_EXT_texture_format_BGRA8888 */ + #ifdef GL_EXT_texture_integer static void _glewInfo_GL_EXT_texture_integer (void) @@ -5183,6 +6054,15 @@ static void _glewInfo_GL_EXT_texture_mirror_clamp (void) #endif /* GL_EXT_texture_mirror_clamp */ +#ifdef GL_EXT_texture_norm16 + +static void _glewInfo_GL_EXT_texture_norm16 (void) +{ + glewPrintExt("GL_EXT_texture_norm16", GLEW_EXT_texture_norm16, glewIsSupported("GL_EXT_texture_norm16"), glewGetExtension("GL_EXT_texture_norm16")); +} + +#endif /* GL_EXT_texture_norm16 */ + #ifdef GL_EXT_texture_object static void _glewInfo_GL_EXT_texture_object (void) @@ -5219,6 +6099,15 @@ static void _glewInfo_GL_EXT_texture_rectangle (void) #endif /* GL_EXT_texture_rectangle */ +#ifdef GL_EXT_texture_rg + +static void _glewInfo_GL_EXT_texture_rg (void) +{ + glewPrintExt("GL_EXT_texture_rg", GLEW_EXT_texture_rg, glewIsSupported("GL_EXT_texture_rg"), glewGetExtension("GL_EXT_texture_rg")); +} + +#endif /* GL_EXT_texture_rg */ + #ifdef GL_EXT_texture_sRGB static void _glewInfo_GL_EXT_texture_sRGB (void) @@ -5228,6 +6117,24 @@ static void _glewInfo_GL_EXT_texture_sRGB (void) #endif /* GL_EXT_texture_sRGB */ +#ifdef GL_EXT_texture_sRGB_R8 + +static void _glewInfo_GL_EXT_texture_sRGB_R8 (void) +{ + glewPrintExt("GL_EXT_texture_sRGB_R8", GLEW_EXT_texture_sRGB_R8, glewIsSupported("GL_EXT_texture_sRGB_R8"), glewGetExtension("GL_EXT_texture_sRGB_R8")); +} + +#endif /* GL_EXT_texture_sRGB_R8 */ + +#ifdef GL_EXT_texture_sRGB_RG8 + +static void _glewInfo_GL_EXT_texture_sRGB_RG8 (void) +{ + glewPrintExt("GL_EXT_texture_sRGB_RG8", GLEW_EXT_texture_sRGB_RG8, glewIsSupported("GL_EXT_texture_sRGB_RG8"), glewGetExtension("GL_EXT_texture_sRGB_RG8")); +} + +#endif /* GL_EXT_texture_sRGB_RG8 */ + #ifdef GL_EXT_texture_sRGB_decode static void _glewInfo_GL_EXT_texture_sRGB_decode (void) @@ -5255,6 +6162,22 @@ static void _glewInfo_GL_EXT_texture_snorm (void) #endif /* GL_EXT_texture_snorm */ +#ifdef GL_EXT_texture_storage + +static void _glewInfo_GL_EXT_texture_storage (void) +{ + glewPrintExt("GL_EXT_texture_storage", GLEW_EXT_texture_storage, glewIsSupported("GL_EXT_texture_storage"), glewGetExtension("GL_EXT_texture_storage")); + + glewInfoFunc("glTexStorage1DEXT", glTexStorage1DEXT == NULL); + glewInfoFunc("glTexStorage2DEXT", glTexStorage2DEXT == NULL); + glewInfoFunc("glTexStorage3DEXT", glTexStorage3DEXT == NULL); + glewInfoFunc("glTextureStorage1DEXT", glTextureStorage1DEXT == NULL); + glewInfoFunc("glTextureStorage2DEXT", glTextureStorage2DEXT == NULL); + glewInfoFunc("glTextureStorage3DEXT", glTextureStorage3DEXT == NULL); +} + +#endif /* GL_EXT_texture_storage */ + #ifdef GL_EXT_texture_swizzle static void _glewInfo_GL_EXT_texture_swizzle (void) @@ -5264,6 +6187,26 @@ static void _glewInfo_GL_EXT_texture_swizzle (void) #endif /* GL_EXT_texture_swizzle */ +#ifdef GL_EXT_texture_type_2_10_10_10_REV + +static void _glewInfo_GL_EXT_texture_type_2_10_10_10_REV (void) +{ + glewPrintExt("GL_EXT_texture_type_2_10_10_10_REV", GLEW_EXT_texture_type_2_10_10_10_REV, glewIsSupported("GL_EXT_texture_type_2_10_10_10_REV"), glewGetExtension("GL_EXT_texture_type_2_10_10_10_REV")); +} + +#endif /* GL_EXT_texture_type_2_10_10_10_REV */ + +#ifdef GL_EXT_texture_view + +static void _glewInfo_GL_EXT_texture_view (void) +{ + glewPrintExt("GL_EXT_texture_view", GLEW_EXT_texture_view, glewIsSupported("GL_EXT_texture_view"), glewGetExtension("GL_EXT_texture_view")); + + glewInfoFunc("glTextureViewEXT", glTextureViewEXT == NULL); +} + +#endif /* GL_EXT_texture_view */ + #ifdef GL_EXT_timer_query static void _glewInfo_GL_EXT_timer_query (void) @@ -5293,6 +6236,15 @@ static void _glewInfo_GL_EXT_transform_feedback (void) #endif /* GL_EXT_transform_feedback */ +#ifdef GL_EXT_unpack_subimage + +static void _glewInfo_GL_EXT_unpack_subimage (void) +{ + glewPrintExt("GL_EXT_unpack_subimage", GLEW_EXT_unpack_subimage, glewIsSupported("GL_EXT_unpack_subimage"), glewGetExtension("GL_EXT_unpack_subimage")); +} + +#endif /* GL_EXT_unpack_subimage */ + #ifdef GL_EXT_vertex_array static void _glewInfo_GL_EXT_vertex_array (void) @@ -5320,6 +6272,19 @@ static void _glewInfo_GL_EXT_vertex_array_bgra (void) #endif /* GL_EXT_vertex_array_bgra */ +#ifdef GL_EXT_vertex_array_setXXX + +static void _glewInfo_GL_EXT_vertex_array_setXXX (void) +{ + glewPrintExt("GL_EXT_vertex_array_setXXX", GLEW_EXT_vertex_array_setXXX, glewIsSupported("GL_EXT_vertex_array_setXXX"), glewGetExtension("GL_EXT_vertex_array_setXXX")); + + glewInfoFunc("glBindArraySetEXT", glBindArraySetEXT == NULL); + glewInfoFunc("glCreateArraySetExt", glCreateArraySetExt == NULL); + glewInfoFunc("glDeleteArraySetsEXT", glDeleteArraySetsEXT == NULL); +} + +#endif /* GL_EXT_vertex_array_setXXX */ + #ifdef GL_EXT_vertex_attrib_64bit static void _glewInfo_GL_EXT_vertex_attrib_64bit (void) @@ -5406,6 +6371,18 @@ static void _glewInfo_GL_EXT_vertex_weighting (void) #endif /* GL_EXT_vertex_weighting */ +#ifdef GL_EXT_win32_keyed_mutex + +static void _glewInfo_GL_EXT_win32_keyed_mutex (void) +{ + glewPrintExt("GL_EXT_win32_keyed_mutex", GLEW_EXT_win32_keyed_mutex, glewIsSupported("GL_EXT_win32_keyed_mutex"), glewGetExtension("GL_EXT_win32_keyed_mutex")); + + glewInfoFunc("glAcquireKeyedMutexWin32EXT", glAcquireKeyedMutexWin32EXT == NULL); + glewInfoFunc("glReleaseKeyedMutexWin32EXT", glReleaseKeyedMutexWin32EXT == NULL); +} + +#endif /* GL_EXT_win32_keyed_mutex */ + #ifdef GL_EXT_window_rectangles static void _glewInfo_GL_EXT_window_rectangles (void) @@ -5721,6 +6698,17 @@ static void _glewInfo_GL_KHR_no_error (void) #endif /* GL_KHR_no_error */ +#ifdef GL_KHR_parallel_shader_compile + +static void _glewInfo_GL_KHR_parallel_shader_compile (void) +{ + glewPrintExt("GL_KHR_parallel_shader_compile", GLEW_KHR_parallel_shader_compile, glewIsSupported("GL_KHR_parallel_shader_compile"), glewGetExtension("GL_KHR_parallel_shader_compile")); + + glewInfoFunc("glMaxShaderCompilerThreadsKHR", glMaxShaderCompilerThreadsKHR == NULL); +} + +#endif /* GL_KHR_parallel_shader_compile */ + #ifdef GL_KHR_robust_buffer_access_behavior static void _glewInfo_GL_KHR_robust_buffer_access_behavior (void) @@ -5910,6 +6898,45 @@ static void _glewInfo_GL_NVX_linked_gpu_multicast (void) #endif /* GL_NVX_linked_gpu_multicast */ +#ifdef GL_NV_3dvision_settings + +static void _glewInfo_GL_NV_3dvision_settings (void) +{ + glewPrintExt("GL_NV_3dvision_settings", GLEW_NV_3dvision_settings, glewIsSupported("GL_NV_3dvision_settings"), glewGetExtension("GL_NV_3dvision_settings")); + + glewInfoFunc("glStereoParameterfNV", glStereoParameterfNV == NULL); + glewInfoFunc("glStereoParameteriNV", glStereoParameteriNV == NULL); +} + +#endif /* GL_NV_3dvision_settings */ + +#ifdef GL_NV_EGL_stream_consumer_external + +static void _glewInfo_GL_NV_EGL_stream_consumer_external (void) +{ + glewPrintExt("GL_NV_EGL_stream_consumer_external", GLEW_NV_EGL_stream_consumer_external, glewIsSupported("GL_NV_EGL_stream_consumer_external"), glewGetExtension("GL_NV_EGL_stream_consumer_external")); +} + +#endif /* GL_NV_EGL_stream_consumer_external */ + +#ifdef GL_NV_alpha_to_coverage_dither_control + +static void _glewInfo_GL_NV_alpha_to_coverage_dither_control (void) +{ + glewPrintExt("GL_NV_alpha_to_coverage_dither_control", GLEW_NV_alpha_to_coverage_dither_control, glewIsSupported("GL_NV_alpha_to_coverage_dither_control"), glewGetExtension("GL_NV_alpha_to_coverage_dither_control")); +} + +#endif /* GL_NV_alpha_to_coverage_dither_control */ + +#ifdef GL_NV_bgr + +static void _glewInfo_GL_NV_bgr (void) +{ + glewPrintExt("GL_NV_bgr", GLEW_NV_bgr, glewIsSupported("GL_NV_bgr"), glewGetExtension("GL_NV_bgr")); +} + +#endif /* GL_NV_bgr */ + #ifdef GL_NV_bindless_multi_draw_indirect static void _glewInfo_GL_NV_bindless_multi_draw_indirect (void) @@ -5978,6 +7005,15 @@ static void _glewInfo_GL_NV_blend_equation_advanced_coherent (void) #endif /* GL_NV_blend_equation_advanced_coherent */ +#ifdef GL_NV_blend_minmax_factor + +static void _glewInfo_GL_NV_blend_minmax_factor (void) +{ + glewPrintExt("GL_NV_blend_minmax_factor", GLEW_NV_blend_minmax_factor, glewIsSupported("GL_NV_blend_minmax_factor"), glewGetExtension("GL_NV_blend_minmax_factor")); +} + +#endif /* GL_NV_blend_minmax_factor */ + #ifdef GL_NV_blend_square static void _glewInfo_GL_NV_blend_square (void) @@ -6079,6 +7115,17 @@ static void _glewInfo_GL_NV_conservative_raster_pre_snap_triangles (void) #endif /* GL_NV_conservative_raster_pre_snap_triangles */ +#ifdef GL_NV_copy_buffer + +static void _glewInfo_GL_NV_copy_buffer (void) +{ + glewPrintExt("GL_NV_copy_buffer", GLEW_NV_copy_buffer, glewIsSupported("GL_NV_copy_buffer"), glewGetExtension("GL_NV_copy_buffer")); + + glewInfoFunc("glCopyBufferSubDataNV", glCopyBufferSubDataNV == NULL); +} + +#endif /* GL_NV_copy_buffer */ + #ifdef GL_NV_copy_depth_to_color static void _glewInfo_GL_NV_copy_depth_to_color (void) @@ -6139,6 +7186,29 @@ static void _glewInfo_GL_NV_depth_range_unclamped (void) #endif /* GL_NV_depth_range_unclamped */ +#ifdef GL_NV_draw_buffers + +static void _glewInfo_GL_NV_draw_buffers (void) +{ + glewPrintExt("GL_NV_draw_buffers", GLEW_NV_draw_buffers, glewIsSupported("GL_NV_draw_buffers"), glewGetExtension("GL_NV_draw_buffers")); + + glewInfoFunc("glDrawBuffersNV", glDrawBuffersNV == NULL); +} + +#endif /* GL_NV_draw_buffers */ + +#ifdef GL_NV_draw_instanced + +static void _glewInfo_GL_NV_draw_instanced (void) +{ + glewPrintExt("GL_NV_draw_instanced", GLEW_NV_draw_instanced, glewIsSupported("GL_NV_draw_instanced"), glewGetExtension("GL_NV_draw_instanced")); + + glewInfoFunc("glDrawArraysInstancedNV", glDrawArraysInstancedNV == NULL); + glewInfoFunc("glDrawElementsInstancedNV", glDrawElementsInstancedNV == NULL); +} + +#endif /* GL_NV_draw_instanced */ + #ifdef GL_NV_draw_texture static void _glewInfo_GL_NV_draw_texture (void) @@ -6184,6 +7254,15 @@ static void _glewInfo_GL_NV_evaluators (void) #endif /* GL_NV_evaluators */ +#ifdef GL_NV_explicit_attrib_location + +static void _glewInfo_GL_NV_explicit_attrib_location (void) +{ + glewPrintExt("GL_NV_explicit_attrib_location", GLEW_NV_explicit_attrib_location, glewIsSupported("GL_NV_explicit_attrib_location"), glewGetExtension("GL_NV_explicit_attrib_location")); +} + +#endif /* GL_NV_explicit_attrib_location */ + #ifdef GL_NV_explicit_multisample static void _glewInfo_GL_NV_explicit_multisample (void) @@ -6197,6 +7276,15 @@ static void _glewInfo_GL_NV_explicit_multisample (void) #endif /* GL_NV_explicit_multisample */ +#ifdef GL_NV_fbo_color_attachments + +static void _glewInfo_GL_NV_fbo_color_attachments (void) +{ + glewPrintExt("GL_NV_fbo_color_attachments", GLEW_NV_fbo_color_attachments, glewIsSupported("GL_NV_fbo_color_attachments"), glewGetExtension("GL_NV_fbo_color_attachments")); +} + +#endif /* GL_NV_fbo_color_attachments */ + #ifdef GL_NV_fence static void _glewInfo_GL_NV_fence (void) @@ -6304,6 +7392,17 @@ static void _glewInfo_GL_NV_fragment_shader_interlock (void) #endif /* GL_NV_fragment_shader_interlock */ +#ifdef GL_NV_framebuffer_blit + +static void _glewInfo_GL_NV_framebuffer_blit (void) +{ + glewPrintExt("GL_NV_framebuffer_blit", GLEW_NV_framebuffer_blit, glewIsSupported("GL_NV_framebuffer_blit"), glewGetExtension("GL_NV_framebuffer_blit")); + + glewInfoFunc("glBlitFramebufferNV", glBlitFramebufferNV == NULL); +} + +#endif /* GL_NV_framebuffer_blit */ + #ifdef GL_NV_framebuffer_mixed_samples static void _glewInfo_GL_NV_framebuffer_mixed_samples (void) @@ -6313,6 +7412,17 @@ static void _glewInfo_GL_NV_framebuffer_mixed_samples (void) #endif /* GL_NV_framebuffer_mixed_samples */ +#ifdef GL_NV_framebuffer_multisample + +static void _glewInfo_GL_NV_framebuffer_multisample (void) +{ + glewPrintExt("GL_NV_framebuffer_multisample", GLEW_NV_framebuffer_multisample, glewIsSupported("GL_NV_framebuffer_multisample"), glewGetExtension("GL_NV_framebuffer_multisample")); + + glewInfoFunc("glRenderbufferStorageMultisampleNV", glRenderbufferStorageMultisampleNV == NULL); +} + +#endif /* GL_NV_framebuffer_multisample */ + #ifdef GL_NV_framebuffer_multisample_coverage static void _glewInfo_GL_NV_framebuffer_multisample_coverage (void) @@ -6324,6 +7434,15 @@ static void _glewInfo_GL_NV_framebuffer_multisample_coverage (void) #endif /* GL_NV_framebuffer_multisample_coverage */ +#ifdef GL_NV_generate_mipmap_sRGB + +static void _glewInfo_GL_NV_generate_mipmap_sRGB (void) +{ + glewPrintExt("GL_NV_generate_mipmap_sRGB", GLEW_NV_generate_mipmap_sRGB, glewIsSupported("GL_NV_generate_mipmap_sRGB"), glewGetExtension("GL_NV_generate_mipmap_sRGB")); +} + +#endif /* GL_NV_generate_mipmap_sRGB */ + #ifdef GL_NV_geometry_program4 static void _glewInfo_GL_NV_geometry_program4 (void) @@ -6524,6 +7643,26 @@ static void _glewInfo_GL_NV_half_float (void) #endif /* GL_NV_half_float */ +#ifdef GL_NV_image_formats + +static void _glewInfo_GL_NV_image_formats (void) +{ + glewPrintExt("GL_NV_image_formats", GLEW_NV_image_formats, glewIsSupported("GL_NV_image_formats"), glewGetExtension("GL_NV_image_formats")); +} + +#endif /* GL_NV_image_formats */ + +#ifdef GL_NV_instanced_arrays + +static void _glewInfo_GL_NV_instanced_arrays (void) +{ + glewPrintExt("GL_NV_instanced_arrays", GLEW_NV_instanced_arrays, glewIsSupported("GL_NV_instanced_arrays"), glewGetExtension("GL_NV_instanced_arrays")); + + glewInfoFunc("glVertexAttribDivisorNV", glVertexAttribDivisorNV == NULL); +} + +#endif /* GL_NV_instanced_arrays */ + #ifdef GL_NV_internalformat_sample_query static void _glewInfo_GL_NV_internalformat_sample_query (void) @@ -6562,6 +7701,22 @@ static void _glewInfo_GL_NV_multisample_filter_hint (void) #endif /* GL_NV_multisample_filter_hint */ +#ifdef GL_NV_non_square_matrices + +static void _glewInfo_GL_NV_non_square_matrices (void) +{ + glewPrintExt("GL_NV_non_square_matrices", GLEW_NV_non_square_matrices, glewIsSupported("GL_NV_non_square_matrices"), glewGetExtension("GL_NV_non_square_matrices")); + + glewInfoFunc("glUniformMatrix2x3fvNV", glUniformMatrix2x3fvNV == NULL); + glewInfoFunc("glUniformMatrix2x4fvNV", glUniformMatrix2x4fvNV == NULL); + glewInfoFunc("glUniformMatrix3x2fvNV", glUniformMatrix3x2fvNV == NULL); + glewInfoFunc("glUniformMatrix3x4fvNV", glUniformMatrix3x4fvNV == NULL); + glewInfoFunc("glUniformMatrix4x2fvNV", glUniformMatrix4x2fvNV == NULL); + glewInfoFunc("glUniformMatrix4x3fvNV", glUniformMatrix4x3fvNV == NULL); +} + +#endif /* GL_NV_non_square_matrices */ + #ifdef GL_NV_occlusion_query static void _glewInfo_GL_NV_occlusion_query (void) @@ -6579,6 +7734,15 @@ static void _glewInfo_GL_NV_occlusion_query (void) #endif /* GL_NV_occlusion_query */ +#ifdef GL_NV_pack_subimage + +static void _glewInfo_GL_NV_pack_subimage (void) +{ + glewPrintExt("GL_NV_pack_subimage", GLEW_NV_pack_subimage, glewIsSupported("GL_NV_pack_subimage"), glewGetExtension("GL_NV_pack_subimage")); +} + +#endif /* GL_NV_pack_subimage */ + #ifdef GL_NV_packed_depth_stencil static void _glewInfo_GL_NV_packed_depth_stencil (void) @@ -6588,6 +7752,24 @@ static void _glewInfo_GL_NV_packed_depth_stencil (void) #endif /* GL_NV_packed_depth_stencil */ +#ifdef GL_NV_packed_float + +static void _glewInfo_GL_NV_packed_float (void) +{ + glewPrintExt("GL_NV_packed_float", GLEW_NV_packed_float, glewIsSupported("GL_NV_packed_float"), glewGetExtension("GL_NV_packed_float")); +} + +#endif /* GL_NV_packed_float */ + +#ifdef GL_NV_packed_float_linear + +static void _glewInfo_GL_NV_packed_float_linear (void) +{ + glewPrintExt("GL_NV_packed_float_linear", GLEW_NV_packed_float_linear, glewIsSupported("GL_NV_packed_float_linear"), glewGetExtension("GL_NV_packed_float_linear")); +} + +#endif /* GL_NV_packed_float_linear */ + #ifdef GL_NV_parameter_buffer_object static void _glewInfo_GL_NV_parameter_buffer_object (void) @@ -6693,6 +7875,15 @@ static void _glewInfo_GL_NV_path_rendering_shared_edge (void) #endif /* GL_NV_path_rendering_shared_edge */ +#ifdef GL_NV_pixel_buffer_object + +static void _glewInfo_GL_NV_pixel_buffer_object (void) +{ + glewPrintExt("GL_NV_pixel_buffer_object", GLEW_NV_pixel_buffer_object, glewIsSupported("GL_NV_pixel_buffer_object"), glewGetExtension("GL_NV_pixel_buffer_object")); +} + +#endif /* GL_NV_pixel_buffer_object */ + #ifdef GL_NV_pixel_data_range static void _glewInfo_GL_NV_pixel_data_range (void) @@ -6705,6 +7896,15 @@ static void _glewInfo_GL_NV_pixel_data_range (void) #endif /* GL_NV_pixel_data_range */ +#ifdef GL_NV_platform_binary + +static void _glewInfo_GL_NV_platform_binary (void) +{ + glewPrintExt("GL_NV_platform_binary", GLEW_NV_platform_binary, glewIsSupported("GL_NV_platform_binary"), glewGetExtension("GL_NV_platform_binary")); +} + +#endif /* GL_NV_platform_binary */ + #ifdef GL_NV_point_sprite static void _glewInfo_GL_NV_point_sprite (void) @@ -6717,6 +7917,17 @@ static void _glewInfo_GL_NV_point_sprite (void) #endif /* GL_NV_point_sprite */ +#ifdef GL_NV_polygon_mode + +static void _glewInfo_GL_NV_polygon_mode (void) +{ + glewPrintExt("GL_NV_polygon_mode", GLEW_NV_polygon_mode, glewIsSupported("GL_NV_polygon_mode"), glewGetExtension("GL_NV_polygon_mode")); + + glewInfoFunc("glPolygonModeNV", glPolygonModeNV == NULL); +} + +#endif /* GL_NV_polygon_mode */ + #ifdef GL_NV_present_video static void _glewInfo_GL_NV_present_video (void) @@ -6745,6 +7956,33 @@ static void _glewInfo_GL_NV_primitive_restart (void) #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_read_depth + +static void _glewInfo_GL_NV_read_depth (void) +{ + glewPrintExt("GL_NV_read_depth", GLEW_NV_read_depth, glewIsSupported("GL_NV_read_depth"), glewGetExtension("GL_NV_read_depth")); +} + +#endif /* GL_NV_read_depth */ + +#ifdef GL_NV_read_depth_stencil + +static void _glewInfo_GL_NV_read_depth_stencil (void) +{ + glewPrintExt("GL_NV_read_depth_stencil", GLEW_NV_read_depth_stencil, glewIsSupported("GL_NV_read_depth_stencil"), glewGetExtension("GL_NV_read_depth_stencil")); +} + +#endif /* GL_NV_read_depth_stencil */ + +#ifdef GL_NV_read_stencil + +static void _glewInfo_GL_NV_read_stencil (void) +{ + glewPrintExt("GL_NV_read_stencil", GLEW_NV_read_stencil, glewIsSupported("GL_NV_read_stencil"), glewGetExtension("GL_NV_read_stencil")); +} + +#endif /* GL_NV_read_stencil */ + #ifdef GL_NV_register_combiners static void _glewInfo_GL_NV_register_combiners (void) @@ -6789,6 +8027,15 @@ static void _glewInfo_GL_NV_robustness_video_memory_purge (void) #endif /* GL_NV_robustness_video_memory_purge */ +#ifdef GL_NV_sRGB_formats + +static void _glewInfo_GL_NV_sRGB_formats (void) +{ + glewPrintExt("GL_NV_sRGB_formats", GLEW_NV_sRGB_formats, glewIsSupported("GL_NV_sRGB_formats"), glewGetExtension("GL_NV_sRGB_formats")); +} + +#endif /* GL_NV_sRGB_formats */ + #ifdef GL_NV_sample_locations static void _glewInfo_GL_NV_sample_locations (void) @@ -6878,6 +8125,15 @@ static void _glewInfo_GL_NV_shader_buffer_load (void) #endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_shader_noperspective_interpolation + +static void _glewInfo_GL_NV_shader_noperspective_interpolation (void) +{ + glewPrintExt("GL_NV_shader_noperspective_interpolation", GLEW_NV_shader_noperspective_interpolation, glewIsSupported("GL_NV_shader_noperspective_interpolation"), glewGetExtension("GL_NV_shader_noperspective_interpolation")); +} + +#endif /* GL_NV_shader_noperspective_interpolation */ + #ifdef GL_NV_shader_storage_buffer_object static void _glewInfo_GL_NV_shader_storage_buffer_object (void) @@ -6905,6 +8161,24 @@ static void _glewInfo_GL_NV_shader_thread_shuffle (void) #endif /* GL_NV_shader_thread_shuffle */ +#ifdef GL_NV_shadow_samplers_array + +static void _glewInfo_GL_NV_shadow_samplers_array (void) +{ + glewPrintExt("GL_NV_shadow_samplers_array", GLEW_NV_shadow_samplers_array, glewIsSupported("GL_NV_shadow_samplers_array"), glewGetExtension("GL_NV_shadow_samplers_array")); +} + +#endif /* GL_NV_shadow_samplers_array */ + +#ifdef GL_NV_shadow_samplers_cube + +static void _glewInfo_GL_NV_shadow_samplers_cube (void) +{ + glewPrintExt("GL_NV_shadow_samplers_cube", GLEW_NV_shadow_samplers_cube, glewIsSupported("GL_NV_shadow_samplers_cube"), glewGetExtension("GL_NV_shadow_samplers_cube")); +} + +#endif /* GL_NV_shadow_samplers_cube */ + #ifdef GL_NV_stereo_view_rendering static void _glewInfo_GL_NV_stereo_view_rendering (void) @@ -6941,6 +8215,22 @@ static void _glewInfo_GL_NV_texgen_reflection (void) #endif /* GL_NV_texgen_reflection */ +#ifdef GL_NV_texture_array + +static void _glewInfo_GL_NV_texture_array (void) +{ + glewPrintExt("GL_NV_texture_array", GLEW_NV_texture_array, glewIsSupported("GL_NV_texture_array"), glewGetExtension("GL_NV_texture_array")); + + glewInfoFunc("glCompressedTexImage3DNV", glCompressedTexImage3DNV == NULL); + glewInfoFunc("glCompressedTexSubImage3DNV", glCompressedTexSubImage3DNV == NULL); + glewInfoFunc("glCopyTexSubImage3DNV", glCopyTexSubImage3DNV == NULL); + glewInfoFunc("glFramebufferTextureLayerNV", glFramebufferTextureLayerNV == NULL); + glewInfoFunc("glTexImage3DNV", glTexImage3DNV == NULL); + glewInfoFunc("glTexSubImage3DNV", glTexSubImage3DNV == NULL); +} + +#endif /* GL_NV_texture_array */ + #ifdef GL_NV_texture_barrier static void _glewInfo_GL_NV_texture_barrier (void) @@ -6952,6 +8242,42 @@ static void _glewInfo_GL_NV_texture_barrier (void) #endif /* GL_NV_texture_barrier */ +#ifdef GL_NV_texture_border_clamp + +static void _glewInfo_GL_NV_texture_border_clamp (void) +{ + glewPrintExt("GL_NV_texture_border_clamp", GLEW_NV_texture_border_clamp, glewIsSupported("GL_NV_texture_border_clamp"), glewGetExtension("GL_NV_texture_border_clamp")); +} + +#endif /* GL_NV_texture_border_clamp */ + +#ifdef GL_NV_texture_compression_latc + +static void _glewInfo_GL_NV_texture_compression_latc (void) +{ + glewPrintExt("GL_NV_texture_compression_latc", GLEW_NV_texture_compression_latc, glewIsSupported("GL_NV_texture_compression_latc"), glewGetExtension("GL_NV_texture_compression_latc")); +} + +#endif /* GL_NV_texture_compression_latc */ + +#ifdef GL_NV_texture_compression_s3tc + +static void _glewInfo_GL_NV_texture_compression_s3tc (void) +{ + glewPrintExt("GL_NV_texture_compression_s3tc", GLEW_NV_texture_compression_s3tc, glewIsSupported("GL_NV_texture_compression_s3tc"), glewGetExtension("GL_NV_texture_compression_s3tc")); +} + +#endif /* GL_NV_texture_compression_s3tc */ + +#ifdef GL_NV_texture_compression_s3tc_update + +static void _glewInfo_GL_NV_texture_compression_s3tc_update (void) +{ + glewPrintExt("GL_NV_texture_compression_s3tc_update", GLEW_NV_texture_compression_s3tc_update, glewIsSupported("GL_NV_texture_compression_s3tc_update"), glewGetExtension("GL_NV_texture_compression_s3tc_update")); +} + +#endif /* GL_NV_texture_compression_s3tc_update */ + #ifdef GL_NV_texture_compression_vtc static void _glewInfo_GL_NV_texture_compression_vtc (void) @@ -6995,6 +8321,15 @@ static void _glewInfo_GL_NV_texture_multisample (void) #endif /* GL_NV_texture_multisample */ +#ifdef GL_NV_texture_npot_2D_mipmap + +static void _glewInfo_GL_NV_texture_npot_2D_mipmap (void) +{ + glewPrintExt("GL_NV_texture_npot_2D_mipmap", GLEW_NV_texture_npot_2D_mipmap, glewIsSupported("GL_NV_texture_npot_2D_mipmap"), glewGetExtension("GL_NV_texture_npot_2D_mipmap")); +} + +#endif /* GL_NV_texture_npot_2D_mipmap */ + #ifdef GL_NV_texture_rectangle static void _glewInfo_GL_NV_texture_rectangle (void) @@ -7004,6 +8339,15 @@ static void _glewInfo_GL_NV_texture_rectangle (void) #endif /* GL_NV_texture_rectangle */ +#ifdef GL_NV_texture_rectangle_compressed + +static void _glewInfo_GL_NV_texture_rectangle_compressed (void) +{ + glewPrintExt("GL_NV_texture_rectangle_compressed", GLEW_NV_texture_rectangle_compressed, glewIsSupported("GL_NV_texture_rectangle_compressed"), glewGetExtension("GL_NV_texture_rectangle_compressed")); +} + +#endif /* GL_NV_texture_rectangle_compressed */ + #ifdef GL_NV_texture_shader static void _glewInfo_GL_NV_texture_shader (void) @@ -7311,6 +8655,28 @@ static void _glewInfo_GL_NV_video_capture (void) #endif /* GL_NV_video_capture */ +#ifdef GL_NV_viewport_array + +static void _glewInfo_GL_NV_viewport_array (void) +{ + glewPrintExt("GL_NV_viewport_array", GLEW_NV_viewport_array, glewIsSupported("GL_NV_viewport_array"), glewGetExtension("GL_NV_viewport_array")); + + glewInfoFunc("glDepthRangeArrayfvNV", glDepthRangeArrayfvNV == NULL); + glewInfoFunc("glDepthRangeIndexedfNV", glDepthRangeIndexedfNV == NULL); + glewInfoFunc("glDisableiNV", glDisableiNV == NULL); + glewInfoFunc("glEnableiNV", glEnableiNV == NULL); + glewInfoFunc("glGetFloati_vNV", glGetFloati_vNV == NULL); + glewInfoFunc("glIsEnablediNV", glIsEnablediNV == NULL); + glewInfoFunc("glScissorArrayvNV", glScissorArrayvNV == NULL); + glewInfoFunc("glScissorIndexedNV", glScissorIndexedNV == NULL); + glewInfoFunc("glScissorIndexedvNV", glScissorIndexedvNV == NULL); + glewInfoFunc("glViewportArrayvNV", glViewportArrayvNV == NULL); + glewInfoFunc("glViewportIndexedfNV", glViewportIndexedfNV == NULL); + glewInfoFunc("glViewportIndexedfvNV", glViewportIndexedfvNV == NULL); +} + +#endif /* GL_NV_viewport_array */ + #ifdef GL_NV_viewport_array2 static void _glewInfo_GL_NV_viewport_array2 (void) @@ -7340,40 +8706,6 @@ static void _glewInfo_GL_OES_byte_coordinates (void) #endif /* GL_OES_byte_coordinates */ -#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_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_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_OML_interlace static void _glewInfo_GL_OML_interlace (void) @@ -7421,6 +8753,17 @@ static void _glewInfo_GL_OVR_multiview2 (void) #endif /* GL_OVR_multiview2 */ +#ifdef GL_OVR_multiview_multisampled_render_to_texture + +static void _glewInfo_GL_OVR_multiview_multisampled_render_to_texture (void) +{ + glewPrintExt("GL_OVR_multiview_multisampled_render_to_texture", GLEW_OVR_multiview_multisampled_render_to_texture, glewIsSupported("GL_OVR_multiview_multisampled_render_to_texture"), glewGetExtension("GL_OVR_multiview_multisampled_render_to_texture")); + + glewInfoFunc("glFramebufferTextureMultisampleMultiviewOVR", glFramebufferTextureMultisampleMultiviewOVR == NULL); +} + +#endif /* GL_OVR_multiview_multisampled_render_to_texture */ + #ifdef GL_PGI_misc_hints static void _glewInfo_GL_PGI_misc_hints (void) @@ -7439,6 +8782,125 @@ static void _glewInfo_GL_PGI_vertex_hints (void) #endif /* GL_PGI_vertex_hints */ +#ifdef GL_QCOM_alpha_test + +static void _glewInfo_GL_QCOM_alpha_test (void) +{ + glewPrintExt("GL_QCOM_alpha_test", GLEW_QCOM_alpha_test, glewIsSupported("GL_QCOM_alpha_test"), glewGetExtension("GL_QCOM_alpha_test")); + + glewInfoFunc("glAlphaFuncQCOM", glAlphaFuncQCOM == NULL); +} + +#endif /* GL_QCOM_alpha_test */ + +#ifdef GL_QCOM_binning_control + +static void _glewInfo_GL_QCOM_binning_control (void) +{ + glewPrintExt("GL_QCOM_binning_control", GLEW_QCOM_binning_control, glewIsSupported("GL_QCOM_binning_control"), glewGetExtension("GL_QCOM_binning_control")); +} + +#endif /* GL_QCOM_binning_control */ + +#ifdef GL_QCOM_driver_control + +static void _glewInfo_GL_QCOM_driver_control (void) +{ + glewPrintExt("GL_QCOM_driver_control", GLEW_QCOM_driver_control, glewIsSupported("GL_QCOM_driver_control"), glewGetExtension("GL_QCOM_driver_control")); + + glewInfoFunc("glDisableDriverControlQCOM", glDisableDriverControlQCOM == NULL); + glewInfoFunc("glEnableDriverControlQCOM", glEnableDriverControlQCOM == NULL); + glewInfoFunc("glGetDriverControlStringQCOM", glGetDriverControlStringQCOM == NULL); + glewInfoFunc("glGetDriverControlsQCOM", glGetDriverControlsQCOM == NULL); +} + +#endif /* GL_QCOM_driver_control */ + +#ifdef GL_QCOM_extended_get + +static void _glewInfo_GL_QCOM_extended_get (void) +{ + glewPrintExt("GL_QCOM_extended_get", GLEW_QCOM_extended_get, glewIsSupported("GL_QCOM_extended_get"), glewGetExtension("GL_QCOM_extended_get")); + + glewInfoFunc("glExtGetBufferPointervQCOM", glExtGetBufferPointervQCOM == NULL); + glewInfoFunc("glExtGetBuffersQCOM", glExtGetBuffersQCOM == NULL); + glewInfoFunc("glExtGetFramebuffersQCOM", glExtGetFramebuffersQCOM == NULL); + glewInfoFunc("glExtGetRenderbuffersQCOM", glExtGetRenderbuffersQCOM == NULL); + glewInfoFunc("glExtGetTexLevelParameterivQCOM", glExtGetTexLevelParameterivQCOM == NULL); + glewInfoFunc("glExtGetTexSubImageQCOM", glExtGetTexSubImageQCOM == NULL); + glewInfoFunc("glExtGetTexturesQCOM", glExtGetTexturesQCOM == NULL); + glewInfoFunc("glExtTexObjectStateOverrideiQCOM", glExtTexObjectStateOverrideiQCOM == NULL); +} + +#endif /* GL_QCOM_extended_get */ + +#ifdef GL_QCOM_extended_get2 + +static void _glewInfo_GL_QCOM_extended_get2 (void) +{ + glewPrintExt("GL_QCOM_extended_get2", GLEW_QCOM_extended_get2, glewIsSupported("GL_QCOM_extended_get2"), glewGetExtension("GL_QCOM_extended_get2")); + + glewInfoFunc("glExtGetProgramBinarySourceQCOM", glExtGetProgramBinarySourceQCOM == NULL); + glewInfoFunc("glExtGetProgramsQCOM", glExtGetProgramsQCOM == NULL); + glewInfoFunc("glExtGetShadersQCOM", glExtGetShadersQCOM == NULL); + glewInfoFunc("glExtIsProgramBinaryQCOM", glExtIsProgramBinaryQCOM == NULL); +} + +#endif /* GL_QCOM_extended_get2 */ + +#ifdef GL_QCOM_framebuffer_foveated + +static void _glewInfo_GL_QCOM_framebuffer_foveated (void) +{ + glewPrintExt("GL_QCOM_framebuffer_foveated", GLEW_QCOM_framebuffer_foveated, glewIsSupported("GL_QCOM_framebuffer_foveated"), glewGetExtension("GL_QCOM_framebuffer_foveated")); + + glewInfoFunc("glFramebufferFoveationConfigQCOM", glFramebufferFoveationConfigQCOM == NULL); + glewInfoFunc("glFramebufferFoveationParametersQCOM", glFramebufferFoveationParametersQCOM == NULL); +} + +#endif /* GL_QCOM_framebuffer_foveated */ + +#ifdef GL_QCOM_perfmon_global_mode + +static void _glewInfo_GL_QCOM_perfmon_global_mode (void) +{ + glewPrintExt("GL_QCOM_perfmon_global_mode", GLEW_QCOM_perfmon_global_mode, glewIsSupported("GL_QCOM_perfmon_global_mode"), glewGetExtension("GL_QCOM_perfmon_global_mode")); +} + +#endif /* GL_QCOM_perfmon_global_mode */ + +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + +static void _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent (void) +{ + glewPrintExt("GL_QCOM_shader_framebuffer_fetch_noncoherent", GLEW_QCOM_shader_framebuffer_fetch_noncoherent, glewIsSupported("GL_QCOM_shader_framebuffer_fetch_noncoherent"), glewGetExtension("GL_QCOM_shader_framebuffer_fetch_noncoherent")); + + glewInfoFunc("glFramebufferFetchBarrierQCOM", glFramebufferFetchBarrierQCOM == NULL); +} + +#endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ + +#ifdef GL_QCOM_tiled_rendering + +static void _glewInfo_GL_QCOM_tiled_rendering (void) +{ + glewPrintExt("GL_QCOM_tiled_rendering", GLEW_QCOM_tiled_rendering, glewIsSupported("GL_QCOM_tiled_rendering"), glewGetExtension("GL_QCOM_tiled_rendering")); + + glewInfoFunc("glEndTilingQCOM", glEndTilingQCOM == NULL); + glewInfoFunc("glStartTilingQCOM", glStartTilingQCOM == NULL); +} + +#endif /* GL_QCOM_tiled_rendering */ + +#ifdef GL_QCOM_writeonly_rendering + +static void _glewInfo_GL_QCOM_writeonly_rendering (void) +{ + glewPrintExt("GL_QCOM_writeonly_rendering", GLEW_QCOM_writeonly_rendering, glewIsSupported("GL_QCOM_writeonly_rendering"), glewGetExtension("GL_QCOM_writeonly_rendering")); +} + +#endif /* GL_QCOM_writeonly_rendering */ + #ifdef GL_REGAL_ES1_0_compatibility static void _glewInfo_GL_REGAL_ES1_0_compatibility (void) @@ -7575,6 +9037,15 @@ static void _glewInfo_GL_S3_s3tc (void) #endif /* GL_S3_s3tc */ +#ifdef GL_SGIS_clip_band_hint + +static void _glewInfo_GL_SGIS_clip_band_hint (void) +{ + glewPrintExt("GL_SGIS_clip_band_hint", GLEW_SGIS_clip_band_hint, glewIsSupported("GL_SGIS_clip_band_hint"), glewGetExtension("GL_SGIS_clip_band_hint")); +} + +#endif /* GL_SGIS_clip_band_hint */ + #ifdef GL_SGIS_color_range static void _glewInfo_GL_SGIS_color_range (void) @@ -7617,6 +9088,15 @@ static void _glewInfo_GL_SGIS_generate_mipmap (void) #endif /* GL_SGIS_generate_mipmap */ +#ifdef GL_SGIS_line_texgen + +static void _glewInfo_GL_SGIS_line_texgen (void) +{ + glewPrintExt("GL_SGIS_line_texgen", GLEW_SGIS_line_texgen, glewIsSupported("GL_SGIS_line_texgen"), glewGetExtension("GL_SGIS_line_texgen")); +} + +#endif /* GL_SGIS_line_texgen */ + #ifdef GL_SGIS_multisample static void _glewInfo_GL_SGIS_multisample (void) @@ -7629,6 +9109,20 @@ static void _glewInfo_GL_SGIS_multisample (void) #endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_multitexture + +static void _glewInfo_GL_SGIS_multitexture (void) +{ + glewPrintExt("GL_SGIS_multitexture", GLEW_SGIS_multitexture, glewIsSupported("GL_SGIS_multitexture"), glewGetExtension("GL_SGIS_multitexture")); + + glewInfoFunc("glInterleavedTextureCoordSetsSGIS", glInterleavedTextureCoordSetsSGIS == NULL); + glewInfoFunc("glSelectTextureCoordSetSGIS", glSelectTextureCoordSetSGIS == NULL); + glewInfoFunc("glSelectTextureSGIS", glSelectTextureSGIS == NULL); + glewInfoFunc("glSelectTextureTransformSGIS", glSelectTextureTransformSGIS == NULL); +} + +#endif /* GL_SGIS_multitexture */ + #ifdef GL_SGIS_pixel_texture static void _glewInfo_GL_SGIS_pixel_texture (void) @@ -7647,6 +9141,17 @@ static void _glewInfo_GL_SGIS_point_line_texgen (void) #endif /* GL_SGIS_point_line_texgen */ +#ifdef GL_SGIS_shared_multisample + +static void _glewInfo_GL_SGIS_shared_multisample (void) +{ + glewPrintExt("GL_SGIS_shared_multisample", GLEW_SGIS_shared_multisample, glewIsSupported("GL_SGIS_shared_multisample"), glewGetExtension("GL_SGIS_shared_multisample")); + + glewInfoFunc("glMultisampleSubRectPosSGIS", glMultisampleSubRectPosSGIS == NULL); +} + +#endif /* GL_SGIS_shared_multisample */ + #ifdef GL_SGIS_sharpen_texture static void _glewInfo_GL_SGIS_sharpen_texture (void) @@ -7753,6 +9258,33 @@ static void _glewInfo_GL_SGIX_async_pixel (void) #endif /* GL_SGIX_async_pixel */ +#ifdef GL_SGIX_bali_g_instruments + +static void _glewInfo_GL_SGIX_bali_g_instruments (void) +{ + glewPrintExt("GL_SGIX_bali_g_instruments", GLEW_SGIX_bali_g_instruments, glewIsSupported("GL_SGIX_bali_g_instruments"), glewGetExtension("GL_SGIX_bali_g_instruments")); +} + +#endif /* GL_SGIX_bali_g_instruments */ + +#ifdef GL_SGIX_bali_r_instruments + +static void _glewInfo_GL_SGIX_bali_r_instruments (void) +{ + glewPrintExt("GL_SGIX_bali_r_instruments", GLEW_SGIX_bali_r_instruments, glewIsSupported("GL_SGIX_bali_r_instruments"), glewGetExtension("GL_SGIX_bali_r_instruments")); +} + +#endif /* GL_SGIX_bali_r_instruments */ + +#ifdef GL_SGIX_bali_timer_instruments + +static void _glewInfo_GL_SGIX_bali_timer_instruments (void) +{ + glewPrintExt("GL_SGIX_bali_timer_instruments", GLEW_SGIX_bali_timer_instruments, glewIsSupported("GL_SGIX_bali_timer_instruments"), glewGetExtension("GL_SGIX_bali_timer_instruments")); +} + +#endif /* GL_SGIX_bali_timer_instruments */ + #ifdef GL_SGIX_blend_alpha_minmax static void _glewInfo_GL_SGIX_blend_alpha_minmax (void) @@ -7762,6 +9294,33 @@ static void _glewInfo_GL_SGIX_blend_alpha_minmax (void) #endif /* GL_SGIX_blend_alpha_minmax */ +#ifdef GL_SGIX_blend_cadd + +static void _glewInfo_GL_SGIX_blend_cadd (void) +{ + glewPrintExt("GL_SGIX_blend_cadd", GLEW_SGIX_blend_cadd, glewIsSupported("GL_SGIX_blend_cadd"), glewGetExtension("GL_SGIX_blend_cadd")); +} + +#endif /* GL_SGIX_blend_cadd */ + +#ifdef GL_SGIX_blend_cmultiply + +static void _glewInfo_GL_SGIX_blend_cmultiply (void) +{ + glewPrintExt("GL_SGIX_blend_cmultiply", GLEW_SGIX_blend_cmultiply, glewIsSupported("GL_SGIX_blend_cmultiply"), glewGetExtension("GL_SGIX_blend_cmultiply")); +} + +#endif /* GL_SGIX_blend_cmultiply */ + +#ifdef GL_SGIX_calligraphic_fragment + +static void _glewInfo_GL_SGIX_calligraphic_fragment (void) +{ + glewPrintExt("GL_SGIX_calligraphic_fragment", GLEW_SGIX_calligraphic_fragment, glewIsSupported("GL_SGIX_calligraphic_fragment"), glewGetExtension("GL_SGIX_calligraphic_fragment")); +} + +#endif /* GL_SGIX_calligraphic_fragment */ + #ifdef GL_SGIX_clipmap static void _glewInfo_GL_SGIX_clipmap (void) @@ -7771,6 +9330,33 @@ static void _glewInfo_GL_SGIX_clipmap (void) #endif /* GL_SGIX_clipmap */ +#ifdef GL_SGIX_color_matrix_accuracy + +static void _glewInfo_GL_SGIX_color_matrix_accuracy (void) +{ + glewPrintExt("GL_SGIX_color_matrix_accuracy", GLEW_SGIX_color_matrix_accuracy, glewIsSupported("GL_SGIX_color_matrix_accuracy"), glewGetExtension("GL_SGIX_color_matrix_accuracy")); +} + +#endif /* GL_SGIX_color_matrix_accuracy */ + +#ifdef GL_SGIX_color_table_index_mode + +static void _glewInfo_GL_SGIX_color_table_index_mode (void) +{ + glewPrintExt("GL_SGIX_color_table_index_mode", GLEW_SGIX_color_table_index_mode, glewIsSupported("GL_SGIX_color_table_index_mode"), glewGetExtension("GL_SGIX_color_table_index_mode")); +} + +#endif /* GL_SGIX_color_table_index_mode */ + +#ifdef GL_SGIX_complex_polar + +static void _glewInfo_GL_SGIX_complex_polar (void) +{ + glewPrintExt("GL_SGIX_complex_polar", GLEW_SGIX_complex_polar, glewIsSupported("GL_SGIX_complex_polar"), glewGetExtension("GL_SGIX_complex_polar")); +} + +#endif /* GL_SGIX_complex_polar */ + #ifdef GL_SGIX_convolution_accuracy static void _glewInfo_GL_SGIX_convolution_accuracy (void) @@ -7780,6 +9366,54 @@ static void _glewInfo_GL_SGIX_convolution_accuracy (void) #endif /* GL_SGIX_convolution_accuracy */ +#ifdef GL_SGIX_cube_map + +static void _glewInfo_GL_SGIX_cube_map (void) +{ + glewPrintExt("GL_SGIX_cube_map", GLEW_SGIX_cube_map, glewIsSupported("GL_SGIX_cube_map"), glewGetExtension("GL_SGIX_cube_map")); +} + +#endif /* GL_SGIX_cube_map */ + +#ifdef GL_SGIX_cylinder_texgen + +static void _glewInfo_GL_SGIX_cylinder_texgen (void) +{ + glewPrintExt("GL_SGIX_cylinder_texgen", GLEW_SGIX_cylinder_texgen, glewIsSupported("GL_SGIX_cylinder_texgen"), glewGetExtension("GL_SGIX_cylinder_texgen")); +} + +#endif /* GL_SGIX_cylinder_texgen */ + +#ifdef GL_SGIX_datapipe + +static void _glewInfo_GL_SGIX_datapipe (void) +{ + glewPrintExt("GL_SGIX_datapipe", GLEW_SGIX_datapipe, glewIsSupported("GL_SGIX_datapipe"), glewGetExtension("GL_SGIX_datapipe")); + + glewInfoFunc("glAddressSpace", glAddressSpace == NULL); + glewInfoFunc("glDataPipe", glDataPipe == NULL); +} + +#endif /* GL_SGIX_datapipe */ + +#ifdef GL_SGIX_decimation + +static void _glewInfo_GL_SGIX_decimation (void) +{ + glewPrintExt("GL_SGIX_decimation", GLEW_SGIX_decimation, glewIsSupported("GL_SGIX_decimation"), glewGetExtension("GL_SGIX_decimation")); +} + +#endif /* GL_SGIX_decimation */ + +#ifdef GL_SGIX_depth_pass_instrument + +static void _glewInfo_GL_SGIX_depth_pass_instrument (void) +{ + glewPrintExt("GL_SGIX_depth_pass_instrument", GLEW_SGIX_depth_pass_instrument, glewIsSupported("GL_SGIX_depth_pass_instrument"), glewGetExtension("GL_SGIX_depth_pass_instrument")); +} + +#endif /* GL_SGIX_depth_pass_instrument */ + #ifdef GL_SGIX_depth_texture static void _glewInfo_GL_SGIX_depth_texture (void) @@ -7789,6 +9423,15 @@ static void _glewInfo_GL_SGIX_depth_texture (void) #endif /* GL_SGIX_depth_texture */ +#ifdef GL_SGIX_dvc + +static void _glewInfo_GL_SGIX_dvc (void) +{ + glewPrintExt("GL_SGIX_dvc", GLEW_SGIX_dvc, glewIsSupported("GL_SGIX_dvc"), glewGetExtension("GL_SGIX_dvc")); +} + +#endif /* GL_SGIX_dvc */ + #ifdef GL_SGIX_flush_raster static void _glewInfo_GL_SGIX_flush_raster (void) @@ -7800,6 +9443,36 @@ static void _glewInfo_GL_SGIX_flush_raster (void) #endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_blend + +static void _glewInfo_GL_SGIX_fog_blend (void) +{ + glewPrintExt("GL_SGIX_fog_blend", GLEW_SGIX_fog_blend, glewIsSupported("GL_SGIX_fog_blend"), glewGetExtension("GL_SGIX_fog_blend")); +} + +#endif /* GL_SGIX_fog_blend */ + +#ifdef GL_SGIX_fog_factor_to_alpha + +static void _glewInfo_GL_SGIX_fog_factor_to_alpha (void) +{ + glewPrintExt("GL_SGIX_fog_factor_to_alpha", GLEW_SGIX_fog_factor_to_alpha, glewIsSupported("GL_SGIX_fog_factor_to_alpha"), glewGetExtension("GL_SGIX_fog_factor_to_alpha")); +} + +#endif /* GL_SGIX_fog_factor_to_alpha */ + +#ifdef GL_SGIX_fog_layers + +static void _glewInfo_GL_SGIX_fog_layers (void) +{ + glewPrintExt("GL_SGIX_fog_layers", GLEW_SGIX_fog_layers, glewIsSupported("GL_SGIX_fog_layers"), glewGetExtension("GL_SGIX_fog_layers")); + + glewInfoFunc("glFogLayersSGIX", glFogLayersSGIX == NULL); + glewInfoFunc("glGetFogLayersSGIX", glGetFogLayersSGIX == NULL); +} + +#endif /* GL_SGIX_fog_layers */ + #ifdef GL_SGIX_fog_offset static void _glewInfo_GL_SGIX_fog_offset (void) @@ -7809,6 +9482,24 @@ static void _glewInfo_GL_SGIX_fog_offset (void) #endif /* GL_SGIX_fog_offset */ +#ifdef GL_SGIX_fog_patchy + +static void _glewInfo_GL_SGIX_fog_patchy (void) +{ + glewPrintExt("GL_SGIX_fog_patchy", GLEW_SGIX_fog_patchy, glewIsSupported("GL_SGIX_fog_patchy"), glewGetExtension("GL_SGIX_fog_patchy")); +} + +#endif /* GL_SGIX_fog_patchy */ + +#ifdef GL_SGIX_fog_scale + +static void _glewInfo_GL_SGIX_fog_scale (void) +{ + glewPrintExt("GL_SGIX_fog_scale", GLEW_SGIX_fog_scale, glewIsSupported("GL_SGIX_fog_scale"), glewGetExtension("GL_SGIX_fog_scale")); +} + +#endif /* GL_SGIX_fog_scale */ + #ifdef GL_SGIX_fog_texture static void _glewInfo_GL_SGIX_fog_texture (void) @@ -7820,6 +9511,15 @@ static void _glewInfo_GL_SGIX_fog_texture (void) #endif /* GL_SGIX_fog_texture */ +#ifdef GL_SGIX_fragment_lighting_space + +static void _glewInfo_GL_SGIX_fragment_lighting_space (void) +{ + glewPrintExt("GL_SGIX_fragment_lighting_space", GLEW_SGIX_fragment_lighting_space, glewIsSupported("GL_SGIX_fragment_lighting_space"), glewGetExtension("GL_SGIX_fragment_lighting_space")); +} + +#endif /* GL_SGIX_fragment_lighting_space */ + #ifdef GL_SGIX_fragment_specular_lighting static void _glewInfo_GL_SGIX_fragment_specular_lighting (void) @@ -7847,6 +9547,15 @@ static void _glewInfo_GL_SGIX_fragment_specular_lighting (void) #endif /* GL_SGIX_fragment_specular_lighting */ +#ifdef GL_SGIX_fragments_instrument + +static void _glewInfo_GL_SGIX_fragments_instrument (void) +{ + glewPrintExt("GL_SGIX_fragments_instrument", GLEW_SGIX_fragments_instrument, glewIsSupported("GL_SGIX_fragments_instrument"), glewGetExtension("GL_SGIX_fragments_instrument")); +} + +#endif /* GL_SGIX_fragments_instrument */ + #ifdef GL_SGIX_framezoom static void _glewInfo_GL_SGIX_framezoom (void) @@ -7858,6 +9567,53 @@ static void _glewInfo_GL_SGIX_framezoom (void) #endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_icc_texture + +static void _glewInfo_GL_SGIX_icc_texture (void) +{ + glewPrintExt("GL_SGIX_icc_texture", GLEW_SGIX_icc_texture, glewIsSupported("GL_SGIX_icc_texture"), glewGetExtension("GL_SGIX_icc_texture")); +} + +#endif /* GL_SGIX_icc_texture */ + +#ifdef GL_SGIX_igloo_interface + +static void _glewInfo_GL_SGIX_igloo_interface (void) +{ + glewPrintExt("GL_SGIX_igloo_interface", GLEW_SGIX_igloo_interface, glewIsSupported("GL_SGIX_igloo_interface"), glewGetExtension("GL_SGIX_igloo_interface")); + + glewInfoFunc("glIglooInterfaceSGIX", glIglooInterfaceSGIX == NULL); +} + +#endif /* GL_SGIX_igloo_interface */ + +#ifdef GL_SGIX_image_compression + +static void _glewInfo_GL_SGIX_image_compression (void) +{ + glewPrintExt("GL_SGIX_image_compression", GLEW_SGIX_image_compression, glewIsSupported("GL_SGIX_image_compression"), glewGetExtension("GL_SGIX_image_compression")); +} + +#endif /* GL_SGIX_image_compression */ + +#ifdef GL_SGIX_impact_pixel_texture + +static void _glewInfo_GL_SGIX_impact_pixel_texture (void) +{ + glewPrintExt("GL_SGIX_impact_pixel_texture", GLEW_SGIX_impact_pixel_texture, glewIsSupported("GL_SGIX_impact_pixel_texture"), glewGetExtension("GL_SGIX_impact_pixel_texture")); +} + +#endif /* GL_SGIX_impact_pixel_texture */ + +#ifdef GL_SGIX_instrument_error + +static void _glewInfo_GL_SGIX_instrument_error (void) +{ + glewPrintExt("GL_SGIX_instrument_error", GLEW_SGIX_instrument_error, glewIsSupported("GL_SGIX_instrument_error"), glewGetExtension("GL_SGIX_instrument_error")); +} + +#endif /* GL_SGIX_instrument_error */ + #ifdef GL_SGIX_interlace static void _glewInfo_GL_SGIX_interlace (void) @@ -7876,6 +9632,15 @@ static void _glewInfo_GL_SGIX_ir_instrument1 (void) #endif /* GL_SGIX_ir_instrument1 */ +#ifdef GL_SGIX_line_quality_hint + +static void _glewInfo_GL_SGIX_line_quality_hint (void) +{ + glewPrintExt("GL_SGIX_line_quality_hint", GLEW_SGIX_line_quality_hint, glewIsSupported("GL_SGIX_line_quality_hint"), glewGetExtension("GL_SGIX_line_quality_hint")); +} + +#endif /* GL_SGIX_line_quality_hint */ + #ifdef GL_SGIX_list_priority static void _glewInfo_GL_SGIX_list_priority (void) @@ -7885,6 +9650,77 @@ static void _glewInfo_GL_SGIX_list_priority (void) #endif /* GL_SGIX_list_priority */ +#ifdef GL_SGIX_mpeg1 + +static void _glewInfo_GL_SGIX_mpeg1 (void) +{ + glewPrintExt("GL_SGIX_mpeg1", GLEW_SGIX_mpeg1, glewIsSupported("GL_SGIX_mpeg1"), glewGetExtension("GL_SGIX_mpeg1")); + + glewInfoFunc("glAllocMPEGPredictorsSGIX", glAllocMPEGPredictorsSGIX == NULL); + glewInfoFunc("glDeleteMPEGPredictorsSGIX", glDeleteMPEGPredictorsSGIX == NULL); + glewInfoFunc("glGenMPEGPredictorsSGIX", glGenMPEGPredictorsSGIX == NULL); + glewInfoFunc("glGetMPEGParameterfvSGIX", glGetMPEGParameterfvSGIX == NULL); + glewInfoFunc("glGetMPEGParameterivSGIX", glGetMPEGParameterivSGIX == NULL); + glewInfoFunc("glGetMPEGPredictorSGIX", glGetMPEGPredictorSGIX == NULL); + glewInfoFunc("glGetMPEGQuantTableubv", glGetMPEGQuantTableubv == NULL); + glewInfoFunc("glIsMPEGPredictorSGIX", glIsMPEGPredictorSGIX == NULL); + glewInfoFunc("glMPEGPredictorSGIX", glMPEGPredictorSGIX == NULL); + glewInfoFunc("glMPEGQuantTableubv", glMPEGQuantTableubv == NULL); + glewInfoFunc("glSwapMPEGPredictorsSGIX", glSwapMPEGPredictorsSGIX == NULL); +} + +#endif /* GL_SGIX_mpeg1 */ + +#ifdef GL_SGIX_mpeg2 + +static void _glewInfo_GL_SGIX_mpeg2 (void) +{ + glewPrintExt("GL_SGIX_mpeg2", GLEW_SGIX_mpeg2, glewIsSupported("GL_SGIX_mpeg2"), glewGetExtension("GL_SGIX_mpeg2")); +} + +#endif /* GL_SGIX_mpeg2 */ + +#ifdef GL_SGIX_nonlinear_lighting_pervertex + +static void _glewInfo_GL_SGIX_nonlinear_lighting_pervertex (void) +{ + glewPrintExt("GL_SGIX_nonlinear_lighting_pervertex", GLEW_SGIX_nonlinear_lighting_pervertex, glewIsSupported("GL_SGIX_nonlinear_lighting_pervertex"), glewGetExtension("GL_SGIX_nonlinear_lighting_pervertex")); + + glewInfoFunc("glGetNonlinLightfvSGIX", glGetNonlinLightfvSGIX == NULL); + glewInfoFunc("glGetNonlinMaterialfvSGIX", glGetNonlinMaterialfvSGIX == NULL); + glewInfoFunc("glNonlinLightfvSGIX", glNonlinLightfvSGIX == NULL); + glewInfoFunc("glNonlinMaterialfvSGIX", glNonlinMaterialfvSGIX == NULL); +} + +#endif /* GL_SGIX_nonlinear_lighting_pervertex */ + +#ifdef GL_SGIX_nurbs_eval + +static void _glewInfo_GL_SGIX_nurbs_eval (void) +{ + glewPrintExt("GL_SGIX_nurbs_eval", GLEW_SGIX_nurbs_eval, glewIsSupported("GL_SGIX_nurbs_eval"), glewGetExtension("GL_SGIX_nurbs_eval")); +} + +#endif /* GL_SGIX_nurbs_eval */ + +#ifdef GL_SGIX_occlusion_instrument + +static void _glewInfo_GL_SGIX_occlusion_instrument (void) +{ + glewPrintExt("GL_SGIX_occlusion_instrument", GLEW_SGIX_occlusion_instrument, glewIsSupported("GL_SGIX_occlusion_instrument"), glewGetExtension("GL_SGIX_occlusion_instrument")); +} + +#endif /* GL_SGIX_occlusion_instrument */ + +#ifdef GL_SGIX_packed_6bytes + +static void _glewInfo_GL_SGIX_packed_6bytes (void) +{ + glewPrintExt("GL_SGIX_packed_6bytes", GLEW_SGIX_packed_6bytes, glewIsSupported("GL_SGIX_packed_6bytes"), glewGetExtension("GL_SGIX_packed_6bytes")); +} + +#endif /* GL_SGIX_packed_6bytes */ + #ifdef GL_SGIX_pixel_texture static void _glewInfo_GL_SGIX_pixel_texture (void) @@ -7905,6 +9741,48 @@ static void _glewInfo_GL_SGIX_pixel_texture_bits (void) #endif /* GL_SGIX_pixel_texture_bits */ +#ifdef GL_SGIX_pixel_texture_lod + +static void _glewInfo_GL_SGIX_pixel_texture_lod (void) +{ + glewPrintExt("GL_SGIX_pixel_texture_lod", GLEW_SGIX_pixel_texture_lod, glewIsSupported("GL_SGIX_pixel_texture_lod"), glewGetExtension("GL_SGIX_pixel_texture_lod")); +} + +#endif /* GL_SGIX_pixel_texture_lod */ + +#ifdef GL_SGIX_pixel_tiles + +static void _glewInfo_GL_SGIX_pixel_tiles (void) +{ + glewPrintExt("GL_SGIX_pixel_tiles", GLEW_SGIX_pixel_tiles, glewIsSupported("GL_SGIX_pixel_tiles"), glewGetExtension("GL_SGIX_pixel_tiles")); +} + +#endif /* GL_SGIX_pixel_tiles */ + +#ifdef GL_SGIX_polynomial_ffd + +static void _glewInfo_GL_SGIX_polynomial_ffd (void) +{ + glewPrintExt("GL_SGIX_polynomial_ffd", GLEW_SGIX_polynomial_ffd, glewIsSupported("GL_SGIX_polynomial_ffd"), glewGetExtension("GL_SGIX_polynomial_ffd")); + + glewInfoFunc("glDeformSGIX", glDeformSGIX == NULL); + glewInfoFunc("glLoadIdentityDeformationMapSGIX", glLoadIdentityDeformationMapSGIX == NULL); +} + +#endif /* GL_SGIX_polynomial_ffd */ + +#ifdef GL_SGIX_quad_mesh + +static void _glewInfo_GL_SGIX_quad_mesh (void) +{ + glewPrintExt("GL_SGIX_quad_mesh", GLEW_SGIX_quad_mesh, glewIsSupported("GL_SGIX_quad_mesh"), glewGetExtension("GL_SGIX_quad_mesh")); + + glewInfoFunc("glMeshBreadthSGIX", glMeshBreadthSGIX == NULL); + glewInfoFunc("glMeshStrideSGIX", glMeshStrideSGIX == NULL); +} + +#endif /* GL_SGIX_quad_mesh */ + #ifdef GL_SGIX_reference_plane static void _glewInfo_GL_SGIX_reference_plane (void) @@ -7925,6 +9803,15 @@ static void _glewInfo_GL_SGIX_resample (void) #endif /* GL_SGIX_resample */ +#ifdef GL_SGIX_scalebias_hint + +static void _glewInfo_GL_SGIX_scalebias_hint (void) +{ + glewPrintExt("GL_SGIX_scalebias_hint", GLEW_SGIX_scalebias_hint, glewIsSupported("GL_SGIX_scalebias_hint"), glewGetExtension("GL_SGIX_scalebias_hint")); +} + +#endif /* GL_SGIX_scalebias_hint */ + #ifdef GL_SGIX_shadow static void _glewInfo_GL_SGIX_shadow (void) @@ -7943,6 +9830,24 @@ static void _glewInfo_GL_SGIX_shadow_ambient (void) #endif /* GL_SGIX_shadow_ambient */ +#ifdef GL_SGIX_slim + +static void _glewInfo_GL_SGIX_slim (void) +{ + glewPrintExt("GL_SGIX_slim", GLEW_SGIX_slim, glewIsSupported("GL_SGIX_slim"), glewGetExtension("GL_SGIX_slim")); +} + +#endif /* GL_SGIX_slim */ + +#ifdef GL_SGIX_spotlight_cutoff + +static void _glewInfo_GL_SGIX_spotlight_cutoff (void) +{ + glewPrintExt("GL_SGIX_spotlight_cutoff", GLEW_SGIX_spotlight_cutoff, glewIsSupported("GL_SGIX_spotlight_cutoff"), glewGetExtension("GL_SGIX_spotlight_cutoff")); +} + +#endif /* GL_SGIX_spotlight_cutoff */ + #ifdef GL_SGIX_sprite static void _glewInfo_GL_SGIX_sprite (void) @@ -7957,6 +9862,24 @@ static void _glewInfo_GL_SGIX_sprite (void) #endif /* GL_SGIX_sprite */ +#ifdef GL_SGIX_subdiv_patch + +static void _glewInfo_GL_SGIX_subdiv_patch (void) +{ + glewPrintExt("GL_SGIX_subdiv_patch", GLEW_SGIX_subdiv_patch, glewIsSupported("GL_SGIX_subdiv_patch"), glewGetExtension("GL_SGIX_subdiv_patch")); +} + +#endif /* GL_SGIX_subdiv_patch */ + +#ifdef GL_SGIX_subsample + +static void _glewInfo_GL_SGIX_subsample (void) +{ + glewPrintExt("GL_SGIX_subsample", GLEW_SGIX_subsample, glewIsSupported("GL_SGIX_subsample"), glewGetExtension("GL_SGIX_subsample")); +} + +#endif /* GL_SGIX_subsample */ + #ifdef GL_SGIX_tag_sample_buffer static void _glewInfo_GL_SGIX_tag_sample_buffer (void) @@ -7995,6 +9918,15 @@ static void _glewInfo_GL_SGIX_texture_lod_bias (void) #endif /* GL_SGIX_texture_lod_bias */ +#ifdef GL_SGIX_texture_mipmap_anisotropic + +static void _glewInfo_GL_SGIX_texture_mipmap_anisotropic (void) +{ + glewPrintExt("GL_SGIX_texture_mipmap_anisotropic", GLEW_SGIX_texture_mipmap_anisotropic, glewIsSupported("GL_SGIX_texture_mipmap_anisotropic"), glewGetExtension("GL_SGIX_texture_mipmap_anisotropic")); +} + +#endif /* GL_SGIX_texture_mipmap_anisotropic */ + #ifdef GL_SGIX_texture_multi_buffer static void _glewInfo_GL_SGIX_texture_multi_buffer (void) @@ -8004,6 +9936,15 @@ static void _glewInfo_GL_SGIX_texture_multi_buffer (void) #endif /* GL_SGIX_texture_multi_buffer */ +#ifdef GL_SGIX_texture_phase + +static void _glewInfo_GL_SGIX_texture_phase (void) +{ + glewPrintExt("GL_SGIX_texture_phase", GLEW_SGIX_texture_phase, glewIsSupported("GL_SGIX_texture_phase"), glewGetExtension("GL_SGIX_texture_phase")); +} + +#endif /* GL_SGIX_texture_phase */ + #ifdef GL_SGIX_texture_range static void _glewInfo_GL_SGIX_texture_range (void) @@ -8022,6 +9963,43 @@ static void _glewInfo_GL_SGIX_texture_scale_bias (void) #endif /* GL_SGIX_texture_scale_bias */ +#ifdef GL_SGIX_texture_supersample + +static void _glewInfo_GL_SGIX_texture_supersample (void) +{ + glewPrintExt("GL_SGIX_texture_supersample", GLEW_SGIX_texture_supersample, glewIsSupported("GL_SGIX_texture_supersample"), glewGetExtension("GL_SGIX_texture_supersample")); +} + +#endif /* GL_SGIX_texture_supersample */ + +#ifdef GL_SGIX_vector_ops + +static void _glewInfo_GL_SGIX_vector_ops (void) +{ + glewPrintExt("GL_SGIX_vector_ops", GLEW_SGIX_vector_ops, glewIsSupported("GL_SGIX_vector_ops"), glewGetExtension("GL_SGIX_vector_ops")); + + glewInfoFunc("glGetVectorOperationSGIX", glGetVectorOperationSGIX == NULL); + glewInfoFunc("glVectorOperationSGIX", glVectorOperationSGIX == NULL); +} + +#endif /* GL_SGIX_vector_ops */ + +#ifdef GL_SGIX_vertex_array_object + +static void _glewInfo_GL_SGIX_vertex_array_object (void) +{ + glewPrintExt("GL_SGIX_vertex_array_object", GLEW_SGIX_vertex_array_object, glewIsSupported("GL_SGIX_vertex_array_object"), glewGetExtension("GL_SGIX_vertex_array_object")); + + glewInfoFunc("glAreVertexArraysResidentSGIX", glAreVertexArraysResidentSGIX == NULL); + glewInfoFunc("glBindVertexArraySGIX", glBindVertexArraySGIX == NULL); + glewInfoFunc("glDeleteVertexArraysSGIX", glDeleteVertexArraysSGIX == NULL); + glewInfoFunc("glGenVertexArraysSGIX", glGenVertexArraysSGIX == NULL); + glewInfoFunc("glIsVertexArraySGIX", glIsVertexArraySGIX == NULL); + glewInfoFunc("glPrioritizeVertexArraysSGIX", glPrioritizeVertexArraysSGIX == NULL); +} + +#endif /* GL_SGIX_vertex_array_object */ + #ifdef GL_SGIX_vertex_preclip static void _glewInfo_GL_SGIX_vertex_preclip (void) @@ -8049,6 +10027,24 @@ static void _glewInfo_GL_SGIX_ycrcb (void) #endif /* GL_SGIX_ycrcb */ +#ifdef GL_SGIX_ycrcb_subsample + +static void _glewInfo_GL_SGIX_ycrcb_subsample (void) +{ + glewPrintExt("GL_SGIX_ycrcb_subsample", GLEW_SGIX_ycrcb_subsample, glewIsSupported("GL_SGIX_ycrcb_subsample"), glewGetExtension("GL_SGIX_ycrcb_subsample")); +} + +#endif /* GL_SGIX_ycrcb_subsample */ + +#ifdef GL_SGIX_ycrcba + +static void _glewInfo_GL_SGIX_ycrcba (void) +{ + glewPrintExt("GL_SGIX_ycrcba", GLEW_SGIX_ycrcba, glewIsSupported("GL_SGIX_ycrcba"), glewGetExtension("GL_SGIX_ycrcba")); +} + +#endif /* GL_SGIX_ycrcba */ + #ifdef GL_SGI_color_matrix static void _glewInfo_GL_SGI_color_matrix (void) @@ -8075,6 +10071,41 @@ static void _glewInfo_GL_SGI_color_table (void) #endif /* GL_SGI_color_table */ +#ifdef GL_SGI_complex + +static void _glewInfo_GL_SGI_complex (void) +{ + glewPrintExt("GL_SGI_complex", GLEW_SGI_complex, glewIsSupported("GL_SGI_complex"), glewGetExtension("GL_SGI_complex")); +} + +#endif /* GL_SGI_complex */ + +#ifdef GL_SGI_complex_type + +static void _glewInfo_GL_SGI_complex_type (void) +{ + glewPrintExt("GL_SGI_complex_type", GLEW_SGI_complex_type, glewIsSupported("GL_SGI_complex_type"), glewGetExtension("GL_SGI_complex_type")); +} + +#endif /* GL_SGI_complex_type */ + +#ifdef GL_SGI_fft + +static void _glewInfo_GL_SGI_fft (void) +{ + glewPrintExt("GL_SGI_fft", GLEW_SGI_fft, glewIsSupported("GL_SGI_fft"), glewGetExtension("GL_SGI_fft")); + + glewInfoFunc("glGetPixelTransformParameterfvSGI", glGetPixelTransformParameterfvSGI == NULL); + glewInfoFunc("glGetPixelTransformParameterivSGI", glGetPixelTransformParameterivSGI == NULL); + glewInfoFunc("glPixelTransformParameterfSGI", glPixelTransformParameterfSGI == NULL); + glewInfoFunc("glPixelTransformParameterfvSGI", glPixelTransformParameterfvSGI == NULL); + glewInfoFunc("glPixelTransformParameteriSGI", glPixelTransformParameteriSGI == NULL); + glewInfoFunc("glPixelTransformParameterivSGI", glPixelTransformParameterivSGI == NULL); + glewInfoFunc("glPixelTransformSGI", glPixelTransformSGI == NULL); +} + +#endif /* GL_SGI_fft */ + #ifdef GL_SGI_texture_color_table static void _glewInfo_GL_SGI_texture_color_table (void) @@ -8227,6 +10258,15 @@ static void _glewInfo_GL_WIN_phong_shading (void) #endif /* GL_WIN_phong_shading */ +#ifdef GL_WIN_scene_markerXXX + +static void _glewInfo_GL_WIN_scene_markerXXX (void) +{ + glewPrintExt("GL_WIN_scene_markerXXX", GLEW_WIN_scene_markerXXX, glewIsSupported("GL_WIN_scene_markerXXX"), glewGetExtension("GL_WIN_scene_markerXXX")); +} + +#endif /* GL_WIN_scene_markerXXX */ + #ifdef GL_WIN_specular_fog static void _glewInfo_GL_WIN_specular_fog (void) @@ -8478,6 +10518,15 @@ static void _glewInfo_EGL_ANGLE_window_fixed_size (void) #endif /* EGL_ANGLE_window_fixed_size */ +#ifdef EGL_ARM_implicit_external_sync + +static void _glewInfo_EGL_ARM_implicit_external_sync (void) +{ + glewPrintExt("EGL_ARM_implicit_external_sync", EGLEW_ARM_implicit_external_sync, eglewIsSupported("EGL_ARM_implicit_external_sync"), eglewGetExtension("EGL_ARM_implicit_external_sync")); +} + +#endif /* EGL_ARM_implicit_external_sync */ + #ifdef EGL_ARM_pixmap_multisample_discard static void _glewInfo_EGL_ARM_pixmap_multisample_discard (void) @@ -8565,6 +10614,33 @@ static void _glewInfo_EGL_EXT_device_query (void) #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_gl_colorspace_bt2020_linear + +static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_bt2020_linear", EGLEW_EXT_gl_colorspace_bt2020_linear, eglewIsSupported("EGL_EXT_gl_colorspace_bt2020_linear"), eglewGetExtension("EGL_EXT_gl_colorspace_bt2020_linear")); +} + +#endif /* EGL_EXT_gl_colorspace_bt2020_linear */ + +#ifdef EGL_EXT_gl_colorspace_bt2020_pq + +static void _glewInfo_EGL_EXT_gl_colorspace_bt2020_pq (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_bt2020_pq", EGLEW_EXT_gl_colorspace_bt2020_pq, eglewIsSupported("EGL_EXT_gl_colorspace_bt2020_pq"), eglewGetExtension("EGL_EXT_gl_colorspace_bt2020_pq")); +} + +#endif /* EGL_EXT_gl_colorspace_bt2020_pq */ + +#ifdef EGL_EXT_gl_colorspace_scrgb_linear + +static void _glewInfo_EGL_EXT_gl_colorspace_scrgb_linear (void) +{ + glewPrintExt("EGL_EXT_gl_colorspace_scrgb_linear", EGLEW_EXT_gl_colorspace_scrgb_linear, eglewIsSupported("EGL_EXT_gl_colorspace_scrgb_linear"), eglewGetExtension("EGL_EXT_gl_colorspace_scrgb_linear")); +} + +#endif /* EGL_EXT_gl_colorspace_scrgb_linear */ + #ifdef EGL_EXT_image_dma_buf_import static void _glewInfo_EGL_EXT_image_dma_buf_import (void) @@ -8574,6 +10650,18 @@ static void _glewInfo_EGL_EXT_image_dma_buf_import (void) #endif /* EGL_EXT_image_dma_buf_import */ +#ifdef EGL_EXT_image_dma_buf_import_modifiers + +static void _glewInfo_EGL_EXT_image_dma_buf_import_modifiers (void) +{ + glewPrintExt("EGL_EXT_image_dma_buf_import_modifiers", EGLEW_EXT_image_dma_buf_import_modifiers, eglewIsSupported("EGL_EXT_image_dma_buf_import_modifiers"), eglewGetExtension("EGL_EXT_image_dma_buf_import_modifiers")); + + glewInfoFunc("eglQueryDmaBufFormatsEXT", eglQueryDmaBufFormatsEXT == NULL); + glewInfoFunc("eglQueryDmaBufModifiersEXT", eglQueryDmaBufModifiersEXT == NULL); +} + +#endif /* EGL_EXT_image_dma_buf_import_modifiers */ + #ifdef EGL_EXT_multiview_window static void _glewInfo_EGL_EXT_multiview_window (void) @@ -8619,6 +10707,15 @@ static void _glewInfo_EGL_EXT_output_openwf (void) #endif /* EGL_EXT_output_openwf */ +#ifdef EGL_EXT_pixel_format_float + +static void _glewInfo_EGL_EXT_pixel_format_float (void) +{ + glewPrintExt("EGL_EXT_pixel_format_float", EGLEW_EXT_pixel_format_float, eglewIsSupported("EGL_EXT_pixel_format_float"), eglewGetExtension("EGL_EXT_pixel_format_float")); +} + +#endif /* EGL_EXT_pixel_format_float */ + #ifdef EGL_EXT_platform_base static void _glewInfo_EGL_EXT_platform_base (void) @@ -8688,6 +10785,15 @@ static void _glewInfo_EGL_EXT_stream_consumer_egloutput (void) #endif /* EGL_EXT_stream_consumer_egloutput */ +#ifdef EGL_EXT_surface_SMPTE2086_metadata + +static void _glewInfo_EGL_EXT_surface_SMPTE2086_metadata (void) +{ + glewPrintExt("EGL_EXT_surface_SMPTE2086_metadata", EGLEW_EXT_surface_SMPTE2086_metadata, eglewIsSupported("EGL_EXT_surface_SMPTE2086_metadata"), eglewGetExtension("EGL_EXT_surface_SMPTE2086_metadata")); +} + +#endif /* EGL_EXT_surface_SMPTE2086_metadata */ + #ifdef EGL_EXT_swap_buffers_with_damage static void _glewInfo_EGL_EXT_swap_buffers_with_damage (void) @@ -8784,6 +10890,15 @@ static void _glewInfo_EGL_KHR_config_attribs (void) #endif /* EGL_KHR_config_attribs */ +#ifdef EGL_KHR_context_flush_control + +static void _glewInfo_EGL_KHR_context_flush_control (void) +{ + glewPrintExt("EGL_KHR_context_flush_control", EGLEW_KHR_context_flush_control, eglewIsSupported("EGL_KHR_context_flush_control"), eglewGetExtension("EGL_KHR_context_flush_control")); +} + +#endif /* EGL_KHR_context_flush_control */ + #ifdef EGL_KHR_create_context static void _glewInfo_EGL_KHR_create_context (void) @@ -8949,6 +11064,15 @@ static void _glewInfo_EGL_KHR_mutable_render_buffer (void) #endif /* EGL_KHR_mutable_render_buffer */ +#ifdef EGL_KHR_no_config_context + +static void _glewInfo_EGL_KHR_no_config_context (void) +{ + glewPrintExt("EGL_KHR_no_config_context", EGLEW_KHR_no_config_context, eglewIsSupported("EGL_KHR_no_config_context"), eglewGetExtension("EGL_KHR_no_config_context")); +} + +#endif /* EGL_KHR_no_config_context */ + #ifdef EGL_KHR_partial_update static void _glewInfo_EGL_KHR_partial_update (void) @@ -9026,6 +11150,21 @@ static void _glewInfo_EGL_KHR_stream (void) #endif /* EGL_KHR_stream */ +#ifdef EGL_KHR_stream_attrib + +static void _glewInfo_EGL_KHR_stream_attrib (void) +{ + glewPrintExt("EGL_KHR_stream_attrib", EGLEW_KHR_stream_attrib, eglewIsSupported("EGL_KHR_stream_attrib"), eglewGetExtension("EGL_KHR_stream_attrib")); + + glewInfoFunc("eglCreateStreamAttribKHR", eglCreateStreamAttribKHR == NULL); + glewInfoFunc("eglQueryStreamAttribKHR", eglQueryStreamAttribKHR == NULL); + glewInfoFunc("eglSetStreamAttribKHR", eglSetStreamAttribKHR == NULL); + glewInfoFunc("eglStreamConsumerAcquireAttribKHR", eglStreamConsumerAcquireAttribKHR == NULL); + glewInfoFunc("eglStreamConsumerReleaseAttribKHR", eglStreamConsumerReleaseAttribKHR == NULL); +} + +#endif /* EGL_KHR_stream_attrib */ + #ifdef EGL_KHR_stream_consumer_gltexture static void _glewInfo_EGL_KHR_stream_consumer_gltexture (void) @@ -9155,6 +11294,15 @@ static void _glewInfo_EGL_MESA_platform_gbm (void) #endif /* EGL_MESA_platform_gbm */ +#ifdef EGL_MESA_platform_surfaceless + +static void _glewInfo_EGL_MESA_platform_surfaceless (void) +{ + glewPrintExt("EGL_MESA_platform_surfaceless", EGLEW_MESA_platform_surfaceless, eglewIsSupported("EGL_MESA_platform_surfaceless"), eglewGetExtension("EGL_MESA_platform_surfaceless")); +} + +#endif /* EGL_MESA_platform_surfaceless */ + #ifdef EGL_NOK_swap_region static void _glewInfo_EGL_NOK_swap_region (void) @@ -9293,6 +11441,78 @@ static void _glewInfo_EGL_NV_stream_consumer_gltexture_yuv (void) #endif /* EGL_NV_stream_consumer_gltexture_yuv */ +#ifdef EGL_NV_stream_cross_display + +static void _glewInfo_EGL_NV_stream_cross_display (void) +{ + glewPrintExt("EGL_NV_stream_cross_display", EGLEW_NV_stream_cross_display, eglewIsSupported("EGL_NV_stream_cross_display"), eglewGetExtension("EGL_NV_stream_cross_display")); +} + +#endif /* EGL_NV_stream_cross_display */ + +#ifdef EGL_NV_stream_cross_object + +static void _glewInfo_EGL_NV_stream_cross_object (void) +{ + glewPrintExt("EGL_NV_stream_cross_object", EGLEW_NV_stream_cross_object, eglewIsSupported("EGL_NV_stream_cross_object"), eglewGetExtension("EGL_NV_stream_cross_object")); +} + +#endif /* EGL_NV_stream_cross_object */ + +#ifdef EGL_NV_stream_cross_partition + +static void _glewInfo_EGL_NV_stream_cross_partition (void) +{ + glewPrintExt("EGL_NV_stream_cross_partition", EGLEW_NV_stream_cross_partition, eglewIsSupported("EGL_NV_stream_cross_partition"), eglewGetExtension("EGL_NV_stream_cross_partition")); +} + +#endif /* EGL_NV_stream_cross_partition */ + +#ifdef EGL_NV_stream_cross_process + +static void _glewInfo_EGL_NV_stream_cross_process (void) +{ + glewPrintExt("EGL_NV_stream_cross_process", EGLEW_NV_stream_cross_process, eglewIsSupported("EGL_NV_stream_cross_process"), eglewGetExtension("EGL_NV_stream_cross_process")); +} + +#endif /* EGL_NV_stream_cross_process */ + +#ifdef EGL_NV_stream_cross_system + +static void _glewInfo_EGL_NV_stream_cross_system (void) +{ + glewPrintExt("EGL_NV_stream_cross_system", EGLEW_NV_stream_cross_system, eglewIsSupported("EGL_NV_stream_cross_system"), eglewGetExtension("EGL_NV_stream_cross_system")); +} + +#endif /* EGL_NV_stream_cross_system */ + +#ifdef EGL_NV_stream_fifo_next + +static void _glewInfo_EGL_NV_stream_fifo_next (void) +{ + glewPrintExt("EGL_NV_stream_fifo_next", EGLEW_NV_stream_fifo_next, eglewIsSupported("EGL_NV_stream_fifo_next"), eglewGetExtension("EGL_NV_stream_fifo_next")); +} + +#endif /* EGL_NV_stream_fifo_next */ + +#ifdef EGL_NV_stream_fifo_synchronous + +static void _glewInfo_EGL_NV_stream_fifo_synchronous (void) +{ + glewPrintExt("EGL_NV_stream_fifo_synchronous", EGLEW_NV_stream_fifo_synchronous, eglewIsSupported("EGL_NV_stream_fifo_synchronous"), eglewGetExtension("EGL_NV_stream_fifo_synchronous")); +} + +#endif /* EGL_NV_stream_fifo_synchronous */ + +#ifdef EGL_NV_stream_frame_limits + +static void _glewInfo_EGL_NV_stream_frame_limits (void) +{ + glewPrintExt("EGL_NV_stream_frame_limits", EGLEW_NV_stream_frame_limits, eglewIsSupported("EGL_NV_stream_frame_limits"), eglewGetExtension("EGL_NV_stream_frame_limits")); +} + +#endif /* EGL_NV_stream_frame_limits */ + #ifdef EGL_NV_stream_metadata static void _glewInfo_EGL_NV_stream_metadata (void) @@ -9306,6 +11526,53 @@ static void _glewInfo_EGL_NV_stream_metadata (void) #endif /* EGL_NV_stream_metadata */ +#ifdef EGL_NV_stream_remote + +static void _glewInfo_EGL_NV_stream_remote (void) +{ + glewPrintExt("EGL_NV_stream_remote", EGLEW_NV_stream_remote, eglewIsSupported("EGL_NV_stream_remote"), eglewGetExtension("EGL_NV_stream_remote")); +} + +#endif /* EGL_NV_stream_remote */ + +#ifdef EGL_NV_stream_reset + +static void _glewInfo_EGL_NV_stream_reset (void) +{ + glewPrintExt("EGL_NV_stream_reset", EGLEW_NV_stream_reset, eglewIsSupported("EGL_NV_stream_reset"), eglewGetExtension("EGL_NV_stream_reset")); + + glewInfoFunc("eglResetStreamNV", eglResetStreamNV == NULL); +} + +#endif /* EGL_NV_stream_reset */ + +#ifdef EGL_NV_stream_socket + +static void _glewInfo_EGL_NV_stream_socket (void) +{ + glewPrintExt("EGL_NV_stream_socket", EGLEW_NV_stream_socket, eglewIsSupported("EGL_NV_stream_socket"), eglewGetExtension("EGL_NV_stream_socket")); +} + +#endif /* EGL_NV_stream_socket */ + +#ifdef EGL_NV_stream_socket_inet + +static void _glewInfo_EGL_NV_stream_socket_inet (void) +{ + glewPrintExt("EGL_NV_stream_socket_inet", EGLEW_NV_stream_socket_inet, eglewIsSupported("EGL_NV_stream_socket_inet"), eglewGetExtension("EGL_NV_stream_socket_inet")); +} + +#endif /* EGL_NV_stream_socket_inet */ + +#ifdef EGL_NV_stream_socket_unix + +static void _glewInfo_EGL_NV_stream_socket_unix (void) +{ + glewPrintExt("EGL_NV_stream_socket_unix", EGLEW_NV_stream_socket_unix, eglewIsSupported("EGL_NV_stream_socket_unix"), eglewGetExtension("EGL_NV_stream_socket_unix")); +} + +#endif /* EGL_NV_stream_socket_unix */ + #ifdef EGL_NV_stream_sync static void _glewInfo_EGL_NV_stream_sync (void) @@ -9438,6 +11705,15 @@ static void _glewInfo_WGL_ARB_create_context (void) #endif /* WGL_ARB_create_context */ +#ifdef WGL_ARB_create_context_no_error + +static void _glewInfo_WGL_ARB_create_context_no_error (void) +{ + glewPrintExt("WGL_ARB_create_context_no_error", WGLEW_ARB_create_context_no_error, wglewIsSupported("WGL_ARB_create_context_no_error"), wglewGetExtension("WGL_ARB_create_context_no_error")); +} + +#endif /* WGL_ARB_create_context_no_error */ + #ifdef WGL_ARB_create_context_profile static void _glewInfo_WGL_ARB_create_context_profile (void) @@ -9583,6 +11859,15 @@ static void _glewInfo_WGL_ATI_render_texture_rectangle (void) #endif /* WGL_ATI_render_texture_rectangle */ +#ifdef WGL_EXT_colorspace + +static void _glewInfo_WGL_EXT_colorspace (void) +{ + glewPrintExt("WGL_EXT_colorspace", WGLEW_EXT_colorspace, wglewIsSupported("WGL_EXT_colorspace"), wglewGetExtension("WGL_EXT_colorspace")); +} + +#endif /* WGL_EXT_colorspace */ + #ifdef WGL_EXT_create_context_es2_profile static void _glewInfo_WGL_EXT_create_context_es2_profile (void) @@ -10098,6 +12383,15 @@ static void _glewInfo_GLX_ARB_create_context (void) #endif /* GLX_ARB_create_context */ +#ifdef GLX_ARB_create_context_no_error + +static void _glewInfo_GLX_ARB_create_context_no_error (void) +{ + glewPrintExt("GLX_ARB_create_context_no_error", GLXEW_ARB_create_context_no_error, glxewIsSupported("GLX_ARB_create_context_no_error"), glxewGetExtension("GLX_ARB_create_context_no_error")); +} + +#endif /* GLX_ARB_create_context_no_error */ + #ifdef GLX_ARB_create_context_profile static void _glewInfo_GLX_ARB_create_context_profile (void) @@ -10844,6 +13138,9 @@ static void glewInfo (void) #ifdef GL_VERSION_4_5 _glewInfo_GL_VERSION_4_5(); #endif /* GL_VERSION_4_5 */ +#ifdef GL_VERSION_4_6 + _glewInfo_GL_VERSION_4_6(); +#endif /* GL_VERSION_4_6 */ #ifdef GL_3DFX_multisample _glewInfo_GL_3DFX_multisample(); #endif /* GL_3DFX_multisample */ @@ -10856,6 +13153,12 @@ static void glewInfo (void) #ifdef GL_AMD_blend_minmax_factor _glewInfo_GL_AMD_blend_minmax_factor(); #endif /* GL_AMD_blend_minmax_factor */ +#ifdef GL_AMD_compressed_3DC_texture + _glewInfo_GL_AMD_compressed_3DC_texture(); +#endif /* GL_AMD_compressed_3DC_texture */ +#ifdef GL_AMD_compressed_ATC_texture + _glewInfo_GL_AMD_compressed_ATC_texture(); +#endif /* GL_AMD_compressed_ATC_texture */ #ifdef GL_AMD_conservative_depth _glewInfo_GL_AMD_conservative_depth(); #endif /* GL_AMD_conservative_depth */ @@ -10868,9 +13171,18 @@ 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_sample_positions + _glewInfo_GL_AMD_framebuffer_sample_positions(); +#endif /* GL_AMD_framebuffer_sample_positions */ #ifdef GL_AMD_gcn_shader _glewInfo_GL_AMD_gcn_shader(); #endif /* GL_AMD_gcn_shader */ +#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_int16 + _glewInfo_GL_AMD_gpu_shader_int16(); +#endif /* GL_AMD_gpu_shader_int16 */ #ifdef GL_AMD_gpu_shader_int64 _glewInfo_GL_AMD_gpu_shader_int64(); #endif /* GL_AMD_gpu_shader_int64 */ @@ -10892,6 +13204,9 @@ static void glewInfo (void) #ifdef GL_AMD_pinned_memory _glewInfo_GL_AMD_pinned_memory(); #endif /* GL_AMD_pinned_memory */ +#ifdef GL_AMD_program_binary_Z400 + _glewInfo_GL_AMD_program_binary_Z400(); +#endif /* GL_AMD_program_binary_Z400 */ #ifdef GL_AMD_query_buffer_object _glewInfo_GL_AMD_query_buffer_object(); #endif /* GL_AMD_query_buffer_object */ @@ -10904,6 +13219,9 @@ static void glewInfo (void) #ifdef GL_AMD_shader_atomic_counter_ops _glewInfo_GL_AMD_shader_atomic_counter_ops(); #endif /* GL_AMD_shader_atomic_counter_ops */ +#ifdef GL_AMD_shader_ballot + _glewInfo_GL_AMD_shader_ballot(); +#endif /* GL_AMD_shader_ballot */ #ifdef GL_AMD_shader_explicit_vertex_parameter _glewInfo_GL_AMD_shader_explicit_vertex_parameter(); #endif /* GL_AMD_shader_explicit_vertex_parameter */ @@ -10922,6 +13240,9 @@ static void glewInfo (void) #ifdef GL_AMD_stencil_operation_extended _glewInfo_GL_AMD_stencil_operation_extended(); #endif /* GL_AMD_stencil_operation_extended */ +#ifdef GL_AMD_texture_gather_bias_lod + _glewInfo_GL_AMD_texture_gather_bias_lod(); +#endif /* GL_AMD_texture_gather_bias_lod */ #ifdef GL_AMD_texture_texture4 _glewInfo_GL_AMD_texture_texture4(); #endif /* GL_AMD_texture_texture4 */ @@ -10940,6 +13261,9 @@ static void glewInfo (void) #ifdef GL_AMD_vertex_shader_viewport_index _glewInfo_GL_AMD_vertex_shader_viewport_index(); #endif /* GL_AMD_vertex_shader_viewport_index */ +#ifdef GL_ANDROID_extension_pack_es31a + _glewInfo_GL_ANDROID_extension_pack_es31a(); +#endif /* GL_ANDROID_extension_pack_es31a */ #ifdef GL_ANGLE_depth_texture _glewInfo_GL_ANGLE_depth_texture(); #endif /* GL_ANGLE_depth_texture */ @@ -10982,6 +13306,15 @@ static void glewInfo (void) #ifdef GL_APPLE_client_storage _glewInfo_GL_APPLE_client_storage(); #endif /* GL_APPLE_client_storage */ +#ifdef GL_APPLE_clip_distance + _glewInfo_GL_APPLE_clip_distance(); +#endif /* GL_APPLE_clip_distance */ +#ifdef GL_APPLE_color_buffer_packed_float + _glewInfo_GL_APPLE_color_buffer_packed_float(); +#endif /* GL_APPLE_color_buffer_packed_float */ +#ifdef GL_APPLE_copy_texture_levels + _glewInfo_GL_APPLE_copy_texture_levels(); +#endif /* GL_APPLE_copy_texture_levels */ #ifdef GL_APPLE_element_array _glewInfo_GL_APPLE_element_array(); #endif /* GL_APPLE_element_array */ @@ -10994,6 +13327,9 @@ static void glewInfo (void) #ifdef GL_APPLE_flush_buffer_range _glewInfo_GL_APPLE_flush_buffer_range(); #endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_framebuffer_multisample + _glewInfo_GL_APPLE_framebuffer_multisample(); +#endif /* GL_APPLE_framebuffer_multisample */ #ifdef GL_APPLE_object_purgeable _glewInfo_GL_APPLE_object_purgeable(); #endif /* GL_APPLE_object_purgeable */ @@ -11009,6 +13345,21 @@ static void glewInfo (void) #ifdef GL_APPLE_specular_vector _glewInfo_GL_APPLE_specular_vector(); #endif /* GL_APPLE_specular_vector */ +#ifdef GL_APPLE_sync + _glewInfo_GL_APPLE_sync(); +#endif /* GL_APPLE_sync */ +#ifdef GL_APPLE_texture_2D_limited_npot + _glewInfo_GL_APPLE_texture_2D_limited_npot(); +#endif /* GL_APPLE_texture_2D_limited_npot */ +#ifdef GL_APPLE_texture_format_BGRA8888 + _glewInfo_GL_APPLE_texture_format_BGRA8888(); +#endif /* GL_APPLE_texture_format_BGRA8888 */ +#ifdef GL_APPLE_texture_max_level + _glewInfo_GL_APPLE_texture_max_level(); +#endif /* GL_APPLE_texture_max_level */ +#ifdef GL_APPLE_texture_packed_float + _glewInfo_GL_APPLE_texture_packed_float(); +#endif /* GL_APPLE_texture_packed_float */ #ifdef GL_APPLE_texture_range _glewInfo_GL_APPLE_texture_range(); #endif /* GL_APPLE_texture_range */ @@ -11252,6 +13603,9 @@ static void glewInfo (void) #ifdef GL_ARB_point_sprite _glewInfo_GL_ARB_point_sprite(); #endif /* GL_ARB_point_sprite */ +#ifdef GL_ARB_polygon_offset_clamp + _glewInfo_GL_ARB_polygon_offset_clamp(); +#endif /* GL_ARB_polygon_offset_clamp */ #ifdef GL_ARB_post_depth_coverage _glewInfo_GL_ARB_post_depth_coverage(); #endif /* GL_ARB_post_depth_coverage */ @@ -11375,6 +13729,9 @@ static void glewInfo (void) #ifdef GL_ARB_sparse_texture_clamp _glewInfo_GL_ARB_sparse_texture_clamp(); #endif /* GL_ARB_sparse_texture_clamp */ +#ifdef GL_ARB_spirv_extensions + _glewInfo_GL_ARB_spirv_extensions(); +#endif /* GL_ARB_spirv_extensions */ #ifdef GL_ARB_stencil_texturing _glewInfo_GL_ARB_stencil_texturing(); #endif /* GL_ARB_stencil_texturing */ @@ -11426,6 +13783,9 @@ static void glewInfo (void) #ifdef GL_ARB_texture_env_dot3 _glewInfo_GL_ARB_texture_env_dot3(); #endif /* GL_ARB_texture_env_dot3 */ +#ifdef GL_ARB_texture_filter_anisotropic + _glewInfo_GL_ARB_texture_filter_anisotropic(); +#endif /* GL_ARB_texture_filter_anisotropic */ #ifdef GL_ARB_texture_filter_minmax _glewInfo_GL_ARB_texture_filter_minmax(); #endif /* GL_ARB_texture_filter_minmax */ @@ -11534,6 +13894,21 @@ static void glewInfo (void) #ifdef GL_ARB_window_pos _glewInfo_GL_ARB_window_pos(); #endif /* GL_ARB_window_pos */ +#ifdef GL_ARM_mali_program_binary + _glewInfo_GL_ARM_mali_program_binary(); +#endif /* GL_ARM_mali_program_binary */ +#ifdef GL_ARM_mali_shader_binary + _glewInfo_GL_ARM_mali_shader_binary(); +#endif /* GL_ARM_mali_shader_binary */ +#ifdef GL_ARM_rgba8 + _glewInfo_GL_ARM_rgba8(); +#endif /* GL_ARM_rgba8 */ +#ifdef GL_ARM_shader_framebuffer_fetch + _glewInfo_GL_ARM_shader_framebuffer_fetch(); +#endif /* GL_ARM_shader_framebuffer_fetch */ +#ifdef GL_ARM_shader_framebuffer_fetch_depth_stencil + _glewInfo_GL_ARM_shader_framebuffer_fetch_depth_stencil(); +#endif /* GL_ARM_shader_framebuffer_fetch_depth_stencil */ #ifdef GL_ATIX_point_sprites _glewInfo_GL_ATIX_point_sprites(); #endif /* GL_ATIX_point_sprites */ @@ -11597,6 +13972,9 @@ 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 */ @@ -11606,9 +13984,18 @@ static void glewInfo (void) #ifdef GL_EXT_Cg_shader _glewInfo_GL_EXT_Cg_shader(); #endif /* GL_EXT_Cg_shader */ +#ifdef GL_EXT_EGL_image_array + _glewInfo_GL_EXT_EGL_image_array(); +#endif /* GL_EXT_EGL_image_array */ +#ifdef GL_EXT_YUV_target + _glewInfo_GL_EXT_YUV_target(); +#endif /* GL_EXT_YUV_target */ #ifdef GL_EXT_abgr _glewInfo_GL_EXT_abgr(); #endif /* GL_EXT_abgr */ +#ifdef GL_EXT_base_instance + _glewInfo_GL_EXT_base_instance(); +#endif /* GL_EXT_base_instance */ #ifdef GL_EXT_bgra _glewInfo_GL_EXT_bgra(); #endif /* GL_EXT_bgra */ @@ -11621,6 +14008,9 @@ static void glewInfo (void) #ifdef GL_EXT_blend_equation_separate _glewInfo_GL_EXT_blend_equation_separate(); #endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_extended + _glewInfo_GL_EXT_blend_func_extended(); +#endif /* GL_EXT_blend_func_extended */ #ifdef GL_EXT_blend_func_separate _glewInfo_GL_EXT_blend_func_separate(); #endif /* GL_EXT_blend_func_separate */ @@ -11633,24 +14023,48 @@ static void glewInfo (void) #ifdef GL_EXT_blend_subtract _glewInfo_GL_EXT_blend_subtract(); #endif /* GL_EXT_blend_subtract */ +#ifdef GL_EXT_buffer_storage + _glewInfo_GL_EXT_buffer_storage(); +#endif /* GL_EXT_buffer_storage */ +#ifdef GL_EXT_clear_texture + _glewInfo_GL_EXT_clear_texture(); +#endif /* GL_EXT_clear_texture */ +#ifdef GL_EXT_clip_cull_distance + _glewInfo_GL_EXT_clip_cull_distance(); +#endif /* GL_EXT_clip_cull_distance */ #ifdef GL_EXT_clip_volume_hint _glewInfo_GL_EXT_clip_volume_hint(); #endif /* GL_EXT_clip_volume_hint */ #ifdef GL_EXT_cmyka _glewInfo_GL_EXT_cmyka(); #endif /* GL_EXT_cmyka */ +#ifdef GL_EXT_color_buffer_float + _glewInfo_GL_EXT_color_buffer_float(); +#endif /* GL_EXT_color_buffer_float */ +#ifdef GL_EXT_color_buffer_half_float + _glewInfo_GL_EXT_color_buffer_half_float(); +#endif /* GL_EXT_color_buffer_half_float */ #ifdef GL_EXT_color_subtable _glewInfo_GL_EXT_color_subtable(); #endif /* GL_EXT_color_subtable */ #ifdef GL_EXT_compiled_vertex_array _glewInfo_GL_EXT_compiled_vertex_array(); #endif /* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_compressed_ETC1_RGB8_sub_texture + _glewInfo_GL_EXT_compressed_ETC1_RGB8_sub_texture(); +#endif /* GL_EXT_compressed_ETC1_RGB8_sub_texture */ +#ifdef GL_EXT_conservative_depth + _glewInfo_GL_EXT_conservative_depth(); +#endif /* GL_EXT_conservative_depth */ #ifdef GL_EXT_convolution _glewInfo_GL_EXT_convolution(); #endif /* GL_EXT_convolution */ #ifdef GL_EXT_coordinate_frame _glewInfo_GL_EXT_coordinate_frame(); #endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_image + _glewInfo_GL_EXT_copy_image(); +#endif /* GL_EXT_copy_image */ #ifdef GL_EXT_copy_texture _glewInfo_GL_EXT_copy_texture(); #endif /* GL_EXT_copy_texture */ @@ -11669,18 +14083,39 @@ static void glewInfo (void) #ifdef GL_EXT_direct_state_access _glewInfo_GL_EXT_direct_state_access(); #endif /* GL_EXT_direct_state_access */ +#ifdef GL_EXT_discard_framebuffer + _glewInfo_GL_EXT_discard_framebuffer(); +#endif /* GL_EXT_discard_framebuffer */ +#ifdef GL_EXT_draw_buffers + _glewInfo_GL_EXT_draw_buffers(); +#endif /* GL_EXT_draw_buffers */ #ifdef GL_EXT_draw_buffers2 _glewInfo_GL_EXT_draw_buffers2(); #endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_buffers_indexed + _glewInfo_GL_EXT_draw_buffers_indexed(); +#endif /* GL_EXT_draw_buffers_indexed */ +#ifdef GL_EXT_draw_elements_base_vertex + _glewInfo_GL_EXT_draw_elements_base_vertex(); +#endif /* GL_EXT_draw_elements_base_vertex */ #ifdef GL_EXT_draw_instanced _glewInfo_GL_EXT_draw_instanced(); #endif /* GL_EXT_draw_instanced */ #ifdef GL_EXT_draw_range_elements _glewInfo_GL_EXT_draw_range_elements(); #endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_external_buffer + _glewInfo_GL_EXT_external_buffer(); +#endif /* GL_EXT_external_buffer */ +#ifdef GL_EXT_float_blend + _glewInfo_GL_EXT_float_blend(); +#endif /* GL_EXT_float_blend */ #ifdef GL_EXT_fog_coord _glewInfo_GL_EXT_fog_coord(); #endif /* GL_EXT_fog_coord */ +#ifdef GL_EXT_frag_depth + _glewInfo_GL_EXT_frag_depth(); +#endif /* GL_EXT_frag_depth */ #ifdef GL_EXT_fragment_lighting _glewInfo_GL_EXT_fragment_lighting(); #endif /* GL_EXT_fragment_lighting */ @@ -11699,6 +14134,12 @@ static void glewInfo (void) #ifdef GL_EXT_framebuffer_sRGB _glewInfo_GL_EXT_framebuffer_sRGB(); #endif /* GL_EXT_framebuffer_sRGB */ +#ifdef GL_EXT_geometry_point_size + _glewInfo_GL_EXT_geometry_point_size(); +#endif /* GL_EXT_geometry_point_size */ +#ifdef GL_EXT_geometry_shader + _glewInfo_GL_EXT_geometry_shader(); +#endif /* GL_EXT_geometry_shader */ #ifdef GL_EXT_geometry_shader4 _glewInfo_GL_EXT_geometry_shader4(); #endif /* GL_EXT_geometry_shader4 */ @@ -11708,6 +14149,9 @@ static void glewInfo (void) #ifdef GL_EXT_gpu_shader4 _glewInfo_GL_EXT_gpu_shader4(); #endif /* GL_EXT_gpu_shader4 */ +#ifdef GL_EXT_gpu_shader5 + _glewInfo_GL_EXT_gpu_shader5(); +#endif /* GL_EXT_gpu_shader5 */ #ifdef GL_EXT_histogram _glewInfo_GL_EXT_histogram(); #endif /* GL_EXT_histogram */ @@ -11723,18 +14167,51 @@ static void glewInfo (void) #ifdef GL_EXT_index_texture _glewInfo_GL_EXT_index_texture(); #endif /* GL_EXT_index_texture */ +#ifdef GL_EXT_instanced_arrays + _glewInfo_GL_EXT_instanced_arrays(); +#endif /* GL_EXT_instanced_arrays */ #ifdef GL_EXT_light_texture _glewInfo_GL_EXT_light_texture(); #endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_map_buffer_range + _glewInfo_GL_EXT_map_buffer_range(); +#endif /* GL_EXT_map_buffer_range */ +#ifdef GL_EXT_memory_object + _glewInfo_GL_EXT_memory_object(); +#endif /* GL_EXT_memory_object */ +#ifdef GL_EXT_memory_object_fd + _glewInfo_GL_EXT_memory_object_fd(); +#endif /* GL_EXT_memory_object_fd */ +#ifdef GL_EXT_memory_object_win32 + _glewInfo_GL_EXT_memory_object_win32(); +#endif /* GL_EXT_memory_object_win32 */ #ifdef GL_EXT_misc_attribute _glewInfo_GL_EXT_misc_attribute(); #endif /* GL_EXT_misc_attribute */ #ifdef GL_EXT_multi_draw_arrays _glewInfo_GL_EXT_multi_draw_arrays(); #endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multi_draw_indirect + _glewInfo_GL_EXT_multi_draw_indirect(); +#endif /* GL_EXT_multi_draw_indirect */ +#ifdef GL_EXT_multiple_textures + _glewInfo_GL_EXT_multiple_textures(); +#endif /* GL_EXT_multiple_textures */ #ifdef GL_EXT_multisample _glewInfo_GL_EXT_multisample(); #endif /* GL_EXT_multisample */ +#ifdef GL_EXT_multisample_compatibility + _glewInfo_GL_EXT_multisample_compatibility(); +#endif /* GL_EXT_multisample_compatibility */ +#ifdef GL_EXT_multisampled_render_to_texture + _glewInfo_GL_EXT_multisampled_render_to_texture(); +#endif /* GL_EXT_multisampled_render_to_texture */ +#ifdef GL_EXT_multisampled_render_to_texture2 + _glewInfo_GL_EXT_multisampled_render_to_texture2(); +#endif /* GL_EXT_multisampled_render_to_texture2 */ +#ifdef GL_EXT_multiview_draw_buffers + _glewInfo_GL_EXT_multiview_draw_buffers(); +#endif /* GL_EXT_multiview_draw_buffers */ #ifdef GL_EXT_packed_depth_stencil _glewInfo_GL_EXT_packed_depth_stencil(); #endif /* GL_EXT_packed_depth_stencil */ @@ -11771,39 +14248,93 @@ static void glewInfo (void) #ifdef GL_EXT_provoking_vertex _glewInfo_GL_EXT_provoking_vertex(); #endif /* GL_EXT_provoking_vertex */ +#ifdef GL_EXT_pvrtc_sRGB + _glewInfo_GL_EXT_pvrtc_sRGB(); +#endif /* GL_EXT_pvrtc_sRGB */ #ifdef GL_EXT_raster_multisample _glewInfo_GL_EXT_raster_multisample(); #endif /* GL_EXT_raster_multisample */ +#ifdef GL_EXT_read_format_bgra + _glewInfo_GL_EXT_read_format_bgra(); +#endif /* GL_EXT_read_format_bgra */ +#ifdef GL_EXT_render_snorm + _glewInfo_GL_EXT_render_snorm(); +#endif /* GL_EXT_render_snorm */ #ifdef GL_EXT_rescale_normal _glewInfo_GL_EXT_rescale_normal(); #endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_sRGB + _glewInfo_GL_EXT_sRGB(); +#endif /* GL_EXT_sRGB */ +#ifdef GL_EXT_sRGB_write_control + _glewInfo_GL_EXT_sRGB_write_control(); +#endif /* GL_EXT_sRGB_write_control */ #ifdef GL_EXT_scene_marker _glewInfo_GL_EXT_scene_marker(); #endif /* GL_EXT_scene_marker */ #ifdef GL_EXT_secondary_color _glewInfo_GL_EXT_secondary_color(); #endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_semaphore + _glewInfo_GL_EXT_semaphore(); +#endif /* GL_EXT_semaphore */ +#ifdef GL_EXT_semaphore_fd + _glewInfo_GL_EXT_semaphore_fd(); +#endif /* GL_EXT_semaphore_fd */ +#ifdef GL_EXT_semaphore_win32 + _glewInfo_GL_EXT_semaphore_win32(); +#endif /* GL_EXT_semaphore_win32 */ #ifdef GL_EXT_separate_shader_objects _glewInfo_GL_EXT_separate_shader_objects(); #endif /* GL_EXT_separate_shader_objects */ #ifdef GL_EXT_separate_specular_color _glewInfo_GL_EXT_separate_specular_color(); #endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shader_framebuffer_fetch + _glewInfo_GL_EXT_shader_framebuffer_fetch(); +#endif /* GL_EXT_shader_framebuffer_fetch */ +#ifdef GL_EXT_shader_group_vote + _glewInfo_GL_EXT_shader_group_vote(); +#endif /* GL_EXT_shader_group_vote */ #ifdef GL_EXT_shader_image_load_formatted _glewInfo_GL_EXT_shader_image_load_formatted(); #endif /* GL_EXT_shader_image_load_formatted */ #ifdef GL_EXT_shader_image_load_store _glewInfo_GL_EXT_shader_image_load_store(); #endif /* GL_EXT_shader_image_load_store */ +#ifdef GL_EXT_shader_implicit_conversions + _glewInfo_GL_EXT_shader_implicit_conversions(); +#endif /* GL_EXT_shader_implicit_conversions */ #ifdef GL_EXT_shader_integer_mix _glewInfo_GL_EXT_shader_integer_mix(); #endif /* GL_EXT_shader_integer_mix */ +#ifdef GL_EXT_shader_io_blocks + _glewInfo_GL_EXT_shader_io_blocks(); +#endif /* GL_EXT_shader_io_blocks */ +#ifdef GL_EXT_shader_non_constant_global_initializers + _glewInfo_GL_EXT_shader_non_constant_global_initializers(); +#endif /* GL_EXT_shader_non_constant_global_initializers */ +#ifdef GL_EXT_shader_pixel_local_storage + _glewInfo_GL_EXT_shader_pixel_local_storage(); +#endif /* GL_EXT_shader_pixel_local_storage */ +#ifdef GL_EXT_shader_pixel_local_storage2 + _glewInfo_GL_EXT_shader_pixel_local_storage2(); +#endif /* GL_EXT_shader_pixel_local_storage2 */ +#ifdef GL_EXT_shader_texture_lod + _glewInfo_GL_EXT_shader_texture_lod(); +#endif /* GL_EXT_shader_texture_lod */ #ifdef GL_EXT_shadow_funcs _glewInfo_GL_EXT_shadow_funcs(); #endif /* GL_EXT_shadow_funcs */ +#ifdef GL_EXT_shadow_samplers + _glewInfo_GL_EXT_shadow_samplers(); +#endif /* GL_EXT_shadow_samplers */ #ifdef GL_EXT_shared_texture_palette _glewInfo_GL_EXT_shared_texture_palette(); #endif /* GL_EXT_shared_texture_palette */ +#ifdef GL_EXT_sparse_texture + _glewInfo_GL_EXT_sparse_texture(); +#endif /* GL_EXT_sparse_texture */ #ifdef GL_EXT_sparse_texture2 _glewInfo_GL_EXT_sparse_texture2(); #endif /* GL_EXT_sparse_texture2 */ @@ -11831,6 +14362,15 @@ static void glewInfo (void) #ifdef GL_EXT_texture_buffer_object _glewInfo_GL_EXT_texture_buffer_object(); #endif /* GL_EXT_texture_buffer_object */ +#ifdef GL_EXT_texture_compression_astc_decode_mode + _glewInfo_GL_EXT_texture_compression_astc_decode_mode(); +#endif /* GL_EXT_texture_compression_astc_decode_mode */ +#ifdef GL_EXT_texture_compression_astc_decode_mode_rgb9e5 + _glewInfo_GL_EXT_texture_compression_astc_decode_mode_rgb9e5(); +#endif /* GL_EXT_texture_compression_astc_decode_mode_rgb9e5 */ +#ifdef GL_EXT_texture_compression_bptc + _glewInfo_GL_EXT_texture_compression_bptc(); +#endif /* GL_EXT_texture_compression_bptc */ #ifdef GL_EXT_texture_compression_dxt1 _glewInfo_GL_EXT_texture_compression_dxt1(); #endif /* GL_EXT_texture_compression_dxt1 */ @@ -11846,6 +14386,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_cube_map _glewInfo_GL_EXT_texture_cube_map(); #endif /* GL_EXT_texture_cube_map */ +#ifdef GL_EXT_texture_cube_map_array + _glewInfo_GL_EXT_texture_cube_map_array(); +#endif /* GL_EXT_texture_cube_map_array */ #ifdef GL_EXT_texture_edge_clamp _glewInfo_GL_EXT_texture_edge_clamp(); #endif /* GL_EXT_texture_edge_clamp */ @@ -11867,6 +14410,9 @@ static void glewInfo (void) #ifdef GL_EXT_texture_filter_minmax _glewInfo_GL_EXT_texture_filter_minmax(); #endif /* GL_EXT_texture_filter_minmax */ +#ifdef GL_EXT_texture_format_BGRA8888 + _glewInfo_GL_EXT_texture_format_BGRA8888(); +#endif /* GL_EXT_texture_format_BGRA8888 */ #ifdef GL_EXT_texture_integer _glewInfo_GL_EXT_texture_integer(); #endif /* GL_EXT_texture_integer */ @@ -11876,6 +14422,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_norm16 + _glewInfo_GL_EXT_texture_norm16(); +#endif /* GL_EXT_texture_norm16 */ #ifdef GL_EXT_texture_object _glewInfo_GL_EXT_texture_object(); #endif /* GL_EXT_texture_object */ @@ -11885,9 +14434,18 @@ static void glewInfo (void) #ifdef GL_EXT_texture_rectangle _glewInfo_GL_EXT_texture_rectangle(); #endif /* GL_EXT_texture_rectangle */ +#ifdef GL_EXT_texture_rg + _glewInfo_GL_EXT_texture_rg(); +#endif /* GL_EXT_texture_rg */ #ifdef GL_EXT_texture_sRGB _glewInfo_GL_EXT_texture_sRGB(); #endif /* GL_EXT_texture_sRGB */ +#ifdef GL_EXT_texture_sRGB_R8 + _glewInfo_GL_EXT_texture_sRGB_R8(); +#endif /* GL_EXT_texture_sRGB_R8 */ +#ifdef GL_EXT_texture_sRGB_RG8 + _glewInfo_GL_EXT_texture_sRGB_RG8(); +#endif /* GL_EXT_texture_sRGB_RG8 */ #ifdef GL_EXT_texture_sRGB_decode _glewInfo_GL_EXT_texture_sRGB_decode(); #endif /* GL_EXT_texture_sRGB_decode */ @@ -11897,21 +14455,36 @@ static void glewInfo (void) #ifdef GL_EXT_texture_snorm _glewInfo_GL_EXT_texture_snorm(); #endif /* GL_EXT_texture_snorm */ +#ifdef GL_EXT_texture_storage + _glewInfo_GL_EXT_texture_storage(); +#endif /* GL_EXT_texture_storage */ #ifdef GL_EXT_texture_swizzle _glewInfo_GL_EXT_texture_swizzle(); #endif /* GL_EXT_texture_swizzle */ +#ifdef GL_EXT_texture_type_2_10_10_10_REV + _glewInfo_GL_EXT_texture_type_2_10_10_10_REV(); +#endif /* GL_EXT_texture_type_2_10_10_10_REV */ +#ifdef GL_EXT_texture_view + _glewInfo_GL_EXT_texture_view(); +#endif /* GL_EXT_texture_view */ #ifdef GL_EXT_timer_query _glewInfo_GL_EXT_timer_query(); #endif /* GL_EXT_timer_query */ #ifdef GL_EXT_transform_feedback _glewInfo_GL_EXT_transform_feedback(); #endif /* GL_EXT_transform_feedback */ +#ifdef GL_EXT_unpack_subimage + _glewInfo_GL_EXT_unpack_subimage(); +#endif /* GL_EXT_unpack_subimage */ #ifdef GL_EXT_vertex_array _glewInfo_GL_EXT_vertex_array(); #endif /* GL_EXT_vertex_array */ #ifdef GL_EXT_vertex_array_bgra _glewInfo_GL_EXT_vertex_array_bgra(); #endif /* GL_EXT_vertex_array_bgra */ +#ifdef GL_EXT_vertex_array_setXXX + _glewInfo_GL_EXT_vertex_array_setXXX(); +#endif /* GL_EXT_vertex_array_setXXX */ #ifdef GL_EXT_vertex_attrib_64bit _glewInfo_GL_EXT_vertex_attrib_64bit(); #endif /* GL_EXT_vertex_attrib_64bit */ @@ -11921,6 +14494,9 @@ static void glewInfo (void) #ifdef GL_EXT_vertex_weighting _glewInfo_GL_EXT_vertex_weighting(); #endif /* GL_EXT_vertex_weighting */ +#ifdef GL_EXT_win32_keyed_mutex + _glewInfo_GL_EXT_win32_keyed_mutex(); +#endif /* GL_EXT_win32_keyed_mutex */ #ifdef GL_EXT_window_rectangles _glewInfo_GL_EXT_window_rectangles(); #endif /* GL_EXT_window_rectangles */ @@ -12005,6 +14581,9 @@ static void glewInfo (void) #ifdef GL_KHR_no_error _glewInfo_GL_KHR_no_error(); #endif /* GL_KHR_no_error */ +#ifdef GL_KHR_parallel_shader_compile + _glewInfo_GL_KHR_parallel_shader_compile(); +#endif /* GL_KHR_parallel_shader_compile */ #ifdef GL_KHR_robust_buffer_access_behavior _glewInfo_GL_KHR_robust_buffer_access_behavior(); #endif /* GL_KHR_robust_buffer_access_behavior */ @@ -12053,6 +14632,18 @@ static void glewInfo (void) #ifdef GL_NVX_linked_gpu_multicast _glewInfo_GL_NVX_linked_gpu_multicast(); #endif /* GL_NVX_linked_gpu_multicast */ +#ifdef GL_NV_3dvision_settings + _glewInfo_GL_NV_3dvision_settings(); +#endif /* GL_NV_3dvision_settings */ +#ifdef GL_NV_EGL_stream_consumer_external + _glewInfo_GL_NV_EGL_stream_consumer_external(); +#endif /* GL_NV_EGL_stream_consumer_external */ +#ifdef GL_NV_alpha_to_coverage_dither_control + _glewInfo_GL_NV_alpha_to_coverage_dither_control(); +#endif /* GL_NV_alpha_to_coverage_dither_control */ +#ifdef GL_NV_bgr + _glewInfo_GL_NV_bgr(); +#endif /* GL_NV_bgr */ #ifdef GL_NV_bindless_multi_draw_indirect _glewInfo_GL_NV_bindless_multi_draw_indirect(); #endif /* GL_NV_bindless_multi_draw_indirect */ @@ -12068,6 +14659,9 @@ static void glewInfo (void) #ifdef GL_NV_blend_equation_advanced_coherent _glewInfo_GL_NV_blend_equation_advanced_coherent(); #endif /* GL_NV_blend_equation_advanced_coherent */ +#ifdef GL_NV_blend_minmax_factor + _glewInfo_GL_NV_blend_minmax_factor(); +#endif /* GL_NV_blend_minmax_factor */ #ifdef GL_NV_blend_square _glewInfo_GL_NV_blend_square(); #endif /* GL_NV_blend_square */ @@ -12092,6 +14686,9 @@ static void glewInfo (void) #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_copy_buffer + _glewInfo_GL_NV_copy_buffer(); +#endif /* GL_NV_copy_buffer */ #ifdef GL_NV_copy_depth_to_color _glewInfo_GL_NV_copy_depth_to_color(); #endif /* GL_NV_copy_depth_to_color */ @@ -12110,6 +14707,12 @@ static void glewInfo (void) #ifdef GL_NV_depth_range_unclamped _glewInfo_GL_NV_depth_range_unclamped(); #endif /* GL_NV_depth_range_unclamped */ +#ifdef GL_NV_draw_buffers + _glewInfo_GL_NV_draw_buffers(); +#endif /* GL_NV_draw_buffers */ +#ifdef GL_NV_draw_instanced + _glewInfo_GL_NV_draw_instanced(); +#endif /* GL_NV_draw_instanced */ #ifdef GL_NV_draw_texture _glewInfo_GL_NV_draw_texture(); #endif /* GL_NV_draw_texture */ @@ -12119,9 +14722,15 @@ static void glewInfo (void) #ifdef GL_NV_evaluators _glewInfo_GL_NV_evaluators(); #endif /* GL_NV_evaluators */ +#ifdef GL_NV_explicit_attrib_location + _glewInfo_GL_NV_explicit_attrib_location(); +#endif /* GL_NV_explicit_attrib_location */ #ifdef GL_NV_explicit_multisample _glewInfo_GL_NV_explicit_multisample(); #endif /* GL_NV_explicit_multisample */ +#ifdef GL_NV_fbo_color_attachments + _glewInfo_GL_NV_fbo_color_attachments(); +#endif /* GL_NV_fbo_color_attachments */ #ifdef GL_NV_fence _glewInfo_GL_NV_fence(); #endif /* GL_NV_fence */ @@ -12152,12 +14761,21 @@ static void glewInfo (void) #ifdef GL_NV_fragment_shader_interlock _glewInfo_GL_NV_fragment_shader_interlock(); #endif /* GL_NV_fragment_shader_interlock */ +#ifdef GL_NV_framebuffer_blit + _glewInfo_GL_NV_framebuffer_blit(); +#endif /* GL_NV_framebuffer_blit */ #ifdef GL_NV_framebuffer_mixed_samples _glewInfo_GL_NV_framebuffer_mixed_samples(); #endif /* GL_NV_framebuffer_mixed_samples */ +#ifdef GL_NV_framebuffer_multisample + _glewInfo_GL_NV_framebuffer_multisample(); +#endif /* GL_NV_framebuffer_multisample */ #ifdef GL_NV_framebuffer_multisample_coverage _glewInfo_GL_NV_framebuffer_multisample_coverage(); #endif /* GL_NV_framebuffer_multisample_coverage */ +#ifdef GL_NV_generate_mipmap_sRGB + _glewInfo_GL_NV_generate_mipmap_sRGB(); +#endif /* GL_NV_generate_mipmap_sRGB */ #ifdef GL_NV_geometry_program4 _glewInfo_GL_NV_geometry_program4(); #endif /* GL_NV_geometry_program4 */ @@ -12188,6 +14806,12 @@ static void glewInfo (void) #ifdef GL_NV_half_float _glewInfo_GL_NV_half_float(); #endif /* GL_NV_half_float */ +#ifdef GL_NV_image_formats + _glewInfo_GL_NV_image_formats(); +#endif /* GL_NV_image_formats */ +#ifdef GL_NV_instanced_arrays + _glewInfo_GL_NV_instanced_arrays(); +#endif /* GL_NV_instanced_arrays */ #ifdef GL_NV_internalformat_sample_query _glewInfo_GL_NV_internalformat_sample_query(); #endif /* GL_NV_internalformat_sample_query */ @@ -12200,12 +14824,24 @@ static void glewInfo (void) #ifdef GL_NV_multisample_filter_hint _glewInfo_GL_NV_multisample_filter_hint(); #endif /* GL_NV_multisample_filter_hint */ +#ifdef GL_NV_non_square_matrices + _glewInfo_GL_NV_non_square_matrices(); +#endif /* GL_NV_non_square_matrices */ #ifdef GL_NV_occlusion_query _glewInfo_GL_NV_occlusion_query(); #endif /* GL_NV_occlusion_query */ +#ifdef GL_NV_pack_subimage + _glewInfo_GL_NV_pack_subimage(); +#endif /* GL_NV_pack_subimage */ #ifdef GL_NV_packed_depth_stencil _glewInfo_GL_NV_packed_depth_stencil(); #endif /* GL_NV_packed_depth_stencil */ +#ifdef GL_NV_packed_float + _glewInfo_GL_NV_packed_float(); +#endif /* GL_NV_packed_float */ +#ifdef GL_NV_packed_float_linear + _glewInfo_GL_NV_packed_float_linear(); +#endif /* GL_NV_packed_float_linear */ #ifdef GL_NV_parameter_buffer_object _glewInfo_GL_NV_parameter_buffer_object(); #endif /* GL_NV_parameter_buffer_object */ @@ -12218,18 +14854,36 @@ static void glewInfo (void) #ifdef GL_NV_path_rendering_shared_edge _glewInfo_GL_NV_path_rendering_shared_edge(); #endif /* GL_NV_path_rendering_shared_edge */ +#ifdef GL_NV_pixel_buffer_object + _glewInfo_GL_NV_pixel_buffer_object(); +#endif /* GL_NV_pixel_buffer_object */ #ifdef GL_NV_pixel_data_range _glewInfo_GL_NV_pixel_data_range(); #endif /* GL_NV_pixel_data_range */ +#ifdef GL_NV_platform_binary + _glewInfo_GL_NV_platform_binary(); +#endif /* GL_NV_platform_binary */ #ifdef GL_NV_point_sprite _glewInfo_GL_NV_point_sprite(); #endif /* GL_NV_point_sprite */ +#ifdef GL_NV_polygon_mode + _glewInfo_GL_NV_polygon_mode(); +#endif /* GL_NV_polygon_mode */ #ifdef GL_NV_present_video _glewInfo_GL_NV_present_video(); #endif /* GL_NV_present_video */ #ifdef GL_NV_primitive_restart _glewInfo_GL_NV_primitive_restart(); #endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_read_depth + _glewInfo_GL_NV_read_depth(); +#endif /* GL_NV_read_depth */ +#ifdef GL_NV_read_depth_stencil + _glewInfo_GL_NV_read_depth_stencil(); +#endif /* GL_NV_read_depth_stencil */ +#ifdef GL_NV_read_stencil + _glewInfo_GL_NV_read_stencil(); +#endif /* GL_NV_read_stencil */ #ifdef GL_NV_register_combiners _glewInfo_GL_NV_register_combiners(); #endif /* GL_NV_register_combiners */ @@ -12239,6 +14893,9 @@ static void glewInfo (void) #ifdef GL_NV_robustness_video_memory_purge _glewInfo_GL_NV_robustness_video_memory_purge(); #endif /* GL_NV_robustness_video_memory_purge */ +#ifdef GL_NV_sRGB_formats + _glewInfo_GL_NV_sRGB_formats(); +#endif /* GL_NV_sRGB_formats */ #ifdef GL_NV_sample_locations _glewInfo_GL_NV_sample_locations(); #endif /* GL_NV_sample_locations */ @@ -12263,6 +14920,9 @@ static void glewInfo (void) #ifdef GL_NV_shader_buffer_load _glewInfo_GL_NV_shader_buffer_load(); #endif /* GL_NV_shader_buffer_load */ +#ifdef GL_NV_shader_noperspective_interpolation + _glewInfo_GL_NV_shader_noperspective_interpolation(); +#endif /* GL_NV_shader_noperspective_interpolation */ #ifdef GL_NV_shader_storage_buffer_object _glewInfo_GL_NV_shader_storage_buffer_object(); #endif /* GL_NV_shader_storage_buffer_object */ @@ -12272,6 +14932,12 @@ static void glewInfo (void) #ifdef GL_NV_shader_thread_shuffle _glewInfo_GL_NV_shader_thread_shuffle(); #endif /* GL_NV_shader_thread_shuffle */ +#ifdef GL_NV_shadow_samplers_array + _glewInfo_GL_NV_shadow_samplers_array(); +#endif /* GL_NV_shadow_samplers_array */ +#ifdef GL_NV_shadow_samplers_cube + _glewInfo_GL_NV_shadow_samplers_cube(); +#endif /* GL_NV_shadow_samplers_cube */ #ifdef GL_NV_stereo_view_rendering _glewInfo_GL_NV_stereo_view_rendering(); #endif /* GL_NV_stereo_view_rendering */ @@ -12284,9 +14950,24 @@ static void glewInfo (void) #ifdef GL_NV_texgen_reflection _glewInfo_GL_NV_texgen_reflection(); #endif /* GL_NV_texgen_reflection */ +#ifdef GL_NV_texture_array + _glewInfo_GL_NV_texture_array(); +#endif /* GL_NV_texture_array */ #ifdef GL_NV_texture_barrier _glewInfo_GL_NV_texture_barrier(); #endif /* GL_NV_texture_barrier */ +#ifdef GL_NV_texture_border_clamp + _glewInfo_GL_NV_texture_border_clamp(); +#endif /* GL_NV_texture_border_clamp */ +#ifdef GL_NV_texture_compression_latc + _glewInfo_GL_NV_texture_compression_latc(); +#endif /* GL_NV_texture_compression_latc */ +#ifdef GL_NV_texture_compression_s3tc + _glewInfo_GL_NV_texture_compression_s3tc(); +#endif /* GL_NV_texture_compression_s3tc */ +#ifdef GL_NV_texture_compression_s3tc_update + _glewInfo_GL_NV_texture_compression_s3tc_update(); +#endif /* GL_NV_texture_compression_s3tc_update */ #ifdef GL_NV_texture_compression_vtc _glewInfo_GL_NV_texture_compression_vtc(); #endif /* GL_NV_texture_compression_vtc */ @@ -12299,9 +14980,15 @@ static void glewInfo (void) #ifdef GL_NV_texture_multisample _glewInfo_GL_NV_texture_multisample(); #endif /* GL_NV_texture_multisample */ +#ifdef GL_NV_texture_npot_2D_mipmap + _glewInfo_GL_NV_texture_npot_2D_mipmap(); +#endif /* GL_NV_texture_npot_2D_mipmap */ #ifdef GL_NV_texture_rectangle _glewInfo_GL_NV_texture_rectangle(); #endif /* GL_NV_texture_rectangle */ +#ifdef GL_NV_texture_rectangle_compressed + _glewInfo_GL_NV_texture_rectangle_compressed(); +#endif /* GL_NV_texture_rectangle_compressed */ #ifdef GL_NV_texture_shader _glewInfo_GL_NV_texture_shader(); #endif /* GL_NV_texture_shader */ @@ -12356,6 +15043,9 @@ static void glewInfo (void) #ifdef GL_NV_video_capture _glewInfo_GL_NV_video_capture(); #endif /* GL_NV_video_capture */ +#ifdef GL_NV_viewport_array + _glewInfo_GL_NV_viewport_array(); +#endif /* GL_NV_viewport_array */ #ifdef GL_NV_viewport_array2 _glewInfo_GL_NV_viewport_array2(); #endif /* GL_NV_viewport_array2 */ @@ -12365,15 +15055,6 @@ static void glewInfo (void) #ifdef GL_OES_byte_coordinates _glewInfo_GL_OES_byte_coordinates(); #endif /* GL_OES_byte_coordinates */ -#ifdef GL_OES_compressed_paletted_texture - _glewInfo_GL_OES_compressed_paletted_texture(); -#endif /* GL_OES_compressed_paletted_texture */ -#ifdef GL_OES_read_format - _glewInfo_GL_OES_read_format(); -#endif /* GL_OES_read_format */ -#ifdef GL_OES_single_precision - _glewInfo_GL_OES_single_precision(); -#endif /* GL_OES_single_precision */ #ifdef GL_OML_interlace _glewInfo_GL_OML_interlace(); #endif /* GL_OML_interlace */ @@ -12389,12 +15070,45 @@ static void glewInfo (void) #ifdef GL_OVR_multiview2 _glewInfo_GL_OVR_multiview2(); #endif /* GL_OVR_multiview2 */ +#ifdef GL_OVR_multiview_multisampled_render_to_texture + _glewInfo_GL_OVR_multiview_multisampled_render_to_texture(); +#endif /* GL_OVR_multiview_multisampled_render_to_texture */ #ifdef GL_PGI_misc_hints _glewInfo_GL_PGI_misc_hints(); #endif /* GL_PGI_misc_hints */ #ifdef GL_PGI_vertex_hints _glewInfo_GL_PGI_vertex_hints(); #endif /* GL_PGI_vertex_hints */ +#ifdef GL_QCOM_alpha_test + _glewInfo_GL_QCOM_alpha_test(); +#endif /* GL_QCOM_alpha_test */ +#ifdef GL_QCOM_binning_control + _glewInfo_GL_QCOM_binning_control(); +#endif /* GL_QCOM_binning_control */ +#ifdef GL_QCOM_driver_control + _glewInfo_GL_QCOM_driver_control(); +#endif /* GL_QCOM_driver_control */ +#ifdef GL_QCOM_extended_get + _glewInfo_GL_QCOM_extended_get(); +#endif /* GL_QCOM_extended_get */ +#ifdef GL_QCOM_extended_get2 + _glewInfo_GL_QCOM_extended_get2(); +#endif /* GL_QCOM_extended_get2 */ +#ifdef GL_QCOM_framebuffer_foveated + _glewInfo_GL_QCOM_framebuffer_foveated(); +#endif /* GL_QCOM_framebuffer_foveated */ +#ifdef GL_QCOM_perfmon_global_mode + _glewInfo_GL_QCOM_perfmon_global_mode(); +#endif /* GL_QCOM_perfmon_global_mode */ +#ifdef GL_QCOM_shader_framebuffer_fetch_noncoherent + _glewInfo_GL_QCOM_shader_framebuffer_fetch_noncoherent(); +#endif /* GL_QCOM_shader_framebuffer_fetch_noncoherent */ +#ifdef GL_QCOM_tiled_rendering + _glewInfo_GL_QCOM_tiled_rendering(); +#endif /* GL_QCOM_tiled_rendering */ +#ifdef GL_QCOM_writeonly_rendering + _glewInfo_GL_QCOM_writeonly_rendering(); +#endif /* GL_QCOM_writeonly_rendering */ #ifdef GL_REGAL_ES1_0_compatibility _glewInfo_GL_REGAL_ES1_0_compatibility(); #endif /* GL_REGAL_ES1_0_compatibility */ @@ -12422,6 +15136,9 @@ static void glewInfo (void) #ifdef GL_S3_s3tc _glewInfo_GL_S3_s3tc(); #endif /* GL_S3_s3tc */ +#ifdef GL_SGIS_clip_band_hint + _glewInfo_GL_SGIS_clip_band_hint(); +#endif /* GL_SGIS_clip_band_hint */ #ifdef GL_SGIS_color_range _glewInfo_GL_SGIS_color_range(); #endif /* GL_SGIS_color_range */ @@ -12434,15 +15151,24 @@ static void glewInfo (void) #ifdef GL_SGIS_generate_mipmap _glewInfo_GL_SGIS_generate_mipmap(); #endif /* GL_SGIS_generate_mipmap */ +#ifdef GL_SGIS_line_texgen + _glewInfo_GL_SGIS_line_texgen(); +#endif /* GL_SGIS_line_texgen */ #ifdef GL_SGIS_multisample _glewInfo_GL_SGIS_multisample(); #endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_multitexture + _glewInfo_GL_SGIS_multitexture(); +#endif /* GL_SGIS_multitexture */ #ifdef GL_SGIS_pixel_texture _glewInfo_GL_SGIS_pixel_texture(); #endif /* GL_SGIS_pixel_texture */ #ifdef GL_SGIS_point_line_texgen _glewInfo_GL_SGIS_point_line_texgen(); #endif /* GL_SGIS_point_line_texgen */ +#ifdef GL_SGIS_shared_multisample + _glewInfo_GL_SGIS_shared_multisample(); +#endif /* GL_SGIS_shared_multisample */ #ifdef GL_SGIS_sharpen_texture _glewInfo_GL_SGIS_sharpen_texture(); #endif /* GL_SGIS_sharpen_texture */ @@ -12473,63 +15199,192 @@ static void glewInfo (void) #ifdef GL_SGIX_async_pixel _glewInfo_GL_SGIX_async_pixel(); #endif /* GL_SGIX_async_pixel */ +#ifdef GL_SGIX_bali_g_instruments + _glewInfo_GL_SGIX_bali_g_instruments(); +#endif /* GL_SGIX_bali_g_instruments */ +#ifdef GL_SGIX_bali_r_instruments + _glewInfo_GL_SGIX_bali_r_instruments(); +#endif /* GL_SGIX_bali_r_instruments */ +#ifdef GL_SGIX_bali_timer_instruments + _glewInfo_GL_SGIX_bali_timer_instruments(); +#endif /* GL_SGIX_bali_timer_instruments */ #ifdef GL_SGIX_blend_alpha_minmax _glewInfo_GL_SGIX_blend_alpha_minmax(); #endif /* GL_SGIX_blend_alpha_minmax */ +#ifdef GL_SGIX_blend_cadd + _glewInfo_GL_SGIX_blend_cadd(); +#endif /* GL_SGIX_blend_cadd */ +#ifdef GL_SGIX_blend_cmultiply + _glewInfo_GL_SGIX_blend_cmultiply(); +#endif /* GL_SGIX_blend_cmultiply */ +#ifdef GL_SGIX_calligraphic_fragment + _glewInfo_GL_SGIX_calligraphic_fragment(); +#endif /* GL_SGIX_calligraphic_fragment */ #ifdef GL_SGIX_clipmap _glewInfo_GL_SGIX_clipmap(); #endif /* GL_SGIX_clipmap */ +#ifdef GL_SGIX_color_matrix_accuracy + _glewInfo_GL_SGIX_color_matrix_accuracy(); +#endif /* GL_SGIX_color_matrix_accuracy */ +#ifdef GL_SGIX_color_table_index_mode + _glewInfo_GL_SGIX_color_table_index_mode(); +#endif /* GL_SGIX_color_table_index_mode */ +#ifdef GL_SGIX_complex_polar + _glewInfo_GL_SGIX_complex_polar(); +#endif /* GL_SGIX_complex_polar */ #ifdef GL_SGIX_convolution_accuracy _glewInfo_GL_SGIX_convolution_accuracy(); #endif /* GL_SGIX_convolution_accuracy */ +#ifdef GL_SGIX_cube_map + _glewInfo_GL_SGIX_cube_map(); +#endif /* GL_SGIX_cube_map */ +#ifdef GL_SGIX_cylinder_texgen + _glewInfo_GL_SGIX_cylinder_texgen(); +#endif /* GL_SGIX_cylinder_texgen */ +#ifdef GL_SGIX_datapipe + _glewInfo_GL_SGIX_datapipe(); +#endif /* GL_SGIX_datapipe */ +#ifdef GL_SGIX_decimation + _glewInfo_GL_SGIX_decimation(); +#endif /* GL_SGIX_decimation */ +#ifdef GL_SGIX_depth_pass_instrument + _glewInfo_GL_SGIX_depth_pass_instrument(); +#endif /* GL_SGIX_depth_pass_instrument */ #ifdef GL_SGIX_depth_texture _glewInfo_GL_SGIX_depth_texture(); #endif /* GL_SGIX_depth_texture */ +#ifdef GL_SGIX_dvc + _glewInfo_GL_SGIX_dvc(); +#endif /* GL_SGIX_dvc */ #ifdef GL_SGIX_flush_raster _glewInfo_GL_SGIX_flush_raster(); #endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_blend + _glewInfo_GL_SGIX_fog_blend(); +#endif /* GL_SGIX_fog_blend */ +#ifdef GL_SGIX_fog_factor_to_alpha + _glewInfo_GL_SGIX_fog_factor_to_alpha(); +#endif /* GL_SGIX_fog_factor_to_alpha */ +#ifdef GL_SGIX_fog_layers + _glewInfo_GL_SGIX_fog_layers(); +#endif /* GL_SGIX_fog_layers */ #ifdef GL_SGIX_fog_offset _glewInfo_GL_SGIX_fog_offset(); #endif /* GL_SGIX_fog_offset */ +#ifdef GL_SGIX_fog_patchy + _glewInfo_GL_SGIX_fog_patchy(); +#endif /* GL_SGIX_fog_patchy */ +#ifdef GL_SGIX_fog_scale + _glewInfo_GL_SGIX_fog_scale(); +#endif /* GL_SGIX_fog_scale */ #ifdef GL_SGIX_fog_texture _glewInfo_GL_SGIX_fog_texture(); #endif /* GL_SGIX_fog_texture */ +#ifdef GL_SGIX_fragment_lighting_space + _glewInfo_GL_SGIX_fragment_lighting_space(); +#endif /* GL_SGIX_fragment_lighting_space */ #ifdef GL_SGIX_fragment_specular_lighting _glewInfo_GL_SGIX_fragment_specular_lighting(); #endif /* GL_SGIX_fragment_specular_lighting */ +#ifdef GL_SGIX_fragments_instrument + _glewInfo_GL_SGIX_fragments_instrument(); +#endif /* GL_SGIX_fragments_instrument */ #ifdef GL_SGIX_framezoom _glewInfo_GL_SGIX_framezoom(); #endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_icc_texture + _glewInfo_GL_SGIX_icc_texture(); +#endif /* GL_SGIX_icc_texture */ +#ifdef GL_SGIX_igloo_interface + _glewInfo_GL_SGIX_igloo_interface(); +#endif /* GL_SGIX_igloo_interface */ +#ifdef GL_SGIX_image_compression + _glewInfo_GL_SGIX_image_compression(); +#endif /* GL_SGIX_image_compression */ +#ifdef GL_SGIX_impact_pixel_texture + _glewInfo_GL_SGIX_impact_pixel_texture(); +#endif /* GL_SGIX_impact_pixel_texture */ +#ifdef GL_SGIX_instrument_error + _glewInfo_GL_SGIX_instrument_error(); +#endif /* GL_SGIX_instrument_error */ #ifdef GL_SGIX_interlace _glewInfo_GL_SGIX_interlace(); #endif /* GL_SGIX_interlace */ #ifdef GL_SGIX_ir_instrument1 _glewInfo_GL_SGIX_ir_instrument1(); #endif /* GL_SGIX_ir_instrument1 */ +#ifdef GL_SGIX_line_quality_hint + _glewInfo_GL_SGIX_line_quality_hint(); +#endif /* GL_SGIX_line_quality_hint */ #ifdef GL_SGIX_list_priority _glewInfo_GL_SGIX_list_priority(); #endif /* GL_SGIX_list_priority */ +#ifdef GL_SGIX_mpeg1 + _glewInfo_GL_SGIX_mpeg1(); +#endif /* GL_SGIX_mpeg1 */ +#ifdef GL_SGIX_mpeg2 + _glewInfo_GL_SGIX_mpeg2(); +#endif /* GL_SGIX_mpeg2 */ +#ifdef GL_SGIX_nonlinear_lighting_pervertex + _glewInfo_GL_SGIX_nonlinear_lighting_pervertex(); +#endif /* GL_SGIX_nonlinear_lighting_pervertex */ +#ifdef GL_SGIX_nurbs_eval + _glewInfo_GL_SGIX_nurbs_eval(); +#endif /* GL_SGIX_nurbs_eval */ +#ifdef GL_SGIX_occlusion_instrument + _glewInfo_GL_SGIX_occlusion_instrument(); +#endif /* GL_SGIX_occlusion_instrument */ +#ifdef GL_SGIX_packed_6bytes + _glewInfo_GL_SGIX_packed_6bytes(); +#endif /* GL_SGIX_packed_6bytes */ #ifdef GL_SGIX_pixel_texture _glewInfo_GL_SGIX_pixel_texture(); #endif /* GL_SGIX_pixel_texture */ #ifdef GL_SGIX_pixel_texture_bits _glewInfo_GL_SGIX_pixel_texture_bits(); #endif /* GL_SGIX_pixel_texture_bits */ +#ifdef GL_SGIX_pixel_texture_lod + _glewInfo_GL_SGIX_pixel_texture_lod(); +#endif /* GL_SGIX_pixel_texture_lod */ +#ifdef GL_SGIX_pixel_tiles + _glewInfo_GL_SGIX_pixel_tiles(); +#endif /* GL_SGIX_pixel_tiles */ +#ifdef GL_SGIX_polynomial_ffd + _glewInfo_GL_SGIX_polynomial_ffd(); +#endif /* GL_SGIX_polynomial_ffd */ +#ifdef GL_SGIX_quad_mesh + _glewInfo_GL_SGIX_quad_mesh(); +#endif /* GL_SGIX_quad_mesh */ #ifdef GL_SGIX_reference_plane _glewInfo_GL_SGIX_reference_plane(); #endif /* GL_SGIX_reference_plane */ #ifdef GL_SGIX_resample _glewInfo_GL_SGIX_resample(); #endif /* GL_SGIX_resample */ +#ifdef GL_SGIX_scalebias_hint + _glewInfo_GL_SGIX_scalebias_hint(); +#endif /* GL_SGIX_scalebias_hint */ #ifdef GL_SGIX_shadow _glewInfo_GL_SGIX_shadow(); #endif /* GL_SGIX_shadow */ #ifdef GL_SGIX_shadow_ambient _glewInfo_GL_SGIX_shadow_ambient(); #endif /* GL_SGIX_shadow_ambient */ +#ifdef GL_SGIX_slim + _glewInfo_GL_SGIX_slim(); +#endif /* GL_SGIX_slim */ +#ifdef GL_SGIX_spotlight_cutoff + _glewInfo_GL_SGIX_spotlight_cutoff(); +#endif /* GL_SGIX_spotlight_cutoff */ #ifdef GL_SGIX_sprite _glewInfo_GL_SGIX_sprite(); #endif /* GL_SGIX_sprite */ +#ifdef GL_SGIX_subdiv_patch + _glewInfo_GL_SGIX_subdiv_patch(); +#endif /* GL_SGIX_subdiv_patch */ +#ifdef GL_SGIX_subsample + _glewInfo_GL_SGIX_subsample(); +#endif /* GL_SGIX_subsample */ #ifdef GL_SGIX_tag_sample_buffer _glewInfo_GL_SGIX_tag_sample_buffer(); #endif /* GL_SGIX_tag_sample_buffer */ @@ -12542,15 +15397,30 @@ static void glewInfo (void) #ifdef GL_SGIX_texture_lod_bias _glewInfo_GL_SGIX_texture_lod_bias(); #endif /* GL_SGIX_texture_lod_bias */ +#ifdef GL_SGIX_texture_mipmap_anisotropic + _glewInfo_GL_SGIX_texture_mipmap_anisotropic(); +#endif /* GL_SGIX_texture_mipmap_anisotropic */ #ifdef GL_SGIX_texture_multi_buffer _glewInfo_GL_SGIX_texture_multi_buffer(); #endif /* GL_SGIX_texture_multi_buffer */ +#ifdef GL_SGIX_texture_phase + _glewInfo_GL_SGIX_texture_phase(); +#endif /* GL_SGIX_texture_phase */ #ifdef GL_SGIX_texture_range _glewInfo_GL_SGIX_texture_range(); #endif /* GL_SGIX_texture_range */ #ifdef GL_SGIX_texture_scale_bias _glewInfo_GL_SGIX_texture_scale_bias(); #endif /* GL_SGIX_texture_scale_bias */ +#ifdef GL_SGIX_texture_supersample + _glewInfo_GL_SGIX_texture_supersample(); +#endif /* GL_SGIX_texture_supersample */ +#ifdef GL_SGIX_vector_ops + _glewInfo_GL_SGIX_vector_ops(); +#endif /* GL_SGIX_vector_ops */ +#ifdef GL_SGIX_vertex_array_object + _glewInfo_GL_SGIX_vertex_array_object(); +#endif /* GL_SGIX_vertex_array_object */ #ifdef GL_SGIX_vertex_preclip _glewInfo_GL_SGIX_vertex_preclip(); #endif /* GL_SGIX_vertex_preclip */ @@ -12560,12 +15430,27 @@ static void glewInfo (void) #ifdef GL_SGIX_ycrcb _glewInfo_GL_SGIX_ycrcb(); #endif /* GL_SGIX_ycrcb */ +#ifdef GL_SGIX_ycrcb_subsample + _glewInfo_GL_SGIX_ycrcb_subsample(); +#endif /* GL_SGIX_ycrcb_subsample */ +#ifdef GL_SGIX_ycrcba + _glewInfo_GL_SGIX_ycrcba(); +#endif /* GL_SGIX_ycrcba */ #ifdef GL_SGI_color_matrix _glewInfo_GL_SGI_color_matrix(); #endif /* GL_SGI_color_matrix */ #ifdef GL_SGI_color_table _glewInfo_GL_SGI_color_table(); #endif /* GL_SGI_color_table */ +#ifdef GL_SGI_complex + _glewInfo_GL_SGI_complex(); +#endif /* GL_SGI_complex */ +#ifdef GL_SGI_complex_type + _glewInfo_GL_SGI_complex_type(); +#endif /* GL_SGI_complex_type */ +#ifdef GL_SGI_fft + _glewInfo_GL_SGI_fft(); +#endif /* GL_SGI_fft */ #ifdef GL_SGI_texture_color_table _glewInfo_GL_SGI_texture_color_table(); #endif /* GL_SGI_texture_color_table */ @@ -12596,6 +15481,9 @@ static void glewInfo (void) #ifdef GL_WIN_phong_shading _glewInfo_GL_WIN_phong_shading(); #endif /* GL_WIN_phong_shading */ +#ifdef GL_WIN_scene_markerXXX + _glewInfo_GL_WIN_scene_markerXXX(); +#endif /* GL_WIN_scene_markerXXX */ #ifdef GL_WIN_specular_fog _glewInfo_GL_WIN_specular_fog(); #endif /* GL_WIN_specular_fog */ @@ -12628,6 +15516,9 @@ static void wglewInfo () #ifdef WGL_ARB_create_context _glewInfo_WGL_ARB_create_context(); #endif /* WGL_ARB_create_context */ +#ifdef WGL_ARB_create_context_no_error + _glewInfo_WGL_ARB_create_context_no_error(); +#endif /* WGL_ARB_create_context_no_error */ #ifdef WGL_ARB_create_context_profile _glewInfo_WGL_ARB_create_context_profile(); #endif /* WGL_ARB_create_context_profile */ @@ -12670,6 +15561,9 @@ static void wglewInfo () #ifdef WGL_ATI_render_texture_rectangle _glewInfo_WGL_ATI_render_texture_rectangle(); #endif /* WGL_ATI_render_texture_rectangle */ +#ifdef WGL_EXT_colorspace + _glewInfo_WGL_EXT_colorspace(); +#endif /* WGL_EXT_colorspace */ #ifdef WGL_EXT_create_context_es2_profile _glewInfo_WGL_EXT_create_context_es2_profile(); #endif /* WGL_EXT_create_context_es2_profile */ @@ -12799,6 +15693,9 @@ static void glxewInfo () #ifdef GLX_ARB_create_context _glewInfo_GLX_ARB_create_context(); #endif /* GLX_ARB_create_context */ +#ifdef GLX_ARB_create_context_no_error + _glewInfo_GLX_ARB_create_context_no_error(); +#endif /* GLX_ARB_create_context_no_error */ #ifdef GLX_ARB_create_context_profile _glewInfo_GLX_ARB_create_context_profile(); #endif /* GLX_ARB_create_context_profile */ @@ -13051,6 +15948,9 @@ static void eglewInfo () #ifdef EGL_ANGLE_window_fixed_size _glewInfo_EGL_ANGLE_window_fixed_size(); #endif /* EGL_ANGLE_window_fixed_size */ +#ifdef EGL_ARM_implicit_external_sync + _glewInfo_EGL_ARM_implicit_external_sync(); +#endif /* EGL_ARM_implicit_external_sync */ #ifdef EGL_ARM_pixmap_multisample_discard _glewInfo_EGL_ARM_pixmap_multisample_discard(); #endif /* EGL_ARM_pixmap_multisample_discard */ @@ -13078,9 +15978,21 @@ static void eglewInfo () #ifdef EGL_EXT_device_query _glewInfo_EGL_EXT_device_query(); #endif /* EGL_EXT_device_query */ +#ifdef EGL_EXT_gl_colorspace_bt2020_linear + _glewInfo_EGL_EXT_gl_colorspace_bt2020_linear(); +#endif /* EGL_EXT_gl_colorspace_bt2020_linear */ +#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_scrgb_linear + _glewInfo_EGL_EXT_gl_colorspace_scrgb_linear(); +#endif /* EGL_EXT_gl_colorspace_scrgb_linear */ #ifdef EGL_EXT_image_dma_buf_import _glewInfo_EGL_EXT_image_dma_buf_import(); #endif /* EGL_EXT_image_dma_buf_import */ +#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_multiview_window _glewInfo_EGL_EXT_multiview_window(); #endif /* EGL_EXT_multiview_window */ @@ -13093,6 +16005,9 @@ static void eglewInfo () #ifdef EGL_EXT_output_openwf _glewInfo_EGL_EXT_output_openwf(); #endif /* EGL_EXT_output_openwf */ +#ifdef EGL_EXT_pixel_format_float + _glewInfo_EGL_EXT_pixel_format_float(); +#endif /* EGL_EXT_pixel_format_float */ #ifdef EGL_EXT_platform_base _glewInfo_EGL_EXT_platform_base(); #endif /* EGL_EXT_platform_base */ @@ -13114,6 +16029,9 @@ 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_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 */ @@ -13144,6 +16062,9 @@ static void eglewInfo () #ifdef EGL_KHR_config_attribs _glewInfo_EGL_KHR_config_attribs(); #endif /* EGL_KHR_config_attribs */ +#ifdef EGL_KHR_context_flush_control + _glewInfo_EGL_KHR_context_flush_control(); +#endif /* EGL_KHR_context_flush_control */ #ifdef EGL_KHR_create_context _glewInfo_EGL_KHR_create_context(); #endif /* EGL_KHR_create_context */ @@ -13195,6 +16116,9 @@ static void eglewInfo () #ifdef EGL_KHR_mutable_render_buffer _glewInfo_EGL_KHR_mutable_render_buffer(); #endif /* EGL_KHR_mutable_render_buffer */ +#ifdef EGL_KHR_no_config_context + _glewInfo_EGL_KHR_no_config_context(); +#endif /* EGL_KHR_no_config_context */ #ifdef EGL_KHR_partial_update _glewInfo_EGL_KHR_partial_update(); #endif /* EGL_KHR_partial_update */ @@ -13216,6 +16140,9 @@ static void eglewInfo () #ifdef EGL_KHR_stream _glewInfo_EGL_KHR_stream(); #endif /* EGL_KHR_stream */ +#ifdef EGL_KHR_stream_attrib + _glewInfo_EGL_KHR_stream_attrib(); +#endif /* EGL_KHR_stream_attrib */ #ifdef EGL_KHR_stream_consumer_gltexture _glewInfo_EGL_KHR_stream_consumer_gltexture(); #endif /* EGL_KHR_stream_consumer_gltexture */ @@ -13252,6 +16179,9 @@ static void eglewInfo () #ifdef EGL_MESA_platform_gbm _glewInfo_EGL_MESA_platform_gbm(); #endif /* EGL_MESA_platform_gbm */ +#ifdef EGL_MESA_platform_surfaceless + _glewInfo_EGL_MESA_platform_surfaceless(); +#endif /* EGL_MESA_platform_surfaceless */ #ifdef EGL_NOK_swap_region _glewInfo_EGL_NOK_swap_region(); #endif /* EGL_NOK_swap_region */ @@ -13294,9 +16224,48 @@ static void eglewInfo () #ifdef EGL_NV_stream_consumer_gltexture_yuv _glewInfo_EGL_NV_stream_consumer_gltexture_yuv(); #endif /* EGL_NV_stream_consumer_gltexture_yuv */ +#ifdef EGL_NV_stream_cross_display + _glewInfo_EGL_NV_stream_cross_display(); +#endif /* EGL_NV_stream_cross_display */ +#ifdef EGL_NV_stream_cross_object + _glewInfo_EGL_NV_stream_cross_object(); +#endif /* EGL_NV_stream_cross_object */ +#ifdef EGL_NV_stream_cross_partition + _glewInfo_EGL_NV_stream_cross_partition(); +#endif /* EGL_NV_stream_cross_partition */ +#ifdef EGL_NV_stream_cross_process + _glewInfo_EGL_NV_stream_cross_process(); +#endif /* EGL_NV_stream_cross_process */ +#ifdef EGL_NV_stream_cross_system + _glewInfo_EGL_NV_stream_cross_system(); +#endif /* EGL_NV_stream_cross_system */ +#ifdef EGL_NV_stream_fifo_next + _glewInfo_EGL_NV_stream_fifo_next(); +#endif /* EGL_NV_stream_fifo_next */ +#ifdef EGL_NV_stream_fifo_synchronous + _glewInfo_EGL_NV_stream_fifo_synchronous(); +#endif /* EGL_NV_stream_fifo_synchronous */ +#ifdef EGL_NV_stream_frame_limits + _glewInfo_EGL_NV_stream_frame_limits(); +#endif /* EGL_NV_stream_frame_limits */ #ifdef EGL_NV_stream_metadata _glewInfo_EGL_NV_stream_metadata(); #endif /* EGL_NV_stream_metadata */ +#ifdef EGL_NV_stream_remote + _glewInfo_EGL_NV_stream_remote(); +#endif /* EGL_NV_stream_remote */ +#ifdef EGL_NV_stream_reset + _glewInfo_EGL_NV_stream_reset(); +#endif /* EGL_NV_stream_reset */ +#ifdef EGL_NV_stream_socket + _glewInfo_EGL_NV_stream_socket(); +#endif /* EGL_NV_stream_socket */ +#ifdef EGL_NV_stream_socket_inet + _glewInfo_EGL_NV_stream_socket_inet(); +#endif /* EGL_NV_stream_socket_inet */ +#ifdef EGL_NV_stream_socket_unix + _glewInfo_EGL_NV_stream_socket_unix(); +#endif /* EGL_NV_stream_socket_unix */ #ifdef EGL_NV_stream_sync _glewInfo_EGL_NV_stream_sync(); #endif /* EGL_NV_stream_sync */ @@ -13748,7 +16717,7 @@ GLboolean glewCreateContext (struct createParams *params) #if MAC_OS_X_VERSION_MIN_REQUIRED >= 1070 if (params->profile & GL_CONTEXT_CORE_PROFILE_BIT) { - if (params->major==3 && params->minor>=2) + if ((params->major==3 && params->minor>=2) || params->major>3) { contextAttrs[i++] = kCGLPFAOpenGLProfile; /* OSX 10.7 Lion onwards */ contextAttrs[i++] = (CGLPixelFormatAttribute) kCGLOGLPVersion_3_2_Core; /* 3.2 Core Context */ diff --git a/src/visualinfo.c b/src/visualinfo.c index d089207..99e8c63 100755 --- a/src/visualinfo.c +++ b/src/visualinfo.c @@ -617,7 +617,7 @@ VisualInfo (GLContext* ctx) #elif defined(__APPLE__) && !defined(GLEW_APPLE_GLX) void -VisualInfo (GLContext* __attribute__((__unused__)) ctx) +VisualInfo (__attribute__((unused)) GLContext* ctx) { /* int attrib[] = { AGL_RGBA, AGL_NONE };