An API for computer graphics, usually used to render three dimensional scenes. OpenGL's specification is controlled by the OpenGL Architecture Review Board (ARB). While technically superior to Direct3D in its earlier incarnations, OpenGL only won what fanbase it has in the consumer space because of id Software and the continuous push of consumer 3D into the workstation space. In another brilliant move, SGI partnered with Microsoft to merge OpenGL into Fahrenheit, but somehow the whole venture fell apart. Some have said that OpenGL's last, best hope is its use in non-Windows environments such as Linux.

An API for programming 3d graphics (and of course 2d graphics, there are some examples of using it as a rasterization only API). Based on a state machine paradigm, it is awfully easy to program, yer typical 3d example of a cube spinning round and round is about thirty lines of code (and the built-in world famous teapot is a plus!). OpenGL is multiplatform and open versions of it exist, like Mesa. It also has some helper libraries like Glu and Glut, who provides an abstraction for windowed interfaces and input devices, amongst other useful things.

It has been said to compete with Microsoft's Direct3D, part of its DirectX, but even though both are used to program games, it has to be said that OpenGL has a wider scope of applications than games, whereas Direct3D is commonly seen just as an easy way to get hardware-accelerated graphics on Windows platform, mainly on games. Perhaps Direct3D is somewhat more suited to games as it kind of integrates with all the other parts of DirectX, with support for media files, network play and some other stuff.

OpenGL is said to win on graphics quality (though I guess that depends on the driver, mostly), and above all, ease of use. The Simple DirectMedia Layer can be used to provide some of the functionality that DirectX has, in a portable way, just like the forthcoming OpenML.

The major difference between Direct3D and OpenGL used to be that OpenGL is a direct mode API only, while D3D had a retained mode interface back around version 6 as well as a hideously clunky direct mode API. Nowadays the retained mode API seems to have been phased out -- not that I care.

Several pretty good retained mode libraries are available for OpenGL; the most well-known are probably SGI's OpenInventor and OpenGL Optimizer, but several free alternatives have been released as well (OpenRM, sgl).

It is rumoured that SGI, at one point, had the entire OpenGL 1.1 rendering pipeline implemented in silicon. That'd really peg my neat-o-meter.

OpenGL (Open Graphics Library) was created by Silicon Graphics as the successor to their own in-house graphics library, IRIS GL. At the time, all graphics workstation vendors developed their own, incompatable libraries which caused most 3D graphics programs to be extremely un-portable. As a result, SGI announced, in 1989, a new unifying standardized graphics library for everyone called, OpenGL. Work progressed quickly and in 1991, the first OpenGL Architectural Review Board (ARB) meetings were held, with the first commercial implementations of the new standard released the following year.

As with IRIS GL, OpenGL is a window system independent API and uses a variety of different matrices for transformations. This means that it only has rendering functionality. It is not tied with any one environment (i.e. X Window System, Microsoft Windows, Mac OS, etc.). This functionality allows for maximum portablilty. There have been window toolkits have been devised for OpenGL, namely, GLUT, the OpenGL Utility Toolkit. Also note that OpenGL was designed for C although extensions have been made for other languages.

When OpenGL first came out, its main, rival, was the ISO and United States government standard, PEX (PHIGS Extension to X). To promote OpenGL, Silicon Graphics mounted a massive marketing campaign (Fueling bitter flame wars as well.) to prove superiority over PEX. Eventually, PEX lost the battle.

Today OpenGL is the standard for 2D/3D graphics development with competition from Microsoft's DirectX/Direct3D APIs. Free clones, and toolkits exist for it such as Mesa and Open Inventor. Current specification is 1.2.

OpenGL is a fairly straight-forward API, a simple wire-frame cube is created as such (With GLUT for window managment):

    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <GL/glut.h>

    /* Compiled on IRIX with cc -o cube cube.c -lglut -lGL -lXext */

    int init(void)
       glClearColor(0.0, 0.0, 0.0, 0.0); /* Clear color-index */
       glShadeModel(GL_FLAT); /* Single color shading */

    int display(void)
       glClear(GL_COLOR_BUFFER_BIT); /* Clear the colorbuffer */
       glColor3f(/* Red* / 1.0, /* Green */ 1.0, /* Blue */ 1.0);
       GlLoadIdentity(); /* Clear the matrix */

        /* Set camera position, angle */
       gluLookAt(0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
       GlScalef(1.0, 2.0, 1.0); /* Modeling transformation */
       glFlush(); /* Clear buffer; force (re)draw */

    int reshape(int w, int h)
       glViewport(0, 0, (GLSize1) w, GLSizei) h); /* Scale display */
       glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); /* Implies projection (human) camera view */

    int main(int argc, char **argv)
       /* Setup GLUT */
       glutInit(&argc, argv);
       glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); /* Single buffer, color */
       glutInitWindowSize(500, 500);
       glutInitWindowPosition(100, 100);
       return 0;

For all those curious, yes, SGI has managed to implement the OpenGL API on a chip, and it can be found in the SGI Fuel. Here's a snippet from SGI's site:

    VPro graphics features OpenGL on a ChipTM for full hardware acceleration of the OpenGL 1.2 pipeline and also offers hardware acceleration of the OpenGL ARB imaging extensions.

Yes, it's brief, please /msg me with any additional info.

Log in or register to write something here or to contact authors.