Intel GMA graphics cards & OpenGL Extensions...

Hi

I’m trying to find a list of OpenGL capabilities & extensions available for various Intel graphics chips, but have been unable to locate any on the web.

If anyone has the time/inclination I’d very much appreciate you downloading the following…

http://delphi3d.net/hardware/glinfo2.zip (from delphi3d.net)

…and posting the results here. If you click on the ‘Reports’ button from the above, and then click ‘Save Report’, it will save an HTML file for you. If you can then copy the data from the table and post here I’d be forever in your debt!

BTW - you don’t need to install the software from the .zip file - just run the .exe it contains. You can then just delete it if you wish.

Many thanks in advance
Mark

PS - Here’s a sample from my graphics card…

Driver version Unknown
Vendor NVIDIA Corporation
Renderer GeForce 7600 GS/AGP/SSE2
OpenGL version 2.1.2

Extension lists
Extensions GL_ARB_color_buffer_float
GL_ARB_depth_texture
GL_ARB_draw_buffers
GL_ARB_fragment_program
GL_ARB_fragment_program_shadow
GL_ARB_fragment_shader
GL_ARB_half_float_pixel
GL_ARB_imaging
GL_ARB_multisample
GL_ARB_multitexture
GL_ARB_occlusion_query
GL_ARB_pixel_buffer_object
GL_ARB_point_parameters
GL_ARB_point_sprite
GL_ARB_shader_objects
GL_ARB_shading_language_100
GL_ARB_shadow
GL_ARB_texture_border_clamp
GL_ARB_texture_compression
GL_ARB_texture_cube_map
GL_ARB_texture_env_add
GL_ARB_texture_env_combine
GL_ARB_texture_env_dot3
GL_ARB_texture_float
GL_ARB_texture_mirrored_repeat
GL_ARB_texture_non_power_of_two
GL_ARB_texture_rectangle
GL_ARB_transpose_matrix
GL_ARB_vertex_buffer_object
GL_ARB_vertex_program
GL_ARB_vertex_shader
GL_ARB_window_pos
GL_ATI_draw_buffers
GL_ATI_texture_float
GL_ATI_texture_mirror_once
GL_EXT_abgr
GL_EXT_bgra
GL_EXT_blend_color
GL_EXT_blend_equation_separate
GL_EXT_blend_func_separate
GL_EXT_blend_minmax
GL_EXT_blend_subtract
GL_EXT_Cg_shader
GL_EXT_compiled_vertex_array
GL_EXT_depth_bounds_test
GL_EXT_draw_range_elements
GL_EXT_fog_coord
GL_EXT_framebuffer_blit
GL_EXT_framebuffer_multisample
GL_EXT_framebuffer_object
GL_EXT_gpu_program_parameters
GL_EXT_multi_draw_arrays
GL_EXT_packed_depth_stencil
GL_EXT_packed_pixels
GL_EXT_pixel_buffer_object
GL_EXT_point_parameters
GL_EXT_rescale_normal
GL_EXT_secondary_color
GL_EXT_separate_specular_color
GL_EXT_shadow_funcs
GL_EXT_stencil_two_side
GL_EXT_stencil_wrap
GL_EXT_texture3D
GL_EXT_texture_compression_s3tc
GL_EXT_texture_cube_map
GL_EXT_texture_edge_clamp
GL_EXT_texture_env_add
GL_EXT_texture_env_combine
GL_EXT_texture_env_dot3
GL_EXT_texture_filter_anisotropic
GL_EXT_texture_lod
GL_EXT_texture_lod_bias
GL_EXT_texture_mirror_clamp
GL_EXT_texture_object
GL_EXT_texture_sRGB
GL_EXT_timer_query
GL_EXT_vertex_array
GL_IBM_rasterpos_clip
GL_IBM_texture_mirrored_repeat
GL_KTX_buffer_region
GL_NVX_conditional_render
GL_NV_blend_square
GL_NV_copy_depth_to_color
GL_NV_depth_clamp
GL_NV_fence
GL_NV_float_buffer
GL_NV_fog_distance
GL_NV_fragment_program
GL_NV_fragment_program2
GL_NV_fragment_program_option
GL_NV_framebuffer_multisample_coverage
GL_NV_half_float
GL_NV_light_max_exponent
GL_NV_multisample_filter_hint
GL_NV_occlusion_query
GL_NV_packed_depth_stencil
GL_NV_pixel_data_range
GL_NV_point_sprite
GL_NV_primitive_restart
GL_NV_register_combiners
GL_NV_register_combiners2
GL_NV_texgen_reflection
GL_NV_texture_compression_vtc
GL_NV_texture_env_combine4
GL_NV_texture_expand_normal
GL_NV_texture_rectangle
GL_NV_texture_shader
GL_NV_texture_shader2
GL_NV_texture_shader3
GL_NV_vertex_array_range
GL_NV_vertex_array_range2
GL_NV_vertex_program
GL_NV_vertex_program1_1
GL_NV_vertex_program2
GL_NV_vertex_program2_option
GL_NV_vertex_program3
GL_S3_s3tc
GL_SGIS_generate_mipmap
GL_SGIS_texture_lod
GL_SGIX_depth_texture
GL_SGIX_shadow
GL_SUN_slice_accum
GL_WIN_swap_hint
WGL_EXT_swap_control

