Chapter 1: Overview of OpenGL

Table of Contents

• Introduction
• The OpenGL Product
  • HP's Implementation of OpenGL
    • HP's Implementation of the OpenGL Libraries
    • Supported Graphics Devices
    • Supported Visuals
    • Stereo Visual Support for VISUALIZE-FX⁴ and VISUALIZE-FX⁶
    • Visual Support for Other Graphics Devices
    • Buffer Sharing between Multiple Processes
    • SIGCHLD and the GRM Daemon
  • The Standard OpenGL Product
    • The OpenGL Utilities Library (GLU)
    • Input and Output Routines
    • The OpenGL Extension for the X Window System (GLX)
• Mixing of OpenGL and Xlib
• Gamma Correction
• OpenGL Extensions
  • Clamp Border and Clamp Edge Extensions
  • 3D Texture Extension
    • Steps for 3D Texturing Programming
    • 3D Texture Program Fragments
  • Shadow and Depth Extensions
    • Steps for Shadow Texturing
    • Shadow Texturing Program
  • Texture Lighting Extension
    • Procedure for preLight Texturing
  • Occlusion Extension
    • Occlusion Culling Code Fragments
  • Texture Autogen Mipmap Extension
  • X Window Extensions for HP's Implementation of OpenGL
    • GLX Visual Information Extension
    • GLX_EXT_visual_info Program Fragments
    • GLX Visual Rating Extension
• Rendering Details
  • Default Visuals
  • EXP and EXP2 Fogging
  • Bow-Tie Quadrilaterals
  • Decomposition of Concave Quadrilaterals
  • Vertices Outside of a Begin/End Pair
  • Index Mode Dithering
• Environment Variables
  • New Environment Variables as of Release 1.05

Introduction

OpenGL is a hardware-independent Application Programming Interface (API) that provides an interface to graphics operations. HP's implementation of OpenGL converts API commands to graphical images via hardware and/or software functionality. The interface consists of a set of commands that allow applications to define and manipulate three-dimensional objects. The commands include:

• Geometric primitive definitions
• Viewing operations
• Lighting specifications
• Primitive attributes
• Pipeline control
• Rasterization control

OpenGL has been implemented on a large number of vendor platforms where the graphics hardware supports a wide range of capabilities (for example, frame buffer only devices, fully accelerated devices, devices without frame buffer, etc.).

For more information on OpenGL, refer to these documents, published by Addison-Wesley and shipped with HP's implementation of OpenGL:

• OpenGL Programming Guide Instruction on programming in OpenGL, offered in a tutorial format.
• OpenGL Reference Manual A reference that contains details on all standard OpenGL functions, as well as utility (GLU) functions and X-windows (GLX) functions.
• OpenGL Programming for the X Window System Instruction on interfacing OpenGL with the X Window system.

The OpenGL Product

HP's Implementation of OpenGL

• HP's implementation of the OpenGL libraries
• Supported graphics devices
• Supported visuals
• Visual support for other graphics devices
• Buffer sharing between multiple processes

HP's Implementation of the OpenGL Libraries

• libGL.sl OpenGL shared library
• libGLU.sl OpenGL utilities library

Supported Graphics Devices

• HP VISUALIZE-FX²
• HP VISUALIZE-FX⁴
• HP VISUALIZE-FX⁶

Supported Visuals

The text in the tables below is deliberately small, so when printing from a browser, the tables will fit on an 8.5"x11" page. If the text is too small to be easily readable in your browser, temporarily increase your font size.

Stereo Visual Support for VISUALIZE-FX⁴ and VISUALIZE-FX⁶

Visual Support for Other Graphics Devices

Buffer Sharing between Multiple Processes

True buffer sharing between multiple processes can be accomplished by utilizing indirect rendering contexts. In this case, rendering on behalf of all GLX clients is performed by the X server OpenGL daemon process, and there is only one set of virtual memory buffers per drawable.

