OpenGL (Open Graphics Library) is a standard specification that defines a multi-language, cross-platform API for writing applications that produce 2D graphics. and 3D. The interface consists of more than 250 different functions that can be used to draw complex three-dimensional scenes from simple geometric primitives, such as points, lines, and triangles. It was originally developed by Silicon Graphics Inc. (SGI) in 1992 and is widely used in CAD, virtual reality, scientific rendering, information visualization, and flight simulation. It is also used in game development, where it competes with Direct3D on Microsoft Windows platforms.

Specification

Fundamentally OpenGL is a specification, that is, a document that describes a set of functions and the exact behavior they should have. From it, hardware manufacturers create implementations, which are libraries of functions that conform to the specification's requirements, using hardware acceleration where possible. Such implementations must pass conformance tests in order for their manufacturers to qualify their implementation as OpenGL compliant and to be able to use the official OpenGL logo.

There are efficient implementations of OpenGL for Mac OS, Microsoft Windows, GNU/Linux, various Unix platforms, and PlayStation 4. There are also several software implementations that allow applications that depend on OpenGL to run without hardware acceleration support. Notable is the free software / open source library Mesa 3D, a graphics API without hardware acceleration and fully compatible with OpenGL. However, to avoid the costs of the license required to be formally named as an OpenGL implementation, it claims to be just a very similar API.

The OpenGL specification was reviewed by the OpenGL Architecture Review Board (ARB), founded in 1992. The ARB was made up of a group of companies interested in creating a consistent and widely available API. Microsoft, one of the founding members, left the project in 2003.

On September 21, 2006, it was announced that control of OpenGL would pass from ARB to the Khronos Group. This was intended to improve OpenGL marketing and remove barriers between OpenGL and OpenGL ES development. ARB became within Khronos in the OpenGL ARB Working Group. The Khronos subgroup that manages the OpenGL specification is called the OpenGL ARB Working Group. For a list of members that make up the OpenGL ARB Working Group, see the Khronos Group Members section. The large number of companies with varied interests that have passed through both the old ARB and the current group have made OpenGL a general-purpose API with a wide range of capabilities.

Mark Segal and Kurt Akeley were the authors of the original OpenGL specification. Chris Frazier was the editor for version 1.1. Jon Leech has edited versions from 1.2 to the present 3.0.

Design

OpenGL serves two essential purposes:

• Hide the complexity of the interface with the different graphics cards, presenting to the programmer a unique and uniform API.
• Hide the different capabilities of the various hardware platforms, requiring all implementations to support the full functionality of OpenGL (using software emulation if necessary).

The basic operation of OpenGL is to accept primitives such as points, lines, and polygons, and convert them to pixels. This process is performed by a graphical pipeline known as an OpenGL State Machine. Most OpenGL commands either issue primitives to the graphical pipeline or configure how the pipeline processes these primitives. Until the appearance of version 2.0, each stage of the pipeline executed a predetermined function, resulting in little configurability. As of version 2.0 some stages are programmable using a programming language called GLSL.

OpenGL is a low-level procedural API that requires the programmer to dictate the exact steps needed to render a scene. This is in contrast to description APIs, where a programmer only has to describe the scene and can let the library handle the details of rendering it. OpenGL's low-level design requires programmers to have a deep understanding of the graphics pipeline, in exchange for giving them the freedom to implement novel graphics algorithms.

OpenGL has influenced the development of graphics cards, promoting a basic level of functionality that is now common in commercial hardware; Some of those contributions are:

• Basic Primitives of Rasterized Points, Lines and Polygons.

Process in the graphics pipeline.

• A transformation and lighting pipeline.
• Z-buffering.
• Texture mapping.
• Alpha blending.

A brief description of the process in the graphical pipeline could be:

1. Evaluation, if appropriate, of the polynomial functions that define certain inputs, such as NURBS surfaces, approximating curves and surface geometry.
2. Vertic operations, transforming them, illuminating them according to their material and cutting out unseen parts of the scene to produce a volume of vision.
3. Rasterization, or conversion of previous information into pixels. Polygons are represented with the right color through interpolation algorithms.
4. Operations by fragments or segments, such as updates according to coming values or already stored in depth and color combinations, among others.
5. Finally, the fragments are dumped in the Frame buffer.

Many current graphics cards provide functionality beyond the basics outlined here, but new features are generally enhancements to this basic pipeline rather than revolutionary changes to it.

Example

Note: Beware, this example is only valid with OpenGL 2.1 and earlier versions. It makes heavy use of currently outdated features.

First, we clear the color buffer to start on a black canvas:

glClear( GL_COLOR_BUFFER_BIT );

Set the modelview array, which controls the position of the camera relative to the primitives we render. We move it back 3 units in the Z axis, leaving it pointing towards the origin:

glMatrixMode( GL_MODELVIEW ); /* The commands for matrix will modify ''modelview' */glLoadIdentity(); ♪ Start 'modelview' ♪glTranslatef( 0, 0, -3 ); /* Displace 3 units on the Z axis */

The projection array controls the perspective applied to the primitives; is used in a similar way to the previous one:

glMatrixMode( GL_PROJECTION ); /* The commands for matrix will modify ''projection' */glLoadIdentity(); /* Initiate 'projection' */glFrustum( -1, 1, -1, 1, 1, 1000 ); /* Apply a projection in perspective */

Lastly, a polygon is drawn (a green square oriented in the XY plane):

glBegin( GL_POLYGON ); /* Polygon start */glColor3f( 0, 1, 0 ); /* Set current color to green */glVertex3f( -1, -1, 0 ); /* Establish a vertex */glVertex3f( -1, 1, 0 ); /* Establish a vertex */glVertex3f( 1, 1, 0 ); /* Establish a vertex */glVertex3f( 1, -1, 0 ); /* Establish a vertex */glEnd(); /* Polygon end */

History

In the 1980s developing software that was compatible with a wide range of graphics hardware was a real challenge for developers. You had to deal with very different interfaces and write specific drivers for each type of hardware, which was very expensive; for this reason, teams of programmers were outsourced to speed up development. Since each team worked separately on their interfaces, a lot of redundant code was produced. In addition, it was an expensive process, so several innovative groups rose to the challenge of finding a better method.

In the early 1990s SGI was a leading 3D graphics group for workstations. His was the IRIS GL API, considered a cutting-edge in the field and a de facto standard, coming to eclipse PHIGS, based on open standards. IRIS GL was considered easier to use and, most importantly, it supported rendering in immediate mode. Furthermore, PHIGS, apart from its greater difficulty, was considered inferior to IRIS GL regarding functionality and capacity.

SGI's competitors (Sun Microsystems, Hewlett-Packard, and IBM, among others) were able to bring PHIGS-compliant 3D hardware to the market through extensions. This gradually reduced SGI's market share as different providers entered the market. Therefore, in an attempt to strengthen its influence in the market, SGI decided to convert the IRIS GL standard into an open standard.

SGI noted that the IRIS GL API could not be open-sourced due to patent and license conflicts; it also contained features not relevant to 3D graphics such as window, keyboard, or mouse APIs (partly because it was developed before the X Window System or Sun's NeWS systems). Also, as market support for the new standard matured, it was intended to maintain old clients through add-on libraries such as Iris Inventor or Iris Performer.

The result of all of the above was the release of the OpenGL standard.

Some of the achievements were:

• Standardize access to hardware.
• Transfer to manufacturers responsibility for the development of interfaces with hardware.
• Delegate windows functions to the operating system.

With the variety of graphics hardware out there, getting everyone speaking the same language had a major effect, giving software developers a high-level platform to work on.

In 1992, SGI led the creation of the OpenGL Architecture Review Board (OpenGL ARB), a group of companies that would maintain and extend the OpenGL specification in subsequent years. OpenGL evolved from IRIS GL, overcoming its hardware dependency problem by offering software emulation for features not supported by existing hardware. Thus, applications could use advanced graphics on relatively low-powered systems.

In 1994 SGI considered releasing a product called OpenGL++, which included things like a scene-graph API (presumably based on Performer technology). This specification was released to a few interested groups, but never finally appeared as a product.

In 1995 Microsoft released Direct3D, which would become the main competitor to OpenGL. On December 17, 1997, Microsoft and SGI started the Fahrenheit project, a cooperative effort with the goal of unifying the OpenGL and Direct3D interfaces (and also adding a scene-graph API). In 1998 he would join the Hewlett-Packard project. Despite having a promising start in standardizing 3D graphics APIs, due to financial constraints at SGI and a general lack of industry support, it was eventually abandoned in 1999.

At GDC 2015, the Khronos Group announced the successor API to OpenGL, called Vulkan. Initially, it was introduced by Khronos as the "OpenGL Initiative. b> next generation", but then the name was discarded, leaving Vulkan as definitive. Vulkan is based on Mantle, another API from AMD, whose code was ceded to Khronos with the intention of generating a similar open standard to OpenGL, but low level.

Versions

OpenGL 1.0

Published in January 1992.
The first OpenGL specification was published by Mark Segal and Kurt Akeley.

OpenGL 1.1

Published in January 1997.
OpenGL 1.1 focused on support for textures and texture formats on GPU hardware.
Supported graphics cards: all

OpenGL 1.2

Published on March 16, 1998.
OpenGL 1.2 focused on volume texture support, packed pixels, normal rescaling, clamped/edge texture sampling, and image processing.
Supported graphics cards: Rage 128, Rage 128 GL, Rage XL/XC, Rage 128 Pro, Rage Fury MAXX, and all later cards.

OpenGL 1.2.1

Published on October 14, 1998
OpenGL 1.2.1 was a minor release released after OpenGL 1.2 (March 16, 1998) which added multi-texture, or texture units, to the rendering pipeline. This allowed multiple textures to be combined per pixel during rasterization.
Supported graphics cards: Radeon, Radeon Mobility, Radeon 7500 Mobility, Radeon 8500, Radeon 9000, Radeon 9200, Radeon 9600, Radeon 9800, GeForce 3, GeForce 4Ti, GeForce FX, and all later cards

OpenGL 1.3

Posted on August 14, 2001.
OpenGL 1.3 added support for cubemap texture, multiple textures, multi-sampling, and texture unit combination operations (add, merge, dot3, border clamp).
Supported graphics cards: Radeon 32/36, Radeon 64/7200, Radeon 7000, Radeon AIW, Radeon 7500, Radeon IGP 320M, Radeon IGP 345M, ES1000, Radeon 8500, Radeon 9000/Pro, Radeon 9100/9200/ 9250 (Pro & IGP), GeForce 3, GeForce 4Ti, GeForce FX, and all subsequent cards.

OpenGL 1.4

Posted on July 24, 2002.
OpenGL 1.4 added support for hardware shading, fog coordinates, automatic mipmap generation, and additional texture modes.
Supported graphics cards: Quadro DCC, Quadro4 380 XGL, Quadro4 500XGL, 550XGL, Quadro4 700XGL, 750XGL, 900XGL, 980XGL, and all later cards.

OpenGL 1.5

Posted on July 29, 2003.
OpenGL 1.5 added support for vertex buffer objects (VBOs), occlusion queries, and extended shading features.
Supported graphics cards: Radeon X800, Radeon 9600, Radeon 9700, Radeon 9800, GeForce FX, and all later cards.

OpenGL 2.0

Posted on September 7, 2004.
OpenGL 2.0 added support for a true GPU-based assembly language, called ARB (designed by the Architecture Review Board), which would become the standard for vertex and fragment shaders. Cards released with OpenGL 2.0 were the first to offer user-programmable shaders.
Supported cards: Radeon 9650, Radeon 9500, Radeon 9500/9550/9600/9700/9800 (Pro, SE, XT), Radeon X1050, Radeon Xpress 200 / 1100, Radeon X300, Radeon X550, Radeon X600/Pro, Radeon X700, Radeon X800 (VE, SE, GT, Pro), Radeon X850, Radeon Xpress 1250, Radeon X1200, Radeon X1250, Radeon 2100, Radeon X1300, X1550, X1600, X1650, X1800, X1900, X1950 (Pro, XT, GT), GeForce 6800, Quadro 600, Quadro FX 500, Quadro FX 700, Quadro FX 1000, FX 2000, FX 3000, Quadro FX 1400, Quadro FX 1500, Quadro FX 3450, Quadro FX 3500, Quadro FX 4500X2, Quadro FX4500 SDI, and all subsequent cards.

OpenGL 2.0 was conceived by 3Dlabs to address concerns that OpenGL was stagnant and lacked strong direction. 3Dlabs proposed a number of important additions to the standard. Most of these were, at the time, rejected by the ARB or otherwise never came to fruition in the way 3Dlabs proposed. However, his proposal for a C-style shading language was completed over time, resulting in the current formulation of GLSL (OpenGL Shading Language, also slang). Like the assembler-style shader languages it tried to replace, it allows the programmer to replace the fixed-function vertex and fragment pipe with shaders, although this times written in a high-level C-like language.

GLSL's design was notable for making relatively few concessions to the limitations of then-available hardware, reminiscent of the earlier OpenGL tradition of setting an ambitious, forward-thinking goal for 3D accelerators rather than just following the lead. currently available hardware status. The latest OpenGL 2.0 specification includes support for GLSL.

OpenGL 2.1

On August 2, 2006, OpenGL 2.1 was released. Being fully compatible with previous versions, it also brings new features such as:

• Revision 1.20 OpenGL Shading Language (GLSL).
• Commands that support the specification of unqualified matrices.
• Objects Pixel buffer to speed up image traffic in the buffers in commands like glTexImage2D and glReadPixels.

This functionality corresponds to the extension ARB_pixel_buffer_object.

• Textures sRGB.

This functionality corresponds to the extension GL_EXT_texture_sRGB.

OpenGL 3.0

OpenGL version 3.0 was released on August 11, 2008.

Supported Cards: GeForce 8 Series ATI HD Radeon 2000 Series. (That is, only Direct3D 10.0 compatible hardware is capable of running OpenGL 3.0.)

It is backwards compatible with all previous versions of OpenGL, although it introduces a new mechanism to deprecate (deprecate) functionality in order to simplify the API in future versions.

The main novelties are:

• OpenGL Shading Language version 1.30 (GLSL)
• Vertex Array Objects.
• Framebuffer Objects more flexible.
• Textures and render buffers in a 32-bit floating coma.
• 16-bit floating comma support for vertices and pixels.
• Ability to store vertices in a buffer after being transformed.
• Texture arrays
• Z-buffer in 32-bit floating coma.

OpenGL 3.1

Version 3.1 (Longs Peak Reloaded) was released on March 24, 2009, and introduces a number of features to make the API more convenient to use, in addition to performance-oriented features:

• OpenGL Hat Language Review 1.40 (GLSL)
• Texture Buffer Objects - a type of new texture containing a single-dimensional texel matrix
• Uniform Buffer Objects to share or update data quickly
• Signed standardized textures (range ± 1.0)
• A minimum of 16 texture units accessible by the Vertex Shader
• Primitive reinstatement
• Instances - drawing of objects on multiple occasions through reuse of objects vertex data
• CopyBuffer API for quick copying of data, used in conjunction with OpenCL

With the release of the OpenGL 3.1 specification, a compatibility extension was also released that allows developers to access the OpenGL 1.X/2.X functionality removed in OpenGL 3.1. In particular, legacy functionality is maintained for a broad support line.

Removed legacy functionality includes:

• All set function options
• Direct mode
• Color index mode, for example, pixel formats with color pallets

OpenGL 3.2

Version 3.2 was released on August 3, 2009. It includes the following features:

• OpenGL Shading Language version 1.50 (GLSL)
• Shader Geometry Support
• BGRA Vertice Order Component
• Fragment Shader coordinates convention control
• Perfect filtered cube map
• Fragment of depth of restraint
• Multisampled textures and texture of samples for specific places of the sample
• Sync and close objects

OpenGL 3.3

Posted on March 11, 2010

OpenGL 3.3, released simultaneously with OpenGL 4.0 and complemented by a set of new ARB extensions, carries as much functionality as possible from the OpenGL 4.0 specification for use on previous generation GPU hardware. Includes GLSL 3.30.

OpenGL 4.0

Posted on March 11, 2010
Supported cards: Radeon HD 5000 series, nVidia GTX 400 series;

Features:

• OpenGL Shading Language version 4.00 (GLSL)
• Two shading phases that allow the GPU to unload the geometric tes of the CPU.
• Per-shaders sample fragment and programmable shading positions input fragment for higher quality representation and anti-aliasing flexibility.
• Shader subroutines for significantly increased programming flexibility.
• Separation of the texture state and texture data by adding a new type of object called sampler objects.
• Drawing of data generated by the OpenGL API or external APIs, such as OpenCL, without CPU intervention.
• 64-bit operations of dual-precision floating comma and inputs/outputs to provide greater accuracy and quality.
• Performance improvements, such as geometry shaders in instances, matrice instances and a new timer consultation.

OpenGL 4.1

Announced July 26, 2010
Supported cards: Nvidia GeForce 400 series, Nvidia GeForce 500 series, ATI Radeon HD 5000 series, AMD Radeon HD 6000 Series

This new version adds these additional features to the specification, many of which help bring it in line with Direct3D 11:

• OpenGL Hat Language (GLSL) 4.1
• Complete compatibility with OpenGL for integrated systems (OpenGL ES) 2.0
• Reduction of recompilation times
• The ability to link programs individually to the five programmable stages (Vertex, Mosaic Control, Teselado Assessment, Geometry, and Fragment)
• General 64-bit floating comma enhancements compatible with OpenGL 4.0 add-on

OpenGL 4.2

Posted on August 8, 2011
Supported cards: Nvidia GeForce 400 series, Nvidia GeForce 500 series, ATI Radeon HD 5000 series, AMD Radeon HD 6000 Series, ATI Radeon HD 7000 series

• Support for shaders with atomic counters and load/store/atomic read-modify-write operations on a single level of texture.
• Ability to capture geometry of the GPU in mosaic and draw several instances of a "transform feedback" so that complex objects are easily replicated or changed position.
• OpenGL can now modify an arbitrary subset of a compressed texture without the need to re-download all the texture to the GPU by bringing this to greater performance.
• Support to package several 8-bit and 16-bit values in a single 32-bit value, leading to more efficient shader processing and reduced pressure in memory and bandwidth.

OpenGL 4.3

Posted on August 6, 2012 Supported Cards: Nvidia GeForce 400 series, Nvidia GeForce 500 series, Nvidia GeForce 600 series, ATI Radeon HD 8000 series

• Includes the most updated version of GLSL in version 4.30 (OpenGL Shading Language).
• A calculation of shaders that take advantage of the parallelism of the GPU for everything related to geometry or graphics.
• Shader object buffer storage.
• Texture parameters queries to find the limits that platforms can have to process them.
• High quality of understanding in ETC2/EAC textures as standard feature.
• Total compatibility with OpenGL ES 3.0 APIs.
• Debug capacities that allow you to receive debugging messages while the application is being developed.
• Texture views for analysis of the same in different forms without data replication.
• It increases memory security.
• A multi-appplication extension that adds robustness to the system, and prevents applications that cause a bug and have to reset to affect others that are running.

OpenGL 4.4

Posted on July 22, 2013

• Tampons placement control
• Efficient asynchronous consultations
• Design of shading variables
• Efficient binding of multiple objects
• Optimized Direct3D App Portability
• Texture extension without binding
• Slim texture extension

OpenGL 4.5

Posted on August 11, 2014

Supported Cards: Nvidia GeForce 400 series and newer, also Tegra K1 and Tegra X1.

• Direct State Access (DSA)- Direct status access
• Flush Control - Improved multiprocess system.
• Robustness - WebGL improvements.
• OpenGL ES 3.1 API and shaders compatibility.

OpenGL 4.6

Posted on July 17, 2017

• Geometry processing of the most efficient GPU side
• More efficient shading (AZDO)
• More information through statistics, overflow consultation and counters
• Increased performance without error management contexts
• Subjecting the polygon displacement function, solves a shadow representation problem
• SPIR-V hats
• Improved anisotropic filter

Hardware support: AMD Radeon HD 7000 Series and later (FP64 shaders implemented by emulation on some TeraScale GPUs), Intel Haswell and later, Nvidia GeForce 400 series and later

Documentation

OpenGL's popularity is due in part to its detailed official documentation. The OpenGL ARB has released a series of updated manuals as the API has evolved. They are easily recognizable (and known) by the color of their caps:

• The Red Book - The Red Book: The OpenGL Programmer's guide. ISBN 0-321-33573-2

Reference book and tutorial. Considered book head for OpenGL programmers.

• The Blue Book - The Blue Book: The OpenGL Manual reference. ISBN 0-321-17383-X

In essence, a copy of the OpenGL man pages.

Includes a drop-down poster with an implementation structure diagram ideal OpenGL.

• The Green Book - The Green Book: Programming OpenGL for the X Window System. ISBN 0-201-48359-9

Book on the interface X11 and GLUT.

• The Book Alpha (white cover) - The Alpha Book: OpenGL Programming for Windows 95 and Windows NT. ISBN 0-201-40709-4

Book on the OpenGL interface on Microsoft Windows platforms.

For OpenGL 2.0 and later:

• The Orange Book - The Orange Book: The OpenGL Shading Language. ISBN 0-321-33489-2

Reference book and tutorial for GLSL.

Extensions

The OpenGL standard allows manufacturers to add new additional functionality via extensions as new technologies become available. Such extensions can introduce new functions and constants, and loosen or even remove restrictions on existing functions. Each manufacturer has an abbreviation that identifies it in the name of its new functions or constants. For example, the abbreviation for NVIDIA (NV) appears in the definition of its function glCombinerParameterfvNV() and its constant GL_NORMAL_MAP_NV.

Several vendors may agree to implement the same extended functionality. In that case, the abbreviation EXT is used. It may even happen that the ARB adopts the extension, thus becoming standard and using the abbreviation ARB in their names. The first ARB extension was GL_ARB_multitexture, released in version 1.2.1. Following the path set by the extension, multitexturing is no longer an optional extension, but has become part of the OpenGL core since version 1.3.

Before using an extension, programs should check its availability and then access the new features offered. This process is platform dependent, but libraries like GLEW and GLEE make it easy.

Specifications for most extensions can be found in the official extension registry.

Vulkan

Vulkan, formerly called the "Next Generation OpenGL Initiative" (glNext), is a basic redesign effort to unify OpenGL and OpenGL ES into a common API that will not be compatible with older versions of OpenGL.

The initial version of the Vulkan API was released on February 16, 2016.

Utility Libraries

Several external libraries have been written that add features not available in OpenGL itself. Some of them are:

• GLU: Offers high-level drawing features based on OpenGL primitives. The functions of GLU are easily recognized as all begin with the prefix glue.

• GLUT: Multi-platform API that facilitates a rudimentary functionality for window management and interaction through keyboard and mouse.

• GLUI: GLUT-based user interface; provides control elements such as buttons, selection boxes and spinners. It is independent of the operating system, holding onto GLUT to handle the system-dependent elements.

References for programming languages (bindings)

To emphasize the multilanguage and crossplatform features of OpenGL, various bindings have been developed in many languages. Some of the languages for which these bindings are available are:

• Ada: Ada OpenGL 1.1supports GL, GLU and GLUT.
• C#: Taois a framework for.NET that includes OpenGL among other multimedia libraries.
• D: see and.
• Embarcadero Delphi: Dot.
• Fortran: f90glsupports OpenGL 1.2, GLU 1.2, GLUT 3.7.
• Gambas: gb.opengl
• Genie
• Lazarus-Free Pascal: LCL/GLUT
• Java: JOGL and LWJGL among others; see.
• Lisp: see.
• Perl: see.
• Pike: has a native interface to OpenGL. It also supports GLU and GLUT.
• Python: PyOpenGLsupports GL, GLU and GLUT.
• Visual Basic: see.
• XBase++: see.

• Haskell: HOpenGLIt supports GL, GLU and GLUT.
• Vala

Members of the Khronos Group

In 2008, some of the members of the Khronos Group are:

• AMD
• Apple
• Blizzard
• Intel Graphics Controllers
• NVIDIA

For a complete and up-to-date list of project members, see the lists of Khronos Group members, contributors, and scholars.