WGL extensions WGL_ARB_buffer_region
WGL_ARB_extensions_string
WGL_ARB_make_current_read
WGL_ARB_multisample
WGL_ARB_pbuffer
WGL_ARB_pixel_format
WGL_ARB_pixel_format_float
WGL_ARB_render_texture
WGL_ATI_pixel_format_float
WGL_EXT_extensions_string
WGL_EXT_swap_control
WGL_NV_float_buffer
WGL_NV_render_depth_texture
WGL_NV_render_texture_rectangle

Implementation specifics
Various limitations Max. texture size 4096 x 4096
Max. number of light sources 8
Max. number of clipping planes 6
Max. pixel map table size 65536
Max. display list nesting level 64
Max. evaluator order 8
Point size range 1.000 to 63.375
Point size granularity 0.125
Line width range 0.500 to 10.000
Line width granularity 0.125

Maximum stack depths Modelview matrix stack 32
Projection matrix stack 4
Texture matrix stack 10
Name stack 128
Attribute stack 16

Framebuffer properties Sub-pixel precision bits 12
Max. viewport size 4096 x 4096
Number of auxiliary buffers 4

Extension specifics
ARB_multitexture Texture units 4

ARB_texture_compression Supported formats DXT1 RGB DXT3 RGBA DXT5 RGBA

Texture_cube_map Max. cube map texture size 4096

EXT_texture_filter_anisotropic Max. anisotropy 16

Texture3D Max. 3D texture size 512 x 512 x 512

NV_register_combiners Max. general combiners 8

Texture_rectangle Max. texture rectangle size 4096 x 4096

NV_vertex_array_range Max. VAR size 1048575

NV_vertex_program Max. tracking matrix stack depth 1
Max. tracking matrices 8

DrawRangeElements Max. recommended index count 1048576
Max. recommended vertex count 1048576

ARB_imaging Max. color matrix stack depth 2

NV_occlusion_query Pixel counter bits 32

ARB_occlusion_query Query counter bits 32

NV_fragment_program Max. texture coords 8
Max. texture image units 16
Max. local parameters 512

ARB_vertex_program Max. instructions 512
Max. native instructions 512
Max. temporaries 48
Max. native temporaries 48
Max. parameters 256
Max. native parameters 256
Max. attribs 16
Max. native attribs 16
Max. address registers 2
Max. native address registers 2
Max. local parameters 256
Max. env. parameters 256
Max. vertex attribs 16
Max. matrices 8
Max. matrix stack depth 1

ARB_shading_language_100 Shading language version 1.20 NVIDIA via Cg compiler