SIGCHLD and the GRM Daemon

The Standard OpenGL Product

• The OpenGL Utilities Library (GLU)
• Input and Output Routines
• The OpenGL Extensions for the X Window System (GLX)

The OpenGL Utilities Library (GLU)

• Generating texture coordinates
• Transforming coordinates
• Tessellating polygons
• Rendering surfaces
• Providing descriptions of curves and surfaces (NURBS)
• Handling errors

Input and Output Routines

The OpenGL Extensions for the X Window System (GLX)

• Choosing a visual
• Managing the OpenGL rendering context
• Off-screen rendering
• Double-buffering
• Using X fonts

Mixing of OpenGL and Xlib

• OpenGL and Xlib renderers are implemented through separate pipelines and control streams, thus, rendering synchronization must be performed as necessary by the user's application via the GLX glXWaitX() and glXWaitGL() function calls.
• Xlib rendering does not affect the Z-buffer, so rendering in X and then OpenGL would result in the OpenGL rendering replacing the Xlib rendering. This is true if the last OpenGL rendering to the Z-buffer at that location resulted in the depth test passing.

Gamma Correction

For details on this feature, read the section "Gamma Correction" found in Chapter 7 of the Graphics Administration Guide.

OpenGL Extensions

Clamp-Border and Clamp-Edge Extensions

Table 1-6: Clamp-Border and Clamp-Edge Extensions

Extended Area	Enumerated Type	Description
Wrap Modes	GL_CLAMP_TO_BORDER_EXT Default: GL_REPEAT	When this enumerated type is passed into glTexParameter, it will clamp to the border of the MIP-map level.
Wrap Modes	GL_CLAMP_TO_EDGE_EXT Default: GL_REPEAT	When this enumerated type is passed into glTexParameter, it will clamp to the edge of the MIP-map level.

To use clamp border extension, substitute GL_CLAMP_TO_BORDER_EXT for the param in glTexParameter. To use clamp edge extension, substitute GL_CLAMP_TO_EDGE_EXT for the param in glTexParameter.

Code fragments and results:

Figure 1-1: Repeat Wrap Mode

Figure 1-2: Clamp-Wrap Mode

Figure 1-3: Clamp-to-Edge Wrap Mode

Figure 1-4: Clamp to Border Wrap Mode

For related information, see the function glTexParameter.

3D Texture Extension

Figure 1-5: Right-Handed Coordinate System for 3D Texturing

Each MIP-map level consists of a block of data (see Figure 1-6 below). Each MIP-map level of the texture map is treated as being arranged in a sequence of adjacent rectangles. Each rectangle is a 2-dimensional image, so each MIP-map level is a (2^m + 2b) (2ⁿ + 2b) (2^l + 2b) block where b is a border width of either 0 or 1, and m, n and l are non-negative integers.

Figure 1-6: Each Mipmap is a Block in 3D Texturing

Figure 1-7: GL_LINEAR_MIPMAP_LINEAR Filtering may use Two Blocks

Table 1-7: Enumerated Types for 3D Texturing

Extended Area	Enumerated Types	Description
Pixel Storage	GL_[UN]PACK_IMAGE_HEIGHT_EXT Default: 0 for each	The height of the image from which the texture is created; it supercedes the value of the height passed into glTexImage3DEXT.
Pixel Storage	GL_[UN]PACK_SKIP_IMAGES_EXT Default: 0 for each	The initial skip of contiguous rectangles of the texture.
Texture Wrap Modes	GL_TEXTURE_WRAP_R_EXT Default: GL_REPEAT	The wrap mode applied to the r texture coordinate.
Enable/Disable	GL_TEXTURE_3D_EXT Default: Disabled	The method to enable/disable 3D texturing.
Get Formats	GL_MAX_3D_TEXTURE_SIZE_EXT, GL_TEXTURE_BINDING_3D_EXT Default: N/A	The maximum size of the 3D texture allowed; bind query.
Proxy	GL_PROXY_TEXTURE_3D_EXT Default: N/A	The proxy texture that can be used to query the configurations.

