OpenGL 3.2 officially released

The spec is available at http://www.opengl.org/registry/ for both profiles as well as the new GLSL 1.5 spec.

Some of the highlights:

• OpenGL 3.2 comes in 2 “flavors” called profiles. The core profile contains the streamlined, modern OpenGL API, while the compatibility profile contains all of core plus all of the old-world APIs. An implementation of OpenGL 3.2 is required to support core, while compatibility is optional. This profile mechanism replaces the ARB_compatibility extension mechanism for providing deprecated functionality.
• GLSL 1.5, which has numerous improvements (listed below).
• Geometry shaders (ARB_geometry_shader4). I think we all know what this does
• Multisampled textures and texture samplers (allows access to specific multi-sampling samples) (ARB_texture_multisample). This is useful for a wide range of applications, including efficient depth peeling, K-buffer emulation and multi-sampled deferred shading.
• Fragment depth clamping (ARB_depth_clamp). Useful for a number of algorithms, such as shadow volumes.
• Fence objects (ARB_sync or APPLE_fence). Allows finer-grained pipeline synchronization and non-blocking “are you done” queries.
• Seamless cube map filtering (ARB_seamless_cube_map). This functionality allows the GPU to sample from adjacent faces for a given cube map sampling operation in order to compute a seamless filtered sample. Without this functionality, any samples falling outside of the selected cube map face are subject to the normal texture wrapping mode (e.g. CLAMP_TO_EDGE, etc.), which leads to seams appearing between the cube map faces.

There are also a number of new features that are designed specifically to make it easier to port Direct3D code or to re-use assets designed for Direct3D. Some of those include:

• BGRA vertex component ordering (ARB_vertex_array_bgra). This is basically the standard Direct3D ordering.
• Modification of the base vertex index (ARB_draw_elements_base_vertex). This adds a variant DrawElements function which allows to specify an offset that is to be added to every index. This in turn allows to have “relocatable” indexed meshes: a particular indexed mesh, for which you have the index array, can be relocated anywhere inside any number of vertex arrays. All you need to know is the new base offset of the mesh inside the vertex array that is to be used by a particular draw call. This is a direct equivalent of BaseVertexIndex in Direct3D 9 and BaseVertexLocation in Direct3D 10.
• Configurable fragment center coordinates (ARB_fragment_coord_conventions). This basically lets you configure the fragment center and origin for fragment processing (e.g. fragment shaders). With this extension, you can adopt the Direct3D 9 conventions (pixel center at <0.0, 0.0> and origin at upper-left corner of window) or the Direct3D 10 conventions (pixel center at <0.5, 0.5> and origin at upper-left corner of window). This does not affect rasterization or transformation (which you can modify using existing OpenGL state).
• Provoking vertex control (ARB_provoking_vertex). Quoting the extension, “[t]he provoking vertex of a primitive is the vertex that determines the constant primary and secondary colors when flat shading is enabled”. In OpenGL, the last vertex is the provoking vertex (with the exception of polygon primitives), whereas it is the first vertex in Direct3D. This lets you instruct OpenGL to use the first vertex.

As for GLSL 1.5, some of the highlights include:

• Geometry shader support. This was previously provided by extensions, now it’s in the core spec.
• New gl_PrimitiveID as an input to fragment shaders (relevant when using geometry shading or instancing).
• New determinant built-in function.
• Vertex shader inputs (e.g. vertex attributes) can now be arrays.
• Vertex shader outputs, geometry shader inputs and outputs as well as fragment shader inputs can now be structures.
• The “interface blocks” mechanism introduced in GLSL 1.4 to support uniform buffer objects has been expanded to include in and out interfaces as well (e.g. vertex attributes and varyings).
• New origin_upper_left and pixel_center_integer qualifiers for gl_FragCoord, to match the configurable fragment center coordinates functionality.
• New sampler types for multi-sampled texture sampling.

Perhaps the most dramatic change to the language are interface blocks, which is an extension of the uniform block functionality introduced in GLSL 1.4 to support uniform buffer objects. Right now, it is illegal to have an input block in a vertex shader or an output block in a fragment shader, so they are mainly used to define coarse granularity backing of interface data (e.g. varyings) between vertex, geometry and fragment shaders. Uniform blocks are shared across all shader types and can be backed by buffer objects, which is how OpenGL expresses Direct3D 10 constant buffers.

Update: More information about the release and some new extensions at http://www.g-truc.net/#news0170.