ARB_fragment_program Max. texture coords 8
Max. texture image units 16
Max. env. parameters 256
Max. local parameters 512
Max. matrices 8
Max. matrix stack depth 1
Max. instructions 4096
Max. ALU instructions 4096
Max. texture instructions 4096
Max. texture indirections 4096
Max. temporaries 32
Max. parameters 1024
Max. attribs 16
Max. native instructions 4096
Max. native ALU instructions 4096
Max. native texture instructions 4096
Max. native texture indirections 4096
Max. native temporaries 32
Max. native parameters 1024
Max. native attribs 16

ARB_vertex_shader Max. vertex attribs 16
Max. uniform vertex components 1024
Max. varying floats 32
Max. combined tex. image units 16
Max. vertex tex. image units 4
Max. tex. image units 16
Max. texture coords 8

ARB_fragment_shader Max. uniform fragment components 2048
Max. tex. image units 16
Max. texture coords 8

NV_fragment_program2 Max. execution instructions 65536
Max. call stack depth 4
Max. if statement nesting 48
Max. loop nesting 4
Max. loop count 255

NV_vertex_program2_option Max. execution instructions 65536
Max. call stack depth 8

NV_vertex_program3 Max. vertex texture image units 4

Draw_buffers Max. draw buffers 4

EXT_framebuffer_object Max. renderbuffer size 4096

Hi,

Just dl OpenGL extension viewer from http://www.realtech-vr.com/. It has a database for almost every card.

Mark, on my MacBook (Leopard 10.5.3 with GMA X3100) therenderer infor is as follows (copied from an Apple OpenGL tool):


Intel GMA X3100 OpenGL Engine 	
Vendor Name                   	Intel Inc.
Version                       	1.2 APPLE-1.5.28
GL Shading Language Version   	1.20
Renderer Name                 	Intel GMA X3100 OpenGL Engine
OpenGL Extensions             	
                              	GL_APPLE_aux_depth_stencil
                              	GL_APPLE_client_storage
                              	GL_APPLE_element_array
                              	GL_APPLE_fence
                              	GL_APPLE_flush_buffer_range
                              	GL_APPLE_flush_render
                              	GL_APPLE_object_purgeable
                              	GL_APPLE_packed_pixels
                              	GL_APPLE_pixel_buffer
                              	GL_APPLE_specular_vector
                              	GL_APPLE_texture_range
                              	GL_APPLE_transform_hint
                              	GL_APPLE_vertex_array_object
                              	GL_APPLE_vertex_array_range
                              	GL_APPLE_vertex_program_evaluators
                              	GL_APPLE_ycbcr_422
                              	GL_ARB_depth_texture
                              	GL_ARB_draw_buffers
                              	GL_ARB_fragment_program
                              	GL_ARB_fragment_program_shadow
                              	GL_ARB_fragment_shader
                              	GL_ARB_multitexture
                              	GL_ARB_occlusion_query
                              	GL_ARB_pixel_buffer_object
                              	GL_ARB_point_sprite
                              	GL_ARB_shader_objects
                              	GL_ARB_shading_language_100
                              	GL_ARB_shadow
                              	GL_ARB_texture_border_clamp
                              	GL_ARB_texture_compression
                              	GL_ARB_texture_cube_map
                              	GL_ARB_texture_env_add
                              	GL_ARB_texture_env_combine
                              	GL_ARB_texture_env_crossbar
                              	GL_ARB_texture_env_dot3
                              	GL_ARB_texture_mirrored_repeat
                              	GL_ARB_texture_non_power_of_two
                              	GL_ARB_texture_rectangle
                              	GL_ARB_transpose_matrix
                              	GL_ARB_vertex_blend
                              	GL_ARB_vertex_buffer_object
                              	GL_ARB_vertex_program
                              	GL_ARB_vertex_shader
                              	GL_ARB_window_pos
                              	GL_EXT_abgr
                              	GL_EXT_bgra
                              	GL_EXT_blend_color
                              	GL_EXT_blend_equation_separate
                              	GL_EXT_blend_func_separate
                              	GL_EXT_blend_minmax
                              	GL_EXT_blend_subtract
                              	GL_EXT_clip_volume_hint
                              	GL_EXT_draw_range_elements
                              	GL_EXT_fog_coord
                              	GL_EXT_framebuffer_blit
                              	GL_EXT_framebuffer_object
                              	GL_EXT_geometry_shader4
                              	GL_EXT_gpu_program_parameters
                              	GL_EXT_multi_draw_arrays
                              	GL_EXT_packed_depth_stencil
                              	GL_EXT_rescale_normal
                              	GL_EXT_secondary_color
                              	GL_EXT_separate_specular_color
                              	GL_EXT_shadow_funcs
                              	GL_EXT_stencil_two_side
                              	GL_EXT_stencil_wrap
                              	GL_EXT_texture_compression_dxt1
                              	GL_EXT_texture_compression_s3tc
                              	GL_EXT_texture_env_add
                              	GL_EXT_texture_filter_anisotropic
                              	GL_EXT_texture_lod_bias
                              	GL_EXT_texture_rectangle
                              	GL_EXT_texture_sRGB
                              	GL_EXT_transform_feedback
                              	GL_IBM_rasterpos_clip
                              	GL_NV_blend_square
                              	GL_NV_light_max_exponent
                              	GL_NV_texgen_reflection
                              	GL_SGIS_generate_mipmap
                              	GL_SGIS_texture_edge_clamp
                              	GL_SGIS_texture_lod
