OpenGL

Original author(s) Silicon Graphics

Developer(s) formerly: ARBnow: Khronos Group

Initial release January 1992

Stable release 4.5 / August 11, 2014

Written in C[1]

Operating system Cross­platform

Platform Cross­platform

Type API

License Various[2]

Website www.opengl.org(https://www.opengl.org/)

Video games outsource real­time renderingcalculations to the GPU over OpenGL. Therendered results are not sent back, and are insteadstored in a framebuffer whose content is sent to thedisplay controller.

OpenGLFrom Wikipedia, the free encyclopedia

OpenGL (Open Graphics Library)[3][4][5] is a cross­language, multi­platform application programminginterface (API) for rendering 2D and 3D vector graphics.The API is typically used to interact with a graphicsprocessing unit (GPU), to achieve hardware­acceleratedrendering.

Silicon Graphics Inc. (SGI) started developing OpenGL in1991 and released it in January 1992;[6] applications use itextensively in the fields of CAD, virtual reality, scientificvisualization, information visualization, flight simulation,and video games. OpenGL is managed by the non­profittechnology consortium Khronos Group.

Contents

1 Design1.1 Development

2 Documentation3 Associated libraries

3.1 Context and window toolkits3.2 Extension loading libraries3.3 Implementations

4 History5 Version history

5.1 OpenGL 1.15.2 OpenGL 1.25.3 OpenGL 1.2.1

5.4 OpenGL 1.35.5 OpenGL 1.45.6 OpenGL 1.55.7 OpenGL 2.05.8 OpenGL 2.15.9 Longs Peak and OpenGL 3.0controversy5.10 OpenGL 3.05.11 OpenGL 3.15.12 OpenGL 3.25.13 OpenGL 3.35.14 OpenGL 4.05.15 OpenGL 4.15.16 OpenGL 4.25.17 OpenGL 4.35.18 OpenGL 4.45.19 OpenGL 4.5

6 Sample renderings7 Successor8 See also9 Further reading10 References11 External links

Design

The OpenGL specification describes an abstract API for drawing 2D and 3D graphics. Although it ispossible for the API to be implemented entirely in software, it is designed to be implemented mostly orentirely in hardware.

The API is defined as a number of functions which may be called by the client program, alongside a numberof named integer constants (for example, the constant GL_TEXTURE_2D, which corresponds to thedecimal number 3553). Although the function definitions are superficially similar to those of the Cprogramming language, they are language­independent. As such, OpenGL has many language bindings,some of the most noteworthy being the JavaScript binding WebGL (API, based on OpenGL ES 2.0, for 3Drendering from within a web browser); the C bindings WGL, GLX and CGL; the C binding provided byiOS; and the Java and C bindings provided by Android.

An illustration of the graphics pipeline process

In addition to being language­independent, OpenGL is also platform­independent. The specification saysnothing on the subject of obtaining, and managing, an OpenGL context, leaving this as a detail of theunderlying windowing system. For the same reason, OpenGL is purely concerned with rendering, providingno APIs related to input, audio, or windowing.

Development

OpenGL is an evolving API. New versions of the OpenGL specifications are regularly released by theKhronos Group, each of which extends the API to support various new features. The details of each versionare decided by consensus between the Group's members, including graphics card manufacturers, operatingsystem designers, and general technology companies such as Mozilla and Google.[7]

In addition to the features required by the core API, GPU vendors may provide additional functionality inthe form of extensions.Extensions may introducenew functions and newconstants, and may relaxor remove restrictions onexisting OpenGLfunctions. Vendors canuse extensions to exposecustom APIs withoutneeding support fromother vendors or theKhronos Group as awhole, which greatlyincreases the flexibility ofOpenGL. All extensionsare collected in, anddefined by, the OpenGLRegistry(http://www.opengl.org/registry/).

Each extension is associated with a short identifier, based on the name of the company which developed it.For example, Nvidia's identifier is NV, which is part of the extension name GL_NV_half_float, the constantGL_HALF_FLOAT_NV, and the function glVertex2hNV().[8] If multiple vendors agree to implement the samefunctionality using the same API, a shared extension may be released, using the identifier EXT. In suchcases, it could also happen that the Khronos Group's Architecture Review Board gives the extension theirexplicit approval, in which case the identifier ARB is used.[9]

The features introduced by each new version of OpenGL are typically formed from the combined features ofseveral widely­implemented extensions, especially extensions of type ARB or EXT.

Documentation

OpenGL's popularity is partially due to the quality of its official documentation. The OpenGL ArchitectureReview Board released a series of manuals along with the specification which have been updated to trackchanges in the API. These are almost universally known by the colors of their covers:

The Red BookOpenGL Programming Guide, 8th Edition. ISBN 0­321­77303­9A tutorial and reference book.

The Orange BookOpenGL Shading Language, 3rd edition. ISBN 0­321­63763­1A tutorial and reference book for GLSL.

Historic books (pre­OpenGL 2.0):

The Green BookOpenGL Programming for the X Window System. ISBN 0­201­47334­5A book about X11 interfacing and GLUT.

The Blue BookOpenGL Reference manual, 4th edition. ISBN 0­321­17383­XEssentially a hard­copy printout of the man pages for OpenGL.Includes a poster­sized fold­out diagram showing the structure of an idealised OpenGLimplementation.

The Alpha Book (white cover)OpenGL Programming for Windows 95 and Windows NT. ISBN 0­201­40709­4A book about interfacing OpenGL with Microsoft Windows.

Associated libraries

The earliest versions of OpenGL were released with a companion library called GLU, the OpenGL UtilityLibrary. It provided simple, useful features which were unlikely to be supported in contemporary hardware,such as mipmap generation, tessellation, and generation of primitive shapes. The GLU specification was lastupdated in 1998, and the latest version depends on features which were deprecated with the release ofOpenGL 3.1 in 2009.[10]

Context and window toolkits

Given that creating an OpenGL context is quite a complex process, and given that it varies betweenoperating systems, automatic OpenGL context creation has become a common feature of several game­development and user­interface libraries, including SDL, Allegro, SFML, FLTK, and Qt. A few librarieshave been designed solely to produce an OpenGL­capable window. The first such library was GLUT (latersuperseded by freeglut). GLFW is a newer alternative.[11]

These toolkits are designed specifically around creating and managing OpenGL windows. They also

manage input, but little beyond that.[12]

GLFW — A crossplatform windowing and keyboard/mouse/joystick handler. Is more aimed forcreating games.freeglut — A crossplatform windowing and keyboard/mouse handler. Its API is a superset of theGLUT API, and it is more stable and up to date than GLUT.GLUT — An old windowing handler, no longer maintained.

Several "multimedia libraries" can create OpenGL windows, in addition to input, sound and othertasks useful for game­like applications.

Allegro 5 — A cross­platform multimedia library with a C API focused on game development.SDL — A cross­platform multimedia library with a C API.SFML — A cross­platform multimedia library with a C++ API.

Widget toolkits

FLTK — A small cross­platform C++ widget library.Qt — A cross­platform C++ widget toolkit. It provides a number of OpenGL helper objects,which even abstract away the difference between desktop GL and OpenGL ES.wxWidgets — A cross­platform C++ widget toolkit.

Extension loading libraries

Given the high workload involved in identifying and loading OpenGL extensions, a few libraries have beendesigned which load all available extensions and functions automatically. Examples include GLEE, GLEWand glbinding. Extensions are also loaded automatically by most language bindings, such as JOGL andPyOpenGL.

Implementations

Mesa 3D is an open source implementation of OpenGL. It can do pure software rendering, and it may alsouse hardware acceleration on the Linux platform by taking advantage of the Direct Rendering Infrastructure.As of version 10.0, it implements version 3.3 of the OpenGL standard.[13]

History

In the 1980s, developing software that could function with a wide range of graphics hardware was a realchallenge. Software developers wrote custom interfaces and drivers for each piece of hardware. This wasexpensive and resulted in multiplication of effort.

By the early 1990s, SGI was a leader in 3D graphics for workstations. Their IRIS GL API[14] was consideredstate­of­the­art and became the de facto industry standard, overshadowing the open standards­based PHIGS.This was because IRIS GL was considered easier to use, and because it supported immediate moderendering. By contrast, PHIGS was considered difficult to use and outdated in terms of functionality.

SGI's competitors (including Sun Microsystems, Hewlett­Packard and IBM) were also able to bring tomarket 3D hardware, supported by extensions made to the PHIGS standard. This in turn caused SGI marketshare to weaken as more 3D graphics hardware suppliers entered the market. In an effort to influence themarket, SGI decided to turn the IrisGL API into an open standard ­ OpenGL.

However, SGI had a large number of software customers for whom the change from IrisGL to OpenGLwould require significant investment. Moreover, IrisGL had API functions that were not relevant to 3Dgraphics. For example, it included a windowing, keyboard and mouse API, in part because it was developedbefore the X Window System and Sun's NeWS systems were developed. And, IrisGL libraries wereunsuitable for opening due to licensing and patent issues. These factors required SGI to continue to supportthe advanced and proprietary Iris Inventor and Iris Performer programming APIs while market support forOpenGL matured.

One of the restrictions of IrisGL was that it only provided access to features supported by the underlyinghardware. If the graphics hardware did not support a feature, then the application could not use it. OpenGLovercame this problem by providing support in software for features unsupported by hardware, allowingapplications to use advanced graphics on relatively low­powered systems. OpenGL standardized access tohardware, pushed the development responsibility of hardware interface programs (sometimes called devicedrivers) to hardware manufacturers, and delegated windowing functions to the underlying operating system.With so many different kinds of graphics hardware, getting them all to speak the same language in this wayhad a remarkable impact by giving software developers a higher level platform for 3D­softwaredevelopment.

In 1992,[15] SGI led the creation of the OpenGL Architecture Review Board (OpenGL ARB), the group ofcompanies that would maintain and expand the OpenGL specification in the future.

In 1994, SGI played with the idea of releasing something called "OpenGL++" which included elements suchas a scene­graph API (presumably based on their Performer technology). The specification was circulatedamong a few interested parties – but never turned into a product.[16]

Microsoft released Direct3D in 1995, which eventually became the main competitor of OpenGL. OnDecember 17, 1997,[17] Microsoft and SGI initiated the Fahrenheit project, which was a joint effort with thegoal of unifying the OpenGL and Direct3D interfaces (and adding a scene­graph API too). In 1998, Hewlett­Packard joined the project.[18] It initially showed some promise of bringing order to the world of interactive3D computer graphics APIs, but on account of financial constraints at SGI, strategic reasons at Microsoft,and general lack of industry support, it was abandoned in 1999.[19]

In July 2006 the OpenGL Architecture Review Board voted to transfer control of the OpenGL API standardto the Khronos Group.[20][21]

Version history

The first version of OpenGL, version 1.0, was released in January 1992 by Mark Segal and Kurt Akeley.Since then, OpenGL has occasionally been extended by releasing a new version of the specification. Suchreleases define a baseline set of features which all conforming graphics cards must support, and against

which new extensions can more easily be written. Each new version of OpenGL tends to incorporate anumber of extensions which have widespread support among graphics­card vendors, although the details ofthose extensions may be changed.

OpenGL 1.1

Release Date: March 4, 1997

Extension DetailsEXT_vertex_array(https://www.opengl.org/registry/specs/EXT/vertex_array.txt)

Multiple vertices may be passed to theGL with a single function call.

EXT_polygon_offset(https://www.opengl.org/registry/specs/EXT/polygon_offset.txt)

Depth values may be offset on a per­primitive basis.

EXT_blend_logic_op(https://www.opengl.org/registry/specs/EXT/blend_logic_op.txt)

Fragment colors may be blended intothe framebuffer using bitwiseoperations.

EXT_texture(https://www.opengl.org/registry/specs/EXT/texture.txt)

Various texturing improvements,including proxy textures and sizedinternal formats.

EXT_copy_texture(https://www.opengl.org/registry/specs/EXT/copy_texture.txt)EXT_subtexture(https://www.opengl.org/registry/specs/EXT/subtexture.txt)

Various methods to alter textureimages, including image copying andsub­image replacement.

EXT_texture_object(https://www.opengl.org/registry/specs/EXT/texture_object.txt)

Texture state may be stored in a GLobject, for greater efficiency.

OpenGL 1.2

Release Date: March 16, 1998

One notable feature of OpenGL 1.2 was the introduction of the imaging subset. This is a set of featureswhich are very useful to image­processing applications, but which have limited usefulness elsewhere.Implementation of this subset has always been optional; support is indicated by advertising the extensionstring ARB_imaging.

Extension DetailsEXT_texture3D(https://www.opengl.org/registry/specs/EXT/texture3D.txt) Three­dimensional texturing.

EXT_bgra (https://www.opengl.org/registry/specs/EXT/bgra.txt)

Pixel data may be specified inBGR or BGRA order, to matchthe pixel format of Windowsbitmaps.

EXT_packed_pixels(https://www.opengl.org/registry/specs/EXT/packed_pixels.txt)

Pixel data may be "packed"into a larger primitive type.For example, all fourcomponents of an RGBA pixelmay be specified as a single32­bit integer.

EXT_rescale_normal(https://www.opengl.org/registry/specs/EXT/rescale_normal.txt)

Normals may be automaticallyrescaled by the GL, which insome cases removes the needfor an expensivenormalization.

EXT_separate_specular_color(https://www.opengl.org/registry/specs/EXT/separate_specular_color.txt)

The GL's lighting capabilitiesare extended to supporttexture­independent specularhighlighting.

SGIS_texture_edge_clamp(https://www.opengl.org/registry/specs/SGIS/texture_edge_clamp.txt)

A new texture­coordinateclamping mode which, unlikeGL_CLAMP, will neversample from the texture'sborder.

SGIS_texture_lod(https://www.opengl.org/registry/specs/SGIS/texture_lod.txt)

The programmer is givengreater control over the level­of­detail calculation used toselect a texture's mipmap.

EXT_draw_range_elements(https://www.opengl.org/registry/specs/EXT/draw_range_elements.txt)

The DrawRangeElementsfunction; a slightly moreperformant alternative toDrawElements.

OpenGL 1.2.1

Release Date: October 14, 1998

OpenGL 1.2.1 was a minor release, appearing only seven months after the release of version 1.2. Itintroduced the concept of ARB extensions, and defined the extension ARB_multitexture(https://www.opengl.org/registry/specs/ARB/multitexture.txt), without yet incorporating it into the OpenGLcore specification.

OpenGL 1.3

Release Date: August 14, 2001

Extension Details

ARB_texture_compression(https://www.opengl.org/registry/specs/ARB/texture_compression.txt)

A standard framework uponwhich compressed textureformats may be supported,without requiring any actualcompression support.

ARB_texture_cube_map(https://www.opengl.org/registry/specs/ARB/texture_cube_map.txt) Cube­mapped texturing.

ARB_multisample(https://www.opengl.org/registry/specs/ARB/multisample.txt)

A standard framework uponwhich multisample anti­aliasingmay be supported, withoutrequiring any actual MSAAsupport.

ARB_multitexture(https://www.opengl.org/registry/specs/ARB/multitexture.txt)

Color values from severaltextures at once may be blendedonto a single fragment.

ARB_texture_env_add(https://www.opengl.org/registry/specs/ARB/texture_env_add.txt)ARB_texture_env_combine(https://www.opengl.org/registry/specs/ARB/texture_env_combine.txt)ARB_texture_env_dot3(https://www.opengl.org/registry/specs/ARB/texture_env_dot3.txt)

Several new "textureenvironment functions":mechanisms for blending texturecolors onto fragment colors.

ARB_texture_border_clamp(https://www.opengl.org/registry/specs/ARB/texture_border_clamp.txt)

A new texture­coordinateclamping mode which forcesout­of­bounds texturecoordinates to sample from thetexture's border.

ARB_transpose_matrix(https://www.opengl.org/registry/specs/ARB/transpose_matrix.txt)

Transformation matrices may bespecified in either row­majororder or column­major order.

OpenGL 1.4

Release date: July 24, 2002

Extension Details

SGIS_generate_mipmap(https://www.opengl.org/registry/specs/SGIS/generate_mipmap.txt)

Texture mipmaps may begenerated automatically by theGL.

NV_blend_square(https://www.opengl.org/registry/specs/NV/blend_square.txt)

RGB and Alpha values maybe squared during alpha­blending.

EXT_blend_color(https://www.opengl.org/registry/specs/EXT/blend_color.txt) Various ways to customize the

EXT_blend_minmax(https://www.opengl.org/registry/specs/EXT/blend_minmax.txt)EXT_blend_subtract(https://www.opengl.org/registry/specs/EXT/blend_subtract.txt)

blend equation, promotedfrom the optional imagingsubset (introduced in version1.2) to the core specification.

ARB_depth_texture(https://www.opengl.org/registry/specs/ARB/depth_texture.txt)ARB_shadow (https://www.opengl.org/registry/specs/ARB/shadow.txt)

Textures which store depthvalues, rather than colorvalues. Such textures areuseful for shadow­casting anddisplacement maps.

EXT_fog_coord(https://www.opengl.org/registry/specs/EXT/fog_coord.txt)

A way to customize the fogintensity on a per­vertex basis.

EXT_multi_draw_arrays(https://www.opengl.org/registry/specs/EXT/multi_draw_arrays.txt)

A set of APIs which emulatemultiple calls to DrawArraysor DrawElements, in a singlefunction call. In some cases,this may be more efficient.

ARB_point_parameters(https://www.opengl.org/registry/specs/ARB/point_parameters.txt)

Greater control over therasterization of pointprimitives.

EXT_secondary_color(https://www.opengl.org/registry/specs/EXT/secondary_color.txt)

The "secondary color"mechanism defined byEXT_separate_specular_colormay be used in allcircumstances, even whenlighting is disabled.

EXT_blend_func_separate(https://www.opengl.org/registry/specs/EXT/blend_func_separate.txt)

Separate blending functionsmay be specified for the RGBand Alpha components of theblended pixels.

EXT_stencil_wrap(https://www.opengl.org/registry/specs/EXT/stencil_wrap.txt)

A stencil mode which causesstencil values to incrementwith wrapping.

ARB_texture_env_crossbar(https://www.opengl.org/registry/specs/ARB/texture_env_crossbar.txt)

Texture environmentfunctions may access all othertexture stages, rather thanbeing restricted to the texturebound to their own textureunit.

EXT_texture_lod_bias(https://www.opengl.org/registry/specs/EXT/texture_lod_bias.txt)

A means to bias thecomputation of mipmapweights in order to add blur orsharpening effects to texturefiltering.

ARB_texture_mirrored_repeat(https://www.opengl.org/registry/specs/ARB/texture_mirrored_repeat.txt)

A new texture­coordingwrapping mode which causesthe texture image to be

horizontally or verticallymirrored.

ARB_window_pos(https://www.opengl.org/registry/specs/ARB/window_pos.txt)

The WindowPos API, analternative to RasterPos whichsets the raster­output positionin screen space rather thanworld space.

OpenGL 1.5

Release Date: July 29, 2003

Alongside the release of OpenGL 1.5, the ARB released the OpenGL Shading Language specification, andthe extensions ARB_shader_objects (https://www.opengl.org/registry/specs/ARB/shader_objects.txt),ARB_vertex_shader (https://www.opengl.org/registry/specs/ARB/vertex_shader.txt), andARB_fragment_shader (https://www.opengl.org/registry/specs/ARB/fragment_shader.txt). However, thesewould not be incorporated into the core specification until the next release.

Extension Details

ARB_vertex_buffer_object(https://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt)

A new type of GL object, the"buffer", which stores varioustypes of data (especially vertexdata) in high­performance videomemory.

ARB_occlusion_query(https://www.opengl.org/registry/specs/ARB/occlusion_query.txt)

The programmer may querywhether or not a primitive wasoccluded during rendering.

EXT_shadow_funcs(https://www.opengl.org/registry/specs/EXT/shadow_funcs.txt)

The capabilities of theARB_shadow extension areslightly extended.

OpenGL 2.0

Release Date: September 7, 2004

OpenGL 2.0 was originally conceived by 3Dlabs to address concerns that OpenGL was stagnating andlacked a strong direction.[22] 3Dlabs proposed a number of major additions to the standard. Most of thesewere, at the time, rejected by the ARB or otherwise never came to fruition in the form that 3Dlabs proposed.However, their proposal for a C­style shading language was eventually completed, resulting in the currentformulation of GLSL (the OpenGL Shading Language or GLslang). Like the assembly­like shadinglanguages that it was replacing, it allowed the programmer to replace the fixed­function vertex and fragmentpipe with shaders, though this time written in a C­like high­level language.

The design of GLSL was notable for making relatively few concessions to the limitations of the hardwarethen available; this hearkened back to the earlier tradition of OpenGL setting an ambitious, forward­lookingtarget for 3D accelerators rather than merely tracking the state of currently available hardware. The finalOpenGL 2.0 specification[23] includes support for GLSL.

Extension DetailsARB_shading_language_100(https://www.opengl.org/registry/specs/ARB/shading_language_100.txt)(heavily modified)ARB_shader_objects(https://www.opengl.org/registry/specs/ARB/shader_objects.txt) (heavilymodified)ARB_vertex_shader(https://www.opengl.org/registry/specs/ARB/vertex_shader.txt) (heavilymodified)ARB_fragment_shader(https://www.opengl.org/registry/specs/ARB/fragment_shader.txt) (heavilymodified)

The high­level OpenGLShading Language, whichprovides direct access toprogrammable vertex andfragment processors.

ARB_draw_buffers(https://www.opengl.org/registry/specs/ARB/draw_buffers.txt)

Fragment shaders mayoutput different colors tomultiple render­targets in asingle pass. (Note thatactual support for multiplerender­targets would notbe guaranteed untilOpenGL 3.0.)

ARB_texture_non_power_of_two(https://www.opengl.org/registry/specs/ARB/texture_non_power_of_two.txt)

Texture images may havenon­power­of­twodimensions.

ARB_point_sprite(https://www.opengl.org/registry/specs/ARB/point_sprite.txt)

Points may be rendered assmall, screen­orientedtexture quads. This isuseful when developingparticle systems.

EXT_blend_equation_separate(https://www.opengl.org/registry/specs/EXT/blend_equation_separate.txt)

Separate blendingequations may be specifiedfor the RGB and Alphacomponents of the blendedpixels. Similar toEXT_blend_func_separate.

ATI_separate_stencil(https://www.opengl.org/registry/specs/ATI/separate_stencil.txt)EXT_stencil_two_side(https://www.opengl.org/registry/specs/EXT/stencil_two_side.txt)

Separate stencil algorithmsmay be used whenrendering the front andback faces of primitives.

OpenGL 2.1

Release Date: July 2, 2006

OpenGL 2.1 required implementations to support version 1.20 of the OpenGL Shading Language.

Extension Details

ARB_pixel_buffer_object(https://www.opengl.org/registry/specs/ARB/pixel_buffer_object.txt)

Buffer objects may be used forasynchronous transfers of imagedata.

EXT_texture_sRGB(https://www.opengl.org/registry/specs/EXT/texture_sRGB.txt)

Texture pixel values may bespecified in the gamma­correctedsRGB color space.

Longs Peak and OpenGL 3.0 controversy

Prior to the release of OpenGL 3.0, the new revision was known as the codename Longs Peak. At the time ofits original announcement, Longs Peak was presented as the first major API revision in OpenGL's lifetime. Itconsisted of an overhaul to the way that OpenGL works, calling for fundamental changes to the API.

The draft introduced a change to object management. The GL 2.1 object model was built upon the state­based design of OpenGL. That is, in order to modify an object or to use it, one needs to bind the object to thestate system, then make modifications to the state or perform function calls that use the bound object.

Because of OpenGL's use of a state system, objects must be mutable. That is, the basic structure of an objectcan change at any time, even if the rendering pipeline is asynchronously using that object. A texture objectcan be redefined from 2D to 3D. This requires any OpenGL implementations to add a degree of complexityto internal object management.

Under the Longs Peak API, object creation would become atomic, using templates to define the properties ofan object which would be created with a single function call. The object could then be used immediatelyacross multiple threads. Objects would also be immutable; however, they could have their contents changedand updated. For example, a texture could change its image, but its size and format could not be changed.

To support backwards compatibility, the old state based API would still be available, but no newfunctionality would be exposed via the old API in later versions of OpenGL. This would have allowedlegacy code bases, such as the majority of CAD products, to continue to run while other software could bewritten against or ported to the new API.

Longs Peak was initially due to be finalized in September 2007 under the name OpenGL 3.0, but theKhronos Group announced on October 30 that it had run into several issues that it wished to address beforereleasing the specification.[24] As a result, the spec was delayed, and the Khronos Group went into a mediablackout until the release of the final OpenGL 3.0 spec.

The final specification proved far less revolutionary than the Longs Peak proposal. Instead of removing allimmediate mode and fixed functionality (non­shader mode), the spec included them as deprecated features.The proposed object model was not included, and no plans have been announced to include it in any futurerevisions. As a result, the API remained largely the same with a few existing extensions being promoted tocore functionality.

Among some developer groups this decision caused something of an uproar,[25] with many developersprofessing that they would switch to DirectX in protest. Most complaints revolved around the lack ofcommunication by Khronos to the development community and multiple features being discarded that were

viewed favorably by many. Other frustrations included the requirement of DirectX 10 level hardware inorder to use OpenGL 3.0 and the absence of geometry shaders and instanced rendering as core features.

Other sources reported that the community reaction was not quite as severe as originally presented,[26] withmany vendors showing support for the update.[27][28]

OpenGL 3.0

Release Date: August 11, 2008

OpenGL 3.0 introduced a deprecation mechanism to simplify future revisions of the API. Certain features,marked as deprecated, could be completely disabled by requesting a forward­compatible context from thewindowing system. OpenGL 3.0 features could still be accessed alongside these deprecated features,however, by requesting a full context.

Deprecated features include:

All fixed­function vertex and fragment processing.Direct­mode rendering, using glBegin and glEnd.Display lists.Indexed­color rendering targets.OpenGL Shading Language versions 1.10 and 1.20.

Extension Details

EXT_gpu_shader4(https://www.opengl.org/registry/specs/EXT/gpu_shader4.txt)

API functions required byversion 1.30 of the OpenGLShading Language.

ARB_map_buffer_range(https://www.opengl.org/registry/specs/ARB/map_buffer_range.txt)

Mapping of buffer subrangesinto client space and flushingmodified data.

ARB_color_buffer_float(https://www.opengl.org/registry/specs/ARB/color_buffer_float.txt)NV_depth_buffer_float(https://www.opengl.org/registry/specs/NV/depth_buffer_float.txt)ARB_texture_float(https://www.opengl.org/registry/specs/ARB/texture_float.txt)EXT_packed_float(https://www.opengl.org/registry/specs/EXT/packed_float.txt)EXT_texture_shared_exponent(https://www.opengl.org/registry/specs/EXT/texture_shared_exponent.txt)

Floating­point color anddepth internal formats fortextures and renderbuffers.

ARB_half_float_pixel(https://www.opengl.org/registry/specs/ARB/half_float_pixel.txt)NV_half_float (https://www.opengl.org/registry/specs/NV/half_float.txt)

Half­float (16­bit) vertexarray and pixel data formats.

EXT_framebuffer_object(https://www.opengl.org/registry/specs/EXT/framebuffer_object.txt)

A new type of GL object, the"framebuffer". Framebuffersenable offscreen rendering

and rendering to textures.

EXT_framebuffer_sRGB(https://www.opengl.org/registry/specs/EXT/framebuffer_sRGB.txt)

Use of the sRGB gamma­corrected image data inframebuffers.

EXT_framebuffer_blit(https://www.opengl.org/registry/specs/EXT/framebuffer_blit.txt)EXT_framebuffer_multisample(https://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt)

Functions to perform a fastblit from one render­target toanother.

ARB_texture_float(https://www.opengl.org/registry/specs/ARB/texture_float.txt)EXT_texture_integer(https://www.opengl.org/registry/specs/EXT/texture_integer.txt)

Support for floating­pointand non­normalized integertexture storage.

EXT_packed_depth_stencil(https://www.opengl.org/registry/specs/EXT/packed_depth_stencil.txt)

Packed depth/stencil internalformats for combineddepth+stencil textures andrenderbuffers.

EXT_draw_buffers2(https://www.opengl.org/registry/specs/EXT/draw_buffers2.txt)

Per­color­attachment blendenables and colorwritemasks.

GL_EXT_texture_array(https://www.opengl.org/registry/specs/EXT/texture_array.txt)

One­ and two­dimensionallayered texture targets.

EXT_texture_compression_rgtc(https://www.opengl.org/registry/specs/EXT/texture_compression_rgtc.txt)

The RGTC texture­compression format, forcompressing one or two­channels of image data.

EXT_transform_feedback(https://www.opengl.org/registry/specs/EXT/transform_feedback.txt)

The results of vertexprocessing can be capturedinto buffers, rather than (orin addition to) being passedto the rest of the pipeline.

ARB_vertex_array_object(https://www.opengl.org/registry/specs/ARB/vertex_array_object.txt)

A new type of GL object, the"vertex array object", whichstores a set of bindings tovertex arrays. This allowsvertex arrays to be reboundwith a single function callrather than several calls toEnableVertexAttribArray,VertexAttribPointer, etc.

NV_conditional_render(https://www.opengl.org/registry/specs/NV/conditional_render.txt)

Conditional rendering, basedon the results of an occlusionquery.

OpenGL 3.1

Release Date: March 24, 2009

OpenGL 3.1 fully removed all of the features which were deprecated in version 3.0, with the exception ofwide lines. From this version onwards, it's not possible to access new features using a full context, or toaccess deprecated features using a forward­compatible context. An exception to the former rule is made ifthe implementation supports the ARB_compatibility(https://www.opengl.org/registry/specs/ARB/compatibility.txt) extension, but this is not guaranteed.

Extension Details

ARB_draw_instanced(https://www.opengl.org/registry/specs/ARB/draw_instanced.txt)

Instanced rendering: the abilityto quickly render the samegeometry data multiple times,with the vertex shader beinggiven information specifyingwhich instance it is operatingon.

EXT_copy_buffer (See: ARB_copy_buffer(https://www.opengl.org/registry/specs/ARB/copy_buffer.txt))

A mechanism to copy datadirectly from one buffer objectto another.

ARB_texture_buffer_object(https://www.opengl.org/registry/specs/ARB/texture_buffer_object.txt)

Buffer textures: one­dimensional textures, where thepixel data store comes from abuffer object.

ARB_texture_rectangle(https://www.opengl.org/registry/specs/ARB/texture_rectangle.txt) Rectangular textures.

ARB_uniform_buffer_object(https://www.opengl.org/registry/specs/ARB/uniform_buffer_object.txt)

The ability to store a set ofshader parameters in a bufferobject.

NV_primitive_restart(https://www.opengl.org/registry/specs/NV/primitive_restart.txt)

The ability to specify that anindex restarts a primitive, sothat objects can be called withfewer calls to DrawElements.

OpenGL 3.2

Release Date: August 3, 2009

OpenGL 3.2 further built on the deprecation mechanisms introduced by OpenGL 3.0, by dividing thespecification into a core profile and compatibility profile. Compatibility contexts include the previously­removed fixed­function APIs, equivalent to the ARB_compatibility extension released alongside OpenGL3.1, while core contexts do not. OpenGL 3.2 also included an upgrade to GLSL version 1.50.

Extension DetailsARB_geometry_shader4(https://www.opengl.org/registry/specs/ARB/geometry_shader4.txt) (heavilymodified)

Geometry shaders.

ARB_sync (https://www.opengl.org/registry/specs/ARB/sync.txt)

A set of GL objectsrepresentingsynchronizationprimitives, which allowthe client to detect whena specific set of tasks hascompleted.

ARB_vertex_array_bgra(https://www.opengl.org/registry/specs/ARB/vertex_array_bgra.txt)

Per­vertex color data maybe specified in BGRAorder, matching theconvention used byDirect3D.

ARB_draw_elements_base_vertex(https://www.opengl.org/registry/specs/ARB/draw_elements_base_vertex.txt)

The DrawElements APIis extended toautomatically add anumerical offset (the"base vertex") to eacharray index.

ARB_seamless_cube_map(https://www.opengl.org/registry/specs/ARB/seamless_cube_map.txt)

Forces blending betweendifferent faces whensampling from a cubemap.

ARB_texture_multisample(https://www.opengl.org/registry/specs/ARB/texture_multisample.txt)

A new type of texture,which can be used as amultisampled rendertarget.

ARB_fragment_coord_conventions(https://www.opengl.org/registry/specs/ARB/fragment_coord_conventions.txt)

Allow fragment shadersto read fragmentcoordinate locations inthe same conventions asDirect3D.

ARB_provoking_vertex(https://www.opengl.org/registry/specs/ARB/provoking_vertex.txt)

The developer mayconfigure which vertexdetermines the propertiesfor flat­shaded vertexcomponents.

ARB_depth_clamp(https://www.opengl.org/registry/specs/ARB/depth_clamp.txt)

The developer mayconfigure whether or nottriangles are clippedagainst the near/far Zrange.

OpenGL 3.3

Release Date: March 11, 2010

OpenGL 3.3 was released alongside version 4.0. It was designed to target hardware capable of supportingDirect3D 10.

Extension Details

ARB_shader_bit_encoding(https://www.opengl.org/registry/specs/ARB/shader_bit_encoding.txt)

Adds shading languagefunctions to performconversions from/tofloating­point andintegers. This extensiononly affects the shadinglanguage.

ARB_blend_func_extended(https://www.opengl.org/registry/specs/ARB/blend_func_extended.txt)

Fragment shaders canoutput multiple colorsthat can be used in asingle blendingoperation.

ARB_explicit_attrib_location(https://www.opengl.org/registry/specs/ARB/explicit_attrib_location.txt)

Shader inputs andoutputs may be assignedresource locations in theshader.

ARB_occlusion_query2(https://www.opengl.org/registry/specs/ARB/occlusion_query2.txt)

The occlusion­querysystem is extended tosupport queryingwhether entire objectswere occluded, ratherthan querying the exactnumber of occludedpixels. In some cases,this may be moreefficient.

ARB_sampler_objects(https://www.opengl.org/registry/specs/ARB/sampler_objects.txt)

A new GL object whichwraps some textureobject state, such asinterpolation andclamping. This allows asingle texture to besimultaneously accessedin multiple ways.

ARB_texture_swizzle(https://www.opengl.org/registry/specs/ARB/texture_swizzle.txt)

The developer mayconfigure the order thatthe components in atexture are presented to ashader when it samplesthem.Functions to accuratelymeasure the time taken

ARB_timer_query(https://www.opengl.org/registry/specs/ARB/timer_query.txt)

by an operation. Thisinformation is useful forprofiling purposes.

ARB_instanced_arrays(https://www.opengl.org/registry/specs/ARB/instanced_arrays.txt)

When performinginstanced rendering,instances may beconfigured using per­instance vertex attributesrather than using avertex shader parameterto access an array.

ARB_texture_rgb10_a2ui(https://www.opengl.org/registry/specs/ARB/texture_rgb10_a2ui.txt)ARB_vertex_type_2_10_10_10_rev(https://www.opengl.org/registry/specs/ARB/vertex_type_2_10_10_10_rev.txt)

Image and vertex datamay be specified bypacking three 10­bitnormalized integervalues into a single 32­bit integer.

OpenGL 4.0

Release Date: March 11, 2010

OpenGL 4.0 was released alongside version 3.3. It was designed to target hardware capable of supportingDirect3D 11.

As in OpenGL 3.0, this version of OpenGL contains a high number of fairly inconsequential extensions,designed to thoroughly expose the capabilities of Direct3D 11­class hardware. Only the most influentialextensions are listed below.

Extension Details

ARB_tessellation_shader(https://www.opengl.org/registry/specs/ARB/tessellation_shader.txt)

Two new shader stages(tessellation­control andtessellation­evaluation) to supportefficient generation of geometryon the GPU.

ARB_shader_subroutine(https://www.opengl.org/registry/specs/ARB/shader_subroutine.txt)

The ability to call differentsubroutines within a shaderdynamically, without recompilingthe source.

ARB_sample_shading(https://www.opengl.org/registry/specs/ARB/sample_shading.txt)

The programmer may request thata fragment program is evaluatedfor each sample within afragment, which increases thefidelity of multisampled anti­aliasing.

ARB_draw_buffers_blend(https://www.opengl.org/registry/specs/ARB/draw_buffers_blend.txt)

The ability to set individual blendequations and blend functions foreach color output.

ARB_draw_indirect(https://www.opengl.org/registry/specs/ARB/draw_indirect.txt)

A mechanism to supply thearguments to certain Drawfunctions from buffer­objectmemory. Combined withtransform feedback or OpenCL,this allows the GPU to renderwithout synchronising with theCPU.

ARB_transform_feedback2(https://www.opengl.org/registry/specs/ARB/transform_feedback2.txt)ARB_transform_feedback3(https://www.opengl.org/registry/specs/ARB/transform_feedback3.txt)

A set of improvements toEXT_transform_feedback.

OpenGL 4.1

Release Date: July 26, 2010

Extension DetailsARB_ES2_compatibility(https://www.opengl.org/registry/specs/ARB/ES2_compatibility.txt)

Full API compatibility withOpenGL ES 2.0.

ARB_get_program_binary(https://www.opengl.org/registry/specs/ARB/get_program_binary.txt)

The ability to retrieve thecontent of program objects ina binary, vendor­specificformat. This eliminates theneed to recompile shaderswhenever the program is run,but the resulting binaries arenot transferable from oneGPU to another.

ARB_separate_shader_objects(https://www.opengl.org/registry/specs/ARB/separate_shader_objects.txt)

Program objects may beseparately associated witheach of the five shadingstages, instead of usingseparate shader stages linkedinto a monolithic programobject. The extension alsointroduces glProgramUniform,which accepts a programobject as parameter, thusenabling direct access toprogram's uniforms.

ARB_viewport_array(https://www.opengl.org/registry/specs/ARB/viewport_array.txt)

The ability to define multipleviewports and scissorrectangles, to be used whengenerating several scenes atonce from a geometry shader.

ARB_vertex_attrib_64bit(https://www.opengl.org/registry/specs/ARB/vertex_attrib_64bit.txt)

Vertex attributes can bedouble­precision values.

ARB_shader_precision(https://www.opengl.org/registry/specs/ARB/shader_precision.txt)

The ability to specify theprecision of certain operationsin the shading language.

OpenGL 4.2

Release Date: August 8, 2011[29]

Supported video cards: Nvidia GeForce 400 series and newer, ATI Radeon HD 5000 Series and newer.Supported by Intel's Windows drivers for the Haswell's integrated GPU.[30]

Support for shaders with atomic counters and load/store/atomic read­modify­write operations to asingle level of a texture.Drawing multiple instances of data captured from GPU vertex processing (including tessellation), toenable complex objects to be efficiently repositioned and replicated.

Support for modifying an arbitrary subset of a compressed texture, without having to re­download thewhole texture to the GPU for significant performance improvements.

OpenGL 4.3

Release Date: August 6, 2012[31]

Supported video cards: Nvidia GeForce 400 series and newer, ATI Radeon HD 5000 Series and newer.

Compute shaders leveraging GPU parallelism within the context of the graphics pipelineShader storage buffer objects, allowing shaders to read and write buffer objects like image load/storefrom 4.2, but through the language rather than function calls.Image format parameter queriesETC2/EAC texture compression as a standard featureFull compatibility with OpenGL ES 3.0 APIsDebug capabilities to receive debugging messages during application developmentTexture views for interpreting textures in different ways without data replicationIncreased memory security and multi­application robustness

OpenGL 4.4

Release Date: July 22, 2013[32]

Supported video cards: Nvidia GeForce 400 series and newer, AMD Radeon HD 5000 Series and newer.

Supported SoC: Tegra K1

Enforced buffer object usage controlsAsynchronous queries into buffer objectsExpression of more layout controls of interface variables in shadersEfficient binding of multiple objects simultaneously

OpenGL 4.5

Release Date: August 11, 2014[33][34]

Supported video cards: Nvidia GeForce 400 series and newer, as well as the Tegra K1 and Tegra X1.[35][36]

Direct State Access (DSA) – object accessors enable state to be queried and modified without binding

objects to contexts, for increased application and middleware efficiency and flexibility.[37]

Flush Control ­ applications can control flushing of pending commands before context switching –enabling high­performance multithreaded applications;

Robustness ­ providing a secure platform for applications such as WebGL browsers, includingpreventing a GPU reset affecting any other running applications;OpenGL ES 3.1 API and shader compatibility – to enable the easy development and execution of thelatest OpenGL ES applications on desktop systems.

Sample renderings

Refraction usingprogrammable vertex

shaders

Animated texturesusing framebuffer

objects andvertex/fragment

program extensions

Procedural artworkusing display lists

Successor

Vulkan, previously known as glNext or the "Next Generation OpenGL Initiative",[38][39] is a grounds­upredesign effort to unify OpenGL and OpenGL ES into one common API that will not be backwardscompatible with existing OpenGL versions.[40][41][42] AMD has offered its Mantle API without anyconditions and for free as the base of the next generation of OpenGL.[43]

Early 2015, an upcoming GDC conference session by Valve Corporation, with participation from ElectronicArts, Epic Games and Unity Technologies is scheduled for the unveiling of Vulkan.[44]

On 3 March, 2015, Valve announced Source 2 which will be compatible with Vulkan.[45]

See also

ARB assembly language – OpenGL's legacy low­level shading languageComparison of OpenGL and Direct3DGlide API – a graphics API once used on 3dfx Voodoo cardsList of OpenGL programsOpenAL – Cross­platform audio library, designed to resemble OpenGLOpenGL ES – OpenGL for embedded systems

OpenSL ES – API for audio on embedded systems, developed by the Khronos GroupOpenVG – API for accelerated 2D graphics, developed by the Khronos GroupRenderMan Interface Specification (RISpec) – Pixar's open API for photorealistic off­line renderingVOGL – a debugger for OpenGL

Further reading

Dave Shreiner, The Khronos OpenGL ARB Working Group: OpenGL Programming Guide: TheOfficial Guide to Learning OpenGL, Version 4.3 (8th Edition), Addison­Wesley, March 30, 2013,ISBN 978­0­321­77303­6Graham Sellers, Richard S. Wright, Nicholas Haemel: OpenGL SuperBible: Comprehensive Tutorialand Reference (6th Edition), Addison­Wesley, July 31, 2013, ISBN 978­0­321­90294­8Rost, Randi J.: OpenGL Shading Language (3rd Edition), Addison­Wesley, July 30, 2009, ISBN 978­0­321­63763­5Lengyel, Eric: The OpenGL Extensions Guide, Charles River Media, ISBN 1­58450­294­0OpenGL Architecture Review Board, et al.: OpenGL Reference Manual: The Official ReferenceDocument to OpenGL, Version 1.4, Addison­Wesley, ISBN 0­321­17383­XOpenGL Architecture Review Board, et al.: OpenGL Programming Guide: The Official Guide toLearning OpenGL, Version 2, Fifth Edition, Addison­Wesley, ISBN 0­321­33573­2

References

1. Lextrait, Vincent (January 2010). "The Programming Languages Beacon, v10.0"(http://www.lextrait.com/Vincent/implementations.html). Retrieved 14 March 2010.

2. "Products: Software: OpenGL: Licensing and Logos" (http://www.sgi.com/products/software/opengl/license.html).SGI. Retrieved November 7, 2012.

3. https://www.opengl.org/wiki/Main_Page4. "OpenGL 4.0 Specification" (http://www.opengl.org/registry/doc/glspec40.core.20100311.pdf) (PDF). Retrieved

2013­05­02.5. http://faculty.ycp.edu/~dbabcock/PastCourses/cs370/labs/index.html6. "SGI – OpenGL Overview" (http://www.sgi.com/products/software/opengl/overview.html).7. "Khronos Membership Overview and FAQ" (http://www.khronos.org/members/). Khronos.org. Retrieved

November 7, 2012.8. http://www.opengl.org/registry/specs/NV/half_float.txt9. "How to Create Khronos API Extensions" (http://www.opengl.org/registry/doc/rules.html). Opengl.org. August

13, 2006. Retrieved November 7, 2012.10. "The OpenGL Registry" (http://www.opengl.org/registry/). Opengl.org. Retrieved 2013­05­02.11. "A list of GLUT alternatives, maintained by" (http://www.opengl.org/resources/libraries/windowtoolkits/).

Opengl.org. Retrieved 2013­05­02.12. "Related toolkits and APIs"

12. "Related toolkits and APIs"(https://www.opengl.org/wiki/Related_toolkits_and_APIs#Context.2FWindow_Toolkits). www.opengl.org.OpenGL. Retrieved 8 October 2014.

13. "Mesa 10.0 Release Notes" (http://mesa3d.org/relnotes/10.0.html). mesa3d.org. 2013­11­30. Retrieved2013­12­05.

14. "IRIS GL, SGI's property" (http://www.cg.tuwien.ac.at/~wimmer/apis/API_Summary.html).15. "Creation of the OpenGL ARB"

(http://www.sgi.com/company_info/newsroom/press_releases/2004/august/opengl.html).16. "End of OpenGL++" (http://www.opengl.org/about/arb/meeting_notes/notes/Meeting1.2/meeting_note_10­03­

98.html). opengl.org.17. "Announcement of Fahrenheit" (http://www.windowsitpro.com/Article/ArticleID/17533/17533.html).18. "Members of Fahrenheit. 1998." (http://www.findarticles.com/p/articles/mi_m0CGN/is_n3341/ai_20211297).

Computergram International. 1998.19. "End of Fahrenheit" (http://www.theregister.co.uk/1999/11/29/ms_quietly_dumps_windows_opengl/).20. OpenGL ARB to pass control of OpenGL specification to Khronos Group

(https://www.khronos.org/news/press/opengl_arb_to_pass_control_of_opengl_specification_to_khronos_group),Khronos press release

21. OpenGL ARB to Pass Control of OpenGL Specification to Khronos Group(http://www.accessmylibrary.com/coms2/summary_0286­16157838_ITM), AccessMyLibrary Archive

22. Fedy Abi­Chahla (September 16, 2008). "OpenGL 3 (3DLabs And The Evolution Of OpenGL)"(http://www.tomshardware.com/reviews/opengl­directx,2019­2.html). Tom's Hardware. Retrieved October 24,2010.

23. http://www.opengl.org/documentation/specs/version2.0/glspec20.pdf24. "OpenGL ARB announces an update on OpenGL 3.0" (http://www.opengl.org/discussion_boards/ubbthreads.php?

ubb=showflat&Number=229374#Post229374). October 30, 2007. Retrieved October 31, 2007.25. "OpenGL 3.0 Released, Developers Furious – Slashdot" (http://tech.slashdot.org/article.pl?sid=08/08/11/2135259).

Tech.slashdot.org. Retrieved November 7, 2012.26. "OpenGL BOF went over well, no pitch forks seen"

(http://www.opengl.org/news/opengl_bof_went_over_well_no_pitch_forks_seen).27. "The Industry Standard for High Performance Graphics"

(http://www.opengl.org/news/nick_haemel_amd_blog_post_opengl_30_a_big_step_in_the_right_direction/).OpenGL. August 18, 2008. Retrieved November 7, 2012.

28. "NVIDIA provides early OpenGL 3.0 driver now"(http://www.opengl.org/news/nvidia_provides_early_opengl_30_driver_now).

29. "Khronos Enriches Cross­Platform 3D Graphics with Release of OpenGL 4.2 Specification"(http://www.khronos.org/news/press/khronos­enriches­cross­platform­3d­graphics­with­release­of­opengl­4.2­spec).

30. "Intel Releases OpenGL 4.2 drivers for Haswell" (http://www.legitreviews.com/intel­releases­new­graphics­driver­ivy­bridge­haswell­sandy­bridge­processors_129577).

31. "Khronos Releases OpenGL 4.3 Specification with Major Enhancements"(http://www.khronos.org/news/press/khronos­releases­opengl­4.3­specification­with­major­enhancements).

32. "Khronos Releases OpenGL 4.4 Specification" (https://www.khronos.org/news/press/khronos­releases­opengl­4.4­specification).

Wikibooks has a book onthe topic of:Programming:OpenGL

External links

Official website (https://www.opengl.org)OpenGL.org's Wiki (https://www.opengl.org/wiki/Main_Page)more information on OpenGL Language bindingsSGI's OpenGL website (http://www.sgi.com/products/software/opengl/)OpenGL (https://www.dmoz.org/Computers/Programming/Graphics/Libraries/OpenGL) at DMOZKhronos Group, Inc. (https://www.khronos.org/)Edward Angel and Dave Shreiner (2013) SIGGRAPH University: "An Introduction to OpenGLProgramming" (https://www.youtube.com/watch?v=6­9XFm7XAT8)—free courseTutorial for modern OpenGL (3.3+) (https://open.gl)OpenGL 3.x/4.x examples (http://nopper.tv/norbert/opengl.html)OpenGL (version 3 and higher) examples (http://oglplus.org/oglplus/html/examples.html)

specification).33. https://www.khronos.org/news/press/khronos­group­announces­key­advances­in­opengl­ecosystem34. OpenGL 4.5 API Specification (updated August 8, 2014) (http://www.opengl.org/registry/)35. http://www.ustream.tv/recorded/5125595936. http://www.slideshare.net/Mark_Kilgard/opengl­45­update­for­nvidia­gpus37. http://arstechnica.com/information­technology/2014/08/opengl­4­5­released­with­one­of­direct3ds­best­features/38. Dingman, Hayden (3 March 2015). "Meet Vulkan, the powerful, platform­agnostic gaming tech taking aim at

DirectX 12" (http://www.pcworld.com/article/2891613/meet­vulkan­the­powerful­platform­agnostic­gaming­tech­taking­aim­at­directx­12.html). PC World. Retrieved 3 March 2015.

39. Bright, Peter (3 March 2015). "Khronos unveils Vulkan: OpenGL built for modern systems"(http://arstechnica.com/gadgets/2015/03/khronos­unveils­vulkan­opengl­built­for­modern­systems/). Ars Technica.Retrieved 3 March 2015.

40. "Khronos Announces Next Generation OpenGL Initiative" (http://www.anandtech.com/show/8363/khronos­announces­next­generation­opengl­initiative). AnandTech. Retrieved 20 August 2014.

41. "OpenGL 4.5 released, next­gen OpenGL unveiled: Cross­platform Mantle killer, DX12 competitor"(http://www.extremetech.com/gaming/187796­opengl­4­5­released­next­gen­opengl­unveiled­cross­platform­mantle­killer­dx12­competitor). Retrieved 20 August 2014.

42. "Khronos Publishes Its Slides About OpenGL­Next" (http://www.phoronix.com/scan.php?page=news_item&px=MTc2ODQ). Phoronix. Retrieved 22 August 2014.

43. "AMD hopes to put a little Mantle in OpenGL Next" (http://techreport.com/news/26922/amd­hopes­to­put­a­little­mantle­in­opengl­next). techreport.

44. "Valve to present glNext: High Performance Graphics at GDC" (http://hexus.net/tech/news/software/80414­valve­present­glnext­high­performance­graphics­gdc/). Hexus. 2014­02­05. Retrieved 2014­02­07.

45. "Valve Announces Source 2, Steam Link, and Steam VR" (http://www.gamespot.com/articles/valve­announces­source­2­steam­link­and­steam­vr/1100­6425674/). Valve Announces Source 2, Steam Link, and Steam VR ­GameSpot. GameSpot. March 3, 2015.

Retrieved from "http://en.wikipedia.org/w/index.php?title=OpenGL&oldid=654673251"

Categories: OpenGL 1992 software Application programming interfaces Cross­platform softwareGraphics libraries Graphics standards Video game development Virtual reality 3D graphics APIs

This page was last modified on 2 April 2015, at 19:19.Text is available under the Creative Commons Attribution­ShareAlike License; additional terms mayapply. By using this site, you agree to the Terms of Use and Privacy Policy. Wikipedia® is aregistered trademark of the Wikimedia Foundation, Inc., a non­profit organization.