diff options
Diffstat (limited to 'mesalib/src/mesa/main/extensions.c')
| -rw-r--r-- | mesalib/src/mesa/main/extensions.c | 908 |
1 files changed, 419 insertions, 489 deletions
diff --git a/mesalib/src/mesa/main/extensions.c b/mesalib/src/mesa/main/extensions.c index 4b656a70f..57267b0d3 100644 --- a/mesalib/src/mesa/main/extensions.c +++ b/mesalib/src/mesa/main/extensions.c @@ -24,6 +24,12 @@ */
+/**
+ * \file
+ * \brief Extension handling
+ */
+
+
#include "glheader.h"
#include "imports.h"
#include "context.h"
@@ -31,200 +37,334 @@ #include "mfeatures.h"
#include "mtypes.h"
+enum {
+ DISABLE = 0,
+ GL = 1 << API_OPENGL,
+ ES1 = 1 << API_OPENGLES,
+ ES2 = 1 << API_OPENGLES2,
+};
-#define F(x) offsetof(struct gl_extensions, x)
-#define ON GL_TRUE
-#define OFF GL_FALSE
+/**
+ * \brief An element of the \c extension_table.
+ */
+struct extension {
+ /** Name of extension, such as "GL_ARB_depth_clamp". */
+ const char *name;
+ /** Offset (in bytes) of the corresponding member in struct gl_extensions. */
+ size_t offset;
-/*
+ /** Set of API's in which the extension exists, as a bitset. */
+ uint8_t api_set;
+};
+
+
+/**
+ * Given a member \c x of struct gl_extensions, return offset of
+ * \c x in bytes.
+ */
+#define o(x) offsetof(struct gl_extensions, x)
+
+
+/**
+ * \brief Table of supported OpenGL extensions for all API's.
+ *
* Note: The GL_MESAX_* extensions are placeholders for future ARB extensions.
*/
-static const struct {
- GLboolean enabled;
- const char *name;
- int flag_offset;
-} default_extensions[] = {
- { OFF, "GL_ARB_blend_func_extended", F(ARB_blend_func_extended) },
- { ON, "GL_ARB_copy_buffer", F(ARB_copy_buffer) },
- { OFF, "GL_ARB_depth_buffer_float", F(ARB_depth_buffer_float) },
- { OFF, "GL_ARB_depth_clamp", F(ARB_depth_clamp) },
- { OFF, "GL_ARB_depth_texture", F(ARB_depth_texture) },
- { ON, "GL_ARB_draw_buffers", F(ARB_draw_buffers) },
- { OFF, "GL_ARB_draw_elements_base_vertex", F(ARB_draw_elements_base_vertex) },
- { OFF, "GL_ARB_draw_instanced", F(ARB_draw_instanced) },
- { OFF, "GL_ARB_explicit_attrib_location", F(ARB_explicit_attrib_location) },
- { OFF, "GL_ARB_fragment_coord_conventions", F(ARB_fragment_coord_conventions) },
- { OFF, "GL_ARB_fragment_program", F(ARB_fragment_program) },
- { OFF, "GL_ARB_fragment_program_shadow", F(ARB_fragment_program_shadow) },
- { OFF, "GL_ARB_fragment_shader", F(ARB_fragment_shader) },
- { OFF, "GL_ARB_framebuffer_object", F(ARB_framebuffer_object) },
- /* TODO: reenable this when the new GLSL compiler actually supports them */
- /* { OFF, "GL_ARB_geometry_shader4", F(ARB_geometry_shader4) }, */
- { OFF, "GL_ARB_half_float_pixel", F(ARB_half_float_pixel) },
- { OFF, "GL_ARB_half_float_vertex", F(ARB_half_float_vertex) },
- { OFF, "GL_ARB_instanced_arrays", F(ARB_instanced_arrays) },
- { OFF, "GL_ARB_map_buffer_range", F(ARB_map_buffer_range) },
- { ON, "GL_ARB_multisample", F(ARB_multisample) },
- { OFF, "GL_ARB_multitexture", F(ARB_multitexture) },
- { OFF, "GL_ARB_occlusion_query", F(ARB_occlusion_query) },
- { OFF, "GL_ARB_occlusion_query2", F(ARB_occlusion_query2) },
- { OFF, "GL_ARB_pixel_buffer_object", F(EXT_pixel_buffer_object) },
- { OFF, "GL_ARB_point_parameters", F(EXT_point_parameters) },
- { OFF, "GL_ARB_point_sprite", F(ARB_point_sprite) },
- { OFF, "GL_ARB_provoking_vertex", F(EXT_provoking_vertex) },
- { OFF, "GL_ARB_sampler_objects", F(ARB_sampler_objects) },
- { OFF, "GL_ARB_seamless_cube_map", F(ARB_seamless_cube_map) },
- { OFF, "GL_ARB_shader_objects", F(ARB_shader_objects) },
- { OFF, "GL_ARB_shader_stencil_export", F(ARB_shader_stencil_export) },
- { OFF, "GL_ARB_shading_language_100", F(ARB_shading_language_100) },
- { OFF, "GL_ARB_shadow", F(ARB_shadow) },
- { OFF, "GL_ARB_shadow_ambient", F(ARB_shadow_ambient) },
- { OFF, "GL_ARB_sync", F(ARB_sync) },
- { OFF, "GL_ARB_texture_border_clamp", F(ARB_texture_border_clamp) },
- { OFF, "GL_ARB_texture_buffer_object", F(ARB_texture_buffer_object) },
- { ON, "GL_ARB_texture_compression", F(ARB_texture_compression) },
- { OFF, "GL_ARB_texture_compression_rgtc", F(ARB_texture_compression_rgtc) },
- { OFF, "GL_ARB_texture_cube_map", F(ARB_texture_cube_map) },
- { OFF, "GL_ARB_texture_env_add", F(EXT_texture_env_add) },
- { OFF, "GL_ARB_texture_env_combine", F(ARB_texture_env_combine) },
- { OFF, "GL_ARB_texture_env_crossbar", F(ARB_texture_env_crossbar) },
- { OFF, "GL_ARB_texture_env_dot3", F(ARB_texture_env_dot3) },
- { OFF, "GL_MESAX_texture_float", F(ARB_texture_float) },
- { OFF, "GL_ARB_texture_mirrored_repeat", F(ARB_texture_mirrored_repeat)},
- { OFF, "GL_ARB_texture_multisample", F(ARB_texture_multisample) },
- { OFF, "GL_ARB_texture_non_power_of_two", F(ARB_texture_non_power_of_two)},
- { OFF, "GL_ARB_texture_rectangle", F(NV_texture_rectangle) },
- { OFF, "GL_ARB_texture_rg", F(ARB_texture_rg) },
- { OFF, "GL_ARB_texture_rgb10_a2ui", F(ARB_texture_rgb10_a2ui) },
- { OFF, "GL_ARB_texture_swizzle", F(EXT_texture_swizzle) },
- { ON, "GL_ARB_transpose_matrix", F(ARB_transpose_matrix) },
- { OFF, "GL_ARB_transform_feedback2", F(ARB_transform_feedback2) },
- { OFF, "GL_ARB_uniform_buffer_object", F(ARB_uniform_buffer_object) },
- { OFF, "GL_ARB_vertex_array_bgra", F(EXT_vertex_array_bgra) },
- { OFF, "GL_ARB_vertex_array_object", F(ARB_vertex_array_object) },
- { ON, "GL_ARB_vertex_buffer_object", F(ARB_vertex_buffer_object) },
- { OFF, "GL_ARB_vertex_program", F(ARB_vertex_program) },
- { OFF, "GL_ARB_vertex_shader", F(ARB_vertex_shader) },
- { OFF, "GL_ARB_vertex_type_2_10_10_10_rev", F(ARB_vertex_type_2_10_10_10_rev) },
- { ON, "GL_ARB_window_pos", F(ARB_window_pos) },
- { ON, "GL_EXT_abgr", F(EXT_abgr) },
- { ON, "GL_EXT_bgra", F(EXT_bgra) },
- { OFF, "GL_EXT_blend_color", F(EXT_blend_color) },
- { OFF, "GL_EXT_blend_equation_separate", F(EXT_blend_equation_separate) },
- { OFF, "GL_EXT_blend_func_separate", F(EXT_blend_func_separate) },
- { OFF, "GL_EXT_blend_logic_op", F(EXT_blend_logic_op) },
- { OFF, "GL_EXT_blend_minmax", F(EXT_blend_minmax) },
- { OFF, "GL_EXT_blend_subtract", F(EXT_blend_subtract) },
- { OFF, "GL_EXT_clip_volume_hint", F(EXT_clip_volume_hint) },
- { ON, "GL_EXT_compiled_vertex_array", F(EXT_compiled_vertex_array) },
- { ON, "GL_EXT_copy_texture", F(EXT_copy_texture) },
- { OFF, "GL_EXT_depth_bounds_test", F(EXT_depth_bounds_test) },
- { OFF, "GL_EXT_draw_buffers2", F(EXT_draw_buffers2) },
- { OFF, "GL_EXT_draw_instanced", F(ARB_draw_instanced) },
- { ON, "GL_EXT_draw_range_elements", F(EXT_draw_range_elements) },
- { OFF, "GL_EXT_framebuffer_blit", F(EXT_framebuffer_blit) },
- { OFF, "GL_EXT_framebuffer_multisample", F(EXT_framebuffer_multisample) },
- { OFF, "GL_EXT_framebuffer_object", F(EXT_framebuffer_object) },
- { OFF, "GL_EXT_framebuffer_sRGB", F(EXT_framebuffer_sRGB) },
- { OFF, "GL_EXT_fog_coord", F(EXT_fog_coord) },
- { OFF, "GL_EXT_gpu_program_parameters", F(EXT_gpu_program_parameters) },
- { OFF, "GL_EXT_gpu_shader4", F(EXT_gpu_shader4) },
- { ON, "GL_EXT_multi_draw_arrays", F(EXT_multi_draw_arrays) },
- { OFF, "GL_EXT_packed_depth_stencil", F(EXT_packed_depth_stencil) },
- { OFF, "GL_EXT_packed_float", F(EXT_packed_float) },
- { ON, "GL_EXT_packed_pixels", F(EXT_packed_pixels) },
- { OFF, "GL_EXT_paletted_texture", F(EXT_paletted_texture) },
- { OFF, "GL_EXT_pixel_buffer_object", F(EXT_pixel_buffer_object) },
- { OFF, "GL_EXT_point_parameters", F(EXT_point_parameters) },
- { ON, "GL_EXT_polygon_offset", F(EXT_polygon_offset) },
- { OFF, "GL_EXT_provoking_vertex", F(EXT_provoking_vertex) },
- { ON, "GL_EXT_rescale_normal", F(EXT_rescale_normal) },
- { OFF, "GL_EXT_secondary_color", F(EXT_secondary_color) },
- { OFF, "GL_EXT_separate_shader_objects", F(EXT_separate_shader_objects) },
- { ON, "GL_EXT_separate_specular_color", F(EXT_separate_specular_color) },
- { OFF, "GL_EXT_shadow_funcs", F(EXT_shadow_funcs) },
- { OFF, "GL_EXT_shared_texture_palette", F(EXT_shared_texture_palette) },
- { OFF, "GL_EXT_stencil_two_side", F(EXT_stencil_two_side) },
- { OFF, "GL_EXT_stencil_wrap", F(EXT_stencil_wrap) },
- { ON, "GL_EXT_subtexture", F(EXT_subtexture) },
- { ON, "GL_EXT_texture", F(EXT_texture) },
- { ON, "GL_EXT_texture3D", F(EXT_texture3D) },
- { OFF, "GL_EXT_texture_array", F(EXT_texture_array) },
- { OFF, "GL_EXT_texture_compression_s3tc", F(EXT_texture_compression_s3tc) },
- { OFF, "GL_EXT_texture_compression_rgtc", F(ARB_texture_compression_rgtc) },
- { OFF, "GL_EXT_texture_cube_map", F(ARB_texture_cube_map) },
- { ON, "GL_EXT_texture_edge_clamp", F(SGIS_texture_edge_clamp) },
- { OFF, "GL_EXT_texture_env_add", F(EXT_texture_env_add) },
- { OFF, "GL_EXT_texture_env_combine", F(EXT_texture_env_combine) },
- { OFF, "GL_EXT_texture_env_dot3", F(EXT_texture_env_dot3) },
- { OFF, "GL_EXT_texture_filter_anisotropic", F(EXT_texture_filter_anisotropic) },
- { OFF, "GL_EXT_texture_integer", F(EXT_texture_integer) },
- { OFF, "GL_EXT_texture_lod_bias", F(EXT_texture_lod_bias) },
- { OFF, "GL_EXT_texture_mirror_clamp", F(EXT_texture_mirror_clamp) },
- { ON, "GL_EXT_texture_object", F(EXT_texture_object) },
- { OFF, "GL_EXT_texture_rectangle", F(NV_texture_rectangle) },
- { OFF, "GL_EXT_texture_shared_exponent", F(EXT_texture_shared_exponent) },
- { OFF, "GL_EXT_texture_sRGB", F(EXT_texture_sRGB) },
- { OFF, "GL_EXT_texture_swizzle", F(EXT_texture_swizzle) },
- { OFF, "GL_EXT_timer_query", F(EXT_timer_query) },
- { OFF, "GL_EXT_transform_feedback", F(EXT_transform_feedback) },
- { ON, "GL_EXT_vertex_array", F(EXT_vertex_array) },
- { OFF, "GL_EXT_vertex_array_bgra", F(EXT_vertex_array_bgra) },
- { OFF, "GL_EXT_vertex_array_set", F(EXT_vertex_array_set) },
- { OFF, "GL_3DFX_texture_compression_FXT1", F(TDFX_texture_compression_FXT1) },
- { OFF, "GL_APPLE_client_storage", F(APPLE_client_storage) },
- { ON, "GL_APPLE_packed_pixels", F(APPLE_packed_pixels) },
- { OFF, "GL_APPLE_vertex_array_object", F(APPLE_vertex_array_object) },
- { OFF, "GL_APPLE_object_purgeable", F(APPLE_object_purgeable) },
- { OFF, "GL_ATI_blend_equation_separate", F(EXT_blend_equation_separate) },
- { OFF, "GL_ATI_envmap_bumpmap", F(ATI_envmap_bumpmap) },
- { OFF, "GL_ATI_texture_env_combine3", F(ATI_texture_env_combine3)},
- { OFF, "GL_ATI_texture_mirror_once", F(ATI_texture_mirror_once)},
- { OFF, "GL_ATI_fragment_shader", F(ATI_fragment_shader)},
- { OFF, "GL_ATI_separate_stencil", F(ATI_separate_stencil)},
- { ON, "GL_IBM_multimode_draw_arrays", F(IBM_multimode_draw_arrays) },
- { ON, "GL_IBM_rasterpos_clip", F(IBM_rasterpos_clip) },
- { OFF, "GL_IBM_texture_mirrored_repeat", F(ARB_texture_mirrored_repeat)},
- { OFF, "GL_INGR_blend_func_separate", F(EXT_blend_func_separate) },
- { OFF, "GL_MESA_pack_invert", F(MESA_pack_invert) },
- { OFF, "GL_MESA_resize_buffers", F(MESA_resize_buffers) },
- { OFF, "GL_MESA_texture_array", F(MESA_texture_array) },
- { OFF, "GL_MESA_texture_signed_rgba", F(MESA_texture_signed_rgba) },
- { OFF, "GL_MESA_ycbcr_texture", F(MESA_ycbcr_texture) },
- { ON, "GL_MESA_window_pos", F(ARB_window_pos) },
- { OFF, "GL_NV_blend_square", F(NV_blend_square) },
- { OFF, "GL_NV_conditional_render", F(NV_conditional_render) },
- { OFF, "GL_NV_depth_clamp", F(ARB_depth_clamp) },
- { OFF, "GL_NV_fragment_program", F(NV_fragment_program) },
- { OFF, "GL_NV_fragment_program_option", F(NV_fragment_program_option) },
- { ON, "GL_NV_light_max_exponent", F(NV_light_max_exponent) },
- { OFF, "GL_NV_packed_depth_stencil", F(EXT_packed_depth_stencil) },
- { OFF, "GL_NV_point_sprite", F(NV_point_sprite) },
- { OFF, "GL_NV_primitive_restart", F(NV_primitive_restart) },
- { ON, "GL_NV_texgen_reflection", F(NV_texgen_reflection) },
- { OFF, "GL_NV_texture_env_combine4", F(NV_texture_env_combine4) },
- { OFF, "GL_NV_texture_rectangle", F(NV_texture_rectangle) },
- { OFF, "GL_NV_vertex_program", F(NV_vertex_program) },
- { OFF, "GL_NV_vertex_program1_1", F(NV_vertex_program1_1) },
- { ON, "GL_OES_read_format", F(OES_read_format) },
- { OFF, "GL_SGI_texture_color_table", F(SGI_texture_color_table) },
- { ON, "GL_SGIS_generate_mipmap", F(SGIS_generate_mipmap) },
- { OFF, "GL_SGIS_texture_border_clamp", F(ARB_texture_border_clamp) },
- { ON, "GL_SGIS_texture_edge_clamp", F(SGIS_texture_edge_clamp) },
- { ON, "GL_SGIS_texture_lod", F(SGIS_texture_lod) },
- { ON, "GL_SUN_multi_draw_arrays", F(EXT_multi_draw_arrays) },
- { OFF, "GL_S3_s3tc", F(S3_s3tc) },
- { OFF, "GL_EXT_texture_format_BGRA8888", F(EXT_texture_format_BGRA8888) },
-#if FEATURE_OES_EGL_image
- { OFF, "GL_OES_EGL_image", F(OES_EGL_image) },
-#endif
+static const struct extension extension_table[] = {
+ /* ARB Extensions */
+ { "GL_ARB_blend_func_extended", o(ARB_blend_func_extended), GL },
+ { "GL_ARB_copy_buffer", o(ARB_copy_buffer), GL },
+ { "GL_ARB_depth_buffer_float", o(ARB_depth_buffer_float), GL },
+ { "GL_ARB_depth_clamp", o(ARB_depth_clamp), GL },
+ { "GL_ARB_depth_texture", o(ARB_depth_texture), GL },
+ { "GL_ARB_draw_buffers", o(ARB_draw_buffers), GL },
+ { "GL_ARB_draw_elements_base_vertex", o(ARB_draw_elements_base_vertex), GL },
+ { "GL_ARB_draw_instanced", o(ARB_draw_instanced), GL },
+ { "GL_ARB_explicit_attrib_location", o(ARB_explicit_attrib_location), GL },
+ { "GL_ARB_fragment_coord_conventions", o(ARB_fragment_coord_conventions), GL },
+ { "GL_ARB_fragment_program", o(ARB_fragment_program), GL },
+ { "GL_ARB_fragment_program_shadow", o(ARB_fragment_program_shadow), GL },
+ { "GL_ARB_fragment_shader", o(ARB_fragment_shader), GL },
+ { "GL_ARB_framebuffer_object", o(ARB_framebuffer_object), GL },
+ { "GL_ARB_half_float_pixel", o(ARB_half_float_pixel), GL },
+ { "GL_ARB_half_float_vertex", o(ARB_half_float_vertex), GL },
+ { "GL_ARB_instanced_arrays", o(ARB_instanced_arrays), GL },
+ { "GL_ARB_map_buffer_range", o(ARB_map_buffer_range), GL },
+ { "GL_ARB_multisample", o(ARB_multisample), GL },
+ { "GL_ARB_multitexture", o(ARB_multitexture), GL },
+ { "GL_ARB_occlusion_query2", o(ARB_occlusion_query2), GL },
+ { "GL_ARB_occlusion_query", o(ARB_occlusion_query), GL },
+ { "GL_ARB_pixel_buffer_object", o(EXT_pixel_buffer_object), GL },
+ { "GL_ARB_point_parameters", o(EXT_point_parameters), GL },
+ { "GL_ARB_point_sprite", o(ARB_point_sprite), GL },
+ { "GL_ARB_provoking_vertex", o(EXT_provoking_vertex), GL },
+ { "GL_ARB_sampler_objects", o(ARB_sampler_objects), GL },
+ { "GL_ARB_seamless_cube_map", o(ARB_seamless_cube_map), GL },
+ { "GL_ARB_shader_objects", o(ARB_shader_objects), GL },
+ { "GL_ARB_shader_stencil_export", o(ARB_shader_stencil_export), GL },
+ { "GL_ARB_shading_language_100", o(ARB_shading_language_100), GL },
+ { "GL_ARB_shadow_ambient", o(ARB_shadow_ambient), GL },
+ { "GL_ARB_shadow", o(ARB_shadow), GL },
+ { "GL_ARB_sync", o(ARB_sync), GL },
+ { "GL_ARB_texture_border_clamp", o(ARB_texture_border_clamp), GL },
+ { "GL_ARB_texture_buffer_object", o(ARB_texture_buffer_object), GL },
+ { "GL_ARB_texture_compression", o(ARB_texture_compression), GL },
+ { "GL_ARB_texture_compression_rgtc", o(ARB_texture_compression_rgtc), GL },
+ { "GL_ARB_texture_cube_map", o(ARB_texture_cube_map), GL },
+ { "GL_ARB_texture_env_add", o(EXT_texture_env_add), GL },
+ { "GL_ARB_texture_env_combine", o(ARB_texture_env_combine), GL },
+ { "GL_ARB_texture_env_crossbar", o(ARB_texture_env_crossbar), GL },
+ { "GL_ARB_texture_env_dot3", o(ARB_texture_env_dot3), GL },
+ { "GL_ARB_texture_mirrored_repeat", o(ARB_texture_mirrored_repeat), GL },
+ { "GL_ARB_texture_multisample", o(ARB_texture_multisample), GL },
+ { "GL_ARB_texture_non_power_of_two", o(ARB_texture_non_power_of_two), GL },
+ { "GL_ARB_texture_rectangle", o(NV_texture_rectangle), GL },
+ { "GL_ARB_texture_rgb10_a2ui", o(ARB_texture_rgb10_a2ui), GL },
+ { "GL_ARB_texture_rg", o(ARB_texture_rg), GL },
+ { "GL_ARB_texture_swizzle", o(EXT_texture_swizzle), GL },
+ { "GL_ARB_transform_feedback2", o(ARB_transform_feedback2), GL },
+ { "GL_ARB_transpose_matrix", o(ARB_transpose_matrix), GL },
+ { "GL_ARB_uniform_buffer_object", o(ARB_uniform_buffer_object), GL },
+ { "GL_ARB_vertex_array_bgra", o(EXT_vertex_array_bgra), GL },
+ { "GL_ARB_vertex_array_object", o(ARB_vertex_array_object), GL },
+ { "GL_ARB_vertex_buffer_object", o(ARB_vertex_buffer_object), GL },
+ { "GL_ARB_vertex_program", o(ARB_vertex_program), GL },
+ { "GL_ARB_vertex_shader", o(ARB_vertex_shader), GL },
+ { "GL_ARB_vertex_type_2_10_10_10_rev", o(ARB_vertex_type_2_10_10_10_rev), GL },
+ { "GL_ARB_window_pos", o(ARB_window_pos), GL },
+
+ /* EXT extensions */
+ { "GL_EXT_abgr", o(EXT_abgr), GL },
+ { "GL_EXT_bgra", o(EXT_bgra), GL },
+ { "GL_EXT_blend_color", o(EXT_blend_color), GL },
+ { "GL_EXT_blend_equation_separate", o(EXT_blend_equation_separate), GL },
+ { "GL_EXT_blend_func_separate", o(EXT_blend_func_separate), GL },
+ { "GL_EXT_blend_logic_op", o(EXT_blend_logic_op), GL },
+ { "GL_EXT_blend_minmax", o(EXT_blend_minmax), GL | ES1 | ES2 },
+ { "GL_EXT_blend_subtract", o(EXT_blend_subtract), GL },
+ { "GL_EXT_clip_volume_hint", o(EXT_clip_volume_hint), GL },
+ { "GL_EXT_compiled_vertex_array", o(EXT_compiled_vertex_array), GL },
+ { "GL_EXT_copy_texture", o(EXT_copy_texture), GL },
+ { "GL_EXT_depth_bounds_test", o(EXT_depth_bounds_test), GL },
+ { "GL_EXT_draw_buffers2", o(EXT_draw_buffers2), GL },
+ { "GL_EXT_draw_instanced", o(ARB_draw_instanced), GL },
+ { "GL_EXT_draw_range_elements", o(EXT_draw_range_elements), GL },
+ { "GL_EXT_fog_coord", o(EXT_fog_coord), GL },
+ { "GL_EXT_framebuffer_blit", o(EXT_framebuffer_blit), GL },
+ { "GL_EXT_framebuffer_multisample", o(EXT_framebuffer_multisample), GL },
+ { "GL_EXT_framebuffer_object", o(EXT_framebuffer_object), GL },
+ { "GL_EXT_framebuffer_sRGB", o(EXT_framebuffer_sRGB), GL },
+ { "GL_EXT_gpu_program_parameters", o(EXT_gpu_program_parameters), GL },
+ { "GL_EXT_gpu_shader4", o(EXT_gpu_shader4), GL },
+ { "GL_EXT_multi_draw_arrays", o(EXT_multi_draw_arrays), GL | ES1 | ES2 },
+ { "GL_EXT_packed_depth_stencil", o(EXT_packed_depth_stencil), GL },
+ { "GL_EXT_packed_float", o(EXT_packed_float), GL },
+ { "GL_EXT_packed_pixels", o(EXT_packed_pixels), GL },
+ { "GL_EXT_paletted_texture", o(EXT_paletted_texture), GL },
+ { "GL_EXT_pixel_buffer_object", o(EXT_pixel_buffer_object), GL },
+ { "GL_EXT_point_parameters", o(EXT_point_parameters), GL },
+ { "GL_EXT_polygon_offset", o(EXT_polygon_offset), GL },
+ { "GL_EXT_provoking_vertex", o(EXT_provoking_vertex), GL },
+ { "GL_EXT_rescale_normal", o(EXT_rescale_normal), GL },
+ { "GL_EXT_secondary_color", o(EXT_secondary_color), GL },
+ { "GL_EXT_separate_shader_objects", o(EXT_separate_shader_objects), GL },
+ { "GL_EXT_separate_specular_color", o(EXT_separate_specular_color), GL },
+ { "GL_EXT_shadow_funcs", o(EXT_shadow_funcs), GL },
+ { "GL_EXT_shared_texture_palette", o(EXT_shared_texture_palette), GL },
+ { "GL_EXT_stencil_two_side", o(EXT_stencil_two_side), GL },
+ { "GL_EXT_stencil_wrap", o(EXT_stencil_wrap), GL },
+ { "GL_EXT_subtexture", o(EXT_subtexture), GL },
+ { "GL_EXT_texture3D", o(EXT_texture3D), GL },
+ { "GL_EXT_texture_array", o(EXT_texture_array), GL },
+ { "GL_EXT_texture_compression_dxt1", o(EXT_texture_compression_s3tc), GL | ES1 | ES2 },
+ { "GL_EXT_texture_compression_rgtc", o(ARB_texture_compression_rgtc), GL },
+ { "GL_EXT_texture_compression_s3tc", o(EXT_texture_compression_s3tc), GL },
+ { "GL_EXT_texture_cube_map", o(ARB_texture_cube_map), GL },
+ { "GL_EXT_texture_edge_clamp", o(SGIS_texture_edge_clamp), GL },
+ { "GL_EXT_texture_env_add", o(EXT_texture_env_add), GL },
+ { "GL_EXT_texture_env_combine", o(EXT_texture_env_combine), GL },
+ { "GL_EXT_texture_env_dot3", o(EXT_texture_env_dot3), GL },
+ { "GL_EXT_texture_filter_anisotropic", o(EXT_texture_filter_anisotropic), GL | ES1 | ES2 },
+ { "GL_EXT_texture_format_BGRA8888", o(EXT_texture_format_BGRA8888), ES1 | ES2 },
+ { "GL_EXT_texture_integer", o(EXT_texture_integer), GL },
+ { "GL_EXT_texture_lod_bias", o(EXT_texture_lod_bias), GL | ES1 },
+ { "GL_EXT_texture_mirror_clamp", o(EXT_texture_mirror_clamp), GL },
+ { "GL_EXT_texture_object", o(EXT_texture_object), GL },
+ { "GL_EXT_texture", o(EXT_texture), GL },
+ { "GL_EXT_texture_rectangle", o(NV_texture_rectangle), GL },
+ { "GL_EXT_texture_shared_exponent", o(EXT_texture_shared_exponent), GL },
+ { "GL_EXT_texture_sRGB", o(EXT_texture_sRGB), GL },
+ { "GL_EXT_texture_swizzle", o(EXT_texture_swizzle), GL },
+ { "GL_EXT_texture_type_2_10_10_10_REV", o(dummy_true), ES2 },
+ { "GL_EXT_timer_query", o(EXT_timer_query), GL },
+ { "GL_EXT_transform_feedback", o(EXT_transform_feedback), GL },
+ { "GL_EXT_vertex_array_bgra", o(EXT_vertex_array_bgra), GL },
+ { "GL_EXT_vertex_array", o(EXT_vertex_array), GL },
+ { "GL_EXT_vertex_array_set", o(EXT_vertex_array_set), GL },
+
+ /* OES extensions */
+ { "GL_OES_blend_equation_separate", o(EXT_blend_equation_separate), ES1 },
+ { "GL_OES_blend_func_separate", o(EXT_blend_func_separate), ES1 },
+ { "GL_OES_blend_subtract", o(EXT_blend_subtract), ES1 },
+ { "GL_OES_byte_coordinates", o(dummy_true), ES1 },
+ { "GL_OES_compressed_paletted_texture", o(dummy_false), DISABLE },
+ { "GL_OES_depth24", o(EXT_framebuffer_object), ES1 | ES2 },
+ { "GL_OES_depth32", o(dummy_false), DISABLE },
+ { "GL_OES_depth_texture", o(ARB_depth_texture), ES2 },
#if FEATURE_OES_draw_texture
- { OFF, "GL_OES_draw_texture", F(OES_draw_texture) },
-#endif /* FEATURE_OES_draw_texture */
+ { "GL_OES_draw_texture", o(OES_draw_texture), ES1 | ES2 },
+#endif
+#if FEATURE_OES_EGL_image
+ /* FIXME: Mesa expects GL_OES_EGL_image to be available in OpenGL contexts. */
+ { "GL_OES_EGL_image", o(OES_EGL_image), GL | ES1 | ES2 },
+#endif
+ { "GL_OES_element_index_uint", o(EXT_vertex_array), ES1 | ES2 },
+ { "GL_OES_fbo_render_mipmap", o(EXT_framebuffer_object), ES1 | ES2 },
+ { "GL_OES_fixed_point", o(dummy_true), ES1 },
+ { "GL_OES_framebuffer_object", o(EXT_framebuffer_object), ES1 },
+ { "GL_OES_mapbuffer", o(ARB_vertex_buffer_object), ES1 | ES2 },
+ { "GL_OES_matrix_get", o(dummy_true), ES1 },
+ { "GL_OES_packed_depth_stencil", o(EXT_packed_depth_stencil), ES1 | ES2 },
+ { "GL_OES_point_size_array", o(dummy_true), ES1 },
+ { "GL_OES_point_sprite", o(ARB_point_sprite), ES1 },
+ { "GL_OES_query_matrix", o(dummy_true), ES1 },
+ { "GL_OES_read_format", o(OES_read_format), GL | ES1 },
+ { "GL_OES_rgb8_rgba8", o(EXT_framebuffer_object), ES1 | ES2 },
+ { "GL_OES_single_precision", o(dummy_true), ES1 },
+ { "GL_OES_standard_derivatives", o(ARB_fragment_shader), ES2 },
+ { "GL_OES_stencil1", o(dummy_false), DISABLE },
+ { "GL_OES_stencil4", o(dummy_false), DISABLE },
+ { "GL_OES_stencil8", o(EXT_framebuffer_object), ES1 | ES2 },
+ { "GL_OES_stencil_wrap", o(EXT_stencil_wrap), ES1 },
+ /* GL_OES_texture_3D is disabled due to missing GLSL support. */
+ { "GL_OES_texture_3D", o(EXT_texture3D), DISABLE },
+ { "GL_OES_texture_cube_map", o(ARB_texture_cube_map), ES1 },
+ { "GL_OES_texture_env_crossbar", o(ARB_texture_env_crossbar), ES1 },
+ { "GL_OES_texture_mirrored_repeat", o(ARB_texture_mirrored_repeat), ES1 },
+ { "GL_OES_texture_npot", o(ARB_texture_non_power_of_two), ES2 },
+
+ /* Vendor extensions */
+ { "GL_3DFX_texture_compression_FXT1", o(TDFX_texture_compression_FXT1), GL },
+ { "GL_APPLE_client_storage", o(APPLE_client_storage), GL },
+ { "GL_APPLE_object_purgeable", o(APPLE_object_purgeable), GL },
+ { "GL_APPLE_packed_pixels", o(APPLE_packed_pixels), GL },
+ { "GL_APPLE_vertex_array_object", o(APPLE_vertex_array_object), GL },
+ { "GL_ATI_blend_equation_separate", o(EXT_blend_equation_separate), GL },
+ { "GL_ATI_envmap_bumpmap", o(ATI_envmap_bumpmap), GL },
+ { "GL_ATI_fragment_shader", o(ATI_fragment_shader), GL },
+ { "GL_ATI_separate_stencil", o(ATI_separate_stencil), GL },
+ { "GL_ATI_texture_env_combine3", o(ATI_texture_env_combine3), GL },
+ { "GL_ATI_texture_mirror_once", o(ATI_texture_mirror_once), GL },
+ { "GL_IBM_multimode_draw_arrays", o(IBM_multimode_draw_arrays), GL },
+ { "GL_IBM_rasterpos_clip", o(IBM_rasterpos_clip), GL },
+ { "GL_IBM_texture_mirrored_repeat", o(ARB_texture_mirrored_repeat), GL },
+ { "GL_INGR_blend_func_separate", o(EXT_blend_func_separate), GL },
+ { "GL_MESA_pack_invert", o(MESA_pack_invert), GL },
+ { "GL_MESA_resize_buffers", o(MESA_resize_buffers), GL },
+ { "GL_MESA_texture_array", o(MESA_texture_array), GL },
+ { "GL_MESA_texture_signed_rgba", o(MESA_texture_signed_rgba), GL },
+ { "GL_MESA_window_pos", o(ARB_window_pos), GL },
+ { "GL_MESAX_texture_float", o(ARB_texture_float), GL },
+ { "GL_MESA_ycbcr_texture", o(MESA_ycbcr_texture), GL },
+ { "GL_NV_blend_square", o(NV_blend_square), GL },
+ { "GL_NV_conditional_render", o(NV_conditional_render), GL },
+ { "GL_NV_depth_clamp", o(ARB_depth_clamp), GL },
+ { "GL_NV_fragment_program", o(NV_fragment_program), GL },
+ { "GL_NV_fragment_program_option", o(NV_fragment_program_option), GL },
+ { "GL_NV_light_max_exponent", o(NV_light_max_exponent), GL },
+ { "GL_NV_packed_depth_stencil", o(EXT_packed_depth_stencil), GL },
+ { "GL_NV_point_sprite", o(NV_point_sprite), GL },
+ { "GL_NV_primitive_restart", o(NV_primitive_restart), GL },
+ { "GL_NV_texgen_reflection", o(NV_texgen_reflection), GL },
+ { "GL_NV_texture_env_combine4", o(NV_texture_env_combine4), GL },
+ { "GL_NV_texture_rectangle", o(NV_texture_rectangle), GL },
+ { "GL_NV_vertex_program1_1", o(NV_vertex_program1_1), GL },
+ { "GL_NV_vertex_program", o(NV_vertex_program), GL },
+ { "GL_S3_s3tc", o(S3_s3tc), GL },
+ { "GL_SGIS_generate_mipmap", o(SGIS_generate_mipmap), GL },
+ { "GL_SGIS_texture_border_clamp", o(ARB_texture_border_clamp), GL },
+ { "GL_SGIS_texture_edge_clamp", o(SGIS_texture_edge_clamp), GL },
+ { "GL_SGIS_texture_lod", o(SGIS_texture_lod), GL },
+ { "GL_SGI_texture_color_table", o(SGI_texture_color_table), GL },
+ { "GL_SUN_multi_draw_arrays", o(EXT_multi_draw_arrays), GL },
+
+ { 0, 0, 0 },
};
+/**
+ * Given an extension name, lookup up the corresponding member of struct
+ * gl_extensions and return that member's offset (in bytes). If the name is
+ * not found in the \c extension_table, return 0.
+ *
+ * \param name Name of extension.
+ * \return Offset of member in struct gl_extensions.
+ */
+static size_t
+name_to_offset(const char* name)
+{
+ const struct extension *i;
+
+ if (name == 0)
+ return 0;
+
+ for (i = extension_table; i->name != 0; ++i) {
+ if (strcmp(name, i->name) == 0)
+ return i->offset;
+ }
+
+ return 0;
+}
+
+
+/**
+ * \brief Extensions enabled by default.
+ *
+ * These extensions are enabled by _mesa_init_extensions().
+ *
+ * XXX: Should these defaults also apply to GLES?
+ */
+static const size_t default_extensions[] = {
+ o(ARB_copy_buffer),
+ o(ARB_draw_buffers),
+ o(ARB_multisample),
+ o(ARB_texture_compression),
+ o(ARB_transpose_matrix),
+ o(ARB_vertex_buffer_object),
+ o(ARB_window_pos),
+
+ o(EXT_abgr),
+ o(EXT_bgra),
+ o(EXT_compiled_vertex_array),
+ o(EXT_copy_texture),
+ o(EXT_draw_range_elements),
+ o(EXT_multi_draw_arrays),
+ o(EXT_packed_pixels),
+ o(EXT_polygon_offset),
+ o(EXT_rescale_normal),
+ o(EXT_separate_specular_color),
+ o(EXT_subtexture),
+ o(EXT_texture),
+ o(EXT_texture3D),
+ o(EXT_texture_object),
+ o(EXT_vertex_array),
+
+ o(OES_read_format),
+
+ /* Vendor Extensions */
+ o(APPLE_packed_pixels),
+ o(IBM_multimode_draw_arrays),
+ o(IBM_rasterpos_clip),
+ o(NV_light_max_exponent),
+ o(NV_texgen_reflection),
+ o(SGIS_generate_mipmap),
+ o(SGIS_texture_edge_clamp),
+ o(SGIS_texture_lod),
+
+ 0,
+};
+
/**
* Enable all extensions suitable for a software-only renderer.
@@ -513,8 +653,7 @@ _mesa_enable_2_1_extensions(struct gl_context *ctx) static GLboolean
set_extension( struct gl_context *ctx, const char *name, GLboolean state )
{
- GLboolean *base = (GLboolean *) &ctx->Extensions;
- GLuint i;
+ size_t offset;
if (ctx->Extensions.String) {
/* The string was already queried - can't change it now! */
@@ -522,16 +661,20 @@ set_extension( struct gl_context *ctx, const char *name, GLboolean state ) return GL_FALSE;
}
- for (i = 0 ; i < Elements(default_extensions) ; i++) {
- if (strcmp(default_extensions[i].name, name) == 0) {
- if (default_extensions[i].flag_offset) {
- GLboolean *enabled = base + default_extensions[i].flag_offset;
- *enabled = state;
- }
- return GL_TRUE;
- }
+ offset = name_to_offset(name);
+ if (offset == 0) {
+ _mesa_problem(ctx, "Trying to enable/disable unknown extension %s",
+ name);
+ return GL_FALSE;
+ } else if (offset == o(dummy_true) && state == GL_FALSE) {
+ _mesa_problem(ctx, "Trying to disable a permanently enabled extension: "
+ "%s", name);
+ return GL_FALSE;
+ } else {
+ GLboolean *base = (GLboolean *) &ctx->Extensions;
+ base[offset] = state;
+ return GL_TRUE;
}
- return GL_FALSE;
}
@@ -560,36 +703,22 @@ _mesa_disable_extension( struct gl_context *ctx, const char *name ) /**
- * Check if the i-th extension is enabled.
- */
-static GLboolean
-extension_enabled(struct gl_context *ctx, GLuint index)
-{
- const GLboolean *base = (const GLboolean *) &ctx->Extensions;
- if (!default_extensions[index].flag_offset ||
- *(base + default_extensions[index].flag_offset)) {
- return GL_TRUE;
- }
- else {
- return GL_FALSE;
- }
-}
-
-
-/**
* Test if the named extension is enabled in this context.
*/
GLboolean
_mesa_extension_is_enabled( struct gl_context *ctx, const char *name )
{
- GLuint i;
+ size_t offset;
+ GLboolean *base;
- for (i = 0 ; i < Elements(default_extensions) ; i++) {
- if (strcmp(default_extensions[i].name, name) == 0) {
- return extension_enabled(ctx, i);
- }
- }
- return GL_FALSE;
+ if (name == 0)
+ return GL_FALSE;
+
+ offset = name_to_offset(name);
+ if (offset == 0)
+ return GL_FALSE;
+ base = (GLboolean *) &ctx->Extensions;
+ return base[offset];
}
@@ -620,8 +749,10 @@ append(const char *a, const char *b) * For extension names that are recognized, turn them on. For extension
* names that are recognized and prefixed with '-', turn them off.
* Return a string of the unknown/leftover names.
+ *
+ * Returnd string needs to be freed.
*/
-static const char *
+static char *
get_extension_override( struct gl_context *ctx )
{
const char *envExt = _mesa_getenv("MESA_EXTENSION_OVERRIDE");
@@ -668,22 +799,27 @@ get_extension_override( struct gl_context *ctx ) /**
- * Run through the default_extensions array above and set the
- * ctx->Extensions.ARB/EXT_* flags accordingly.
- * To be called during context initialization.
+ * \brief Initialize extension tables and enable default extensions.
+ *
+ * This should be called during context initialization.
+ * Note: Sets gl_extensions.dummy_true to true.
*/
void
_mesa_init_extensions( struct gl_context *ctx )
{
GLboolean *base = (GLboolean *) &ctx->Extensions;
- GLuint i;
-
- for (i = 0 ; i < Elements(default_extensions) ; i++) {
- if (default_extensions[i].enabled &&
- default_extensions[i].flag_offset) {
- *(base + default_extensions[i].flag_offset) = GL_TRUE;
- }
- }
+ GLboolean *sentinel = base + o(extension_sentinel);
+ GLboolean *i;
+ const size_t *j;
+
+ /* First, turn all extensions off. */
+ for (i = base; i != sentinel; ++i)
+ *i = GL_FALSE;
+
+ /* Then, selectively turn default extensions on. */
+ ctx->Extensions.dummy_true = GL_TRUE;
+ for (j = default_extensions; *j != 0; ++j)
+ base[*j] = GL_TRUE;
}
@@ -691,256 +827,46 @@ _mesa_init_extensions( struct gl_context *ctx ) * Construct the GL_EXTENSIONS string. Called the first time that
* glGetString(GL_EXTENSIONS) is called.
*/
-static GLubyte *
-compute_extensions( struct gl_context *ctx )
+GLubyte*
+_mesa_make_extension_string(struct gl_context *ctx)
{
- const char *extraExt = get_extension_override(ctx);
- GLuint extStrLen = 0;
- char *s;
- GLuint i;
+ /* The extension string. */
+ char *exts = 0;
+ /* Length of extension string. */
+ size_t length = 0;
+ /* String of extra extensions. */
+ char *extra_extensions = get_extension_override(ctx);
+ GLboolean *base = (GLboolean *) &ctx->Extensions;
+ const struct extension *i;
- /* first, compute length of the extension string */
- for (i = 0 ; i < Elements(default_extensions) ; i++) {
- if (extension_enabled(ctx, i)) {
- extStrLen += (GLuint) strlen(default_extensions[i].name) + 1;
+ /* Compute length of the extension string. */
+ for (i = extension_table; i->name != 0; ++i) {
+ if (base[i->offset] && (i->api_set & (1 << ctx->API))) {
+ length += strlen(i->name) + 1; /* +1 for space */
}
}
+ if (extra_extensions != NULL)
+ length += 1 + strlen(extra_extensions); /* +1 for space */
- if (extraExt)
- extStrLen += strlen(extraExt) + 1; /* +1 for space */
-
- /* allocate the extension string */
- s = (char *) malloc(extStrLen);
- if (!s)
+ exts = (char *) calloc(length + 1, sizeof(char));
+ if (exts == NULL) {
+ free(extra_extensions);
return NULL;
-
- /* second, build the extension string */
- extStrLen = 0;
- for (i = 0 ; i < Elements(default_extensions) ; i++) {
- if (extension_enabled(ctx, i)) {
- GLuint len = (GLuint) strlen(default_extensions[i].name);
- memcpy(s + extStrLen, default_extensions[i].name, len);
- extStrLen += len;
- s[extStrLen] = ' ';
- extStrLen++;
- }
- }
- ASSERT(extStrLen > 0);
-
- s[extStrLen - 1] = 0; /* -1 to overwrite trailing the ' ' */
-
- if (extraExt) {
- s = append(s, " ");
- s = append(s, extraExt);
- }
-
- return (GLubyte *) s;
-}
-
-static size_t
-append_extension(GLubyte **str, const char *ext)
-{
- GLubyte *s = *str;
- size_t len = strlen(ext);
-
- if (s) {
- memcpy(s, ext, len);
- s[len++] = ' ';
- s[len] = '\0';
-
- *str += len;
}
- else {
- len++;
- }
-
- return len;
-}
-
-
-static size_t
-make_extension_string_es1(const struct gl_context *ctx, GLubyte *str)
-{
- size_t len = 0;
-
- /* Core additions */
- len += append_extension(&str, "GL_OES_byte_coordinates");
- len += append_extension(&str, "GL_OES_fixed_point");
- len += append_extension(&str, "GL_OES_single_precision");
- len += append_extension(&str, "GL_OES_matrix_get");
-
- /* 1.1 required extensions */
- len += append_extension(&str, "GL_OES_read_format");
- len += append_extension(&str, "GL_OES_compressed_paletted_texture");
- len += append_extension(&str, "GL_OES_point_size_array");
- len += append_extension(&str, "GL_OES_point_sprite");
- /* 1.1 deprecated extensions */
- len += append_extension(&str, "GL_OES_query_matrix");
-
-#if FEATURE_OES_draw_texture
- if (ctx->Extensions.OES_draw_texture)
- len += append_extension(&str, "GL_OES_draw_texture");
-#endif
-
- if (ctx->Extensions.EXT_blend_equation_separate)
- len += append_extension(&str, "GL_OES_blend_equation_separate");
- if (ctx->Extensions.EXT_blend_func_separate)
- len += append_extension(&str, "GL_OES_blend_func_separate");
- if (ctx->Extensions.EXT_blend_subtract)
- len += append_extension(&str, "GL_OES_blend_subtract");
-
- if (ctx->Extensions.EXT_stencil_wrap)
- len += append_extension(&str, "GL_OES_stencil_wrap");
-
- if (ctx->Extensions.ARB_texture_cube_map)
- len += append_extension(&str, "GL_OES_texture_cube_map");
- if (ctx->Extensions.ARB_texture_env_crossbar)
- len += append_extension(&str, "GL_OES_texture_env_crossbar");
- if (ctx->Extensions.ARB_texture_mirrored_repeat)
- len += append_extension(&str, "GL_OES_texture_mirrored_repeat");
-
- if (ctx->Extensions.ARB_framebuffer_object) {
- len += append_extension(&str, "GL_OES_framebuffer_object");
- len += append_extension(&str, "GL_OES_depth24");
- len += append_extension(&str, "GL_OES_depth32");
- len += append_extension(&str, "GL_OES_fbo_render_mipmap");
- len += append_extension(&str, "GL_OES_rgb8_rgba8");
- len += append_extension(&str, "GL_OES_stencil1");
- len += append_extension(&str, "GL_OES_stencil4");
- len += append_extension(&str, "GL_OES_stencil8");
+ /* Build the extension string.*/
+ for (i = extension_table; i->name != 0; ++i) {
+ if (base[i->offset] && (i->api_set & (1 << ctx->API))) {
+ strcat(exts, i->name);
+ strcat(exts, " ");
+ }
}
-
- if (ctx->Extensions.EXT_vertex_array)
- len += append_extension(&str, "GL_OES_element_index_uint");
- if (ctx->Extensions.ARB_vertex_buffer_object)
- len += append_extension(&str, "GL_OES_mapbuffer");
- if (ctx->Extensions.EXT_texture_filter_anisotropic)
- len += append_extension(&str, "GL_EXT_texture_filter_anisotropic");
-
- /* some applications check this for NPOT support */
- if (ctx->Extensions.ARB_texture_non_power_of_two)
- len += append_extension(&str, "GL_ARB_texture_non_power_of_two");
-
- if (ctx->Extensions.EXT_texture_compression_s3tc)
- len += append_extension(&str, "GL_EXT_texture_compression_dxt1");
- if (ctx->Extensions.EXT_texture_lod_bias)
- len += append_extension(&str, "GL_EXT_texture_lod_bias");
- if (ctx->Extensions.EXT_blend_minmax)
- len += append_extension(&str, "GL_EXT_blend_minmax");
- if (ctx->Extensions.EXT_multi_draw_arrays)
- len += append_extension(&str, "GL_EXT_multi_draw_arrays");
-
-#if FEATURE_OES_EGL_image
- if (ctx->Extensions.OES_EGL_image)
- len += append_extension(&str, "GL_OES_EGL_image");
-#endif
-
- return len;
-}
-
-
-static GLubyte *
-compute_extensions_es1(const struct gl_context *ctx)
-{
- GLubyte *s;
- unsigned int len;
-
- len = make_extension_string_es1(ctx, NULL);
- s = malloc(len + 1);
- if (!s)
- return NULL;
- make_extension_string_es1(ctx, s);
-
- return s;
-}
-
-static size_t
-make_extension_string_es2(const struct gl_context *ctx, GLubyte *str)
-{
- size_t len = 0;
-
- if (ctx->Extensions.ARB_framebuffer_object) {
- len += append_extension(&str, "GL_OES_depth24");
- len += append_extension(&str, "GL_OES_depth32");
- len += append_extension(&str, "GL_OES_fbo_render_mipmap");
- len += append_extension(&str, "GL_OES_rgb8_rgba8");
- len += append_extension(&str, "GL_OES_stencil1");
- len += append_extension(&str, "GL_OES_stencil4");
+ if (extra_extensions != 0) {
+ strcat(exts, extra_extensions);
+ free(extra_extensions);
}
- if (ctx->Extensions.EXT_vertex_array)
- len += append_extension(&str, "GL_OES_element_index_uint");
- if (ctx->Extensions.ARB_vertex_buffer_object)
- len += append_extension(&str, "GL_OES_mapbuffer");
-
-#if 0
- /* disabled because of missing GLSL support */
- if (ctx->Extensions.EXT_texture3D)
- len += append_extension(&str, "GL_OES_texture_3D");
-#endif
-
- if (ctx->Extensions.ARB_texture_non_power_of_two)
- len += append_extension(&str, "GL_OES_texture_npot");
- if (ctx->Extensions.EXT_texture_filter_anisotropic)
- len += append_extension(&str, "GL_EXT_texture_filter_anisotropic");
-
- len += append_extension(&str, "GL_EXT_texture_type_2_10_10_10_REV");
- if (ctx->Extensions.ARB_depth_texture)
- len += append_extension(&str, "GL_OES_depth_texture");
- if (ctx->Extensions.EXT_packed_depth_stencil)
- len += append_extension(&str, "GL_OES_packed_depth_stencil");
- if (ctx->Extensions.ARB_fragment_shader)
- len += append_extension(&str, "GL_OES_standard_derivatives");
-
- if (ctx->Extensions.EXT_texture_compression_s3tc)
- len += append_extension(&str, "GL_EXT_texture_compression_dxt1");
- if (ctx->Extensions.EXT_blend_minmax)
- len += append_extension(&str, "GL_EXT_blend_minmax");
- if (ctx->Extensions.EXT_multi_draw_arrays)
- len += append_extension(&str, "GL_EXT_multi_draw_arrays");
-
-#if FEATURE_OES_EGL_image
- if (ctx->Extensions.OES_EGL_image)
- len += append_extension(&str, "GL_OES_EGL_image");
-#endif
-
- if (ctx->Extensions.EXT_texture_format_BGRA8888)
- len += append_extension(&str, "GL_EXT_texture_format_BGRA8888");
-
- return len;
-}
-
-static GLubyte *
-compute_extensions_es2(struct gl_context *ctx)
-{
- GLubyte *s;
- unsigned int len;
-
- len = make_extension_string_es2(ctx, NULL);
- s = malloc(len + 1);
- if (!s)
- return NULL;
- make_extension_string_es2(ctx, s);
-
- return s;
-}
-
-
-GLubyte *
-_mesa_make_extension_string(struct gl_context *ctx)
-{
- switch (ctx->API) {
- case API_OPENGL:
- return compute_extensions(ctx);
- case API_OPENGLES2:
- return compute_extensions_es2(ctx);
- case API_OPENGLES:
- return compute_extensions_es1(ctx);
- default:
- assert(0);
- return NULL;
- }
+ return (GLubyte *) exts;
}
/**
@@ -949,38 +875,42 @@ _mesa_make_extension_string(struct gl_context *ctx) GLuint
_mesa_get_extension_count(struct gl_context *ctx)
{
- GLuint i;
+ GLboolean *base;
+ const struct extension *i;
/* only count once */
- if (!ctx->Extensions.Count) {
- for (i = 0; i < Elements(default_extensions); i++) {
- if (extension_enabled(ctx, i)) {
- ctx->Extensions.Count++;
- }
+ if (ctx->Extensions.Count != 0)
+ return ctx->Extensions.Count;
+
+ base = (GLboolean *) &ctx->Extensions;
+ for (i = extension_table; i->name != 0; ++i) {
+ if (base[i->offset]) {
+ ctx->Extensions.Count++;
}
}
-
- if (0)
- _mesa_debug(ctx, "%u of %d extensions enabled\n", ctx->Extensions.Count,
- (int) Elements(default_extensions));
-
return ctx->Extensions.Count;
}
-
/**
* Return name of i-th enabled extension
*/
const GLubyte *
_mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
{
- GLuint i;
+ const GLboolean *base;
+ size_t n;
+ const struct extension *i;
+
+ if (index < 0)
+ return NULL;
- for (i = 0; i < Elements(default_extensions); i++) {
- if (extension_enabled(ctx, i)) {
- if (index == 0)
- return (const GLubyte *) default_extensions[i].name;
- index--;
+ base = (GLboolean*) &ctx->Extensions;
+ n = 0;
+ for (i = extension_table; i->name != 0; ++i) {
+ if (n == index && base[i->offset]) {
+ return (GLubyte*) i->name;
+ } else if (base[i->offset]) {
+ ++n;
}
}
|