OpenGL Limits                 	
Display Mask                  	1 (0x00000001)
Renderer ID                   	147968 (0x00024200)
Off Screen                    	No
Full Screen                   	Yes
Hardware Accelerated          	Yes
Robust                        	No
Backing Store                 	Yes
MP Safe                       	Yes
Window                        	Yes
Multi Screen                  	No
Compliant                     	Yes
Buffer Modes                  	13 (0x0000000d)
Color Buffer Modes            	32768 (0x00008000)
Accum Buffer Modes            	8421376 (0x00808000)
Depth Buffer Modes            	3073 (0x00000c01)
Stencil Buffer Modes          	129 (0x00000081)
Max Aux Buffers               	2 (0x00000002)
Max Sample Buffers            	0 (0x00000000)
Max Samples                   	0 (0x00000000)
Sample Modes                  	0 (0x00000000)
Alpha Sampling                	No
GPU Vertex Processing Capable 	Yes
GPU Fragment Processing Capable	Yes
Total Video Memory            	134217728 (0x08000000)
Total Texture Memory          	134217728 (0x08000000)

Basically, you have shading language 1.2 with vertex, fragment and geomatry shaders, transform feedback, framebuffer blit etc. (alas, no floating-point textures yet). I don’t think this will differ much for windows (as far as I know, floating-pint textures are supported on windows)

Actually, I would be surprised if the Windows driver even has GLSL support.

Thanks Zengar…

Best I can tell (hence me asking here) is that the intel windows drivers don’t even support frame buffer objects! And I’d much rather have a simple render path - not use FBOs if they exist, else pBuffers etc.

I’m doing an app which is seriously CPU bound, so it makes sense to move all GUI to an accelerated graphics card (there’s quite a lot of GUI stuff going on). I’ve held off for GL3, but I’m loosing confidence in that… but that’s another story.

So, I’ve got to make a choice - either OpenGL or Direct3D. I really WANT* to use GL, but I’m concerned that many laptops will struggle with it - I need things like frame buffer object & GLSL. I may be forced down the D3D route though. Which sucks. Intel are totally pissing me off with their useless drivers - even more than Kronos :wink:

Mark

*In an ideal world I’d like the potential to easily port to Mac and/or Linux, so I only use Win32 stuff to create windows (one for each monitor) which are essentially just surfaces on which to draw. I also use Win32 to handle mouse/keyboard, and create threads. This tiny amount of code should be trivial in a port.

Na, the world is everything but ideal :slight_smile:

Is there any indication that intel will be improving their openGL drivers?

