Two opReflMap map types—sphere and Gaussian—use simple reflection mapping. These map types are discussed in the following sections:

Simple reflection maps determine coordinates for the texture image by assuming the following:

These three assumptions imply that the texture coordinates for any point on a surface are determined by the viewing angle to the center of the scene and the vector normal to the surface. For a tessellated surface, which includes correct surface-normal vectors only at vertices, the rendering algorithm calculates the texture coordinates for a point inside a triangular surface tile by interpolating the coordinates of the triangle's three vertices. As an object rotates, the directions of the normal vectors completely determine texture coordinates; you do not have to calculate a new mapping from the surface to the texture image.

You can simulate complex lighting environments at low computational cost with a simple reflection map. However, reflection angles are not exact. For example, the algorithm yields the same image point for every point on a large, flat surface. This effect is illustrated in Figure 8-1, where collimating “lenses” indicate the effects of the remote viewer and remote source approximations. Notice that the shading for all points on each face of the cube is determined by one point on the texture image, which is determined by the normal to each surface. Furthermore, the texture image is usually blurred to avoid problems that occur when the curvature of a surface can cause two points that are close together to reflect widely separated points on the texture map, an effect called aliasing. Thus you cannot closely examine reflection-map images to make accurate inferences about a surface or its reflected environment.

Figure 8-1. Reflection-Map Geometry: Remote Viewer, Remote Environment

Gaussian Map

Gaussian mapping creates an environment map on a sphere that simulates the effect of a light source directed along the viewing direction at an imperfectly reflecting surface. It provides efficient lighting effects for models with inconsistent normals; it is a faster alternative to using two lights.

The mapping is a Phong-like illumination model characterized by a specularity parameter that controls the amount of light that is imperfectly reflected. As the specularity increases, reflections become less diffuse and more mirror-like. For more details on the Phong illumination model, see the book by van Dam and others listed in the “Recommended Background Reading”.

A special form is an infinite viewer/infinite sphere environment map where the environment is two lights with a fixed gaussian distribution. The texture map is only generated if the user does not specify an image file name or a csImage, in case Gaussian mapping act just like sphere environment mapping.

---

Note: Gaussian map mode only supports two lights fixed in the environment map.

---

Reflection mapping assumes:

The texture coordinates depend on the complete ray-path geometry: the location of the viewpoint and the location of the reflecting surface point and its normal. These quantities, and the dimensions of the cylinder, define the point where a ray intersects the cylinder and determine the point in the texture image (see Figure 8-2).

Unlike the remote viewer and environment configuration, a ray between the viewpoint and the texture image changes as you bring the viewpoint closer to the surface or translate the surface; the complete ray geometry determines the texture coordinates associated with a point on a surface. For example, as you “walk” by a car, translating the viewpoint of the scene, lines of lights slide over the car's surface.

Figure 8-2 illustrates the general effects of a local viewer and local environment. To simplify the comparison with the remote-viewer-remote-environment approximation, the spherical texture image is the same as in Figure 8-1; the difference is that the collimating lenses have been removed. Note how each point on the cube maps to a different point on the texture map; the entire ray geometry determines the texture image point and the size of the image on the cube.

Figure 8-2. Reflection-Map Geometry: Local Viewer, Local Environment

Any change in the scene or viewpoint requires a recomputation of the reflected ray, and a new mapping of the surface to the texture image. The member function updateViewInfo() calculates cylinder texture map coordinates for each frame. Clearly, this is a greater processing burden than using a remote viewer in a remote environment.

Cylinder Map

Cylinder reflection maps simulate tube lighting. The mapping assumes a local viewer and a local environment; the x axis is the axis of a cylinder with lights that run down the wall, parallel to the axis. As you move the viewpoint, the simulated lighting tubes slide over the surface.Tube lighting is the default when opReflMap has no image file; that is, you can attach an image to the cylinder.

In cylinder mapping (a.k.a. reality mapping) the environment map is placed on a finite radius sphere, at a user-defined origin. If no image file or csImage is given to opReflMap, then a default black and white striped texture map is automatically generated. The user can control the width, spacing, and coloration of the stripes. Stripes reflected off the body of an automobile can be an useful aid to visualizing surface curvature and anomolies.

The sample application zebraFly can be used to illustrate this (see “Reflection Mapping”).

Figure 8-3 illustrates the viewing configuration used for the cylinder map.

Figure 8-3. Viewing Configuration for the Cylinder Reflection Map

opReflMap has accessor methods to control parameters of the cylinder map.

The opReflMap class provides the tools for the different reflection-mapping types discussed in this section.

In addition to the constructor, opReflMap's methods fall into three groups: those that are independent of the type of reflection map set by the constructor, those that apply only to the Gaussian map type, and those that apply only to the cylinder, floor, and ceiling maps. No special function is needed to control the sphere map.

class opReflMap
{
public:
opReflMap( csGroup *root,  char *fileName, unsigned int mt );
opReflMap( csGroup *root,  csImage *inputImage, unsigned int mt );
opReflMap( csGroup *root,  opReal spec,    unsigned int mt );

~opReflMap( void );

     
// Sets and gets
void     setScene( csGroup *root )      ;
csGroup *getScene( )                    ;

void     setSpecularity( opReal spec );
opReal   getSpecularity( );

void     setScale( opReal _scale );
opReal   getScale(  );

void     setXoffset( opReal offset );
opReal   getXoffset(  );
void     setYoffset( opReal offset );
opReal   getYoffset( );

void     setZoffset( opReal offset );
opReal   getZoffset( );

void     setStartAngle( opReal angle );
opReal   getStartAngle( );

void     setEndAngle( opReal angle );
opReal   getEndAngle( );

void             setMapType( uint mt );
unsigned int     getMapType( );

void     setShinyThres( float t );
float    getShinyThres( );

void     setXRes(int res);
int      getXRes();

void     setYRes(int res);
int      getYRes();

csTexture  *getTex()
csTexGen   *getTexGen()

void     setCBias(float bias)            
float    getCBias()                      

void     setLightTint(float r, float g, float b)
void     setSpaceTint(float r, float g, float b) 

// Compute the new texture coordinates for a given geoset
void computeTexCoords( csTriStripSet *gs );
void computeTexCoords( csTriFanSet   *gs );

// Run over the scene graph updating the texture coord
void computeAllTexCoords( );

// Tell the reflection map to update it's viewing information
void updateViewInfo( 
          csCamera &camera, csTransform &transform, csVec3f &center  );


// Enables the texture appearance on the scene graph's shape nodes'
// apearances
void setTextureApp( bool enable );
};