Steps for 3D Texturing Programming

1. Enable the 3D texture extension using glEnable(GL_TEXTURE_3D_EXT);
2. Create a 3D texture using glTexImage3DEXT;
3. Specify or generate the s, t and r texture coordinates using glTexGen or glTexCoord3*;
4. Specify other parameters such as filters just as you would for 2D texturing, but use GL_TEXTURE_3D_EXT for the target.

3D Texture Program Fragments

The results of code fragments are shown in Figure 1-8. This figure shows four layers in the base MIP-map level, and a diagonal slice through the base MIP-map level.

Figure 1-8: Results from the 3D Texture Program Fragments

For more information on 3D texture, see the functions: glTexImage3DEXT, glTexSubImage3DEXT, glCopyTexSubImage3DEXT, glEnable, glDisable.

Shadow and Depth Extensions

The texture-depth extension provides a depth-texture format. This is needed in order to use the shadow-texture extension. The shadow-texture extension is used to compare the texture's r components against the corresponding texel value. Each texel is compared using user specified comparison rules. If the comparison rule passes, the fragment's alpha value will be set to one by the shadow-texture extension. If the comparison rule fails, the fragment's alpha value will be set to zero. The resulting alpha value can then be used in an alpha test, blending operation, and other appropriate operations to create photo-realistic shadows.

The shadow extension was added to HP's implementation of OpenGL specifically to support the depth-map shadow algorithm. A typical implementation of this algorithm might be to use the shadow extension to render the scene with the viewport at the light location. The contents of the depth buffer are then read back and sent to HP's implementation of OpenGL as a depth-format texture map. The scene is then rendered a second time from the viewpoint of the eye. Texture r coordinates are automatically generated and transformed, so that they correspond to z values as viewed from the light position. If the transformed r value is greater than the depth-texture map texel value, the corresponding fragment is considered to be in the shadow. A transformed r that is equal to or less than the depth-texture map texel value indicates a fragment that is fully illuminated. The shadow extension indicates the r comparison result by modifying the alpha value. An application can then use this modified alpha value to accurately render shadows in the scene.

After rendering the scene from the light position and reading back the depth map, an application would typically render the final scene in two passes. The first pass would be a normal rendering of the full scene with full illumination.

The second pass is used to add the shadows. HP's implementation of the OpenGL state should be configured to only render the shadow fragments. A typical application of this feature might be to set up HP's implementation of OpenGL state as follows:

1. Store a transformation in the texture matrix which is identical to the transformation used when viewing the scene from the light.

2. Enable object-plane texture coordinate generation for s, t, and r.

3. Store the depth map as the single-component texture map.

4. Enable shadow texturing and r compare. Set the r compare function so that shadow fragments will have an alpha of zero.

5. Enable alpha test to discard fragments with a non-zero alpha.

6. Disable diffuse and specular light components, so that only ambient illumination is present.

7. Set the depth function to pass fragments of equal depth value.

The full scene is then rendered a second time. Only shadow fragments are added to the full scene rendered in the first pass. Figure 1-9 show an example of results that could be achieved by this algorithm.

Figure 1-9: Texture-depth Extension Algorithm Results

When using this extension, set minification and magnification filter to either GL_NEAREST or GL_LINEAR. Mipmap minification filters of GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, and GL_LINEAR_MIPMAP_LINEAR will give indeterminate results.

Table 1-8: Enumerated Types for Shadow and Depth-Texture Extension

