|28 July 2003; 14 years ago (2003-07-28)|
3.2 / 10 August 2015; 2 years ago (2015-08-10)
|Free of charge, royalty or licensing|
OpenGL for Embedded Systems (OpenGL ES or GLES) is a subset of the OpenGL computer graphics rendering application programming interface (API) for rendering 2D and 3D computer graphics such as those used by video games, typically hardware-accelerated using a graphics processing unit (GPU). It is designed for embedded systems like smartphones, tablet computers, video game consoles and PDAs. OpenGL ES is the "most widely deployed 3D graphics API in history".
The API is cross-language and multi-platform. The libraries GLUT and GLU are not available for OpenGL ES. OpenGL ES is managed by the non-profit technology consortium Khronos Group. Vulkan, a next-generation API from Khronos, is made for simpler high performance drivers for mobile and desktop devices.
Several versions of the OpenGL ES specification now exist. OpenGL ES 1.0 is drawn up against the OpenGL 1.3 specification, OpenGL ES 1.1 is defined relative to the OpenGL 1.5 specification and OpenGL ES 2.0 is defined relative to the OpenGL 2.0 specification. This means that, for example, an application written for OpenGL ES 1.0 should be easily portable to the desktop OpenGL 1.3; as the OpenGL ES is a stripped-down version of the API, the reverse may or may not be true, depending on the particular features used.
Version 1.0 and 1.1 both have common (CM) and common lite (CL) profiles, the difference being that the common lite profile only supports fixed-point instead of floating point data type support, whereas common supports both.
OpenGL ES 1.0
OpenGL ES 1.0 was released publicly July 28, 2003. OpenGL ES 1.0 is based on the original OpenGL API, with much functionality removed and a little bit added. One significant difference between OpenGL and OpenGL ES is that OpenGL ES removed the need to bracket OpenGL library calls with
glEnd. Other significant differences are that the calling semantics for primitive rendering functions were changed in favor of vertex arrays, and fixed-point data types were introduced for vertex coordinates. Attributes were also added to better support the computational abilities of embedded processors, which often lack a floating point unit (FPU). Many other functions and rendering primitives were removed in version 1.0 to produce a lightweight interface, including:
- quad and polygon rendering primitives,
- texgen, line and polygon stipple,
- polygon mode and antialiased polygon rendering are not supported, although rendering using multisample is still possible (rather than alpha border fragments),
ARB_Imagepixel class operation are not supported, nor are bitmaps or 3D textures,
- several of the more technical drawing modes are eliminated, including frontbuffer and accumulation buffer. Bitmap operations, specifically copying pixels (individually) is not allowed, nor are evaluators, nor (user) selection operations,
- display lists and feedback are removed, as are push and pop operations for state attributes,
- some material parameters were removed, including back-face parameters and user defined clip planes.
OpenGL ES 1.1
OpenGL ES 1.1 added features such as mandatory support for multitexture, better multitexture support (including combiners and dot product texture operations), automatic mipmap generation, vertex buffer objects, state queries, user clip planes, and greater control over point rendering.
OpenGL ES 2.0
OpenGL ES 2.0 was publicly released in March 2007. It is based roughly on OpenGL 2.0, but it eliminates most of the fixed-function rendering pipeline in favor of a programmable one in a move similar to transition from OpenGL 3.0 to 3.1. Control flow in shaders is generally limited to forward branching and to loops where the maximum number of iterations can easily be determined at compile time. Almost all rendering features of the transform and lighting stage, such as the specification of materials and light parameters formerly specified by the fixed-function API, are replaced by shaders written by the graphics programmer. As a result, OpenGL ES 2.0 is not backward compatible with OpenGL ES 1.1. Some incompatibilities between the desktop version of OpenGL and OpenGL ES 2.0 persisted until OpenGL 4.1, which added the
The Khronos Group has written a document describing the differences between OpenGL ES 2.0 and ordinary OpenGL 2.0.
OpenGL ES 3.0
The OpenGL ES 3.0 specification was publicly released in August 2012. OpenGL ES 3.0 is backwards compatible with OpenGL ES 2.0, enabling applications to incrementally add new visual features to applications. OpenGL 4.3 provides full compatibility with OpenGL ES 3.0. Version 3.0 is also the basis for WebGL 2.0.
New functionality in the OpenGL ES 3.0 specification includes:
- multiple enhancements to the rendering pipeline to enable acceleration of advanced visual effects including: occlusion queries, transform feedback, instanced rendering and support for four or more rendering targets,
- high quality ETC2 / EAC texture compression as a standard feature, eliminating the need for a different set of textures for each platform,
- a new version of the GLSL ES shading language with full support for integer and 32-bit floating point operations;
- greatly enhanced texturing functionality including guaranteed support for floating point textures, 3D textures, depth textures, vertex textures, NPOT textures, R/RG textures, immutable textures, 2D array textures, swizzles, LOD and mip level clamps, seamless cube maps and sampler objects,
- an extensive set of required, explicitly sized texture and render-buffer formats, reducing implementation variability and making it much easier to write portable applications.
OpenGL ES 3.1
The OpenGL ES 3.1 specification was publicly released in March 2014. New functionality in OpenGL ES 3.1 includes:
OpenGL ES 3.1 is backward compatible with OpenGL ES 2.0 and 3.0, thus enabling applications to incrementally incorporate new features.
|ARB_arrays_of_arrays.txt||ARB Extension #120||Multi-dimensional arrays are a frequently requested feature. This extension removes the restriciton that arrays cannot be formed into arrays, allowing arrays of arrays to be declared.|
|ARB_compute_shader.txt||ARB Extension #122||This extension interacts with OpenGL 4.3, ARB_shader_storage_buffer_object and NV_vertex_buffer_unified_memory.|
|ARB_explicit_uniform_location.txt||ARB Extension #128||Requires OpenGL 3.3 or ARB_explicit_attrib_location. This extension interacts with ARB_shader_subroutine.|
|ARB_framebuffer_no_attachments.txt||ARB Extension #130||OpenGL 3.0 or ARB_framebuffer_object is required. This extension interacts with OpenGL 3.0, EXT_texture_array and EXT_direct_state_access.|
|ARB_program_interface_query.txt||ARB Extension #134||This extension provides a single unified set of query commands that can be used by applications to determine properties of various interfaces and resources used by program objects to communicate with application code, fixed-function OpenGL pipeline stages, and other programs.|
|ARB_shader_atomic_counters.txt||ARB Extension #114||This extension provides a set of atomic counters.|
|ARB_shader_image_load_store.txt||ARB Extension #115||This extension provides GLSL built-in functions allowing shaders to load from, store to, and perform atomic read-modify-write operations to a single level of a texture object from any shader stage.|
|ARB_shader_storage_buffer_object.txt||ARB Extension #137||his extension provides the ability for OpenGL shaders to perform random access reads, writes, and atomic memory operations on variables stored in a buffer object.|
|ARB_separate_shader_objects.txt||ARB Extension #97||This extension adopts a "mix-and-match" shader stage model for GLSL allowing multiple different GLSL program objects to be bound at once each to an individual rendering pipeline stage independently of other stage bindings. This allows program objects to contain only the shader stages that best suit the applications needs.|
|ARB_stencil_texturing.txt||ARB Extension #138||This extension allows texturing of the stencil component of a packed depth stencil texture.|
|ARB_vertex_attrib_binding.txt||ARB Extension #125||This extension allows the application to change the mapping between attributes and bindings, which can make it more efficient to update vertex buffer bindings for interleaved vertex formats where many attributes share the same buffer.|
|ARB_draw_indirect.txt||ARB Extension #87||This extension provides a mechanism for supplying the arguments to a DrawArraysInstanced or DrawElementsInstancedBaseVertex from buffer object memory.|
|ARB_shading_language_packing.txt||ARB Extension #116||This extension provides the GLSL built-in functions to convert a 32-bit unsigned integer holding a pair of 16-bit floating-point values to or from a two-component floating-point vector (vec2).|
|ARB_shader_image_size.txt||ARB Extension #136||This extension provides GLSL built-in functions allowing shaders to query the size of an image.|
|ARB_texture_storage_multisample.txt||ARB Extension #141||The ARB_texture_storage extension and OpenGL 4.2 introduced the concept of immutable texture objects.|
|ARB_texture_multisample.txt||ARB Extension #67||This extension provides support for two new types of "multisample textures" - two-dimensional and two-dimensional array - as well as mechanisms to fetch a specific sample from such a texture in a shader, and to attach such textures to FBOs for rendering.|
|EXT_shader_integer_mix.txt||OpenGL ES Extension #161||also OpenGL Extension #437, GLSL 1.30 (and GLSL ES 3.00) expanded the mix() built-in function to operate on a boolean third argument that does not interpolate but selects. This extension extends mix() to select between int, uint, and bool components.|
OpenGL ES 3.2
The OpenGL ES 3.2 specification was publicly released in August 2015. New capabilities in OpenGL ES 3.2 include:
- Geometry and tessellation shaders to efficiently process complex scenes on the GPU.
- Floating point render targets for increased flexibility in higher precision compute operations.
- ASTC compression to reduce the memory footprint and bandwidth used to process textures.
- Enhanced blending for sophisticated compositing and handling of multiple color attachments.
- Advanced texture targets such as texture buffers, multisample 2D array and cube map arrays.
- Debug and robustness features for easier code development and secure execution.
|KHR_blend_equation_advanced.txt||OpenGL ES Extension #168||also ARB Extension #174, This extension adds a number of "advanced" blending equations that can be used to perform new color blending operations, many of which are more complex than the standard blend modes provided by unextended OpenGL.|
|EXT_color_buffer_float.txt||OpenGL ES Extension #137||This extension allows a variety of floating point formats to be rendered to via framebuffer objects.|
|KHR_debug.txt||OpenGL ES Extension #118||also ARB Extension #119, This extension allows the GL to notify applications when various events occur that may be useful during application development, debugging and profiling.|
|KHR_robustness.txt||OpenGL ES Extension #190||also ARB Extension #170, Several recent trends in how OpenGL ES integrates into modern computer systems have created new requirements for robustness and security for GL rendering contexts.|
|OES_copy_image.txt||OpenGL ES Extension #208||This extension enables efficient image data transfer between image objects (i.e. textures and renderbuffers) without the need to bind the objects or otherwise configure the rendering pipeline.|
|OES_draw_buffers_indexed.txt||OpenGL ES Extension #209||OpenGL ES 3.0 or EXT_draw_buffers is required. This extension builds upon the EXT_draw_buffers extension.|
|OES_draw_elements_base_vertex.txt||OpenGL ES Extension #219||Requires OpenGL ES 2.0, interacts with OpenGL ES 3.1 and OpenGL ES 3.0. This extension interacts with EXT_draw_instanced, NV_draw_instanced, EXT_instanced_arrays, ANGLE_instanced_arrays, NV_instanced_arrays, EXT_multi_draw_arrays.|
|OES_geometry_shader.txt||OpenGL ES Extension #210||OES_geometry_shader defines a new shader type available to be run on the GPU, called a geometry shader. Geometry shaders are run after vertices are transformed, but prior to color clamping, flatshading and clipping.|
|OES_gpu_shader5.txt||OpenGL ES Extension #211||This extension interacts with OES_geometry_shader.|
|OES_sample_shading.txt||OpenGL ES Extension #169||This extension requires OES_sample_variables.|
|OES_sample_variables.txt||OpenGL ES Extension #170||This extension interacts with OES_sample_shading and with OES_shader_multisample_interpolation. This extension allows fragment shaders more control over multisample rendering.|
|OES_shader_image_atomic.txt||OpenGL ES Extension #171||This extension provides built-in functions allowing shaders to perform atomic read-modify-write operations to a single level of a texture object from any shader stage.|
|OES_shader_io_blocks.txt||OpenGL ES Extension #213||This extension extends the functionality of interface blocks to support input and output interfaces in the OpenGL ES Shading Language.|
|OES_shader_multisample_interpolation.txt||OpenGL ES Extension #172||This extension provides built-in fragment shader functions to provide fine-grained control over interpolation, including interpolating a fragment shader input at a programmable offset relative to the pixel center, a specific sample number, or at the centroid.|
|OES_tessellation_shader.txt||OpenGL ES Extension #214||This extension introduces new tessellation stages and two new shader types to the OpenGL ES primitive processing pipeline.|
|OES_texture_border_clamp.txt||OpenGL ES Extension #215||OpenGL ES provides only a single clamping wrap mode: CLAMP_TO_EDGE. However, the ability to clamp to a constant border color can be useful to quickly detect texture coordinates that exceed their expected limits or to dummy out any such accesses with transparency or a neutral color in tiling or light maps.|
|OES_texture_buffer.txt||OpenGL ES Extension #216||This extension provides a new texture type, called a buffer texture. Buffer textures are one-dimensional arrays of texels whose storage comes from an attached buffer object.|
|OES_texture_cube_map_array.txt||OpenGL ES Extension #217||This extension expands texture array support to include cube map textures.|
|OES_texture_stencil8.txt||OpenGL ES Extension #173||This extension accepts STENCIL_INDEX8 as a texture internal format, and adds STENCIL_INDEX8 to the required internal format list. This removes the need to use renderbuffers if a stencil-only format is desired.|
|OES_texture_storage_multisample_2d_array.txt||OpenGL ES Extension #174||This extension provides support for a new type of immutable texture, two-dimensional multisample array textures.|
|KHR_texture_compression_astc_ldr.txt||OpenGL ES Extension #117||also ARB Extension #118, here ldr profile only. Adaptive Scalable Texture Compression (ASTC) is a new texture compression technology that offers unprecendented flexibility, while producing better or comparable results than existing texture compressions at all bit rates. It includes support for 2D and slice-based 3D textures, with low and high dynamic range, at bitrates from below 1 bit/pixel up to 8 bits/pixel in fine steps.|
|OES_primitive_bounding_box.txt||OpenGL ES Extension #212||This extension provides a way for implementations to know which tiles incoming geometry will intersect before fully transforming (and expanding) the geometry. This allows them to only store the unexpanded geometry in memory, and perform expansion on-chip for each intersected tile.|
Some more extensions are developed or in Development in Mesa for next OpenGL ES Version (see Mesamatrix).
For complete list of companies and their conformant products, view here
OpenGL ES 1.0
OpenGL ES 1.0 added an official 3D graphics API to the Android and Symbian operating systems, as well as by QNX It is also supported by the PlayStation 3 as one of its official graphics APIs (the other one being low level libgcm library) with Nvidia's Cg in lieu of GLSL. The PlayStation 3 also includes several features of the 2.0 version of OpenGL ES.
OpenGL ES 1.1
The 1.1 version of OpenGL ES is supported by:
OpenGL ES 2.0
OpenGL ES 3.0
- Android since version 4.3, on devices with appropriate hardware and drivers, including:
- iOS since version 7, on devices including:
- BlackBerry 10 OS since version 10.2, on devices including:
Supported by some recent versions of these GPUs:
OpenGL ES 3.1
Supported by Windows, Linux, Android (since version 5.0) on devices with appropriate hardware and drivers, including:
Android Extension Pack
Android Extension Pack is a set of OpenGL ES 3.1 extensions, all bundled into a single extension introduced by Google in 2014. This allows applications to use all of the features of the set of extensions, while only testing for the presence of a single one. The AEP was officially added to Android Lollipop to provide extra features like tessellation over what was officially in the GLES 3.1 revision. OpenGL ES 3.2 update is largely made up of the AEP additions, which are already present in desktop OpenGL.
OpenGL ES 3.2
OpenGL ES 3.2 works mostly on the same hardware as OpenGL 3.1. It incorporates Android Extension Pack (AEP) into it: "OpenGL ES 3.2 boasts a small number of improvements over last year’s OpenGL ES 3.1. Both make use of similar features from the AEP. From the AEP, OpenGL ES 3.2 compliant hardware will support Tessellation for additional geometry detail, new geometry shaders, ASTC texture compression for a smaller memory bandwidth footprint, floating point render targets for high accuracy compute processes, and new debugging features for developers. These high-end features are already found in the group’s full OpenGL 4 specification."
Supported by Windows, Linux, Android (since version 6.0) on devices with appropriate hardware and drivers, including:
- Adreno 420 and newer (Android)
- Mali-T760 and newer (Android)
- Nvidia GeForce 400 series (Fermi) and newer (Windows, Linux)
|This section needs expansion.|
|Wikibooks has a book on the topic of: OpenGL Programming/OpenGL ES Overview|