| OpenGL ES | OpenGL | OpenGL ES detail | OpenGL Detail |
| 1.0 (1992) | First release | ||
| 1.1 (1997) | Vertex arrays | ||
| 1.2 (1998) | 3D textures | ||
| 1.2.1 (1998) | This version defines ARB extensions concept. ARB extensions are not required to be supported by a conformant OpenGL implementation, but are expected to be widely available; they define functionality that is likely to move into the required feature set in a future revision of the specification. GL implementations of such later revisions should continue to export the name strings of promoted extensions in the EXTENSIONS string, and continue to support the ARB-affixed versions of functions and enumerants as a transition aid. | ||
| OpenGL ES 1.0 (2003.07) OpenGL SC 1.0 (2005.06) | 1.3 (2001) | enabling software rendering and basic hardware acceleration | Compressed textures |
| 1.4 (2002) | Automatic mipmap generation | ||
| 1.1 (2004) | 1.5 (2003) | Compatible with 1.0 Improved image quanlity and optimizations to increase performance while reducing memory bandwidth usage to save power In addtion to features of OpenGL ES 1.0, OpenGL ES 1.1 adds: Buffer objects OpenGL 1.5 as a reference Auto mipmap generation Enhanced texture processing Vertex skinning functionality User-defined clip planes Enhanced point sprites and point sprite arrays Static and Dynamic state queries Draw Texture New Core Additons and Profile Extensions Click here to view detail. | Buffer objects |
| OpenGL ES 2.0 (2007.03) OpenGL SC 2.0 (2016.04) | 2.0 (2004) | OpenGL 2.0 as a reference OpenGL ES Shading Language Programmable Pipeline of OpenGL 2.0 replaces the fixed function transformation and fragment pipeline of OpenGL 1.x. Wider range of precision options for use in embedded devices Frame Buffer Objects Not 100% backward compatible with OpenGL ES 1.x Click here to view detail Some incompatibilities between the desktop version of OpenGL and OpenGL ES 2.0 persisted until OpenGL 4.1, which added the GL_ARB_ES2_compatibility extension. | Shader objects |
| 2.1 (2006) | Pixel buffer objects | ||
| 3.0 (2008) | New context creation mechanism Full and forward compatible context Profiles Mapping buffer subranges into client space Single- and double-channel (R and RG) internal formats for textures and renderbuffers Click here to view detail | ||
| 3.1 (2009) | All features deprecated in OpenGL 3.0 are removed except wide lines | ||
| 3.2 (2009) | Core and compatibility profiles | ||
| 3.3 (2010) | Addition Core Extension Shading language 3.30 ARB_shader_bit_encoding Dual-source blending. ARB_blend_func_extended Shader-defined locations for attributes and fragment shader outputs. ARB_explicit_attrib_location Simple boolean Occlusion Query ARB_occlusion_query2 Sampler Objects ARB_sampler_objects A new image format for unsigned 10.10.10.2 colors ARB_texture_rgb10_a2ui Texture swizzle ARB_texture_swizzle Timer queries ARB_timer_query Instanced arrays ARB_instanced_arrays Vertex attributes 2.10.10.10 ARB_vertex_type_2_10_10_10_rev | ||
| 4.0 (2010) | Addition Core Extension Shading language 4.00 ARB_texture_query_lod, ARB_gpu_shader5, ARB_gpu_shader_fp64, ARB_shader_subroutine, ARB_texture_gather Indirect Drawing, without multidraw ARB_draw_indirect Request minimum number of fragment inputs ARB_sample_shading Tessellation, with shader stages ARB_tessellation_shader Buffer Texture formats RGB32F, RGB32I, RGB32UI ARB_texture_buffer_object_rgb32 Cubemap Array Texture ARB_texture_cube_map_array Transform Feedback objects and multiple feedback stream output. ARB_transform_feedback2, ARB_transform_feedback3 Addition Promoted from Individual blend equations for each color output ARB_draw_buffers_blend | ||
| 4.1 (2010) | Addition Core Extension Query and load a binary blob for program objects ARB_get_program_binary Ability to bind programs individually to programmable stages ARB_separate_shader_objects Pulling missing functionality from OpenGL ES 2.0 into OpenGL ARB_ES2_compatibility Documents precision requirements for several FP operations ARB_shader_precision Provides 64-bit floating-point component vertex attributes ARB_vertex_attrib_64_bit Multiple Viewports for the same rendering surface, or one per surface ARB_viewport_array | ||
| 4.2 (2011) | Addition Core Extension Allows atomically incrementing/decrementing and fetching of buffer object memory locations from shaders ARB_shader_atomic_counters Allows shaders to read and write images, with few but difficult restrictions ARB_shader_image_load_store Allows texture objects to have immutable storage, and allocating all mipmap levels and images in one call. The storage becomes immutable, but the contents of the storage are not ARB_texture_storage Allows instanced rendering of data written by transform feedback operations ARB_transform_feedback_instanced Allows the setting of Uniform Buffer Object and sampler binding points directly from GLSL, among many other small changes ARB_shading_language_420pack Allows instanced rendering with a starting instance value. ARB_base_instance Allows the user to detect the maximum number of samples possible for a particular image format and texture type ARB_internalformat_query Allows for sub-rectangle selection when transferring compressed texture data. ARB_compressed_texture_pixel_storage Allows unpacking 16-bit floats from a 32-bit unsigned integer value in shaders. ARB_shading_language_packing Allows querying of the alignment for pointers returned from buffer object mapping operations ARB_map_buffer_alignment Allows explicitly defining how a fragment shader will modify the depth value, so that the system can optimize these cases better ARB_conservative_depth Addition Promoted from Allows the use of BPTC compressed image formats. ARB_texture_compression_BPTC | ||
| 3.0 (2012.08) | 4.3 (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. 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[12] 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. | Addition Core Extension Debug messaging KHR_debug GLSL multidimensional arrays ARB_arrays_of_arrays Clear Buffer Objects to specific values, ala memset ARB_clear_buffer_object Arbitrary Compute Shaders ARB_compute_shader Arbitrary image copying ARB_copy_image Compatibility with OpenGL ES 3.0 ARB_ES3_compatibility Specifying uniform locations in a shader ARB_explicit_uniform_location Layer and viewport indices available from the fragment shader ARB_fragment_layer_viewport Rendering to a Framebuffer Object that has no attachments ARB_framebuffer_no_attachments Generalized queries for information about Image Formats ARB_internalformat_query2 Texture, buffer object, and framebuffer invalidation. ARB_invalidate_subdata Issuing multiple indirect rendering commands from a single drawing command. ARB_multi_draw_indirect Improved API for getting info about program object interfaces ARB_program_interface_query Get size of images from GLSL ARB_shader_image_size Buffer object read-write access from shader, via a uniform-block style mechanism ARB_shader_storage_buffer_object Accessing the stencil values from a depth/stencil texture ARB_stencil_texturing Buffer Textures can now be bound to a range of a buffer object rather than the whole thing ARB_texture_buffer_range GLSL can detect the available mipmap pyramid of a sampler or image ARB_texture_query_levels Immutable storage for multisample textures ARB_texture_storage_multisample The ability to create a new texture, with a new internal format, that references an existing texture's storage ARB_texture_view Separation of vertex format from buffer object ARB_vertex_attrib_binding Addition Promoted from More robustness of API ARB_robust_buffer_access_behavior, ARB_robustness_isolation, WGL_ARB_robustness_isolation, GLX_ARB_robustness_isolation EAC and ETC compressed image formats. |
| 4.4 (2013) | Addition Core Extension Immutable storage for buffer objects, including the ability to use buffers while they are mapped. ARB_buffer_storage Direct clearing of a texture image. ARB_clear_texture A number of enhancements to layout qualifiers: Integer layout qualifiers can take any constant expression, not just integer literals. Explicit layout requests for buffer-backed interface blocks. Tight packing of disparate input/output variables. In-shader specification of transform feedback parameters. Locations can be set on input/output interface blocks, for packing purposes. ARB_enhanced_layouts Bind an array of objects of the same type to a sequential range of indexed binding targets in one call. ARB_multi_bind Values from Query Objects values can be written to a buffer object instead of directly to client memory. ARB_query_buffer_object A special clamping mode that doubles the size of the texture in each dimension, mirroring it exactly once in the negative texture coordinate directions. ARB_texture_mirror_clamp_to_edge One of the stencil-only image formats can be used for textures, and 8-bit stencil is a required format. ARB_texture_stencil8 Provides a packed, 3-component 11F/11F/10F format for vertex attributes. ARB_vertex_type_10f_11f_11f_rev While a number of features made it into core OpenGL, a number of other features were left to specific extensions. These offer certainly functionality that lesser 4.x hardware would be unable to handle. | ||
| 3.1 (2014.03) | 4.5 (2014) | New functionality in OpenGL ES 3.1 includes: Compute shaders Independent vertex and fragment shaders Indirect draw commands OpenGL ES 3.1 is backward compatible with OpenGL ES 2.0 and 3.0, thus enabling applications to incrementally incorporate new features. | Addition Core Extension Additional clip control modes to configure how clip space is mapped to window space. ARB_clip_control Adds a new GLSL gl_CullDistance shader output, similar to gl_ClipDistance, but used for whole primitive culling. ARB_cull_distance Compatibility with OpenGL ES 3.1 ARB_ES3_1_compatibility Adds new modes to glBeginConditionalRender which invert condition used to determine whether to draw or not. ARB_conditional_render_inverted Provides control over the spacial granularity at which the underlying implementation computes derivatives. ARB_derivative_control Allows modifying and querying object state without binding objects. ARB_direct_state_access Adds a new function to get sub-regions of texture images. ARB_get_texture_sub_image Upgrades the ARB_robustness functionality to meet ES 3.1 standards. KHR_robustness Provides GLSL built-in functions allowing shaders to query the number of samples of a texture. ARB_shader_texture_image_samples Relaxes the restrictions on rendering to a currently bound texture and provides a mechanism to avoid read-after-write hazards. ARB_texture_barrier |
| 3.2 (2015.08) | 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. | ||
| Vulkan (2016) | Vulkan, formerly named the "Next Generation OpenGL Initiative" (glNext),is a grounds-up redesign effort to unify OpenGL and OpenGL ES into one common API that will not be backwards compatible with existing OpenGL versions. | ||
History of OpenGL
https://www.opengl.org/wiki/History_of_OpenGL
https://www.opengl.org/wiki/OpenGL_ES
https://en.m.wikipedia.org/wiki/OpenGL
https://en.m.wikipedia.org/wiki/OpenGL_ES
OpenGL ES 1.1 adds:
https://www.khronos.org/opengles/1_X/
Buffer objects provide a mechanism that clients can use to allocate, initialize and render from memory. Buffer objects can be used to store vertex array and element index data.
Auto mipmap generation can offload the application from having to generate mip-levels. Hardware implementations can potentially accelerate auto mip-level generation especially for video textures or when rendering to texture. A texture is considered incomplete in OpenGL ES if the set of mipmap arrays are not specified with the same type. The check for completeness is done when a given texture is used to render geometry.
Enhanced texture processing including a minimum of two multi-textures and texture combiner functionality for effects such as bump-mapping and per-pixel lighting. All OpenGL 1.5 texture environments except for the texture crossbar are supported.
Vertex skinning functionality using the oes_matrix_palette extension allows smooth animation of complex figures and geometries. The extension allow OpenGL ES to support a palette of matrices. The matrix palette defines a set of matrices that can be used to transform a vertex. The matrix palette is not part of the model view matrix stack
User-defined clip planes permit for efficient early culling of non-visible polygons -increasing performance and saving power
Enhanced point sprites and point sprite arrays provides a method for application to draw particles using points instead of quads. This enables efficient and realistic particle effects. The point sprites extension also allows an app to specify texture coordinates that are interpolated across the point instead of the same texture coordinate used by traditional GL points. The Point Size Array extension permits an array of point sizes instead of a fixed input point size and provides flexibility for applications to do particle effects.
Static and Dynamic state queries are supported for static and dynamic state explicitly supported in the profile. The supported GL state queries can be categorized into simple queries, enumerated queries, texture queries, pointer and string queries, and buffer object queries. This enables OpenGL ES to be used in a sophisticated, layered software environment
Draw Texture defines a mechanism for writing pixel rectangles from one or more textures to a rectangular region of the screen. This capability is useful for fast rendering of background paintings, bitmapped font glyphs, and 2D framing elements in games
New Core Additons and Profile Extensions for the Common and Common-Lite profiles add subsets of the OES byte coordinates, OES fixed - point, OES single precision and OES matrix get ES-specific extensions as core additions; OES - read format, OES compressed paletted texture, OES point size array and OES point sprite as required profile extensions; and OES matrix palette and OES draw texture as optional profile extensions.
OpenGL ES 2.0 in more detail
https://www.khronos.org/opengles/2_X/
OpenGL ES 2.0 combines a version of the OpenGL Shading Language for programming vertex and fragment shaders that has been adapted for embedded platforms, together with a streamlined API from OpenGL ES 1.1 that has removed any fixed functionality that can be easily replaced by shader programs, to minimize the cost and power consumption of advanced programmable graphics subsystems.
OpenGL 2.0 as a reference - the specification is defined relative to the OpenGL 2.0 specification.
OpenGL ES Shading Language - adds the same basic shading language as used in OpenGL 2.0, but adapted for embedded platforms.
Programmable Pipeline of OpenGL 2.0 replaces the fixed function transformation and fragment pipeline of OpenGL 1.x. (see diagram below). Using shaders minimize the cost and power of advanced programmable graphics subsystems.
Wider range of precision options for use in embedded devices - adds the same basic shading language as used in OpenGL 2.0.
Frame Buffer Objects - simplify surface management and offer a subset of functionality from the desktop FBO
Not 100% backward compatible with OpenGL ES 1.x - though changes are minimized and removed functionality can be replaced with shade
- New context creation mechanism
- Full and forward compatible context
- Profiles
- Mapping buffer subranges into client space
- Single- and double-channel (R and RG) internal formats for textures and renderbuffers
Addition | |
Framebuffer Objects, along with blitting, Multisample Renderbuffer Objects, and packed depth/stencil image formats | |
Addition | Promoted from |
Floating-point color and depth internal formats for textures and render buffers | ARB_color_buffer_float, NV_depth_buffer_float, ARB_texture_float, EXT_packed_float, EXT_texture_shared_exponent |
Half-float (16-bit) vertex array and pixel data formats | |
Integral Image Formats, which can be fetched as integers rather than being converted to normalized floats. | |
sRGB framebuffer mode |
Deprecation Model
OpenGL 3 specification marks many features as deprecated, which will be removed in next versions. This features include:
- Application-generated object names
- Color index mode
- Shading language 1.10 and 1.20
- Begin/End primitive specification
- Edge flags
- Fixed function vertex processing
- Client-side vertex arrays
- Rectangles
- Current raster position
- Two-sided color selection
- Non-sprite points
- Wide lines and line stripple
- Quadrilateral and polygon primitives
- Separate polygon draw mode
- Polygon stripple
- Pixel transfer modes and operations
- Pixel drawing
- Bitmaps
- Legacy OpenGL 1.0 pixel formats
- Legacy pixel formats
- Depth texture mode
- Texture wrap mode CLAMP
- Texture borders
- Automatic mipmap generation
- Fixed function fragment processing
- Alpha test
- Accumulation buffers
- Context framebuffer size queries
- Evaluators
- Selection and feedback mode
- Display lists
- Hints
- Attribute stacks
- Unified extension string