Extended Area	Enumerated Types	Description
Texture Formats	GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16_EXT, GL_DEPTH_COMPONENT24_EXT, GL_DEPTH_COMPONENT32_EXT Default: N/A	Texel formats which are useful when using shadow texturing.
Texture Parameter	GL_TEXTURE_COMPARE_EXT, Default: GL_FALSE	Enables comparison to the r coordinate when set to true.
Texture Parameter	GL_TEXTURE_DEPTH_EXT Default: GL_FALSE	Used to query if you have depth extension available.
Texture Parameter	GL_TEXTURE_COMPARE_OPERATOR_EXT, GL_LEQUAL_R_EXT, GL_GEQUAL_R_EXT Default: GL_TEXTURE_LEQUAL_R_EXT	Sets the particular type of comparison with the r texture coordinate.

Steps for Shadow Texturing

1. Set the GL_TEXTURE_COMPARE_EXT to GL_TRUE in glTexParameter
2. Set the GL_TEXTURE_COMPARE_OPERATOR_EXT to either GL_TEXTURE_LEQUAL_R_EXT or GL_TEXTURE_GEQUAL_R_EXT using glTexParameter.
3. Use glTexImage with GL_DEPTH_COMPONENT to fill the texture with the image which will be compared with the r coordinate.
4. Use glTexCoord3* to set the s, t, and r texture coordinates at the vertices of the object to be rendered.

Shadow Texturing Program

Figure 1-10: Results from Shadow Texturing

For related information, see the function glTexParameter.

Texture Lighting Extension

The texture lighting extension defines a mechanism for applications to request that color originating from specular lighting be added to the fragment color after texture application. This is referred to as preLight texturing.

Table 1-9: Enumerated Types for preLight Texturing

Extended area	Enumerated Types	Description
Texture Environment	GL_TEXTURE_LIGHTING_MODE_HP, GL_TEXTURE_PRE_SPECULAR_HP, GL_TEXTURE_POST_SPECULAR_HP Default: N/A	pname and param parameters for glTexEnv.

Procedure for preLight Texturing

or

The results from using preLight texturing are given in Figure 1-11. Note that the top image is without prelight texturing, and the bottom is with preLight texturing. The left half of both images is the untextured specular-lighted image, and the right half of both images uses GL_REPLACE texturing.

Figure 1-11: Results from Prelight Texturing

For related information, see the function glTexEnv.

Occlusion Extension

This occlusion culling extension defines a mechanism whereby an application can determine the non-visibility of some set of geometry based on whether an encompassing set of geometry is non-visible. In general, this feature does not guarantee that the target geometry is visible when the test fails, but is accurate with regard to non-visibility.

Typical usage of this feature would include testing the bounding boxes of complex objects for visibility. If the bounding box is not visible, then it is known that the object is not visible and need not be rendered.

Occlusion Culling Code Fragments

The following is a sample code segment that shows a simple usage of occlusion culling.

The key idea behind occlusion culling is that the bounding box is much simpler (i.e., fewer vertices) than the part itself. Occlusion culling provides a quick means to test non-visibility of a part by testing its bounding box.

It should also be noted that this occlusion culling functionality is very useful for viewing frustum culling. If a part's bounding box is not visible for any reason (not just because it's occluded in the Z-buffer) this test will give correct results.

To maximize the probability that an object is occluded by other objects in a scene, the database should be sorted and rendered from front to back. Also, the database may be sorted hierarchically such that the outer objects are rendered first and the inner are rendered last. An example would be rendering the body of an automobile first and the engine and transmission last. In this way, the engine would not be rendered due to the bounding box test indicating that the engine is not visible.

For related information, see the functions: glGet, glEnable, glDisable, and glIsEnabled.

Texture Autogen Mipmap Extension

To use the autogen MIP-map extension, set GL_GENERATE_MIPMAP_EXT to GL_TRUE in glTexParameter. For example, here is a code fragment that uses this extension:

   glTexParameter[if](GL_TEXTURE_2D, GL_GENERATE_MIPMAP_EXT, GL_TRUE);

For related information on this extension, see the function: glTexParameter.

X Window Extensions for HP's Implementation of OpenGL

