OpenGL Evolution & JOGL

OpenGL Evolution

SGI released the first OpenGL specification in January 1992.
Since this point OpenGL 1.x constantly evolved, first under the ARB and later under the Khronos Group.

The OpenGL API was specified with the objective of maximal hardware acceleration,
ie the API functions shall be implemented in hardware - as much as possible.
Further more, OpenGL is considered a vendor neutral and platform agnostic API,
ie should run anywhere, implemented by all 3D GPU manufacturer.

Up until OpenGL 1.5, released in July 2003, the core API reflected the so called fixed function pipeline (FFP).
FFP allowed a user to pass triangles, textures and attributes to the GPU.
The attributes had to be utilized to select predefined function of rendering,
hence the name fixed function.

Around 2000 new types of GPU hardware evolved,
allowing custom code running on the GPU hardware,
instead of being restricted to the fixed function rendering code.

To allow processing of such user defined algorithms on the GPU,
in 2002 the programmable shader pipeline (PSP) was introduced.
The OpenGL Shading Language (GLSL) used to write such shader programs
became an extension to OpenGL 1.4.

GLSL allows users to

write ANSI-C like shader programs

compile shader programs

upload shader programs to the GPU

The shader, executed on the GPU, transform the
triangle position and determine the pixel color.

Within this process, the shader may use any form of data,
arrays, textures and framebuffer.
It reads it, computes and stores the result in the target framebuffer(s),
hence the name programmable.

Still the fixed function subset is provided by most drivers.
However, since the hardware itself does not implement such functionality anymore,
it is completely implemented in software by the OpenGL driver.

This leads to the conclusion it is best advised for OpenGL applications
to avoid the FFP, but using the PSP. This allows the implementor
to utilize application level optimization which usually cannot be reached
by the very generic implemented FFP in the OpenGL drivers.

JOGL & The OpenGL Evolution

Like GL4Java, the 1st JOGL release 1.x
mapped OpenGL in one interface. This architecture was feasible and correct until the new OpenGL
profiles surfaced. There was only one unique way to create an OpenGL context for all available
OpenGL versions.