Vertex arrays
Polygon offset
Logical operation
Internal texture formats
GL_REPLACE texture env
Texture proxy
Copy texture and subtexture
Texture objects
3D textures
BGRA pixel formats
Packed pixel formats
Normal rescaling
Separate specular color
Texture coordinate edge clamping
Texture LOD control
Vertex array draw element range
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 SC 1.0 (2005.06)
Compressed textures
Cube map textures
Multisample
Multitexture
Texture add env mode
Texture combine env mode
Texture dot3 env mode
Texture border clamp
Transpose matrix
Automatic mipmap generation
Blend squaring
Depth textures and shadows
Fog coordinate
Multiple draw arrays
Point parameters
Secondary color
Separate blend functions
Stencil wrap
Texture crossbar env mode
Texture LOD bias
Texture mirrored repeat
Window raster position
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
Occlusion query
Shadow functions
OpenGL SC 2.0 (2016.04)
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
Shader programs
Shading language 1.10
Multiple render targets
Non-power-of-two textures
Separate stencil
Pixel buffer objects
sRGB textures
Shading language 1.20:
·Non-square matrices in GLSL.
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
All features deprecated in OpenGL 3.0 are removed except wide lines
Shading language 1.40
SNORM texture component formats
Addition Core Extension
Uniform Buffer Objects ARB_uniform_buffer_object
Addition Promoted from
Instanced rendering with a per instance counter accessible to vertex shaders ARB_draw_instanced
Data copying between buffer objects EXT_copy_buffer
Primitive restart NV_primitive_restart
Buffer Textures ARB_texture_buffer_object
Rectangle Textures ARB_texture_rectangle
Core and compatibility profiles
Shading language 1.50
Addition Core Extension
D3D compatible color vertex component ordering ARB_vertex_array_bgra
Drawing command allowing modification of the base vertex index ARB_draw_elements_base_vertex
Shader fragment coordinate convention control ARB_fragment_coord_conventions
Provoking vertex control ARB_provoking_vertex
Seamless cube map filtering ARB_seamless_cube_map
Multisampled textures and texture samplers for specific sample locations ARB_texture_multisample
Fragment Depth Clamping ARB_depth_clamp
Fence sync objects ARB_sync
Addition Promoted from
Geometry Shaders, as well as input/output Interface Blocks ARB_geometry_shader4, heavily modified.
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
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
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
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
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.
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.
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.
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.
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
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.
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
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
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: