(July 30, 2017)
OpenGL ( Open G raphics L ibrary ; German Open Graphics Library ) is a specification of a platform and programming multi- programming interface (API) for developing 2D and 3D computer graphics applications . The OpenGL standard describes around 250 commands that allow the display of complex 3D scenes in real time . In addition, other organizations (mostly manufacturers of graphics cards ) can define proprietary extensions.
The OpenGL API is usually implemented using system libraries , and on some operating systems as part of the graphics card driver . These execute commands from the graphics card accordingly; in particular, functions that do not exist on the graphics card must be emulated by the CPU .
The successor to OpenGL is Vulkan .
The programming model
OpenGL was designed as a state machine that does not receive all required parameters with every function call, but uses the same values until the corresponding states are changed. In this way you don't need to tell OpenGL the desired color for each vertex , for example , but set a color once, whereupon all subsequent vertices are displayed in this color. In the same way, light sources can be switched on or off globally and many other states can be set.
The reason for this design is that almost every change in the drawing mode entails extensive reorganization of the graphics pipeline , so it is better to avoid this as long as it makes sense. It would also be tiresome for the programmer to enter dozens of parameters over and over again. Often many thousands of vertices can be edited before a state has to be changed again, while some states are even never changed. For example, the light sources mostly remain the same for all objects in a scene. Many states are retained at least for the duration of the rendering of a complete object, for example a car as a whole is moved around a certain vector and not broken down into its individual parts and then moved individually. This state-based concept is also followed in Direct3D .
An important property of OpenGL is its extensibility. Individual providers (typically graphics card manufacturers) can expand the OpenGL state machine to include additional states. A four-stage procedure is followed:
- If a manufacturer wants to implement an extension, he delivers a C header file in which he defines the extension with the necessary constants and possibly function prototypes. The function names and constants are given a manufacturer-specific suffix (e.g. NV for Nvidia or ATI for ATI ).
- If several manufacturers then agree to offer the same extension, the function names and constants are given the suffix EXT.
- If the ARB (Architecture Review Board) finally agrees to standardize the extension, all names will be given the suffix ARB.
- Most of the extensions standardized by the ARB are then "core" in the following OpenGL specification, that is, they become part of OpenGL itself and then no longer have a suffix.
OpenGL was originally developed from IRIS GL developed by Silicon Graphics (SGI) . The OpenGL 1.0 version was written by Mark Segal and Kurt Akeley. In the so-called Fahrenheit project , Microsoft and SGI tried to unify their 3D standards, but the project was canceled due to financial difficulties on the part of SGI.
The OpenGL standard is set by the OpenGL ARB (Architecture Review Board). The ARB has existed since 1992 and consists of a number of companies. Voting members are the companies 3DLabs , Apple , AMD / ATI , Dell , IBM , Intel , Nvidia , SGI and Sun (as of Nov. 2004). Other companies involved are Evans & Sutherland , Imagination Technologies , Matrox , Quantum3D , S3 Graphics , Spinor GmbH , Tungsten Graphics and Xi Graphics . Microsoft , one of the founding members, left the ARB in March 2003.
New functions in OpenGL are usually first introduced as manufacturer-specific extensions and then go through manufacturer-independent extensions and ARB extensions to core functionality. This makes it possible to use the latest possibilities of graphics hardware and still keep OpenGL abstract enough.
Since July 31, 2006, the further development of the OpenGL API has been in the hands of the Khronos Group .
|Legend:||Older version; no longer supported||Older version; still supported||Current version||Current preliminary version||Future version|
|version||publication||Description / changes|
|Older version; no longer supported: 1.0||January 1992||first publication|
|Older version; still supported: 1.1||January 1997||
|Older version; still supported: 1.2||March 16, 1998||
|Older version; still supported: 1.2.1||October 14, 1998||
|Older version; still supported: 1.3||August 14, 2001||
|Older version; still supported: 1.4||July 24, 2002||
|Older version; still supported: 1.5||July 29, 2003||
|Older version; still supported: 2.0||September 7, 2004||
|Older version; still supported: 2.1||August 2, 2006||
|Older version; still supported: 3.0 "Longs Peak"||August 11, 2008||[originally planned goals, only partially implemented]
|Older version; still supported: 3.1 "Longs Peak Reloaded"||March 24, 2009||
|Older version; still supported: 3.2||August 3, 2009||
|Older version; still supported: 3.3||March 11, 2010||
|Older version; still supported: 4.0||March 11, 2010||
|Older version; still supported: 4.1||July 26, 2010||
|Older version; still supported: 4.2||August 8, 2011||
|Older version; still supported: 4.3||August 6, 2012||
|Older version; still supported: 4.4||22. July 2013||
|Older version; still supported: 4.5||11th August 2014||
|Current version: 4.6||July 30, 2017||
The big leap from OpenGL 1.5 to 2.0 can be explained with the introduction of the "OpenGL Shading Language". This is such a big change and expansion that the ARB decided to take this step. The Khronos Group announced the specification for OpenGL 3.0 on August 11th at Siggraph 2008. The API has been extensively revised (away from the fixed function pipeline - towards the shaders or programs, away from the state machine - towards an object-based system). OpenGL is still backwards compatible, but there are no longer any new functions for the old API. For the first time, the new OpenGL has the powerful geometry shaders of the 3.0 model.
With the rapid release of OpenGL 4.0 and its feature set - especially the introduction of tessellation - the Khronos Group has been able to catch up again for a long time and has again entered into competition with DirectX (11).
NVIDIA has introduced several new ARBs under the titles OpenGL 2015 and OpenGL 2016. Some of this became standard with OpenGL 4.6. In 2017 and 2018, further extensions, especially for VR and ray tracing, were made available for Pascal and Turing.
Longs Peak and the OpenGL 3.0 Controversy
Before the release of the OpenGL 3.0 version on August 11, 2008, this revision of the API was known under the code name "Longs Peak". At the time of the original announcement, Longs Peak was presented as the very first major and in-depth overhaul of the API interface in OpenGL history. This consisted of a fundamental revision of the way OpenGL works, which should result in fundamental changes to the API. In order to ensure downward compatibility with older software despite the extensive changes and revolutionary innovations that have been announced, older versions of the API should still be available, but no new functions should be incorporated there. This would have allowed old program code, such as B. in the majority of CAD applications - which have been using their code base almost unchanged for decades - continue to run with older versions of the OpenGL API, while other programs would gradually have been rewritten or ported to the new interface.
Longs Peak was originally supposed to be released in September 2007 under the name OpenGL 3.0. Then, however, on October 30, 2007, the Khronos Group announced that it had encountered various issues that it wanted resolved before releasing the specifications.
As a result, publication postponed and the sources of information ceased completely. The Khronos group was used to coordinate the further development, as innovations and ideas were difficult and very time-consuming to implement due to the numerous members. After starting her job, she strived for a clear and tight schedule with clearly defined goals and committed herself to more open communication.
The specifications ultimately adopted turned out to be far less spectacular than advertised. Large parts of the code were retained and the object mode presented was not integrated. There are also no known plans to submit these in future versions. In the end, the API has remained largely the same, with a few additions to the core functionality.
This disappointing result caused dissatisfaction among some developer groups, as they had hoped for groundbreaking innovations and a serious, future-oriented, cross-platform competitor product to Microsoft's DirectX. In protest, some threatened to switch to DirectX in the future. Most of the disappointment was blamed on the lack of communication on the part of Khronos. One felt downright locked out and left in the dark. Other criticisms were made of the need for DirectX 10 capable hardware and the lack of geometry shaders and instanced rendering as core functions.
Other sources indicate that the response from the developer community has not been as bad as originally reported, with many vendors showing planned support for the new version.
Advantages and disadvantages of OpenGL compared to Direct3D
- Client-server model
- Draw calls are more powerful than Direct3D under certain circumstances
- expandable by manufacturers themselves
- There are a number of extensions for new functions not yet supported by the standard
- the available features depend on the GPU or its driver, not on the operating system
- OpenGL still has a partially outdated and more complex to use programming interface (API), which some developers consider cumbersome.
Interfaces to the system
Since OpenGL is a pure graphics library, it does not care about the management of drawing surfaces (windows), other buffers (such as the Z-Buffer or the Stencil-Buffer ) or rendering contexts to use the interface with several applications at the same time to be able to. These must be made available with the help of the intended, operating system-dependent libraries.
There are several libraries that connect OpenGL to the underlying operating system:
- AGL and CGL, the corresponding counterpart for macOS ,
- FreeGLUT , a newer alternative to the no longer developed GLUT,
- GLFW , a library similar to GLUT, which abstracts the underlying operating system,
- GLUT , a library that, based on OpenGL, GLU and, depending on the platform, GLX, WGL or AGL, offers a cross-platform API for input / output, creating rendering contexts and the like,
- GLX , which forms the interface between the X Window System and OpenGL,
- With GtkGLExt, OpenGL graphics can be integrated into GTK + programs (cross-platform),
- LWJGL , interface for programming with Java,
- Qt , can create OpenGL contexts and offers many options for interaction with its own library
- SDL , can also create an OpenGL context across platforms,
- SFML , also uses an OpenGL rendering context across platforms for drawing in windows,
- WebKit uses OpenGL for hardware acceleration,
- WGL, the Windows Graphics Library that connects OpenGL and Windows .
OpenGL commands contain a prefix that indicates which library the command comes from, followed by words that begin with capital letters:
|gl *||glu *||embers *|
|Basic command of the OpenGL Library||OpenGL Utility Library (GLU) command||OpenGL Utility Toolkit (GLUT) command|
Typical uses for OpenGL
- Screen saver
- Computer games
- Expanded reality
- Simulations (ASAMGpu)
- Virtual reality
- VRML authoring
Due to the continuity of the platform, programs run up to 40 times faster than 12 years ago compared to AMD graphics cards and with up to 15 times less consumption per action, without having to change the program code.
OpenGL is supported by many operating systems, including most of the leading ones:
- macOS (Mac OS X), Mac OS 9 (Classic)
- Microsoft Windows : OpenGL has been part of Windows 98 and NT 3.5 ( a patch was still required for Windows 95 ).
- X Window System : OpenGL is supported by the X Window System on the following platforms:
Open Graphics Library for Embedded Systems (OpenGL ES) is available for the following platforms:
- Acorn RISC OS
- Amiga (StormMesa) and Amiga MiniGL
- AmigaOS MiniGL
- Apple iOS
- HP webOS
- MorphOS TinyGL
- PlayStation 2/3/4
- Pocket PC
- Xbox 360
Cross-platform (Windows, Mac OS, Solaris and Linux) OpenGL is also supported by the additions JOGL or LWJGL of the Java platform , which act as a wrapper between Java and the native implementation of the operating system.
On March 3, 2015, the successor to OpenGL was presented at the Game Developers Conference (GDC). The new API, initially known as Next Generation OpenGL or glNext , is called Vulkan.
- DevIL , a cross-platform API for quickly loading and saving graphics. Formerly OpenIL . Works very well with OpenGL, as it is possible to load an image file into an OpenGL texture or to save screen shots with a single function call.
- Direct rendering infrastructure
- OpenGL Utility Library (GLU) standardized by the ARB and part of every OpenGL implementation.
- Java 3D , a library of Java classes for creating, manipulating and displaying three-dimensional graphics within Java applications and applets. Uses OpenGL or Direct3D depending on the platform and implementation.
- AMD Mantle , a programming interface for graphics output developed by AMD.
- Open Inventor , a free, object-oriented C ++ program library for creating 3D graphics.
- OpenAL , a cross-platform 3D audio API that is a kind of audio extension to OpenGL and is based on OpenGL in terms of structure, programming style and naming conventions.
- Simple DirectMedia Layer (SDL), a cross-platform API for graphics, audio and input devices including OpenGL-specific functionality.
- Graham Sellers, Richard S. Wright, and Nicholas Haemel: OpenGL Superbible: Comprehensive Tutorial and Reference . Addison-Wesley Longman, Amsterdam 2015, ISBN 978-0-672-33747-5 .
- Lorenz Burggraf: Now I'm learning OpenGL. The simple introduction to interface programming . Markt + Technik, Munich 2003, ISBN 3-8272-6237-2 .
- Dave Shreiner, Graham Sellers, John Kessenich and Bill Licea-Kane: OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 4.3 . Addison-Wesley Longman, Amsterdam 2013, ISBN 978-0-321-77303-6 .
- www.OpenGL.org - Official website (English)
- SGI: OpenGL Homepage (English)
- DelphiGL - German OpenGL community for many programming languages (focus on Delphi ).
- DGL-Wiki - German-language OpenGL reference work
- TinyGL on the website of Fabrice Bellard (English)
- OpenGLsamples OpenGL codes (english)
- History of OpenGL - OpenGL Wiki. Retrieved March 2, 2017 (English).
- OpenGL 3.1 specifications (PDF; 2.2 MB)
- opengl.org (PDF) OpenGL Core Specification with changes marked
- OpenGL 3.3 and 4.0 - bye DirectX 11? - Article at Golem.de , from March 11, 2010.
- on-demand.gputechconf.com (PDF)
- khronos.org (PDF)
- khronos.org (PDF)
- nvidia.com Source: Nvidia
- Bringing Unreal Engine 4 to OpenGL (PDF) Nvidia Developer. Retrieved August 24, 2014.
- Things that drive me nuts about OpenGL . Rich Geldreich's Tech Blog. Retrieved August 24, 2014.
- OpenGL Is Broken . Retrieved August 24, 2014.
- GTK + OpenGL Extension
- Alfred Nischwitz, Max Fischer, Peter Haberacker: Computer graphics and image processing . 2nd Edition. Vieweg-Verlag , 2007, ISBN 978-3-8348-0186-9 , p. 48 .
- core.ac.uk (PDF)