GLX Visual Information Extension

The enumerated types listed below can be used only through glXGetConfig when it is known that the GLX visual being queried supports transparency or in other words, has a GLX_TRANSPARENT_TYPE_EXT property other than GLX_NONE_EXT.

GLX_EXT_visual_info Program Fragments

Here is a sample code segment that forces selection only of a TrueColor visual.

The following sample is a code segment that selects an overlay visual with index transparency, and then obtains the Pixel index for the transparent color.

GLX Visual Rating Extension

Note that all current HP GLX visuals are rated as GLX_NONE_EXT. This extension is implemented for possible future visual support and for use with non-HP servers. Coding to use the GLX_EXT_visual_rating extension is similar to the segments listed above for the GLX_EXT_visual_info extension.

Rendering Details

Default Visuals

EXP and EXP2 Fogging

Bow-Tie Quadrilaterals

Decomposition of Concave Quadrilaterals

Vertices Outside of a Begin/End Pair

Index Mode Dithering

Environment Variables

HPOGL_ALLOW_LOCAL_INDIRECT_CONTEXTS

This variable may be set if a need arises to really create a local indirect context. By default, if an indirect context is requested for a local HP display connection, a direct context will be created instead because the performance will be much better.

HPOGL_ENABLE_MIT_SHMEM

When rendering locally using the VM Driver, this variable allows the server and client to look at the rendering buffer at the same time. This variable has no effect through DHA. It merely eliminates the data transfer for XPutImage() that is done by VMD. This only offers a performance improvement on simple wireframes. Under most circumstances, it does not provide any performance improvements.

HPOGL_FORCE_VGL

This variable can be set to force HP's Virtual GL (VGL) rendering mode using VMD. This differs from HPOGL_FORCE_VMD in that the GLX Visual list and other GLX extension information is not retrieved from the GLX Server extension, but is rather synthesized from standard X Visual information and the capabilities known to exist in VMD.

HPOGL_FORCE_VMD

This variable forces clients to render through the VMD. This variable can be used as a temporary fix and/or a diagnostic. You should set this variable when a rendering defect in the hardware device driver is suspected. When this variable is set, rendering speed will slow down. If rendering is identical in both hardware and software, then this may indicate a problem in the application code.

HPOGL_LIB_PATH

This variable can be used to load OpenGL driver libraries from a directory outside the standard LIB_PATH. This variable should be set to the actual directory the libraries are in, with or without a trailing '/'.

HPOGL_LIGHTING_SPACE

This variable allows the user to specify the coordinate space to be used for lighting. By default, HP's implementation of the OpenGL will select the lighting space. Possible values are:

HPOGL_LIGHTING_SPACE=OC HPOGL_LIGHTING_SPACE=EC

where OC equals Object Coordinates and EC equals Eye Coordinates. For details on the lighting space, see the sections "Lighting Space" and "Optimization of Lighting" found in Chapter 5.

HPOGL_TXTR_SHMEM_THRESHOLD

This variable sets a fence for the use of process memory vs. shared memory. Any 2D or 3D texture that has a size greater than or equal to the threshold set is stored in shared memory. The initial value is set to 10241024 bytes. This variable should be set to the byte size desired for shared memory usage.

New Environment Variables as of Release 1.05

HPOGL_DSM_ENABLE_FAST_BUFFER_SWAP

When set to any non-NULL value, the new or faster double buffering method will be used. (This is the default behavior and does not need to be set except to override glHint as discussed below)

HPOGL_DSM_DISABLE_FAST_BUFFER_SWAP

When set to any non-NULL value, the old or slower double buffering method will be used.

glHint(GL_BUFFER_SWAP_MODE_HINT_HP, GL_FASTEST);

Switches to the faster double buffering method.

glHint(GL_BUFFER_SWAP_MODE_HINT_HP, GL_NICEST);

Switches to the slower double buffering method.