Microsoft Wants OpenGL

Microsoft Wants OpenGL Microsoft Wants OpenGL

The OpenGL Application Programming Interface(API), a graphics standard found on most modern desktops is, among other things, a means of utilizing the 3D hardware acceleration provided by the video card and a cross platform graphics standard. Microsoft however, have recently laid claim to technology which is vital to OpenGL. Back in early March Microsoft had first mentioned that they had "possible claims" on a technology called vertex programming. Vertex programming is essential in giving developers more control over 3D effects.
Microsoft's claims, at the time, had caused great concern among members of the OpenGL Architectural Review Board (ARB), the governing body of the specification.
Microsoft later went on to claim Intellectual Property (IP) rights on a technology called fragment shading.
According to early Microsoft claims they are willing to license their IP under reasonable and nondiscriminatory terms. What exactly that means however, is unclear.
What most experts claim is that if Microsoft have some claim on these technologies then the standard will be at their mercy. They will easily be able to finish it off by asking for excessive loyalties. Considering Microsoft's acquisitions of IP's from SGI, Nvidia, ATI, Intel and others it is quite possible that their claims may be valid. Whether they can actually use IP's acquired in that manner, is a point which still remains unclear.

Many suggest that there is a distinct possibility that this claim may lead to OpenGL becoming a specification restricted to MS and its partners.

OpenGL is an API to assist in delivering 3D drawing services in real-time environments. It's an immediate mode design, in that each frame is drawn explicitly by the client application, and each mode change will affect all subsequent drawing calls. This is instead of a retained mode design (like SGI's IRIX Performer), where the client application first describes the scene and then changes the camera and objects as needed.

The OpenGL API itself is controlled by an independent board, known as the Architecture Review Board (ARB), with each member having a single vote. The ARB governs changes and extensions to the API, new releases, and the conformance tests. This ensures that SGI can't solely control where the standard goes. News and development information is available at the site.

It's interesting to note that through its extension functions, new abilities are added to OpenGL in a very open-source manner. Any implementer can add a new extension, so long as it includes a prefix which identifies it as unique to the implementer. If the extension is submitted to the ARB and approved for adoption, it then becomes part of the official standard.

The API is carefully designed to allow large portions of the work to be carried out with the assistance of 3D hardware. A full implementation (like OpenGL or Mesa, but unlike many of the MiniGLs) will fall back from hardware acceleration to a software version for any features requested that aren't available from the hardware. This is referred to as falling back from the fast path to a slow path and can dramatically lower the frame rate delivered.

Rendering, or drawing, complex and realistic scenes full-screen at 50 frames per second is not possible even with today's fastest general-purpose processors, so specialized hardware assistance is needed for most applications. Small demonstration programs can still be run solely with software rendering, for example, as can applications where high frame rates aren't needed. But once hardware acceleration is used, no one is ever willing to go back.

To the application program author, OpenGL provides approximately 250 calls, or entry points, that are used to set up the rendering environment, create lights, and set background colors, drawing and blending modes, etc. Calls are also provided for drawing points, lines, polygons (convex and planar only, please), and bitmaps. These can be painted with textures and "lit" in different ways.

OpenGL provides several different types of buffers that the programmer can use to render the scene. For example, the frame or color buffer is where the actual drawing that is seen by the user takes place. There may be several frame buffers available, including front and back versions of both left and right buffers. Each OpenGL implementation can offer all of these, plus additional auxiliary buffers, or may only provide a subset. At the minimum, at least one frame buffer must be available.

Other buffer types include a depth or Z buffer, which is used to eliminate hidden surfaces, and a stencil buffer, used to control where drawing takes place. Lastly, an accumulation buffer can be used to blend scenes together for motion blur and anti-aliasing effects. Not all buffers are supported in hardware on all devices though, and using an unsupported buffer will slow the refresh rate down considerably.

There are also several support libraries available for use with OpenGL, two of the most important being the OpenGL Utility (GLU) library and the OpenGL Utility Toolkit (GLUT). The former provides functions that help in creating texture mipmaps (explained below), accessing extended functions of OpenGL, as well as several that assist in building different object types including complex, curved NURBs and quadratic surfaces.

The latter library, GLUT, was written by Mark Kilgard, and is a windowing-system-independent toolkit designed to let a program run anywhere, regardless of the platform. In addition to window creation, handling, and event-processing functions, the library also provides several object creation functions. Included are wire and solid versions of a sphere, cube, torus, and cone, plus icosa-, octa-, tetra- and dodeca-hedrons. And, just for fun, a teapot is available at the request of a single function call.

3D programming is quite math intensive, relying on passing objects through 4x4 floating point transform matrices in order to figure out how a bunch of rotated, transformed, scaled objects map to a rotated, transformed, scaled projection. While those strong in math are welcome to manipulate the various matrices directly, those to whom math is rather intimidating can still produce impressive results using OpenGL and nothing but the simplest trigonometry.

OpenGL History
According to O'Reilly OpenGL was developed by SGI (split off from IrixGL when the company was still known as Silicon Graphics), and the OpenGL name is a registered trademark owned by the company. For many years, the only real access to OpenGL was by way of high-end Unix workstations, which were used for engineering, scientific, and visualization work. SGI's IRIX-based machines were generally considered to be the best, as they usually came with leading-edge, highly optimized 3D acceleration hardware. They also came with extremely high price tags.

For anyone who wanted to provide the OpenGL API itself (as opposed to just using the API as a client program), SGI licensed the use of the name, a set of conformance tests, and a Sample Implementation (SI) in software for $100,000, with binary redistribution rights available for an additional $5 per copy royalty. Having this license and passing the tests gave someone the right to claim to be truly OpenGL compliant.

Fast-forward a few years and bring mass-market consumer economics to bear, and 3D acceleration hardware which used to cost $50,000 is now available for $250. Oh, and it's faster. It seems people just can't get enough of shooting at each other, and those who have machines that can render high-resolution displays at high frame rates have a better chance of taking out their opponents.

In order to still be considered open, and to help get their API used, SGI has always allowed the copying of the OpenGL header files in order to produce compatible "clones." Examples include all the various "MiniGL" versions available for different 3D hardware cards under Windows. These are often written solely with games in mind and may not work well with, for example, a CAD program.

Just recently, SGI has revised the access terms to their SI to be much more "open." Available for free download, the new license now allows hardware vendors who based their drivers on the SI to release their code in source form, if they so choose. This is great news for users and developers on Linux, and continues SGI's commitment to contributing technologies to the open source community. It's important to note, however, that SGI still owns, controls, and limits the use of the term OpenGL.

One clone implementation of particular interest to Linux/Free Unix users is the Mesa 3-D graphics library, written by Brian Paul and others at . Mesa is a GPLed, OpenGL-like implementation which until recently was as close to "real" OpenGL as you can get (with source code) without paying money. And while SGI's SI does provide "complete feature coverage," including new imaging features defined in OpenGL 1.2, Mesa actually turns out to be a bit faster in some situations. SGI is quite supportive of Mesa, and has recently given Brian a copy of the conformance tests to use. Mesa is still not allowed to claim to be OpenGL, however.