Programmability
Programmability is the key word in OpenGL 2.0, and it means it is designed to be accessible to applications. As befits a standard for a wide range of applications and users, graphics programmability is added through a similar high-level language that is used for CPU-style programmability. It will offer a rich feature set, it will be hardware independent (as a standard should be), and it will be designed specifically for use within the OpenGL framework.
- Programmable vertex processing will be the most talked about feature. It will replace coordinate transformation, material application, and lighting, and allow arbitrary per-vertex operations.
- Programmable fragment processing is another key feature. It will replace texture access, texture application, and fog, and it will allow arbitrary per-fragment operations, something that developers have long wanted.
- Programmable image formats will replace fixed format image packing and unpacking operations, which will allow arbitrary combinations of type and format when sending pixel data to and from OpenGL.
The idea is to reduce the need for existing and future extensions by replacing complexity with programmability and provide rich, long-lasting functionality.
Features
The other functions being incorporated into the new standard include:
- Direct support for multi-pass algorithms under application control
- More flexible frame buffer configuration
- Off-screen rendering within OpenGL
- Application control of texture memory
- Unifying framework for OpenGL objects
- More flexible support for reading and writing image formats
- Cleaner and more efficient synchronization mechanisms
- Application control of buffer swaps
- Use of any color buffer as a texture
This results in a roadmap of OpenGL development and evolution as illustrated by the following chart:
The benefits of this new API will be the standardization of features and improved performance, along with the standardization of existing functionality. Most of the optional OpenGL 1.3 imaging subset is required in OpenGL 2.0, and numerous extensions will be incorporated into standard OpenGL, which will expose the full performance of the hardware. The result will be the ultimate in performance for transfers to and from the graphics subsystem, and more parallelism between CPU and graphics processing. This new API looks like the following diagram:
