wined3d: Cleanup GL extension detection
H. Verbeet
hverbeet at gmail.com
Tue Jun 26 16:05:41 CDT 2007
Separates extension detection from filling caps/limits, and should
make the actual extension detection a bit more manageable.
Changelog:
- Cleanup GL extension detection
-------------- next part --------------
---
dlls/wined3d/directx.c | 490 +++++++++++++++++++--------------------------
include/wine/wined3d_gl.h | 4
2 files changed, 215 insertions(+), 279 deletions(-)
diff --git a/dlls/wined3d/directx.c b/dlls/wined3d/directx.c
index 1beba2c..171d969 100644
--- a/dlls/wined3d/directx.c
+++ b/dlls/wined3d/directx.c
@@ -36,6 +36,88 @@
WINE_DEFAULT_DEBUG_CHANNEL(d3d);
WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
+/* Extension detection */
+static const struct {
+ const char *extension_string;
+ GL_SupportedExt extension;
+} EXTENSION_MAP[] = {
+ /* APPLE */
+ {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE},
+ {"GL_APPLE_fence", APPLE_FENCE},
+
+ /* ATI */
+ {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL},
+ {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3},
+ {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE},
+ {"GL_ATI_envmap_bumpmap", ATI_ENVMAP_BUMPMAP},
+
+ /* ARB */
+ {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS},
+ {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM},
+ {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER},
+ {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL},
+ {"GL_ARB_imaging", ARB_IMAGING},
+ {"GL_ARB_multisample", ARB_MULTISAMPLE}, /* needs GLX_ARB_MULTISAMPLE as well */
+ {"GL_ARB_multitexture", ARB_MULTITEXTURE},
+ {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY},
+ {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT},
+ {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS},
+ {"GL_ARB_point_sprite", ARB_POINT_SPRITE},
+ {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP},
+ {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION},
+ {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP},
+ {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD},
+ {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE},
+ {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3},
+ {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT},
+ {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT},
+ {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO},
+ {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND},
+ {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT},
+ {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM},
+ {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER},
+
+ /* EXT */
+ {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX},
+ {"GL_EXT_fog_coord", EXT_FOG_COORD},
+ {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT},
+ {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT},
+ {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE},
+ {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS},
+ {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR},
+ {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE},
+ {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP},
+ {"GL_EXT_texture3D", EXT_TEXTURE3D},
+ {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC},
+ {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD},
+ {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE},
+ {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3},
+ {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB},
+ {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC},
+ {"GL_EXT_texture_lod", EXT_TEXTURE_LOD},
+ {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS},
+ {"GL_EXT_vertex_shader", EXT_VERTEX_SHADER},
+ {"GL_EXT_vertex_weighting", EXT_VERTEX_WEIGHTING},
+
+ /* NV */
+ {"GL_NV_fence", NV_FENCE},
+ {"GL_NV_fog_distance", NV_FOG_DISTANCE},
+ {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM},
+ {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2},
+ {"GL_NV_register_combiners", NV_REGISTER_COMBINERS},
+ {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2},
+ {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION},
+ {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4},
+ {"GL_NV_texture_shader", NV_TEXTURE_SHADER},
+ {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2},
+ {"GL_NV_texture_shader3", NV_TEXTURE_SHADER3},
+ {"GL_NV_occlusion_query", NV_OCCLUSION_QUERY},
+ {"GL_NV_vertex_program", NV_VERTEX_PROGRAM},
+ {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1},
+ {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2},
+ {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3},
+};
+
/**********************************************************
* Utility functions follow
**********************************************************/
@@ -556,290 +638,142 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info, Display* display) {
memcpy(ThisExtn, Start, (GL_Extensions - Start));
TRACE_(d3d_caps)("- %s\n", ThisExtn);
- /**
- * ARB
- */
- if (strcmp(ThisExtn, "GL_ARB_draw_buffers") == 0) {
- glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB_draw_buffers support - max buffers=%u\n", gl_max);
- gl_info->supported[ARB_DRAW_BUFFERS] = TRUE;
- gl_info->max_buffers = gl_max;
- } else if (strcmp(ThisExtn, "GL_ARB_fragment_program") == 0) {
- gl_info->ps_arb_version = PS_VERSION_11;
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - version=%02x\n", gl_info->ps_arb_version);
- gl_info->supported[ARB_FRAGMENT_PROGRAM] = TRUE;
- glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - GL_MAX_TEXTURE_IMAGE_UNITS_ARB=%u\n", gl_max);
- gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, gl_max);
- GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max float constants=%u\n", gl_max);
- gl_info->ps_arb_constantsF = gl_max;
- GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max temporaries=%u\n", gl_max);
- gl_info->ps_arb_max_temps = gl_max;
- GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max instructions=%u\n", gl_max);
- gl_info->ps_arb_max_instructions = gl_max;
- } else if (strcmp(ThisExtn, "GL_ARB_fragment_shader") == 0) {
- gl_info->supported[ARB_FRAGMENT_SHADER] = TRUE;
- glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
- gl_max /= 4;
- TRACE_(d3d_caps)(" FOUND: ARB_fragment_shader (GLSL) support - max float ps constants=%u\n", gl_max);
- gl_info->ps_glsl_constantsF = gl_max;
- } else if (strcmp(ThisExtn, "GL_ARB_imaging") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB imaging support\n");
- gl_info->supported[ARB_IMAGING] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Multisample support\n");
- gl_info->supported[ARB_MULTISAMPLE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
- glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%u\n", gl_max);
- gl_info->supported[ARB_MULTITEXTURE] = TRUE;
- gl_info->max_textures = min(MAX_TEXTURES, gl_max);
- gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
- gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
- } else if (strcmp(ThisExtn, "GL_ARB_texture_cube_map") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture Cube Map support\n");
- gl_info->supported[ARB_TEXTURE_CUBE_MAP] = TRUE;
- TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
- gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_compression") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture Compression support\n");
- gl_info->supported[ARB_TEXTURE_COMPRESSION] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_env_add") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture Env Add support\n");
- gl_info->supported[ARB_TEXTURE_ENV_ADD] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_env_combine") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture Env combine support\n");
- gl_info->supported[ARB_TEXTURE_ENV_COMBINE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_env_dot3") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Dot3 support\n");
- gl_info->supported[ARB_TEXTURE_ENV_DOT3] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_float") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Float texture support\n");
- gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_half_float_pixel") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Half-float pixel support\n");
- gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_border_clamp") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture border clamp support\n");
- gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_mirrored_repeat") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Texture mirrored repeat support\n");
- gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_texture_non_power_of_two") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB NPOT texture support\n");
- gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = TRUE;
- } else if (strcmp(ThisExtn, "GLX_ARB_multisample") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB multisample support\n");
- gl_info->supported[ARB_MULTISAMPLE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_pixel_buffer_object") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Pixel Buffer support\n");
- gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_point_sprite") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB point sprite support\n");
- gl_info->supported[ARB_POINT_SPRITE] = TRUE;
- } else if (strstr(ThisExtn, "GL_ARB_vertex_program")) {
- gl_info->vs_arb_version = VS_VERSION_11;
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - version=%02x\n", gl_info->vs_arb_version);
- gl_info->supported[ARB_VERTEX_PROGRAM] = TRUE;
- GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max float constants=%u\n", gl_max);
- gl_info->vs_arb_constantsF = gl_max;
- GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max temporaries=%u\n", gl_max);
- gl_info->vs_arb_max_temps = gl_max;
- GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max instructions=%u\n", gl_max);
- gl_info->vs_arb_max_instructions = gl_max;
- } else if (strcmp(ThisExtn, "GL_ARB_vertex_shader") == 0) {
- gl_info->supported[ARB_VERTEX_SHADER] = TRUE;
- glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
- gl_max /= 4;
- TRACE_(d3d_caps)(" FOUND: ARB_vertex_shader (GLSL) support - max float vs constants=%u\n", gl_max);
- gl_info->vs_glsl_constantsF = gl_max;
- glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB_vertex_shader (GLSL) support - GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB=%u\n", gl_max);
- gl_info->max_vertex_samplers = gl_max;
- glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB_vertex_shader (GLSL) support - GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB=%u\n", gl_max);
- gl_info->max_combined_samplers = gl_max;
- } else if (strcmp(ThisExtn, "GL_ARB_vertex_blend") == 0) {
- glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Blend support GL_MAX_VERTEX_UNITS_ARB %d\n", gl_max);
- gl_info->max_blends = gl_max;
- gl_info->supported[ARB_VERTEX_BLEND] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_vertex_buffer_object") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Vertex Buffer support\n");
- gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_occlusion_query") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Occlusion Query support\n");
- gl_info->supported[ARB_OCCLUSION_QUERY] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ARB_point_parameters") == 0) {
- TRACE_(d3d_caps)(" FOUND: ARB Point parameters support\n");
- gl_info->supported[ARB_POINT_PARAMETERS] = TRUE;
- /**
- * EXT
- */
- } else if (strcmp(ThisExtn, "GL_EXT_fog_coord") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Fog coord support\n");
- gl_info->supported[EXT_FOG_COORD] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_framebuffer_object") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Frame Buffer Object support\n");
- gl_info->supported[EXT_FRAMEBUFFER_OBJECT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_framebuffer_blit") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Frame Buffer Blit support\n");
- gl_info->supported[EXT_FRAMEBUFFER_BLIT] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_blend_minmax") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Blend minmax support\n");
- gl_info->supported[EXT_BLEND_MINMAX] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_paletted_texture") == 0) { /* handle paletted texture extensions */
- TRACE_(d3d_caps)(" FOUND: EXT Paletted texture support\n");
- gl_info->supported[EXT_PALETTED_TEXTURE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_point_parameters") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Point parameters support\n");
- gl_info->supported[EXT_POINT_PARAMETERS] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_secondary_color") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Secondary color support\n");
- gl_info->supported[EXT_SECONDARY_COLOR] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_stencil_two_side") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Stencil two side support\n");
- gl_info->supported[EXT_STENCIL_TWO_SIDE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_stencil_wrap") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Stencil wrap support\n");
- gl_info->supported[EXT_STENCIL_WRAP] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture3D") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT_texture3D support\n");
- gl_info->supported[EXT_TEXTURE3D] = TRUE;
- glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
- TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_max);
- gl_info->max_texture3d_size = gl_max;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_compression_s3tc") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Texture S3TC compression support\n");
- gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_env_add") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Texture Env Add support\n");
- gl_info->supported[EXT_TEXTURE_ENV_ADD] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_env_combine") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Texture Env combine support\n");
- gl_info->supported[EXT_TEXTURE_ENV_COMBINE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_env_dot3") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Dot3 support\n");
- gl_info->supported[EXT_TEXTURE_ENV_DOT3] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_sRGB") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT sRGB support\n");
- gl_info->supported[EXT_TEXTURE_SRGB] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_filter_anisotropic") == 0) {
- gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] = TRUE;
- glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
- TRACE_(d3d_caps)(" FOUND: EXT Texture Anisotropic filter support. GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT %d\n", gl_max);
- gl_info->max_anisotropy = gl_max;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_lod") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Texture LOD support\n");
- gl_info->supported[EXT_TEXTURE_LOD] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_texture_lod_bias") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Texture LOD bias support\n");
- gl_info->supported[EXT_TEXTURE_LOD_BIAS] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_vertex_weighting") == 0) {
- TRACE_(d3d_caps)(" FOUND: EXT Vertex weighting support\n");
- gl_info->supported[EXT_VERTEX_WEIGHTING] = TRUE;
-
- /**
- * NVIDIA
- */
- } else if (strstr(ThisExtn, "GL_NV_fog_distance")) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Fog Distance support\n");
- gl_info->supported[NV_FOG_DISTANCE] = TRUE;
- } else if (strstr(ThisExtn, "GL_NV_fragment_program")) {
- gl_info->ps_nv_version = (strcmp(ThisExtn, "GL_NV_fragment_program2") == 0) ? PS_VERSION_30 : PS_VERSION_20;
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Pixel Shader support - version=%02x\n", gl_info->ps_nv_version);
- } else if (strcmp(ThisExtn, "GL_NV_register_combiners") == 0) {
- glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
- gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (1) support - GL_MAX_GENERAL_COMBINERS_NV=%d\n", gl_max);
- gl_info->supported[NV_REGISTER_COMBINERS] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_register_combiners2") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (2) support\n");
- gl_info->supported[NV_REGISTER_COMBINERS2] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_texgen_reflection") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Gen Reflection support\n");
- gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_texture_env_combine4") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Env combine (4) support\n");
- gl_info->supported[NV_TEXTURE_ENV_COMBINE4] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_texture_shader") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (1) support\n");
- gl_info->supported[NV_TEXTURE_SHADER] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_texture_shader2") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (2) support\n");
- gl_info->supported[NV_TEXTURE_SHADER2] = TRUE;
- /* Prevent both extensions to be used at the same time. I don't expect them to play nice together */
- gl_info->supported[ATI_ENVMAP_BUMPMAP] = FALSE;
- } else if (strcmp(ThisExtn, "GL_NV_texture_shader3") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (3) support\n");
- gl_info->supported[NV_TEXTURE_SHADER3] = TRUE;
- } else if (strcmp(ThisExtn, "GL_NV_occlusion_query") == 0) {
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Occlusion Query (3) support\n");
- gl_info->supported[NV_OCCLUSION_QUERY] = TRUE;
- } else if (strstr(ThisExtn, "GL_NV_vertex_program")) {
- if(strcmp(ThisExtn, "GL_NV_vertex_program3") == 0)
- gl_info->vs_nv_version = VS_VERSION_30;
- else if(strcmp(ThisExtn, "GL_NV_vertex_program2") == 0)
- gl_info->vs_nv_version = VS_VERSION_20;
- else if(strcmp(ThisExtn, "GL_NV_vertex_program1_1") == 0)
- gl_info->vs_nv_version = VS_VERSION_11;
- else
- gl_info->vs_nv_version = VS_VERSION_10;
- TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Vertex Shader support - version=%02x\n", gl_info->vs_nv_version);
- gl_info->supported[NV_VERTEX_PROGRAM] = TRUE;
- } else if (strstr(ThisExtn, "GL_NV_fence")) {
- if(!gl_info->supported[APPLE_FENCE]) {
- gl_info->supported[NV_FENCE] = TRUE;
+ for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
+ if (!strcmp(ThisExtn, EXTENSION_MAP[i].extension_string)) {
+ TRACE_(d3d_caps)(" FOUND: %s support\n", EXTENSION_MAP[i].extension_string);
+ gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
+ break;
}
+ }
- /**
- * ATI
+ if (*GL_Extensions == ' ') GL_Extensions++;
+ }
+
+ if (gl_info->supported[APPLE_FENCE]) {
+ /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
+ * The apple extension interacts with some other apple exts. Disable the NV
+ * extension if the apple one is support to prevent confusion in other parts
+ * of the code
*/
- /** TODO */
- } else if (strcmp(ThisExtn, "GL_ATI_separate_stencil") == 0) {
- TRACE_(d3d_caps)(" FOUND: ATI Separate stencil support\n");
- gl_info->supported[ATI_SEPARATE_STENCIL] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ATI_texture_env_combine3") == 0) {
- TRACE_(d3d_caps)(" FOUND: ATI Texture Env combine (3) support\n");
- gl_info->supported[ATI_TEXTURE_ENV_COMBINE3] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ATI_texture_mirror_once") == 0) {
- TRACE_(d3d_caps)(" FOUND: ATI Texture Mirror Once support\n");
- gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE;
- } else if (strcmp(ThisExtn, "GL_EXT_vertex_shader") == 0) {
- gl_info->vs_ati_version = VS_VERSION_11;
- TRACE_(d3d_caps)(" FOUND: ATI (EXT) Vertex Shader support - version=%02x\n", gl_info->vs_ati_version);
- gl_info->supported[EXT_VERTEX_SHADER] = TRUE;
- } else if (strcmp(ThisExtn, "GL_ATI_envmap_bumpmap") == 0) {
- TRACE_(d3d_caps)(" FOUND: ATI Environment Bump Mapping support\n");
- /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
- * Won't occur in any real world situation though
- */
- if(!gl_info->supported[NV_TEXTURE_SHADER2]) {
- gl_info->supported[ATI_ENVMAP_BUMPMAP] = TRUE;
- }
- /**
- * Apple
+ gl_info->supported[NV_FENCE] = FALSE;
+ }
+ if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) {
+ TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
+ gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
+ }
+ if (gl_info->supported[NV_TEXTURE_SHADER2]) {
+ /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
+ * Won't occur in any real world situation though
*/
- } else if (strstr(ThisExtn, "GL_APPLE_fence")) {
- /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
- * The apple extension interacts with some other apple exts. Disable the NV
- * extension if the apple one is support to prevent confusion in other parts
- * of the code
- */
- gl_info->supported[NV_FENCE] = FALSE;
- gl_info->supported[APPLE_FENCE] = TRUE;
- } else if (strstr(ThisExtn, "GL_APPLE_client_storage")) {
- gl_info->supported[APPLE_CLIENT_STORAGE] = TRUE;
+ gl_info->supported[ATI_ENVMAP_BUMPMAP] = FALSE;
+ }
+ if (gl_info->supported[ARB_DRAW_BUFFERS]) {
+ glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
+ gl_info->max_buffers = gl_max;
+ TRACE_(d3d_caps)("Max draw buffers: %u\n", gl_max);
+ }
+ if (gl_info->supported[ARB_MULTITEXTURE]) {
+ glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
+ gl_info->max_textures = min(MAX_TEXTURES, gl_max);
+ TRACE_(d3d_caps)("Max textures: %d\n", gl_info->max_textures);
+
+ if (gl_info->supported[NV_REGISTER_COMBINERS]) {
+ GLint tmp;
+ glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &tmp);
+ gl_info->max_texture_stages = min(MAX_TEXTURES, tmp);
+ } else {
+ gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
}
+ TRACE_(d3d_caps)("Max texture stages: %d\n", gl_info->max_texture_stages);
- if (*GL_Extensions == ' ') GL_Extensions++;
+ if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
+ GLint tmp;
+ glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
+ gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
+ } else {
+ gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
+ }
+ TRACE_(d3d_caps)("Max fragment samplers: %d\n", gl_info->max_fragment_samplers);
+
+ if (gl_info->supported[ARB_VERTEX_SHADER]) {
+ GLint tmp;
+ glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
+ gl_info->max_vertex_samplers = tmp;
+ glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
+ gl_info->max_combined_samplers = tmp;
+ } else {
+ gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
+ }
+ TRACE_(d3d_caps)("Max vertex samplers: %u\n", gl_info->max_vertex_samplers);
+ TRACE_(d3d_caps)("Max combined samplers: %u\n", gl_info->max_combined_samplers);
+ }
+ if (gl_info->supported[ARB_VERTEX_BLEND]) {
+ glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
+ gl_info->max_blends = gl_max;
+ TRACE_(d3d_caps)("Max blends: %u\n", gl_info->max_blends);
+ }
+ if (gl_info->supported[EXT_TEXTURE3D]) {
+ glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
+ gl_info->max_texture3d_size = gl_max;
+ TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_info->max_texture3d_size);
+ }
+ if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC]) {
+ glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
+ gl_info->max_anisotropy = gl_max;
+ TRACE_(d3d_caps)("Max anisotropy: %d\n", gl_info->max_anisotropy);
}
+ if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
+ gl_info->ps_arb_version = PS_VERSION_11;
+ GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
+ gl_info->ps_arb_constantsF = gl_max;
+ TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info->ps_arb_constantsF);
+ GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
+ gl_info->ps_arb_max_temps = gl_max;
+ TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM temporaries: %d\n", gl_info->ps_arb_max_temps);
+ GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
+ gl_info->ps_arb_max_instructions = gl_max;
+ TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM instructions: %d\n", gl_info->ps_arb_max_instructions);
+ }
+ if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
+ gl_info->vs_arb_version = VS_VERSION_11;
+ GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
+ gl_info->vs_arb_constantsF = gl_max;
+ TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info->vs_arb_constantsF);
+ GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
+ gl_info->vs_arb_max_temps = gl_max;
+ TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM temporaries: %d\n", gl_info->vs_arb_max_temps);
+ GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
+ gl_info->vs_arb_max_instructions = gl_max;
+ TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM instructions: %d\n", gl_info->vs_arb_max_instructions);
+ }
+ if (gl_info->supported[ARB_VERTEX_SHADER]) {
+ glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
+ gl_info->vs_glsl_constantsF = gl_max / 4;
+ TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info->vs_glsl_constantsF);
+ }
+ if (gl_info->supported[ARB_FRAGMENT_SHADER]) {
+ glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
+ gl_info->ps_glsl_constantsF = gl_max / 4;
+ TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info->ps_glsl_constantsF);
+ }
+ if (gl_info->supported[EXT_VERTEX_SHADER]) {
+ gl_info->vs_ati_version = VS_VERSION_11;
+ }
+ if (gl_info->supported[NV_VERTEX_PROGRAM3]) {
+ gl_info->vs_nv_version = VS_VERSION_30;
+ } else if (gl_info->supported[NV_VERTEX_PROGRAM2]) {
+ gl_info->vs_nv_version = VS_VERSION_20;
+ } else if (gl_info->supported[NV_VERTEX_PROGRAM1_1]) {
+ gl_info->vs_nv_version = VS_VERSION_11;
+ } else if (gl_info->supported[NV_VERTEX_PROGRAM]) {
+ gl_info->vs_nv_version = VS_VERSION_10;
+ }
+ if (gl_info->supported[NV_FRAGMENT_PROGRAM2]) {
+ gl_info->ps_nv_version = PS_VERSION_30;
+ } else if (gl_info->supported[NV_FRAGMENT_PROGRAM]) {
+ gl_info->ps_nv_version = PS_VERSION_20;
+ }
+
}
checkGLcall("extension detection\n");
@@ -848,8 +782,6 @@ BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info, Display* display) {
* shaders), but 8 texture stages (register combiners). */
gl_info->max_sampler_stages = max(gl_info->max_fragment_samplers, gl_info->max_texture_stages);
- if (!gl_info->max_combined_samplers) gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
-
/* We can only use ORM_FBO when the hardware supports it. */
if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
diff --git a/include/wine/wined3d_gl.h b/include/wine/wined3d_gl.h
index 1d69e59..b0e1bc5 100644
--- a/include/wine/wined3d_gl.h
+++ b/include/wine/wined3d_gl.h
@@ -1578,6 +1578,7 @@ typedef enum _GL_SupportedExt {
/* NVIDIA */
NV_FOG_DISTANCE,
NV_FRAGMENT_PROGRAM,
+ NV_FRAGMENT_PROGRAM2,
NV_OCCLUSION_QUERY,
NV_REGISTER_COMBINERS,
NV_REGISTER_COMBINERS2,
@@ -1587,6 +1588,9 @@ typedef enum _GL_SupportedExt {
NV_TEXTURE_SHADER2,
NV_TEXTURE_SHADER3,
NV_VERTEX_PROGRAM,
+ NV_VERTEX_PROGRAM1_1,
+ NV_VERTEX_PROGRAM2,
+ NV_VERTEX_PROGRAM3,
NV_FENCE,
/* ATI */
ATI_SEPARATE_STENCIL,
More information about the wine-patches
mailing list