Seeing as Intel are part of the decision making process regarding OpenGL’s future, I think it’s a totaly obvious answer…

No.

Intel are shite. A bunch of scumbags :frowning: Intel are causing me no end of grief, simply because they don’t know how to write drivers - their chipsets are [feature wise] quite adaquate for my purposes but they seem unable/unwilling to write GL drivers. Thank goodness they have a say about the future of OpenGL. Not.

I apologise to Intel about my personal anguish over how they are single handedly forcing me to double my workload. STOP. Actually, I don’t apologise at all - Intel really are shite :smiley:

I just dream of the day when we can use one 3D API (or in my case mostly 2D) on multiple platforms. Any intel employees reading this? Shoot yourselfs!!! PLEASE!

Sorry. End of rant.

Mark

It looks strange … today’s intel graphic processor support OpenGL 2.x ! I don’t know it very well but I think that intel windows driver supports OpenGL 2.x if hardware is designed for OpenGL 2.x. If driver on Mac/Intel enables FBO, why windows/Intel can’t do it ?

I think the problem comes from the testing hardware and not from the intel driver. If you find any documentation on non-support OpenGL API of Windows Intel driver, I will be happy to read it :wink:

Intel graphic processors are not so bad since MacOS works perfectly on it !

I don’t know how the Windows drivers are handled, but Apple did a significant amount of work on their Intel drivers, to “raise the bar” as much as possible, and support a common feature set (GLSL, FBO, etc) across all hardware vendors.

There definitely are limitations to the Intel hardware though, which are difficult for the drivers to work around (CLAMP, multisample, float pixels…)

On Windows, the IHV writes the entire GL driver.
On Mac, for OpenGL, a part of it is done by Apple and the IHV just codes a certain mini driver.

If you need to support Intel on Windows, then I recommend using Direct3D.

Zengar shows that a part of driver is done by Apple : GL_APPLE_*, for MacOS convenience I guess. I don’t know about other extensions … it seems to be “classical” OpenGL extensions and thus, support by intel driver, otherwise, I don’t understand why there are not prefixed with GL_APPLE …

You seems to missunderstand what V-man says… The fact is, the OpenGL implementation on Mac is written by Apple. They also write most extensions (like GLSL). The IHV then provides a minimal implementation that does the actual job. Even if the IHV does not provide support of a certain feature, Apple may include it in their driver (either by software emulation or by some other means). That said, I have no idea how the internals of the Apple driver work. It is also possible that Apple wrote the entire Intel driver as well, seeing that information about X3100 is fully open and well-documented.

I see … but it is still stange for me ! I mean that Apple seems to develop only GL_APPLE_* extensions or I am wrong ? Or it it is another Apple secret :slight_smile: If yes, the IHV do most of the job so it is certainly enabled for Windows too.

Sorry, I just try to understand :slight_smile:

Why does it matter which extension Apple develops? Yes, they have a bunch of own extensions. But developing an extension and providing an implementation are two different things. Fact is, Apple has written a large pat of it’s GL implementation, and the IHV only comes where required.

I believe that Apple develops all the features. They code all the logic and management needed to have a GL 2.1 driver and all the other extensions including anything starting with GL_ARB, GL_EXT, GL_NV, GL_INTEL, …
The IHV just codes the part that communicates commands to the hardware.
This is similar to the Direct3D situation on Windows.

Thanks a lot …

I think I don’t see the limit between extension and IHV. Maybe because most of extension are provided by hardware manufacturers as I can see with my NVidia card and Linux driver.

It doesn’t matter which extension Apple develops but It can explain why Intel Windows drivers are not supported OpenGL when hardware could !

One has nothing to do with the other.
IHV = integrated hardware developer. These are the companies like Intel, nVidia, ATI, 3D Labs, SiS, Matrox, …

An extension is just a document that explains something
The list
http://www.opengl.org/registry
Notice that there are extensions written by non-IHVs (IBM, SUN, MESA).

The document is taken by an IHV and implemented into their driver if they think it is worthwhile.