X provides both a procedural interface and a network protocol for creating and manipulating framebuffer windows and drawing certain 2D objects into those windows. OpenGL is integrated into X by making it a formal X extension called GLX. GLX consists of about a dozen calls (with corresponding network encodings) that provide a compact, general embedding of OpenGL in X. As with other X extensions (two examples are Display PostScript and PEX), there is a specific network protocol for OpenGL rendering commands encapsulated in the X byte stream.
OpenGL requires a region of a framebuffer into which primitives may be rendered. In X, such a region is called a drawable. A window, one type of drawable, has associated with it a visual that describes the window's framebuffer configuration. In GLX, the visual is extended to include information about OpenGL buffers that are not present in unadorned X (depth, stencil, accumulation, front, back, etc.).
X also provides a second type of drawable, the pixmap, which is an off-screen framebuffer. GLX provides a GLX pixmap that corresponds to an X pixmap, but with additional buffers as indicated by some visual. The GLX pixmap provides a means for OpenGL applications to render off-screen into a software buffer.
To make use of an OpenGL-capable drawable, the programmer creates an OpenGL context targeted to that drawable. When the context is created, a copy of an OpenGL renderer is initialized with the visual information about the drawable. This OpenGL renderer is conceptually (if not actually) part of the X server, so that, once created, an X client may connect to the OpenGL context and issue OpenGL commands (Figure 4). Multiple OpenGL contexts may be created that are targeted to distinct or shared drawables. Any OpenGL-capable drawable may also be used for standard X drawing (those buffers of the drawable that are unused by X are ignored by X).
A GLX client that is running on a computer of which the graphics subsystem
is a part may avoid passing OpenGL tokens through the X server.
Such direct rendering may result in increased graphics performance since
the overhead of token encoding, decoding, and dispatching is eliminated.
Direct rendering is supported but not required by GLX.
Direct rendering is feasible because sequentiality need not be maintained
between X commands and OpenGL commands except where commands
are explicitly synchronized.
Because OpenGL comprises rendering operations only, it fits well into already existing window systems (integration into Windows is similar to that described for X) without duplicating operations already present in the window system (like window control or mouse event generation). It can also make use of window system features such as off-screen rendering, which, among other uses, can send the results of OpenGL commands to a printer. Rendering operations provided by the window system may even be interspersed with those of OpenGL.